@bitmagic/world-forger 0.1.0

package/dist/pipeline/starter-scatter.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The starter template's scattered trees/rocks a forged level orphans, and the
+ * plan for stripping them.
+ *
+ * Moved here from game-play-agent's `utils/voxel-default-assets.ts` — which
+ * MINTS these ids and now re-exports this planner — because the world-forger's
+ * persist step is its only caller and that step no longer lives in
+ * game-play-agent. The generator and the matcher still share one definition of
+ * the id shapes; they are just imported across the seam instead of adjacent.
+ */
+/** Ids of the starter scatter to strip from a world.json. */
+export interface StarterScatterRemoval {
+    /** `assets[].id` values to drop. */
+    assetIds: string[];
+    /** `environmentObjects[].id` values to drop. */
+    objectIds: string[];
+}
+/**
+ * Work out which starter trees/rocks a world.json still carries from its template.
+ *
+ * Every voxel starter template ships the six default tree/rock assets, and two of them
+ * (standard-3d, first-person) also ship 23 scattered instances — that's the scene in the
+ * template screenshot. When the World-Forger bakes a real level it *replaces* the template's
+ * terrain but only upserts its own assets/instances, so the starter scatter survives: the
+ * trees get re-snapped onto the forged terrain (they're `placeOnTerrain`) somewhere off in
+ * the origin corner, and the six assets stay in the library where the creator's Remove button
+ * is hidden for anything still referenced by an instance.
+ *
+ * Only exact id matches on BOTH the instance id and its assetId count as starter scatter, so
+ * anything the AI later placed from these assets is left alone; an asset is dropped only once
+ * nothing else references it.
+ */
+export declare function planStarterScatterRemoval(worldData: Record<string, unknown> | null | undefined): StarterScatterRemoval;
+//# sourceMappingURL=starter-scatter.d.ts.map

package/dist/pipeline/starter-scatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starter-scatter.d.ts","sourceRoot":"","sources":["../../src/pipeline/starter-scatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,6DAA6D;AAC7D,MAAM,WAAW,qBAAqB;IACpC,oCAAoC;IACpC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,gDAAgD;IAChD,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GACpD,qBAAqB,CA0BvB"}

package/dist/pipeline/starter-scatter.js

@@ -0,0 +1,49 @@
+/**
+ * The starter template's scattered trees/rocks a forged level orphans, and the
+ * plan for stripping them.
+ *
+ * Moved here from game-play-agent's `utils/voxel-default-assets.ts` — which
+ * MINTS these ids and now re-exports this planner — because the world-forger's
+ * persist step is its only caller and that step no longer lives in
+ * game-play-agent. The generator and the matcher still share one definition of
+ * the id shapes; they are just imported across the seam instead of adjacent.
+ */
+/** Asset ids minted by the default-asset generator (and hardcoded in the starter templates' world.json). */
+const STARTER_ASSET_ID_RE = /^default-(tree|rock)-\d+$/;
+/** Instance ids minted by `generateObjectId` (and hardcoded in the starter templates). */
+const STARTER_OBJECT_ID_RE = /^default_(tree|rock)_\d+$/;
+/**
+ * Work out which starter trees/rocks a world.json still carries from its template.
+ *
+ * Every voxel starter template ships the six default tree/rock assets, and two of them
+ * (standard-3d, first-person) also ship 23 scattered instances — that's the scene in the
+ * template screenshot. When the World-Forger bakes a real level it *replaces* the template's
+ * terrain but only upserts its own assets/instances, so the starter scatter survives: the
+ * trees get re-snapped onto the forged terrain (they're `placeOnTerrain`) somewhere off in
+ * the origin corner, and the six assets stay in the library where the creator's Remove button
+ * is hidden for anything still referenced by an instance.
+ *
+ * Only exact id matches on BOTH the instance id and its assetId count as starter scatter, so
+ * anything the AI later placed from these assets is left alone; an asset is dropped only once
+ * nothing else references it.
+ */
+export function planStarterScatterRemoval(worldData) {
+    const empty = { assetIds: [], objectIds: [] };
+    if (!worldData)
+        return empty;
+    const assets = Array.isArray(worldData.assets) ? worldData.assets : [];
+    const environmentObjects = Array.isArray(worldData.environmentObjects) ? worldData.environmentObjects : [];
+    const idOf = (item, key) => String(item?.[key] ?? '');
+    const objectIds = environmentObjects
+        .filter((obj) => STARTER_OBJECT_ID_RE.test(idOf(obj, 'id')) && STARTER_ASSET_ID_RE.test(idOf(obj, 'assetId')))
+        .map((obj) => idOf(obj, 'id'));
+    const removedObjectIds = new Set(objectIds);
+    const stillReferenced = new Set(environmentObjects
+        .filter((obj) => !removedObjectIds.has(idOf(obj, 'id')))
+        .map((obj) => idOf(obj, 'assetId')));
+    const assetIds = assets
+        .map((asset) => idOf(asset, 'id'))
+        .filter((id) => STARTER_ASSET_ID_RE.test(id) && !stillReferenced.has(id));
+    return { assetIds, objectIds };
+}
+//# sourceMappingURL=starter-scatter.js.map

package/dist/pipeline/starter-scatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"starter-scatter.js","sourceRoot":"","sources":["../../src/pipeline/starter-scatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,4GAA4G;AAC5G,MAAM,mBAAmB,GAAG,2BAA2B,CAAC;AACxD,0FAA0F;AAC1F,MAAM,oBAAoB,GAAG,2BAA2B,CAAC;AAUzD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,yBAAyB,CACvC,SAAqD;IAErD,MAAM,KAAK,GAA0B,EAAE,QAAQ,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;IACrE,IAAI,CAAC,SAAS;QAAE,OAAO,KAAK,CAAC;IAE7B,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IACvE,MAAM,kBAAkB,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,CAAC;IAE3G,MAAM,IAAI,GAAG,CAAC,IAAa,EAAE,GAAqB,EAAU,EAAE,CAC5D,MAAM,CAAE,IAAuC,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;IAEhE,MAAM,SAAS,GAAG,kBAAkB;SACjC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC;SAC7G,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;IAEjC,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;IAC5C,MAAM,eAAe,GAAG,IAAI,GAAG,CAC7B,kBAAkB;SACf,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;SACvD,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CACtC,CAAC;IAEF,MAAM,QAAQ,GAAG,MAAM;SACpB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;SACjC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAE5E,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;AACjC,CAAC"}

package/dist/pipeline/storage-types.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The storage seam — deliberately a NARROW structural subset of the host's
+ * real `StorageClient`/`StorageEnv` (game-play-agent's
+ * `src/mastra/storage/StorageClient.ts` / `storage-env.ts`), field-for-field
+ * on the methods this package actually calls. Because TypeScript interfaces
+ * are structural, the host's real S3/GCS/local client satisfies this without
+ * any adapter — `getStorageEnv()` can be passed straight through as
+ * `ForgeDeps.storage`.
+ *
+ * Bytes are `Uint8Array`, not node's `Buffer`. `Buffer` would be correct for
+ * every host today, but it is a NODE type: putting it in this published
+ * package's type surface forces every consumer to install `@types/node` or
+ * type-check with `skipLibCheck`, and a consumer without either gets
+ * `Cannot find name 'Buffer'` from a .d.ts they never wrote. `Buffer` extends
+ * `Uint8Array`, so a host whose real client takes and returns Buffers still
+ * satisfies this unchanged.
+ */
+export interface ForgePutObjectParams {
+    bucket: string;
+    key: string;
+    body: string | Uint8Array;
+    contentType: string;
+    cacheControl: string;
+    contentEncoding?: string;
+}
+export interface ForgeHeadObjectParams {
+    bucket: string;
+    key: string;
+}
+export interface ForgeGetObjectParams {
+    bucket: string;
+    key: string;
+}
+export interface ForgeStorageClient {
+    /** Returns the number of bytes actually written (the host may compress). */
+    putObject(params: ForgePutObjectParams): Promise<number>;
+    headObject(params: ForgeHeadObjectParams): Promise<boolean>;
+    getObject(params: ForgeGetObjectParams): Promise<Uint8Array | null>;
+}
+/** `createForgedWorkStore(jobId, env)` already takes this shape as a parameter
+ *  (see forged-work-store.ts) — this is that SAME seam, not a new one. */
+export interface ForgeStorageEnv {
+    storageClient: ForgeStorageClient;
+    bucket: string;
+    /** Public URL prefix (CDN, or file://) the uploaded key is appended to. */
+    publicUrl: string;
+}
+//# sourceMappingURL=storage-types.d.ts.map

package/dist/pipeline/storage-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-types.d.ts","sourceRoot":"","sources":["../../src/pipeline/storage-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,4EAA4E;IAC5E,SAAS,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACzD,UAAU,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5D,SAAS,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;CACrE;AAED;0EAC0E;AAC1E,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,kBAAkB,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/pipeline/storage-types.js

@@ -0,0 +1,19 @@
+/**
+ * The storage seam — deliberately a NARROW structural subset of the host's
+ * real `StorageClient`/`StorageEnv` (game-play-agent's
+ * `src/mastra/storage/StorageClient.ts` / `storage-env.ts`), field-for-field
+ * on the methods this package actually calls. Because TypeScript interfaces
+ * are structural, the host's real S3/GCS/local client satisfies this without
+ * any adapter — `getStorageEnv()` can be passed straight through as
+ * `ForgeDeps.storage`.
+ *
+ * Bytes are `Uint8Array`, not node's `Buffer`. `Buffer` would be correct for
+ * every host today, but it is a NODE type: putting it in this published
+ * package's type surface forces every consumer to install `@types/node` or
+ * type-check with `skipLibCheck`, and a consumer without either gets
+ * `Cannot find name 'Buffer'` from a .d.ts they never wrote. `Buffer` extends
+ * `Uint8Array`, so a host whose real client takes and returns Buffers still
+ * satisfies this unchanged.
+ */
+export {};
+//# sourceMappingURL=storage-types.js.map

package/dist/pipeline/storage-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-types.js","sourceRoot":"","sources":["../../src/pipeline/storage-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG"}

package/dist/pipeline/transport-types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The transport seam — replaces game-play-agent's `sendAndWaitForResult`
+ * (`utils/voxel-ws.ts`). One method: send a command, await a typed result.
+ *
+ * Not read by steps 1-2 (design/forge+upload), which is why api-server's host
+ * passes a throwing stub. Its three consumers are the browser-driven steps in
+ * this package: `create-level-archetypes.ts`, `voxelize-level.ts` and
+ * `place-and-persist-level.ts`. The web lane wires a real WebSocket
+ * implementation (`game-play-agent`'s `transport-client.ts`); the CLI lane
+ * wires one over a headless-Chrome page bridge (`cli/src/forge/transport.ts`).
+ */
+export interface ForgeTransportOptions {
+    /** Default 3 (matches the web lane's WS retry policy). Pass 1 for
+     *  expensive, non-idempotent work (a level bake) where a timed-out attempt
+     *  must not be silently re-fired. */
+    maxRetries?: number;
+    /**
+     * When set, `timeoutMs` becomes an IDLE timeout: a message of this type
+     * (matching the command's requestId, when present) RE-ARMS the timer
+     * instead of counting toward it, so a long-but-active job (a chunk-by-chunk
+     * level bake that can legitimately run many minutes) is not killed
+     * mid-flight — only genuine silence for `timeoutMs` fails the attempt.
+     */
+    progressType?: string;
+}
+export interface ForgeTransport {
+    /**
+     * Send `command` and await the first message of type `resultType` (matched
+     * on `requestId` when the command carries one). Resolves `null` on timeout
+     * or transport failure — never rejects for that case, so callers can tell
+     * "no answer" apart from "answered with an error".
+     */
+    sendAndWait(command: Record<string, unknown>, resultType: string, timeoutMs: number, options?: ForgeTransportOptions): Promise<Record<string, unknown> | null>;
+}
+//# sourceMappingURL=transport-types.d.ts.map

package/dist/pipeline/transport-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-types.d.ts","sourceRoot":"","sources":["../../src/pipeline/transport-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,WAAW,qBAAqB;IACpC;;yCAEqC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,WAAW,CACT,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;CAC5C"}

package/dist/pipeline/transport-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transport-types.js.map

package/dist/pipeline/transport-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-types.js","sourceRoot":"","sources":["../../src/pipeline/transport-types.ts"],"names":[],"mappings":""}

package/dist/pipeline/voxelize-level.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Step 4 — bake the level in the browser through the host's transport seam.
+ *
+ * Moved from game-play-agent's `pipeline.ts` verbatim, with the one
+ * `sendAndWaitForResult` call site turned into `deps.transport.sendAndWait`
+ * (same timeout, same `{ maxRetries: 1, progressType }` policy) and the logger
+ * turned into `deps.logger`.
+ */
+import type { ForgedWorkStore } from './forged-work-store.js';
+import type { ForgeDeps } from './deps.js';
+/**
+ * Idle timeout for the level bake: it runs chunk-by-chunk in the browser and
+ * emits VOXELIZE_GLB_AS_LEVEL_PROGRESS per chunk, each of which re-arms this
+ * timer (see the transport seam's `progressType`). So a slow-but-active bake is
+ * never killed mid-flight — only ~20 min of true silence (browser closed, tab
+ * frozen) fails the attempt.
+ */
+export declare const VOXELIZE_TIMEOUT_MS: number;
+/**
+ * Bake the level. Tagged instance groups are skipped (objectAssetInstances).
+ * Single attempt: a timed-out bake must not be silently re-run.
+ */
+export declare function voxelizeLevel(store: ForgedWorkStore, deps: ForgeDeps): Promise<void>;
+//# sourceMappingURL=voxelize-level.d.ts.map

package/dist/pipeline/voxelize-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voxelize-level.d.ts","sourceRoot":"","sources":["../../src/pipeline/voxelize-level.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAM3C;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,QAAiB,CAAC;AAIlD;;;GAGG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAyD1F"}

package/dist/pipeline/voxelize-level.js

@@ -0,0 +1,63 @@
+import { requireArtifact } from './artifact-store.js';
+import { ForgeStepError } from './errors.js';
+import { forgeRequestId } from './request-id.js';
+/**
+ * Idle timeout for the level bake: it runs chunk-by-chunk in the browser and
+ * emits VOXELIZE_GLB_AS_LEVEL_PROGRESS per chunk, each of which re-arms this
+ * timer (see the transport seam's `progressType`). So a slow-but-active bake is
+ * never killed mid-flight — only ~20 min of true silence (browser closed, tab
+ * frozen) fails the attempt.
+ */
+export const VOXELIZE_TIMEOUT_MS = 20 * 60 * 1000;
+/** Progress message the bake emits per chunk; resets the idle timeout above. */
+const VOXELIZE_PROGRESS_TYPE = 'VOXELIZE_GLB_AS_LEVEL_PROGRESS';
+/**
+ * Bake the level. Tagged instance groups are skipped (objectAssetInstances).
+ * Single attempt: a timed-out bake must not be silently re-run.
+ */
+export async function voxelizeLevel(store, deps) {
+    const input = await requireArtifact(store, 'input');
+    const forge = await requireArtifact(store, 'forge');
+    const requestId = forgeRequestId();
+    const result = await deps.transport.sendAndWait({
+        type: 'VOXELIZE_GLB_AS_LEVEL',
+        requestId,
+        glbUrl: forge.glbUrl,
+        levelName: input.name,
+        // Carries the dungeon's `emissiveByColor` map (deriveVoxelizeOptions put
+        // it there): the bake matches those authored colors against the palette
+        // it actually produces and writes the level's emissive block.
+        options: forge.voxelizeOptions,
+    }, 'VOXELIZE_GLB_AS_LEVEL_RESULT', VOXELIZE_TIMEOUT_MS, 
+    // Single attempt (a timed-out bake must not be silently re-fired), but the
+    // timeout is now idle-based: per-chunk progress re-arms it.
+    { maxRetries: 1, progressType: VOXELIZE_PROGRESS_TYPE });
+    if (!result) {
+        throw new ForgeStepError('Level voxelization timed out. The editor (browser) must be open for baking. The designed GLB was uploaded and can be voxelized manually from the Assets tab.', forge.glbUrl);
+    }
+    if (!result.success) {
+        throw new ForgeStepError(`Level voxelization failed: ${result.error || result.message || 'Unknown error'}`, forge.glbUrl);
+    }
+    // Authored emissive colors the bake's palette never produced: an advisory
+    // (the glow simply doesn't appear), never a failure.
+    const unmatched = result.emissiveUnmatched ?? [];
+    const notes = unmatched.length > 0
+        ? [`Emissive colors that matched no baked voxel: ${unmatched.join(', ')} — those surfaces do not glow`]
+        : [];
+    const bake = {
+        vwldUrl: result.vwldUrl,
+        bakedRecord: {
+            ...result.assetRecord,
+            // The navmesh sidecar was compiled against THIS bake's level transform,
+            // so it rides on the level asset the engine installs at level load.
+            ...(forge.navUrl ? { navUrl: forge.navUrl } : {}),
+        },
+        nonEmptyChunkCount: result.nonEmptyChunkCount,
+        totalLod0Leaves: result.totalLod0Leaves,
+        totalTrimeshTriangles: result.totalTrimeshTriangles,
+        ...(notes.length > 0 ? { notes } : {}),
+    };
+    await store.put('level-bake', bake);
+    deps.logger.info({ jobId: store.jobId, vwldUrl: bake.vwldUrl, chunks: bake.nonEmptyChunkCount, navUrl: forge.navUrl, unmatched }, 'Level baked');
+}
+//# sourceMappingURL=voxelize-level.js.map

package/dist/pipeline/voxelize-level.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"voxelize-level.js","sourceRoot":"","sources":["../../src/pipeline/voxelize-level.ts"],"names":[],"mappings":"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"}

package/dist/pipeline/world-json-source.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The world.json READ seam — the persist step (step 5) plans against the
+ * game's current world.json, but this package never opens a file. The host
+ * supplies the content; the host also applies the modifications the step
+ * returns (see `place-and-persist-level.ts`).
+ *
+ * ── Why TWO reads, and what each one actually wants ──────────────────────────
+ *
+ * game-play-agent's step 5 read TWO DIFFERENT files, and the difference is not
+ * cosmetic — so this seam preserves it rather than quietly picking one:
+ *
+ *   - the starter-scatter plan read the SESSION copy
+ *     (`readWorldData(runtimeContext)` → `tempGenrePath/world.json`, the file
+ *     the agent's writer also writes),
+ *   - the persist plan read the monorepo WORK copy
+ *     (`readWorkWorldJson()` → `game/src/work/world.json`, the copy the
+ *     creator/browser edits and that the session copy is copied wholesale OVER
+ *     at cleanup — a `copyFileSync` behind one "did temp go completely empty"
+ *     guard, not a merge, so whichever file a plan was computed against is the
+ *     one whose content ends up surviving).
+ *
+ * What each SHOULD want is the same thing: the file the returned modifications
+ * will be applied to. Both plans are differential — the scatter plan emits
+ * `removeRoot` predicates over ids it saw, the persist plan emits a whole-array
+ * `setRoot ['environmentObjects']` computed from the instances it saw plus a
+ * purge over the assets it saw — so planning against a file OTHER than the
+ * write target either drops work that is only in the target or writes back
+ * content the target had already removed.
+ *
+ * That is an argument about what the code should do, not a licence to change
+ * what it does: in game-play-agent's web lane the two files genuinely differ
+ * mid-session (the creator writes assets into the work copy while the agent
+ * writes the session copy), so collapsing them here would silently change which
+ * content survives a forge — outside the scope of this extraction, and exactly
+ * the kind of change that would only show up in a shipped level. So the seam
+ * keeps both reads, named for what they FEED rather than for which file they
+ * happen to hit, and the host decides:
+ *
+ *   - the web lane wires each to the exact file it reads today (no behaviour
+ *     change),
+ *   - a CLI project has exactly ONE world.json, so its adapter returns that
+ *     same file from both — which is what "plan against the write target"
+ *     means when there is only one target.
+ *
+ * Both reads DEGRADE deliberately and that degradation is part of the contract
+ * (see each method): a game with no world.json, or an unparseable one, must
+ * still be able to forge a level — the persist plan then simply plans against
+ * an empty world, and the scatter plan finds nothing to strip. Neither is a
+ * failure the user could act on, and both cost a paid 4-8 minute forge.
+ *
+ * Asynchronous on purpose: a host that keeps world.json in object storage (the
+ * CLI lane's api-server) must not be forced to pretend the read is local.
+ */
+import type { WorldJsonShape } from './world-json-types.js';
+export interface ForgeWorldJsonSource {
+    /**
+     * The world.json the persist plan is computed against — the level registry,
+     * the existing instances the level-scoped replace preserves, and the assets
+     * the placeholder purge considers.
+     *
+     * Returns `{}` when the game has no world.json or it cannot be parsed: every
+     * consumer downstream has a sane empty-world path (no levels registry, no
+     * instances to keep, nothing to purge), so an unreadable file costs the user
+     * nothing but a fresh start.
+     */
+    readForPersistPlan(): Promise<WorldJsonShape>;
+    /**
+     * The world.json the starter-scatter removal is planned against — the
+     * template's `default_tree_N` / `default-tree-N` instances and assets the
+     * forged level orphans.
+     *
+     * Returns `null` when unavailable: no read means no ids, which means no
+     * removals. Stripping nothing is always safe; the leftovers are cosmetic and
+     * removable in the creator afterwards.
+     */
+    readForStarterScatterPlan(): Promise<Record<string, unknown> | null>;
+}
+//# sourceMappingURL=world-json-source.d.ts.map

package/dist/pipeline/world-json-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-json-source.d.ts","sourceRoot":"","sources":["../../src/pipeline/world-json-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;OASG;IACH,kBAAkB,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC;IAE9C;;;;;;;;OAQG;IACH,yBAAyB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;CACtE"}

package/dist/pipeline/world-json-source.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=world-json-source.js.map

package/dist/pipeline/world-json-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-json-source.js","sourceRoot":"","sources":["../../src/pipeline/world-json-source.ts"],"names":[],"mappings":""}

package/dist/pipeline/world-json-types.d.ts

@@ -0,0 +1,104 @@
+/**
+ * The world.json shapes the persist step speaks — the MODIFICATION format it
+ * returns, and the minimal read shape it plans against.
+ *
+ * Types only, no runtime: this package never reads or writes world.json. The
+ * host owns the file (game-play-agent's `utils/world-json-editor.ts` applies
+ * these against the session's copy; a CLI lane applies them against the one
+ * file its project has) and re-exports {@link WorldJsonModification} from here
+ * so there is exactly one definition of the format on both sides of the seam.
+ *
+ * Moved verbatim from game-play-agent's `utils/world-json-editor.ts` (the
+ * modification union) and `utils/level-registry.ts` (the read shape).
+ */
+/** Base modification type for `worldProfileData` paths. */
+export interface BaseModification {
+    /** Path within worldProfileData to modify (e.g. `['skyboxUrl']` or `['animations']`). */
+    path: string[];
+}
+/** Set a single property value within worldProfileData. */
+export interface SetModification extends BaseModification {
+    type: 'set';
+    value: unknown;
+}
+/** Push a value to an array within worldProfileData (creates the array if absent). */
+export interface PushModification extends BaseModification {
+    type: 'push';
+    value: unknown;
+}
+/** Update an existing array item within worldProfileData. */
+export interface UpdateModification extends BaseModification {
+    type: 'update';
+    /** Predicate to find the item to update. */
+    predicate: (item: unknown) => boolean;
+    /** New value to replace the found item, or an updater function. */
+    value: unknown | ((item: unknown) => unknown);
+}
+/** Remove items from an array within worldProfileData. */
+export interface RemoveModification extends BaseModification {
+    type: 'remove';
+    /** Items matching this predicate are removed. */
+    predicate: (item: unknown) => boolean;
+}
+/** Upsert (update or insert) an array item within worldProfileData. */
+export interface UpsertModification extends BaseModification {
+    type: 'upsert';
+    predicate: (item: unknown) => boolean;
+    value: unknown;
+}
+/** Base modification type for root-level paths (not within worldProfileData). */
+export interface BaseRootModification {
+    /** Path from the JSON root (e.g. `['assets']`). */
+    path: string[];
+}
+/** Set a property at root level. */
+export interface SetRootModification extends BaseRootModification {
+    type: 'setRoot';
+    value: unknown;
+}
+/** Push to an array at root level. */
+export interface PushRootModification extends BaseRootModification {
+    type: 'pushRoot';
+    value: unknown;
+}
+/** Update an array item at root level. */
+export interface UpdateRootModification extends BaseRootModification {
+    type: 'updateRoot';
+    predicate: (item: unknown) => boolean;
+    value: unknown | ((item: unknown) => unknown);
+}
+/** Remove items from an array at root level. */
+export interface RemoveRootModification extends BaseRootModification {
+    type: 'removeRoot';
+    predicate: (item: unknown) => boolean;
+}
+/** Upsert (update or insert) an array item at root level. */
+export interface UpsertRootModification extends BaseRootModification {
+    type: 'upsertRoot';
+    predicate: (item: unknown) => boolean;
+    value: unknown;
+}
+export type WorldJsonModification = SetModification | PushModification | UpdateModification | RemoveModification | UpsertModification | SetRootModification | PushRootModification | UpdateRootModification | RemoveRootModification | UpsertRootModification;
+/** One entry of the multi-level registry (`worldProfileData.levels`). */
+export interface LevelEntry {
+    id: string;
+    name: string;
+    vwldAssetId: string;
+    spawnPoints?: Array<Record<string, unknown>>;
+    overrides?: Record<string, unknown>;
+}
+/** The parts of world.json the persist plan reads. Everything else passes through untouched. */
+export interface WorldJsonShape {
+    worldProfileData?: {
+        levels?: LevelEntry[];
+        startLevelId?: string;
+        voxelUrl?: string | null;
+        spawnPoints?: Array<Record<string, unknown>>;
+        playerSpawnPosition?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    assets?: Array<Record<string, unknown>>;
+    environmentObjects?: Array<Record<string, unknown>>;
+    [key: string]: unknown;
+}
+//# sourceMappingURL=world-json-types.d.ts.map

package/dist/pipeline/world-json-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-json-types.d.ts","sourceRoot":"","sources":["../../src/pipeline/world-json-types.ts"],"names":[],"mappings":"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"}

package/dist/pipeline/world-json-types.js

@@ -0,0 +1,15 @@
+/**
+ * The world.json shapes the persist step speaks — the MODIFICATION format it
+ * returns, and the minimal read shape it plans against.
+ *
+ * Types only, no runtime: this package never reads or writes world.json. The
+ * host owns the file (game-play-agent's `utils/world-json-editor.ts` applies
+ * these against the session's copy; a CLI lane applies them against the one
+ * file its project has) and re-exports {@link WorldJsonModification} from here
+ * so there is exactly one definition of the format on both sides of the seam.
+ *
+ * Moved verbatim from game-play-agent's `utils/world-json-editor.ts` (the
+ * modification union) and `utils/level-registry.ts` (the read shape).
+ */
+export {};
+//# sourceMappingURL=world-json-types.js.map

package/dist/pipeline/world-json-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-json-types.js","sourceRoot":"","sources":["../../src/pipeline/world-json-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/dist/terrain-height-grid.d.ts

@@ -0,0 +1,45 @@
+/**
+ * World-space terrain height grid — the bridge that lets objects placed AFTER
+ * a forge (e.g. collectibles the coding/asset agent scatters via the voxel CLI)
+ * sit on the forged surface instead of the world floor.
+ *
+ * The forge knows each prop's exact ground height because it samples its own
+ * GLB-space `Heightfield` and maps the result to world space with the level
+ * transform (see `forge-world.ts`). Agent-driven placements happen later, in a
+ * separate process, with no access to that in-memory heightfield — and a
+ * placement raycast can't help because the freshly-forged terrain only loads
+ * after the session reload. So the forge persists THIS grid (a sidecar next to
+ * world.json); the CLI samples it to resolve `placeOnTerrain` Y the same way
+ * the forge resolved its props.
+ *
+ * The grid is the carved heightfield expressed in WORLD coordinates. Because the
+ * level transform is affine and axis-aligned (uniform scale + translate, no
+ * rotation — see `marker-transform.ts`), a GLB-regular grid maps to a
+ * world-regular grid, so the conversion is a per-vertex scale/translate.
+ *
+ * The GRID and its SAMPLER live on the publishable side, because the host that
+ * writes the sidecar and the tools that read it are CLIENTS of the forge, not
+ * part of it. The producer — `heightfieldToWorldGrid`, which needs the forge's
+ * own heightfield and level transform — stays with the geometry, in the private
+ * package's module of the same name.
+ */
+/** Sidecar filename written next to world.json. The CLI hardcodes the same name. */
+export declare const FORGED_HEIGHTFIELD_FILE = "forged-heightfield.json";
+export interface ForgedHeightGrid {
+    /** World coordinate of vertex (0, 0). */
+    minX: number;
+    minZ: number;
+    /** World meters per cell. */
+    cellSize: number;
+    /** Cells along X / Z. Vertex counts are nx+1 / nz+1. */
+    nx: number;
+    nz: number;
+    /** Row-major world-space heights, index = j * (nx + 1) + i, length (nx+1)*(nz+1). */
+    heights: number[];
+}
+/**
+ * Bilinear height sample in world space, clamped to the grid edge. Mirrors
+ * `heightfield.ts` `heightAt` so the CLI's sampler and this one agree.
+ */
+export declare function sampleWorldHeight(g: ForgedHeightGrid, x: number, z: number): number;
+//# sourceMappingURL=terrain-height-grid.d.ts.map

package/dist/terrain-height-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-height-grid.d.ts","sourceRoot":"","sources":["../src/terrain-height-grid.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,oFAAoF;AACpF,eAAO,MAAM,uBAAuB,4BAA4B,CAAC;AAEjE,MAAM,WAAW,gBAAgB;IAC/B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,qFAAqF;IACrF,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAiBnF"}