v0.13.0 - The Genre Toolkits Update 🔨✂️

v0.13.0 - The Genre Toolkits Update

This release ships whole game genres as event-sheet toolkits - a complete incremental/idle kit, a composition (ECS-lite) system layer, and procedural generation wired through one shared random source - plus a data-driven pass over abilities and content. Everything still compiles to plain, typed GDScript with zero runtime dependency, and every pack round-trips byte-for-byte.

Highlights

• The incremental / idle toolkit (7 packs) - build a clicker or idle game from parts: Big Numbers (short-scale/scientific/engineering/time formatting past a trillion, plus a Decimal type for values beyond a float's 1.8e308 ceiling), Idle Generator (a producer with a geometric cost curve, exact closed-form Buy Max, and an optional fill-and-collect cycle), Click Power (manual-tap income with crits), Boosts (golden-cookie timed multipliers), Upgrades (stacking add/mult buffs with tags), Prestige (reset for a permanent multiplier, no double-award), and Milestones (threshold achievements that grant an aggregated reward). Each has a deep-dive guide with 16+ worked use cases.
• Composition and systems (ECS-lite) - a new Systems vocabulary treats a group as a set of entities and a sheet as a system that runs over it (Entities In Group, the archetype "in both groups" queries, Run On Tagged Entities), with an Entity System autoload starter and an honest guide on where node-and-group composition fits and where it does not.
• Advanced Random, everywhere - flip one Use Advanced Random toggle on ProcRoom, Loot Table, SkinVault, or Storylets and that pack draws from the shared AdvancedRandom autoload, so a single seed reproduces a whole run (map, loot, cosmetics, and narrative). Off by default and byte-identical, with a safe local fallback.
• Data-driven odds and content - a RandomTableResource (a value/weight grid as a .tres) plus Advanced Random's Pick From Table; an AbilitySetResource that defines a Simple Abilities loadout as a .tres and auto-creates it on ready (or via Load Ability Set at runtime). Tune drop rates and loadouts in the Inspector, not in events.
• Seeded generation for tools and resources - a new Procedural module of stateless, seeded expressions (Seeded Value / Int / Pick / Sign / Chance) that need no autoload, so they work inside Editor Tool sheets and while filling Custom Resources, as well as at runtime.
• Pack builders auto-register - drop a tools/pack_builders/<name>.gd with a build() and it registers itself; there is no list to maintain (the same zero-config discovery the helper ACE modules use). The suite is now 58 packs.
• A kill-refresh fix for Simple Abilities - Reset Cooldown now grants the next charge back, so a spent ability is genuinely ready again (readiness is charge-based) - the "killing an enemy refreshes your dash" idiom a roguelite expects.
• A procedural-generation guide with 26 use cases pairing Advanced Random with every other addon and a start-to-finish seeded-run workflow, plus the updated Simple Abilities and composition guides.

Quality: every feature landed suite-green with byte-exact round-trip gates and drifted=0 across all 58 packs; the incremental math and both new mechanisms are pinned in tests, and two rounds of adversarial review hardened a dozen edge cases before ship. Generated code still never depends on the plugin, templates bake at apply-time, and output remains performance-identical to hand-written GDScript - all test-enforced. Verified on Godot 4.7 stable.

Full ledger: CHANGELOG.md

v0.12.0 - The Inspector Designer Update 🕵️

v0.12.0 - The Inspector Designer Update

Your event-sheet variables were already real @export properties. This release lets you design the whole Godot Inspector they produce - visually, from the sheet, with no code - and ships four UI packs plus a faster, lighter plugin load. Everything still compiles to plain, typed GDScript with zero runtime dependency, and every drawer, marker, and pack round-trips byte-for-byte.

• The Inspector Designer - a Sheet-menu view lays out every exported variable as a live, stacked preview card exactly as Godot will show it; edit a variable in place or reorder fields without leaving the picture. Hover any exported variable row in the sheet and the same preview floats up as a tooltip.
• Eight rich drawers, all authored from the Variable dialog with no code and all round-tripping to plain @export GDScript: min-max range sliders (one handle per bound), an editable table (an Array becomes an add/remove/reorder grid), toggle-button rows (a String's choices shown as buttons), plus progress bar, direction dial, colour swatch, texture thumbnail, and inline curve.
• Decor and guard rails from plain comments - accent section headers, info-note panels, a required badge that lights when a field is empty, inline validation (a sheet function's warning shown under the field), and inline field buttons (run a method from the Inspector). Every marker is a comment the importer reads back, so none of it costs the byte-exact round-trip.
• A Custom Resource showcase - EnemyStats puts the drawers, decor, required fields, and a loot table together as one designer-tunable resource, and the Custom Block + EventSheets APIs gained the matching hooks (build_inspector_preview, describe_inspector, variable_code, block hover_text).
• Four UI packs (now 34 in all) - a HUD Kit (menus and HUDs addressed by name, every descendant button auto-wired into one On Button Pressed trigger, zero connected signals), Scene Flow (scene changes behind a polished fade that survives the swap), and a Dialogue Kit (typewriter conversations), shipping alongside a ready-to-edit Menu Starter scene you can copy as your project's UI.
• The Doctor enforces required fields project-wide - every scene node and saved resource using a script with Required, empty-by-default variables is scanned, and any that leaves one unset gets a warning naming the exact file and property. Runs in the dock, the CLI, CI, and MCP.
• 2D overlap queries - "what is HERE right now" point / circle / rect checks with no Area2D needed.
• Born where you already right-click - the FileSystem dock's native Create New submenu now offers Event Sheet..., which mints a new .gd sheet (Blank or a starter) straight into the clicked folder and opens it ready to edit.
• A faster, lighter load - the workspace editor is built lazily on first use, so enabling the plugin (or opening a project that never touches event sheets) skips the whole dock construction at editor startup; the top-strip tab still appears instantly.
• Construct-3 muscle memory - the row right-click menu gained Insert Above, Cut (copy plus delete as one undo step), and Copy as Text (readable plain-language sentences for an issue or a chat message).
• Docs, reorganized and illustrated - every doc file now wears its kind as a prefix (GUIDE-, REFERENCE-, internal SPEC-), eleven guides open with a rendered picture of the feature they teach, and every guide grew a rich set of concrete use-case examples.

Quality: every feature landed suite-green with byte-exact round-trip gates and drifted=0 across all 34 packs. Generated code still never depends on the plugin, templates bake at apply-time, and output remains performance-identical to hand-written GDScript - all test-enforced. Verified on Godot 4.7 stable.

Full ledger: CHANGELOG.md

Full Changelog: v0.11.0...v0.12.0

v0.11.0 - The Structure & Vocabulary Update

Big sheets need structure, and a growing project deserves a growing vocabulary. This release makes both first-class: fold thousands of rows into colored regions that read like chapters, and turn the logic you write into named, reusable verbs that every sheet in the project can pick - without ever leaving the event sheet, and without changing a single byte of the GDScript your sheets compile to.

• Collapsible regions - #region fences become foldable, color-tinted bubble outlines around any run of rows. Groups and every block kind nest inside, regions glow when you drag into them, each carries an editable color and description, and folds survive reopening the project. Byte-identical .gd output, always.
• The abstraction levers, complete - multi-line actions show a quiet →N "compiles to N lines" cue; Extract to Function honours a partial selection and turns captured locals into typed parameters automatically; Teach a Verb publishes a sheet's functions into every picker in the project (node-targeted and retargetable, with un-teach in Manage Providers); and the picker now leads with featured intention verbs (Wait, Play Sound, Destroy, Move Toward...) rendered bold at the top of their categories.
• Choose Inspector looks by picture - the Look Gallery shows one miniature tile per Inspector widget (checkbox flags, layer grids, file pickers, easing curves) with plain-language explanations, and a live Inspector preview card states your choices as one sentence plus the exact @export line they ship as.
• Translate your game from the sheet - a globe toggle marks any string translatable (tr() underneath), a Translation ACE module covers locale switching, context, and plurals, and the Project Doctor flags untranslated projects.
• Every node speaks EventSheet - any engine class or your own class_name scripts reflect into browsable vocabulary on demand: methods classify by return type, signals become triggers, properties become Set/Get pairs.
• Terse addon authoring - a ## doc comment is the description, one class-level @ace_category plus @ace_expose_all(node) publishes a whole behavior, and all 31 shipped packs now demonstrate the style - permanently audit-gated so they can never drift.
• A public API to build on - the EventSheets facade exposes vocabulary, editor, codegen, and project-health services with the same stability covenant as ace_ids; the plugin's own features run on the same seams, and the Project Doctor accepts pack-registered health checks.
• Fixed along the way - reflected property actions that silently compiled to nothing now write real code; autoload providers call the singleton instead of spawning a second copy; twice-registered providers no longer double-list in the picker; the picker's codegen line is never blank; and the row-type square that cluttered every row is gone.

Quality: every feature landed suite-green with byte-exact round-trip gates and drifted=0 across all 31 packs. Generated code still never depends on the plugin, and output remains performance-identical to hand-written GDScript - all test-enforced.

Full ledger: CHANGELOG.md

Full Changelog: v0.10.0...v0.11.0

v0.10.0 - The In-Sheet Authoring Update

v0.10.0 - The In-Sheet Authoring Update

The whole authoring loop now lives inside the sheet. The ACE Studio reframes
"define a verb" as three plain-language cards (Does something / Is it true? /
A value) with a live picker preview and a "Ships as:" signature; double-click a
Define block to edit a verb in place. Opened packs become editable vocabulary:
a per-function, byte-verified shell-lift turns annotated pack verbs into real
EventFunctions (331 across the library), and helpers anywhere in the file -
mid-file or with custom return types - anchor in place and re-emit at their
exact original slot. A left-rail Anatomy panel shows any sheet as seven organs,
click-to-jump. Editing hits speed-of-thought: a zero-dialog Ghost Row, the
Param Hop (Enter then Tab across a row's values), Ctrl+Enter bulk retune, and
single-key B/I/R. Navigate like the script editor: Ctrl+Click opens a behaviour
as a sheet, Alt+Left/Right history, Ctrl+P # sheet / @ symbol search, paste an
error line to land on the row that caused it, and What Changed Since Save names
a save's touched rows in event language.

The Custom Block API lands complete: register non-ACE row kinds (preloads,
region markers, notes, pack data blocks) with one small script - compiler,
importer, viewport, Add menu, Command Palette, and a schema-driven edit dialog
wire up generically, every kind byte-verify gated - and the plugin dogfoods it
(enum and signal rows run on the registry; plugins can register kinds through
the EventForge bridge). Variables grow folders (drag one onto another for a
Discord-style Inspector-group bubble, again for a subgroup) and the Variable
dialog's "Inspector look" picker covers every Godot export option in plain
language - range modifiers, flags, layer grids, file/folder pickers, node-path
filters, password/expression/link, storage - with a live "Ships as:" strip.
Creating a sheet now asks what you're making: Custom Resources and Editor Tools
join behaviours and autoloads as first-class, guided destinations. Plus
GDScript-as-an-action script blocks, a RegEx text module, global-signal
triggers, console ACEs, event-group round-trip, the visual expression builder,
an Open Sheets panel, and friendly Number/Text/Yes-No variable types.

Under the hood: the editor opens and switches tabs much faster (session-cached
ACE definitions; warm registry refresh ~200ms to ~5ms), the whole codebase
follows the suite-enforced GDScript style guide, every user guide was restyled
to one house structure (the Custom Block API gets a full guide), and the theme
tokens became the single source of truth (the vestigial designer template
scenes are gone, proven token-identical).

Suite 3535 checks green, 31 packs drift-free. Verified on Godot 4.7 stable.

Full Changelog: v0.9.5...v0.10.0

v0.9.5 — Code-Free Authoring & First-Class Variables

Event sheets become .gd-native and code-free. A sheet is now just GDScript by default (no .tres), every bundled behaviour compiles with zero GDScript blocks, and the importer can open any .gd back as events. On top of that: first-class variables with the full Tier 3 Inspector drawers, a Construct-3-migrant-friendly progressive-disclosure pass, and real relief for Godot's node-heavy picking.

Compatibility covenant holds: generated code never depends on the plugin, templates bake at apply, and output stays performance-identical to hand-written GDScript. Verified on Godot 4.7 stable.

Highlights

• 📄 .gd is the default sheet format — no .tres needed; lossless, editable round-trip.
• 🧱 Code-free behaviour authoring — every bundled pack compiles with zero GDScript blocks, and any .gd opens back as events.
• 🎚️ First-class variables + the full Tier 3 Inspector drawers — progress bar, direction dial, swatch row, texture preview, inline curve.
• 👪 Families, collapsible blocks, and Extract-to-Function — organize and abstract without leaving the sheet.
• 🌲 Node-heavy picking relief — pick children by type, collapse deep paths to %Name, drop a node onto a param.

.gd-native sheets

• .gd is the default sheet format — a sheet is just GDScript with a lossless, editable round-trip. Open in Godot to edit in the script editor, auto-preview a .gd as an event sheet, and sheet metadata (tags, autoload) round-trips through the file. An unlocked .gd sheet stays editable across editor restarts; "Save As .tres" no longer silently converts a .gd-backed sheet.

Code-free behaviour authoring

• Zero GDScript blocks across the bundled packs — flash, timer, 8-direction movement, state machine, and move-to all compile from ACE rows alone.
• A behaviour-building ACE vocabulary (physics, input, typed locals, signals-as-triggers) plus the {host.} idiom so a pack's ACEs can target the node they're attached to.
• Open any .gd as events — the importer de-codes function bodies, if/elif/else, for/while/repeat loops, and match back into structured rows (near-zero-RawCode), so a hand-written script reads as a sheet.
• @ace_expose_all — author a custom addon with near-zero annotations.

Families, blocks & abstraction

• Families — declare a sheet as a Family and iterate over a whole family of objects (with a family-scoped group), demonstrated end-to-end in the new Family Arena showcase.
• Collapsible GDScript blocks — class scaffolding folds into a tidy, type-aware strip.
• Extract-to-Function — turn a selection of actions into a named, reusable verb; function calls render as first-class named verbs (e.g. ƒ Apply Physics).

Node-heavy picking relief

• Pick child nodes by type — defuse Godot's deep node trees instead of hunting paths.
• "Make %unique" — give any deep node a flat scene-unique handle in one click; drag-references and the node picker prefer %Name.
• Drop a Scene-dock node straight onto a param value to fill it with a node reference — no dialog.

First-class variables & Tier 3 Inspector drawers

• @export badge on variable rows, @export_group / @export_subgroup grouping (with "Group › Subgroup" chips), and variable tooltips — all with a lossless, editable .gd round-trip (the importer absorbs the grouping/tooltip back onto the variable, verify-lift-gated so it's byte-exact-safe).
• The full Tier 3 Inspector drawers — a numeric progress bar, a Vector2 direction dial, a Color swatch row, a texture preview, and an inline curve — each authored via a per-type picker with a live widget preview, and each round-tripping into an editable drawer. Without the editor plugin (or in an exported game) the property is a plain field, so generated games stay parity-clean.
• New host value types — Vector2, Color, Texture2D, and Curve are first-class sheet-variable types.
• Inspector Playground showcase — all five drawers + @export grouping on one tunable node; press Play and the ship drifts/tints/scales from those designer-tweakable variables.

Progressive disclosure (Construct-3-migrant UX)

• The Variable dialog's Inspector options are tiered (Basic "More options" + a nested Advanced disclosure that auto-unfurls only when used), drawer config is de-overloaded (a dial's reach is just 150), wording is C3-first ("Editable in the Inspector", "Group under heading", "Constant"), Simple Mode is offered on first run, and Clamp is pre-validated against a valid Range.

Authoring & safety

• "New Behaviour Addon…" scaffold that teaches the @ace_* vocabulary by example, plain-language hover descriptions on every built-in ACE (authored inline), and ACE deprecation (a deprecated ACE keeps compiling, is hidden, and warns with its replacement).
• BBCode in condition/action cell text and hover descriptions; an inline colour picker on the cell swatch.
• Syntax-error prevention — auto-closed brackets and an always-on structural guard; the code-block dialog live-disables Save on an unbalanced bracket.

Quality

3,400+ assertions, all green; byte-exact golden round-trips guard the lossless rules; zero showcase drift, CI-gated on every push.

Full changelog: CHANGELOG.md · compare v0.9.0...v0.9.5

v0.9.0 - Performance & Game Feel

EventSheets that scale to real games and feel good to play. Frame-spreading and time-budgeting so heavy work never hitches, a game-feel pack, a big jump in code-free vocabulary (the Construct→Godot idiom taught right in the editor), and a thorough pre-release hardening pass — all still compiling to plain, typed, zero-runtime GDScript.

⚡ Performance & scale - frame-spreading, no hitches

• Time Slicer pack (30th addon) — a managed work queue that drains within a per-frame budget (ms, count, or both). Enqueue items (or a whole group) in one event, react to On Process Item in another; heavy work self-spreads across as many frames as it needs — no loop, no await — then fires On Drained. Pause/Resume, Set Frame Budget, Is Busy, Items Remaining; attach as a component or register as a global autoload.
• Budgeted For Each - set frame_spread_count / frame_spread_budget_ms on a pick filter and the For Each becomes an in-place loop that processes a slice per frame and resumes next frame. Snapshots once per pass, skips freed items, restarts cleanly — no behavior to attach, no restructuring.
• Run In Background pack (31st addon) — hand a pure function to the engine's WorkerThreadPool (or Run Batch In Background to fan an array across threads); the main thread only polls, and On Done(result) fires on the main thread when finished — for procgen, pathfinding bakes, data crunching too heavy even to spread.
• Budget ACEs (advanced) — hand-rolled spreading for power users: Await Next Frame, Begin Frame Budget(ms), Await If Over Budget(ms).
• Project Doctor advisories - flags an unbounded heavy For Each under On Process that's neither capped nor budgeted, and a coroutine under a per-frame trigger (await re-entrancy); both go quiet once you fix them.
• A watchable "Swarm" showcase — 800 sprites, one Budgeted For Each at 90/frame: you see the colour refresh sweep through the crowd while the FPS stays pinned.

🎮 Game feel

• Juice pack (29th addon) - game feel in one behavior: trauma-based screenshake (additive on the camera, composes with follow), smooth zoom in three flavours (by percent, Zoom To Position, Zoom Toward Point / wheel-to-cursor), volume-preserving squash & stretch (tween and a real per-frame spring variant) on a Node2D or a Control, and slow-mo (eased time_scale, realtime-or-scaled hold, tunable fade curves). The camera is auto-found; every effect is fire-and-forget and emits a finished trigger to chain the next beat.
• Nearest / Furthest / Nearest-Visible picking - pick the closest or farthest group member by distance with no loop (2D and 3D from one expression); pair with Has Line Of Sight To for "attack the nearest enemy I can see" — the occlusion-correct Nearest Visible In Group skips a nearer-but-blocked target.

🧭 Construct → Godot - the idiom, taught where you choose

• The picker nudges polling toward signals - look at Overlaps Body / Is Timer Stopped / Is Animation Playing / Is Button Pressed and a one-line tip points at the reactive trigger that fires once (On Body Entered, On Timeout, …); the reactive twin even becomes the type-and-Enter default. Curated so it never suggests a cargo-cult signal.
• Tree-membership triggers — On Tree Entered / Tree Exiting / Tree Exited / Renamed / Child Entered Tree, so "when this node enters/leaves" is reactive, not a per-frame IsInsideTree poll.
• "Designer-tweakable (Inspector)" split from "global", off by default — new variables are private vars, not auto-@exported, so internal state stops leaking onto the Inspector.
• Behavior Component starter — a signal-driven Pickup you attach as a child (the Godot answer to a Construct behavior): typed host, reacts to the host's body_entered, emits its own On Collected.
• Three Project Doctor advisories — duplicated globals → autoload (Game State singleton), fan-out god-sheet (by distinct-node count, not row count), and the coroutine/loop checks above. Info-tier, never fails CI.
• Migration guide — "Polling vs reacting" — the biggest mental shift, with an explicit "when polling is correct" carve-out so you don't over-correct.

🧰 Code-free vocabulary - far less dropping to GDScript

• Every host-scoped node ACE can target another node — an optional "On node" field on 180+ setters ($Enemy, get_node("UI/Score")); blank = unchanged, so existing sheets compile byte-for-byte identically.
• New node-type batch - UI/menus (Button On Pressed/Toggled triggers, focus nav, Range/LineEdit), 2D raycasts, particles (+On Particles Finished), AnimationTree travel/params, tilemaps, shader materials, runtime input rebinding, physics joints, 24 collision helpers (on-wall/floor, slide info, area overlaps, layer bits), and loop control (Break / Continue / Current Item).
• ~80 dev-helper ACEs - Debug / Groups / Metadata / Nodes, 12 more math, 7 Color helpers, project utilities (Settings / Window / Time), node manipulation + picking - the everyday chores that used to force a code block.
• File & JSON modules - null-safe FileAccess/DirAccess reads and guarded writes; a dedicated JSON category with pretty-print and parse-into-variable.
• Group aggregates — Sum / Average / Lowest / Highest In Group, each a zero-runtime reduce one-liner.
• On Signal can receive typed parameters; remappable keyboard shortcuts (rebind ~18 authoring actions, saved per-user).

📦 Behavior library - now 31 packs

• New: Advanced Random (#27 — seeded / dice / Gaussian / Perlin / shuffle-bags / weighted), Simple Abilities (#28 — cooldowns / stacks / temporary / tags), Juice (#29), Time Slicer (#30), Run In Background (#31).
• Hardening - Spring, Health, Simple Abilities and the HTN Agent now use typed inner classes instead of cast Dictionaries (a field typo fails at compile); Car edge-fires On Drift Started/Recovered and Follow On Reached Target; Tile Movement / Sine 3D / Drag & Drop / Save System polish. Every pack rebuilds byte-identically (no-drift covenant) with a runtime test driving its real logic.

✨ Editor & debugging

• Code-free authoring - visual expression builder (host members under "This Object"), reflection-driven method/property pickers, Extract GDScript to Function, a visual Array/Dictionary data editor, and conditional breakpoints (if <cond>: breakpoint).
• Step/watch debugging - live Event Trace (highlights firing rows in real time), a Watch panel (pin expressions, evaluated editor-side), editable Live Values, and error → row deep-linking (the offending row gets a red stripe + tooltip, with "did you mean…?").
• Picker — relevance ranking (best match, not first-in-tree), de-jargoned plain-language hints, Favorites / Recent panes, keyboard-first dialogs, persisted recents.
• Auto-discovered ACE modules + tests - drop a module/test file, zero registration edits.

🛡️ Correctness, safety & polish (pre-release pass)

• ACE safety audit - a compile-coverage test parses all 446 built-in ACEs in their host class; 9 verified runtime-safety bugs fixed (null-derefs, a node leak, a wrong-host crash, a self-targeting look_at), pinned by ace_safety_test.
• Silent-bug sweep - 6 defects that shipped wrong behaviour without ever crashing (awaited-multiline await var, colliding handler names, conditions failing open, negated stateful timers, reverse-lift shadowing, charge-ability regen), each pinned by a regression test.
• Pick Filter (For Each) authoring - a commit guard (won't save a non-compiling loop), ƒx autocomplete on Where / Order-by, and on-save linting of all three fields.
• Modern signal.emit() codegen across both signal ACEs; Set Material default fixed; the Quick-Start demo and showcases sharpened (clean, hook-free generated .gd); Juice restores time_scale on scene change.

📚 Docs

• New "Using EventSheets with your existing code" guide (call your GDScript / autoloads / signals from sheets and the reverse), a Custom ACEs guide, and game-feel + crowd-spreading recipes. Redundant spec scaffolding removed; internal status docs moved out of the user-facing docs/ folder.

---

The covenant holds

Everything still compiles to plain, typed GDScript with zero runtime dependency - performance-identical to hand-written code, debuggable as ordinary GDScript, and reversible (import a .gd back into events). Verified on Godot 4.7 stable: the full headless suite is green, the addon drift audit reports 0, and generated code round-trips byte-for-byte (2,500+ test assertions).

⚠️ Early, experimental project: the generated output is parity-clean and test-enforced, but the editor and on-disk format may still churn before 1.0.

📋 Full feature-by-feature ledger: CHANGELOG.md

v0.8.0 — "The Team & Scale Update"

EventSheets built to survive growing projects and teams. This release adds collaboration tooling, a much bigger behavior library, and Godot 4.7 support.

🤝 Team & version control

• Semantic 3-way git merge driver — merges sheets at the row level keyed on stable UIDs. Two people editing different rows merge cleanly; a genuine same-row edit keeps both versions (fenced by ⚠ comment rows) instead of an unmergeable .tres. Opt-in per clone — see docs/VERSION-CONTROL.md.
• Symbol-aware Find References + Go-to-Definition — whole-symbol matching, so speed finds the variable but never move_speed; backs a rename preview. Edit ▸ Find References…
• Includes, made usable — Edit ▸ Extract Selection to Include… moves selected events into a new library sheet and wires the include; an includes manager previews what each contributes with a cycle guard and read-only provenance.
• Byte-stable regeneration — packs/showcases regenerate identically, so diffs stay small instead of churning every UID on rebuild.

🧰 Bigger behavior library — C3-addon parity (26 packs)

• Platformer juice: coyote time, jump buffering, variable jump height, multi/wall jump.
• Spring colour springs + lifecycle (pause/resume/reset, started signal).
• Weapon Kit (new): ammo/reserve, fire-rate, single/auto/burst, timed + instant reload.
• HTN Agent (new): utility-driven hierarchical task-network planning, ported from the custom C3 DHTN addons.
• Richer Array / Dictionary / Vector / String Helper ACEs, behavior-declared autocomplete, and a structured GDScript escape hatch.

✨ Editor & onboarding

• Godot 4.7 support (verified: full suite + in-editor smoke) and Modern-theme visuals.
• Theme-editor Quick Style — re-skin from a few colour pickers without learning every token.
• New platformer-shooter showcase (Platformer + Weapon Kit together).

🔧 Tooling

• An optional scripting & automation API (the pure-GDScript MCP server) lets external tools or AI assistants list/read/compile/lint sheets and apply snippets — opt-in and toggleable live in View ▸ MCP Server (off by default). It can also turn a plain-English description into editable events.

Compatibility covenant: generated code never depends on the plugin; templates bake at apply (updates never rewrite your sheets); output is performance-identical to hand-written GDScript. Quality: 2,198 test assertions, all green; Project Doctor drift gate clean. Full notes in CHANGELOG.md.

Godot EventSheets 0.7.0

Full Changelog: v0.6.2...v0.7.0

Godot EventSheets 0.6.2

Full Changelog: v0.6.1...v0.6.2

Godot EventSheets 0.6.1

Full Changelog: v0.6.0...v0.6.1