castle-web-cli 0.4.95 → 0.4.97

package/dist/agent.js

@@ -24,7 +24,7 @@ import { rawDataToString } from "./ide.js";
 import { buildRouterPrompt, buildTaskPrompt, userTurnInstruction, CLAUDE_TASK_SYSTEM_REMINDER, } from "./agent-prompts.js";
 import { checkOpenrouterKey, checkOpenrouterModel, openrouterCatalogEntry, primeOpenrouterCatalog, } from "./openrouter-catalog.js";
 import { classifyProviderError, failureCopy, } from "./agent-failures.js";
-import { meteringHeaders, newAgentSessionId, withCustomHeaders, } from "./metering.js";
+import { meteringHeaders, newAgentSessionId, reportCursorRun, withCustomHeaders, } from "./metering.js";
 import { runAgentNative } from "./native/loop.js";
 import { createPlaytestBrowserManager } from "./native/playtest-browser.js";
 import { createPlaywrightPlaytestExecutor } from "./native/playtest-executor.js";
@@ -356,6 +356,9 @@ function handleModelCaps(req, res) {
 // Single `=` token because --allowedTools is variadic and would otherwise
 // swallow the trailing prompt positional.
 const OPENROUTER_ALLOWED_TOOLS = "--allowedTools=Edit,Write,NotebookEdit,Bash";
+// Cursor's proprietary model. Also the slug reported to the metering ledger, so
+// the two can never drift into disagreeing about what a cursor row ran on.
+const CURSOR_MODEL = "composer-2.5-fast";
 function buildAgentInvocation(backend, role, prompt, claudeModel, 
 // Already resolved for this role by the caller (router turns pass
 // settings.routerOpenrouterModel, task spawns settings.tasksOpenrouterModel).
@@ -426,7 +429,7 @@ metering) {
             "--stream-partial-output",
             "--trust",
             "--model",
-            "composer-2.5-fast",
+            CURSOR_MODEL,
             ...(role === "router" ? ["--mode", "ask"] : ["--force"]),
             prompt,
         ],
@@ -1226,67 +1229,6 @@ function logAgentUsage(label, backend, usage) {
     const output = formatTokenCount(usage.output_tokens);
     console.error(`[agent usage] ${label} ${backend}: input=${input} cache_read=${read} cache_created=${created} output=${output}`);
 }
-// Per-deck machine-readable usage ledger, appended to <deckDir>/.castle/agent/,
-// harvested out-of-band (by the cloud launcher) for rough per-user token
-// metering. Distinct from logAgentUsage's stderr line, which is lossy
-// (rounds to "3.2k") and gets truncated when the serve restarts.
-const USAGE_LEDGER_FILE = "usage.jsonl";
-// The ledger is only useful where the cloud launcher harvests it, so the managed
-// sandbox environments set CASTLE_USAGE_LEDGER=1 (E2B via cloudSandbox.serveOnPort,
-// castle-sandboxes via its image). A local `castle-web serve` leaves it unset, so
-// dev deck dirs don't accumulate a ledger nothing reads.
-const USAGE_LEDGER_ENABLED = process.env.CASTLE_USAGE_LEDGER === "1";
-// Concrete model behind a finished run: smith and claude-via-OpenRouter both
-// bill the OpenRouter slug; plain claude bills its own slug; cursor has no
-// per-model split tracked here.
-function resolveRunModel(backend, claudeModel, openrouterModel) {
-    if (backend === "smith")
-        return openrouterModel;
-    if (backend === "claude") {
-        return claudeModel === "openrouter" ? openrouterModel : claudeModel;
-    }
-    return backend;
-}
-// One record per finished run: the human-readable stderr line PLUS a precise
-// append-only JSONL line in the deck's usage ledger. Precise counts (not the
-// stderr line's rounded values) and self-describing (id/role/backend/model) so
-// the harvester can attribute and de-dup. Best-effort: a metering write must
-// never fail an agent run.
-function reportRunUsage(agentDir, role, backend, claudeModel, openrouterModel, result, taskId) {
-    const usage = result.usage;
-    logAgentUsage(taskId ? `task ${taskId}` : "router", backend, usage);
-    if (!USAGE_LEDGER_ENABLED)
-        return;
-    // cursor-agent's stream-json doesn't report token usage, so a cursor run has no
-    // `usage`; still record it (zero counts, tokens_reported:false) for run-count
-    // visibility. Other backends only write once they actually produced usage.
-    if (!usage && backend !== "cursor")
-        return;
-    try {
-        const line = JSON.stringify({
-            at: nowIso(),
-            id: nanoid(),
-            role,
-            backend,
-            model: resolveRunModel(backend, claudeModel, openrouterModel),
-            ...(taskId ? { taskId } : {}),
-            // A failed run still resolves with a usage object of all zeros (an auth
-            // error emits a result event with zeroed counts), so its zeros would
-            // otherwise be indistinguishable downstream from a real "measured zero".
-            ...(result.ok ? {} : { failed: true }),
-            tokens_reported: usage !== undefined,
-            input_tokens: usage?.input_tokens ?? 0,
-            output_tokens: usage?.output_tokens ?? 0,
-            cache_read_input_tokens: usage?.cache_read_input_tokens ?? 0,
-            cache_creation_input_tokens: usage?.cache_creation_input_tokens ?? 0,
-        });
-        fs.mkdirSync(agentDir, { recursive: true });
-        fs.appendFileSync(path.join(agentDir, USAGE_LEDGER_FILE), line + "\n");
-    }
-    catch {
-        /* best-effort: a metering write must never fail an agent run */
-    }
-}
 // Build the per-run stdout event handler over a shared mutable parser state.
 // Splitting the cursor + claude stream decoding out of runAgentCli keeps each
 // within the max-lines budget; behavior is identical (same delta/activity/
@@ -1735,7 +1677,8 @@ async function runAgentTurn(opts) {
         });
     }
     const invocation = buildAgentInvocation(opts.backend, opts.role, opts.prompt, opts.claudeModel, opts.openrouterModel, { sessionId, deckDir: opts.cwd });
-    return runAgentCli({
+    const startedMs = Date.now();
+    const run = runAgentCli({
         cwd: opts.cwd,
         command: invocation.command,
         args: invocation.args,
@@ -1753,6 +1696,21 @@ async function runAgentTurn(opts) {
             ? opts.openrouterModel
             : undefined,
     });
+    // Cursor is the only backend whose traffic never reaches the llm-proxy, so its
+    // run is reported from here. Every other backend is already recorded upstream,
+    // and reporting them here too would double-count them in the same table.
+    if (opts.backend !== "cursor")
+        return run;
+    return run.then((result) => {
+        reportCursorRun({
+            deckDir: opts.cwd,
+            sessionId,
+            model: CURSOR_MODEL,
+            durationMs: Date.now() - startedMs,
+            ok: result.ok,
+        });
+        return result;
+    });
 }
 // -- task store ---------------------------------------------------------------
 function persistTaskFile(tasksDir, task) {
@@ -1999,7 +1957,7 @@ async function runTaskAgentIn(ctx, task) {
                     ctx.onFeed(`[${activity}]`);
             },
         });
-        reportRunUsage(path.dirname(ctx.tasksDir), "task", ctx.backend, ctx.claudeModel, ctx.openrouterModel, result, task.id);
+        logAgentUsage(`task ${task.id}`, ctx.backend, result.usage);
         if (ctx.stopRequested.has(task.id))
             return result;
         if (!result.crashed)
@@ -2794,7 +2752,7 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
         },
     })
         .then((result) => {
-        reportRunUsage(ctx.agentDir, "router", backend, ctx.claudeModel(), ctx.openrouterModel(), result);
+        logAgentUsage("router", backend, result.usage);
         // Signals the finally -> onSettled(retryable): the turn failed cleanly
         // enough (transient, nothing salvaged) that the queue may re-run it.
         let retryable = false;

package/dist/init.js

@@ -145,6 +145,23 @@ function tryMakeAgentsSymlink(agentsPath) {
         // symlink already exists / unsupported FS — non-fatal
     }
 }
+// Scripts for a deck whose kit is an import. The same deck commands every
+// scaffold gets, plus the kit's own authoring commands re-pointed at where the
+// kit now lives -- a kit's CLAUDE.md tells the agent to run `npm run draw` and
+// `npm run restart`, and those have to exist in the deck for that to be true.
+function makeKitDeckScripts(kitDir, alias, cliCommand) {
+    const scripts = {
+        restart: `${cliCommand} restart .`,
+        screenshot: `${cliCommand} screenshot .`,
+        "save-deck": `${cliCommand} save-deck .`,
+    };
+    // `draw` is a kit script, not a CLI one, so it only exists if this kit ships
+    // it -- and it runs from the deck root, where the sprites belong.
+    if (fs.existsSync(path.join(kitDir, "scripts", "draw.mjs"))) {
+        scripts.draw = `node ${IMPORTS_DIR}/${alias}/scripts/draw.mjs`;
+    }
+    return scripts;
+}
 function makePackageJson(projectDir) {
     const { sdkRef, cliCommand } = resolveScaffoldRefs();
     return {
@@ -291,6 +308,23 @@ something in the kit behaves, define your own behavior of the same name in
 \`behaviors/\` -- the deck's own files win over an import's.
 `;
 }
+// How the deck names the kit it was built on. `scripts/publish-kits.mjs` stamps
+// a published kit's castle.json with the deckId it lives at and the version it
+// was published as, and both have to be present to pin it that way: a deckId
+// with no version would read as "you have some unknown version", which the
+// update check would report as an update available forever.
+//
+// Falling back to the CLI's copy is what makes a kit usable before it is ever
+// published -- a new kit works from the day it exists, and starts offering
+// updates the day it is published, with nothing in between to migrate.
+function makeKitPin(kitConfig, kit) {
+    const deckId = kitConfig.deckId;
+    const version = kitConfig.publishedVersion;
+    if (typeof deckId === "string" && typeof version === "string") {
+        return { deckId, version };
+    }
+    return { source: "builtin", kit, version: getCliVersion() };
+}
 // Scaffold a deck that IMPORTS its kit instead of copying it. The kit's files
 // land in `imports/<kit>/` (read-only, like any dependency) and the deck itself
 // holds only what is genuinely its own: an entry point, its config, and its
@@ -298,10 +332,11 @@ something in the kit behaves, define your own behavior of the same name in
 // rather than being frozen into the deck at scaffold time -- which is what
 // copying the kit in meant.
 //
-// The kit comes from the copy shipped with this CLI, so `init` works offline and
-// needs no account. The pin records that origin; once kits are published as
-// decks it becomes a deckId + version and the files are fetched instead, with
-// the same deck shape either way.
+// The files always come from the copy shipped with this CLI, so `init` works
+// offline and needs no account. What the pin SAYS depends on whether the kit has
+// been published: an unpublished one can only be named as the CLI's own copy,
+// while a published one is pinned by deckId so the deck can be told about kit
+// releases and take them, without waiting for a CLI release.
 function scaffoldFromKitImport(kit, projectDir) {
     const kitDir = requireKitDir(kit);
     // Qualified like any other import (`<author>.<deck>`), and qualified NOW even
@@ -326,12 +361,12 @@ function scaffoldFromKitImport(kit, projectDir) {
     // the import pin.
     writeJsonFile(path.join(projectDir, "castle.json"), {
         ...(kitConfig.editor ? { editor: kitConfig.editor } : {}),
-        imports: { [alias]: { source: "builtin", kit, version: getCliVersion() } },
+        imports: { [alias]: makeKitPin(kitConfig, kit) },
     });
     // The kit's code runs from THIS deck's node_modules, so its dependencies are
     // declared here (see syncImportDependencies, which does the same for imports
     // added later).
-    const { sdkRef } = resolveScaffoldRefs();
+    const { sdkRef, cliCommand } = resolveScaffoldRefs();
     const dependencies = {};
     for (const [name, range] of Object.entries(kitPkg.dependencies ?? {})) {
         dependencies[name] =
@@ -343,6 +378,7 @@ function scaffoldFromKitImport(kit, projectDir) {
         name: path.basename(projectDir),
         private: true,
         type: "module",
+        scripts: makeKitDeckScripts(kitDir, alias, cliCommand),
         dependencies,
     });
     fs.writeFileSync(path.join(projectDir, "CLAUDE.md"), makeImportedKitClaudeMd(alias));

package/dist/metering.d.ts

@@ -7,6 +7,29 @@ export type MeteringRoute = "anthropic" | "openrouter";
  * background-task spend" a prefix match with no extra column.
  */
 export declare function newAgentSessionId(role: "router" | "task"): string;
+/**
+ * Report a cursor run to the llm-proxy, which stamps the user + sandbox from
+ * our token and forwards it to the ledger alongside the anthropic/openrouter
+ * rows the proxy records itself.
+ *
+ * Cursor needs this because it is the one backend the proxy cannot see:
+ * cursor-agent has no base-URL override, so it talks to Cursor directly on its
+ * own key. There are no token counts to send -- cursor-agent's stream-json
+ * reports none -- so a row is a run count with its deck, agent run, model, and
+ * outcome, and the ledger's NULL tokens read as "not measured".
+ *
+ * Fire-and-forget by contract: the run is already over and its output already
+ * reached the user, so every failure here is swallowed. A dropped post loses
+ * one row rather than retrying, which is the right trade for a signal whose
+ * value is aggregate.
+ */
+export declare function reportCursorRun(opts: {
+    deckDir: string;
+    sessionId: string;
+    model: string;
+    durationMs: number;
+    ok: boolean;
+}): void;
 export declare function meteringHeaders(opts: {
     deckDir: string;
     sessionId: string;

package/dist/metering.js

@@ -48,6 +48,58 @@ function deckIdFor(deckDir) {
         return null;
     return parsed.deckId.replace(/[\r\n]/g, "") || null;
 }
+// Path on the proxy that accepts a run the proxy never routed. Must match
+// CASTLE_USAGE_PATH in castle-sandboxes/shared/src/index.ts.
+const CASTLE_USAGE_PATH = "/castle/usage";
+// A metering post must never delay a turn that has already finished, and its
+// result is never awaited -- so a proxy that has gone away costs one socket
+// timeout in the background, not a hung run.
+const USAGE_POST_TIMEOUT_MS = 5_000;
+/**
+ * Report a cursor run to the llm-proxy, which stamps the user + sandbox from
+ * our token and forwards it to the ledger alongside the anthropic/openrouter
+ * rows the proxy records itself.
+ *
+ * Cursor needs this because it is the one backend the proxy cannot see:
+ * cursor-agent has no base-URL override, so it talks to Cursor directly on its
+ * own key. There are no token counts to send -- cursor-agent's stream-json
+ * reports none -- so a row is a run count with its deck, agent run, model, and
+ * outcome, and the ledger's NULL tokens read as "not measured".
+ *
+ * Fire-and-forget by contract: the run is already over and its output already
+ * reached the user, so every failure here is swallowed. A dropped post loses
+ * one row rather than retrying, which is the right trade for a signal whose
+ * value is aggregate.
+ */
+export function reportCursorRun(opts) {
+    const base = process.env.CASTLE_LLM_PROXY_URL;
+    const token = process.env.CASTLE_LLM_PROXY_TOKEN;
+    // Absent outside a sandbox, and on a host whose proxy predates this route --
+    // both cases correctly report nothing rather than posting into the void.
+    if (!base || !token)
+        return;
+    const deckId = deckIdFor(opts.deckDir);
+    void fetch(`${base}${CASTLE_USAGE_PATH}`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+            provider: "cursor",
+            model: opts.model,
+            ...(deckId ? { deckId } : {}),
+            agentSessionId: opts.sessionId,
+            durationMs: opts.durationMs,
+            // A cursor run has no HTTP status; the ledger's column is one, and
+            // `>= 400 means it failed` is the reading every other row already gets.
+            status: opts.ok ? 200 : 500,
+        }),
+        signal: AbortSignal.timeout(USAGE_POST_TIMEOUT_MS),
+    }).catch(() => {
+        /* best-effort: metering must never surface in a finished run */
+    });
+}
 export function meteringHeaders(opts) {
     if (opts.direct || !proxyInjected(opts.route))
         return {};

package/kits/basic-2d/castle.json

@@ -3,11 +3,30 @@
     "initialPanels": [
       {
         "width": 400,
-        "column": [{ "type": "playtest" }, { "type": "files" }]
+        "column": [
+          {
+            "type": "playtest"
+          },
+          {
+            "type": "files"
+          }
+        ]
       },
-      { "type": "editor", "file": "scenes/main.scene" }
+      {
+        "type": "editor",
+        "file": "scenes/main.scene"
+      }
     ],
     "hiddenPaths": [],
-    "visiblePaths": ["drawings/**", "scenes/**", "blueprints/**", "behaviors/**"]
-  }
+    "visiblePaths": [
+      "drawings/**",
+      "scenes/**",
+      "blueprints/**",
+      "behaviors/**"
+    ]
+  },
+  "deckId": "5R39TxaRfLLQ",
+  "cardId": "AZk0PWHTrFcT",
+  "title": "basic-2d",
+  "publishedVersion": "2026-07-28T17:52:37.298Z"
 }

package/kits/basic-2d/editors/behaviorRegistry.js

@@ -1,5 +1,5 @@
 // Discover every behavior class from `behaviors/*.jsx` and the physics module's
-// `physics/behaviors/*.jsx`. Vite HMR is off, so a newly-added behavior file is
+// `physics/behaviors/**/*.jsx`. Vite HMR is off, so a newly-added behavior file is
 // picked up on the next reload/restart. The physics glob is what lets the
 // self-contained physics module ship its behaviors without polluting the core
 // `behaviors/` folder — a kit adopts physics by copying `physics/` in.
@@ -8,10 +8,10 @@
 // own behaviors last: collectBehaviors keys by behaviorName, so a behavior the
 // deck defines wins over one of the same name from a dependency.
 const modules = {
-  ...import.meta.glob('/imports/*/behaviors/*.jsx', { eager: true }),
-  ...import.meta.glob('/imports/*/physics/behaviors/*.jsx', { eager: true }),
-  ...import.meta.glob('/behaviors/*.jsx', { eager: true }),
-  ...import.meta.glob('/physics/behaviors/*.jsx', { eager: true }),
+  ...import.meta.glob('/imports/*/behaviors/**/*.jsx', { eager: true }),
+  ...import.meta.glob('/imports/*/physics/behaviors/**/*.jsx', { eager: true }),
+  ...import.meta.glob('/behaviors/**/*.jsx', { eager: true }),
+  ...import.meta.glob('/physics/behaviors/**/*.jsx', { eager: true }),
 };
 function isBehaviorClass(value) {
   return typeof value === 'function' && typeof value.behaviorName === 'string';

package/kits/basic-2d/engine/behaviorExtensions.js

@@ -2,7 +2,7 @@
 // add fields to a behavior defined in the shared core WITHOUT editing that
 // behavior's file -- so the core behavior stays byte-identical across kits and
 // the module owns its own additions. Each extension module under any
-// `<module>/extensions/*.js` exports:
+// `<module>/extensions/**/*.js` exports:
 //
 //   export const behaviorExtension = {
 //     behaviorName: 'Collider',
@@ -16,8 +16,8 @@
 // basic-2d). Symmetric with engine/systemRegistry.js and editors/behaviorRegistry.js.
 // Root-anchored, deck + imports (see engine/files.js).
 const modules = {
-  ...import.meta.glob('/imports/*/*/extensions/*.js', { eager: true }),
-  ...import.meta.glob('/*/extensions/*.js', { eager: true }),
+  ...import.meta.glob('/imports/*/*/extensions/**/*.js', { eager: true }),
+  ...import.meta.glob('/*/extensions/**/*.js', { eager: true }),
 };
 const extensions = Object.values(modules)
   .map((mod) => mod.behaviorExtension)

package/kits/basic-2d/engine/files.js

@@ -8,20 +8,23 @@
 // The first glob adds every import's content, keyed by its full path
 // (`imports/<alias>/drawings/rock.pxart`) -- which is exactly how a scene or
 // blueprint refers to a dependency's file, so no lookup elsewhere changes.
+// Recursive (`**`), because the files panel shows these folders recursively and
+// so lets you organize inside them -- a flat `drawings/*.pxart` meant art moved
+// into a subfolder vanished from the map, and so from the editor and the game.
 // (Patterns and options must be literals: import.meta.glob is a compile-time
 // transform, so these can't be hoisted into shared constants.)
 const rawModules = {
   ...import.meta.glob(
     [
-      '/imports/*/scenes/*.scene',
-      '/imports/*/blueprints/*.scene',
-      '/imports/*/drawings/*.pxart',
-      '/imports/*/behaviors/*.jsx',
+      '/imports/*/scenes/**/*.scene',
+      '/imports/*/blueprints/**/*.scene',
+      '/imports/*/drawings/**/*.pxart',
+      '/imports/*/behaviors/**/*.jsx',
     ],
     { query: '?raw', import: 'default', eager: true }
   ),
   ...import.meta.glob(
-    ['/scenes/*.scene', '/blueprints/*.scene', '/drawings/*.pxart', '/behaviors/*.jsx'],
+    ['/scenes/**/*.scene', '/blueprints/**/*.scene', '/drawings/**/*.pxart', '/behaviors/**/*.jsx'],
     { query: '?raw', import: 'default', eager: true }
   ),
 };

package/kits/basic-2d/engine/systemRegistry.js

@@ -8,8 +8,8 @@
 // with editors/behaviorRegistry.js.
 // Root-anchored, deck + imports (see engine/files.js).
 const modules = {
-  ...import.meta.glob('/imports/*/systems/*.js', { eager: true }),
-  ...import.meta.glob('/systems/*.js', { eager: true }),
+  ...import.meta.glob('/imports/*/systems/**/*.js', { eager: true }),
+  ...import.meta.glob('/systems/**/*.js', { eager: true }),
 };
 export const systemInstallers = Object.values(modules)
   .map((mod) => mod.installSystem)

package/kits/physics-2d/castle.json

@@ -3,11 +3,30 @@
     "initialPanels": [
       {
         "width": 400,
-        "column": [{ "type": "playtest" }, { "type": "files" }]
+        "column": [
+          {
+            "type": "playtest"
+          },
+          {
+            "type": "files"
+          }
+        ]
       },
-      { "type": "editor", "file": "scenes/main.scene" }
+      {
+        "type": "editor",
+        "file": "scenes/main.scene"
+      }
     ],
     "hiddenPaths": [],
-    "visiblePaths": ["drawings/**", "scenes/**", "blueprints/**", "behaviors/**"]
-  }
+    "visiblePaths": [
+      "drawings/**",
+      "scenes/**",
+      "blueprints/**",
+      "behaviors/**"
+    ]
+  },
+  "deckId": "ckRZGFW4iPrx",
+  "cardId": "_oBFbAW6DxsO",
+  "title": "physics-2d",
+  "publishedVersion": "2026-07-28T17:50:39.741Z"
 }

package/kits/physics-2d/editors/behaviorRegistry.js

@@ -1,5 +1,5 @@
 // Discover every behavior class from `behaviors/*.jsx` and the physics module's
-// `physics/behaviors/*.jsx`. Vite HMR is off, so a newly-added behavior file is
+// `physics/behaviors/**/*.jsx`. Vite HMR is off, so a newly-added behavior file is
 // picked up on the next reload/restart. The physics glob is what lets the
 // self-contained physics module ship its behaviors without polluting the core
 // `behaviors/` folder — a kit adopts physics by copying `physics/` in.
@@ -8,10 +8,10 @@
 // own behaviors last: collectBehaviors keys by behaviorName, so a behavior the
 // deck defines wins over one of the same name from a dependency.
 const modules = {
-  ...import.meta.glob('/imports/*/behaviors/*.jsx', { eager: true }),
-  ...import.meta.glob('/imports/*/physics/behaviors/*.jsx', { eager: true }),
-  ...import.meta.glob('/behaviors/*.jsx', { eager: true }),
-  ...import.meta.glob('/physics/behaviors/*.jsx', { eager: true }),
+  ...import.meta.glob('/imports/*/behaviors/**/*.jsx', { eager: true }),
+  ...import.meta.glob('/imports/*/physics/behaviors/**/*.jsx', { eager: true }),
+  ...import.meta.glob('/behaviors/**/*.jsx', { eager: true }),
+  ...import.meta.glob('/physics/behaviors/**/*.jsx', { eager: true }),
 };
 function isBehaviorClass(value) {
   return typeof value === 'function' && typeof value.behaviorName === 'string';

package/kits/physics-2d/engine/files.js

@@ -8,20 +8,23 @@
 // The first glob adds every import's content, keyed by its full path
 // (`imports/<alias>/drawings/rock.pxart`) -- which is exactly how a scene or
 // blueprint refers to a dependency's file, so no lookup elsewhere changes.
+// Recursive (`**`), because the files panel shows these folders recursively and
+// so lets you organize inside them -- a flat `drawings/*.pxart` meant art moved
+// into a subfolder vanished from the map, and so from the editor and the game.
 // (Patterns and options must be literals: import.meta.glob is a compile-time
 // transform, so these can't be hoisted into shared constants.)
 const rawModules = {
   ...import.meta.glob(
     [
-      '/imports/*/scenes/*.scene',
-      '/imports/*/blueprints/*.scene',
-      '/imports/*/drawings/*.pxart',
-      '/imports/*/behaviors/*.jsx',
+      '/imports/*/scenes/**/*.scene',
+      '/imports/*/blueprints/**/*.scene',
+      '/imports/*/drawings/**/*.pxart',
+      '/imports/*/behaviors/**/*.jsx',
     ],
     { query: '?raw', import: 'default', eager: true }
   ),
   ...import.meta.glob(
-    ['/scenes/*.scene', '/blueprints/*.scene', '/drawings/*.pxart', '/behaviors/*.jsx'],
+    ['/scenes/**/*.scene', '/blueprints/**/*.scene', '/drawings/**/*.pxart', '/behaviors/**/*.jsx'],
     { query: '?raw', import: 'default', eager: true }
   ),
 };

package/kits/physics-2d/engine/systemRegistry.js

@@ -8,8 +8,8 @@
 // with editors/behaviorRegistry.js.
 // Root-anchored, deck + imports (see engine/files.js).
 const modules = {
-  ...import.meta.glob('/imports/*/systems/*.js', { eager: true }),
-  ...import.meta.glob('/systems/*.js', { eager: true }),
+  ...import.meta.glob('/imports/*/systems/**/*.js', { eager: true }),
+  ...import.meta.glob('/systems/**/*.js', { eager: true }),
 };
 export const systemInstallers = Object.values(modules)
   .map((mod) => mod.installSystem)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castle-web-cli",
-  "version": "0.4.95",
+  "version": "0.4.97",
   "type": "module",
   "bin": {
     "castle-web": "./dist/index.js"