@vgai/engine 0.2.0 → 0.3.0

package/dist/scene/scene-apply.js

@@ -0,0 +1,326 @@
+/**
+ * `applyDiff` — the exact inverse of `diffScene` (T4.5, `vgai apply-diff`).
+ *
+ * `diffScene` (packages/editor/src/scene-diff.ts) computes a `SceneDiff` from
+ * two `SceneFile`s. This module does the other direction: given ONE
+ * `SceneFile` and a `SceneDiff`, produce the `SceneFile` the diff describes —
+ * a pure function, no editor/live-scene state involved.
+ *
+ * DEPENDENCY-DIRECTION NOTE (why this lives in the engine, not next to
+ * `diffScene`): the natural home for `applyDiff` is beside `diffScene` in
+ * `packages/editor/src/`. But the CLI (`packages/vgai-cli`) is the caller —
+ * `vgai apply-diff <scene> <patch>` — and `packages/vgai-cli/package.json`
+ * does not depend on `@vgai/editor` today (it depends on `@vgai/editor-sdk`,
+ * a thin RPC client for a *running* editor server, and `create-vgai-project`
+ * — neither pulls in editor source). Adding a cli→editor edge purely to reach
+ * one pure function would be a real, new dependency inversion (the T3.7 row
+ * for `deploy.ts` recorded the opposite call deliberately staying out for the
+ * same reason). `@vgai/engine`, by contrast, is already a dependency of
+ * `@vgai/editor` (one-directional: editor → engine) and is trivially addable
+ * to vgai-cli (mirroring `packages/editor/template/validate-scenes.ts`, which
+ * already imports `@vgai/engine/scene/parse` by its real published subpath).
+ * So: `DiffOp`/`SceneDiff` (the shared TYPES) and `applyDiff`/`SceneDiffSchema`
+ * (the new CODE) live in the engine; `scene-diff.ts` keeps its `diffScene`
+ * implementation where it is and re-exports the two type names, so no editor
+ * call site changes. Net edge added: vgai-cli → @vgai/engine (already the
+ * direction every other package depends on engine). Zero new editor edges.
+ *
+ * ROUND-TRIP LAW: for any two scenes A, B — `applyDiff(A, diffScene(A, B))`
+ * is deep-equal to B, WITH ONE NORMALIZATION: an entity whose `children`
+ * becomes empty is left with `children` omitted (not `children: []`) —
+ * matching the convention `cleanDocument`/`serializeScene`
+ * (packages/editor/src/scene-serializer.ts) already use for saved scene
+ * files. If B's own file happened to spell "no children" as a literal
+ * `children: []` rather than omitting the key, a byte-level diff would show
+ * that one field; every other field, and the full entity tree/order, matches
+ * exactly. This holds because `diffScene` emits an explicit `move` op for
+ * ANY entity whose absolute sibling index changes for ANY reason — not just
+ * reparenting, but also a sibling being added/removed/reordered earlier in
+ * the same array — so `applyDiff` never has to guess whether an untouched
+ * entity's position shifted; every position-relevant entity carries an
+ * explicit target index in the FINAL array.
+ *
+ * OP-ORDERING RULE (why applying `diff.ops` in array order would be wrong,
+ * and what this function does instead):
+ *
+ *   1. Detach every `move` target from wherever it currently sits — BEFORE
+ *      processing any `remove`. Proof this matters: consider "remove parent
+ *      with moved-out child" — parent P is deleted in the new doc, but one
+ *      of P's old children, C, survives (reparented elsewhere). `diffScene`
+ *      necessarily emits BOTH `{ remove: P }` and `{ move: C, parentId: ... }`
+ *      (C's parentId can't still be P, since P doesn't exist in the new doc,
+ *      so a parentId change — hence a move op — is guaranteed). If `remove P`
+ *      ran first, it would delete P's whole subtree, including C, before C's
+ *      `move` op ever got to detach it. Detaching every mover first means C
+ *      is already pulled out of P's subtree by the time `remove P` runs, so
+ *      only what's genuinely being deleted is deleted.
+ *   2. Process `remove` ops. A remove target that's already gone (not found)
+ *      is NOT an error IF it was swept away as a descendant of an earlier
+ *      remove in the SAME diff — `diffScene` lists every removed id
+ *      independently (both a removed parent AND its removed descendants each
+ *      get their own `remove` op, since `flattenEntities` flattens every
+ *      level regardless of ancestor state). A remove target not found and
+ *      not swept is a genuine error (bad id).
+ *   3. Build a complete id → node resolution map covering EVERY entity that
+ *      will exist in the output: the stationary survivors (walked fresh from
+ *      what's left of the tree), then a freshly-created node object for each
+ *      `add` (children stripped — see below), then the already-detached node
+ *      for each `move`. Because this map is built in full before any
+ *      placement happens, a node object exists (and is resolvable as a
+ *      parent) from the moment it's created, independent of whether it has
+ *      itself been spliced into ITS OWN parent's array yet. This is what
+ *      makes "add-under-added-parent" (a newly-added parent with newly-added
+ *      children in the same diff) work with no dependency/topological-sort
+ *      logic: a child's `add`/`move` op resolves its `parentId` against this
+ *      map regardless of which op appears first in `diff.ops`.
+ *   4. Placement: group `add` + `move` ops by target parentId, sort each
+ *      group ascending by `index`, then splice one at a time into the target
+ *      array in that order. Inserting in ascending order of FINAL target
+ *      index into an array that already holds every untouched sibling in
+ *      their final relative order (untouched siblings never move — any
+ *      absolute-index change gets its own `move` op, per the round-trip-law
+ *      note above) reconstructs the exact final array: by induction, every
+ *      element with a smaller final index than the one being inserted is
+ *      already in the array, so splicing at `index` places it correctly
+ *      relative to all of them, whether the array started empty (a brand
+ *      new parent) or partially populated (survivors of an existing parent).
+ *   5. `update` ops last (order relative to placement doesn't matter — they
+ *      mutate an object by reference, found via the same id map, regardless
+ *      of where in the tree that reference currently lives).
+ *
+ * Every thrown error is an `ApplyDiffError` naming the 0-based index into
+ * `diff.ops`, the op's `type`, and the entity id involved — enough for an
+ * agent to locate and fix the offending op from the message alone.
+ */
+export class ApplyDiffError extends Error {
+    opIndex;
+    opType;
+    entityId;
+    constructor(message, opIndex, opType, entityId) {
+        super(`op #${opIndex} (${opType}, id=${entityId}): ${message}`);
+        this.name = 'ApplyDiffError';
+        this.opIndex = opIndex;
+        this.opType = opType;
+        this.entityId = entityId;
+    }
+}
+function cloneEntity(e) {
+    return JSON.parse(JSON.stringify(e));
+}
+/** Recursively search `list` (and descendants) for `id`; if found, splice it out (subtree intact) and return it. */
+function detachById(list, id) {
+    for (let i = 0; i < list.length; i++) {
+        const node = list[i];
+        if (node.id === id) {
+            list.splice(i, 1);
+            return node;
+        }
+        if (node.children) {
+            const found = detachById(node.children, id);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+/** Collect the id of `node` and every descendant's id into `into`. */
+function collectIds(node, into) {
+    if (node.id)
+        into.add(node.id);
+    if (node.children) {
+        for (const child of node.children)
+            collectIds(child, into);
+    }
+}
+/** Delete `children` if it is now an empty array, to match the `cleanDocument`/`serializeScene` convention (see the round-trip-law note above). */
+function stripEmptyChildrenArrays(list) {
+    for (const node of list) {
+        if (node.children) {
+            if (node.children.length === 0) {
+                delete node.children;
+            }
+            else {
+                stripEmptyChildrenArrays(node.children);
+            }
+        }
+    }
+}
+/**
+ * Apply a `SceneDiff` to a `SceneFile`, returning a NEW `SceneFile` (input is
+ * not mutated). See the module jsdoc above for the round-trip law and the
+ * op-ordering rule/proof.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one cohesive apply-in-5-phases pipeline (detach movers, remove, index survivors, place adds+moves, update) — the phases share too much local state (working tree, id maps) to split without just passing that state through a longer parameter list.
+export function applyDiff(scene, diff) {
+    const working = JSON.parse(JSON.stringify(scene));
+    const ops = diff.ops;
+    // --- Metadata / environment (independent of entity ops) ---
+    if (diff.metaChanged && diff.newName !== undefined) {
+        working.name = diff.newName;
+    }
+    if (diff.environmentChanged) {
+        if (diff.newEnvironment) {
+            working.environment = diff.newEnvironment;
+        }
+        else {
+            delete working.environment;
+        }
+    }
+    // --- Phase 1: detach every `move` target before any `remove` runs ---
+    //
+    // A move target isn't always reachable directly off `working.entities`: if
+    // its immediate (or more distant) ancestor ALSO has a `move` op that gets
+    // detached first, the target now hangs off that already-detached ancestor
+    // node, not off the main tree. `diffScene` always emits an ancestor's own
+    // move/update entry before its descendants' (`flattenEntities` sets a
+    // parent's map entry before recursing into children), so a single forward
+    // pass already covers every diffScene-computed diff — but this loop doesn't
+    // assume that ordering: it retries whatever hasn't been found yet against
+    // the growing set of already-detached movers' subtrees, to a fixed point,
+    // so `diff.ops` order genuinely does not matter (per SceneDiffSchema's
+    // `ops` doc).
+    const movedNodes = new Map();
+    function detachFromAnywhere(id) {
+        const direct = detachById(working.entities, id);
+        if (direct)
+            return direct;
+        for (const mover of movedNodes.values()) {
+            if (mover.children) {
+                const found = detachById(mover.children, id);
+                if (found)
+                    return found;
+            }
+        }
+        return undefined;
+    }
+    const moveOpIndices = ops
+        .map((op, i) => ({ op, i }))
+        .filter((x) => x.op.type === 'move');
+    const pendingMoves = new Set(moveOpIndices.map((x) => x.i));
+    let madeProgress = true;
+    while (pendingMoves.size > 0 && madeProgress) {
+        madeProgress = false;
+        for (const { op, i } of moveOpIndices) {
+            if (!pendingMoves.has(i))
+                continue;
+            const node = detachFromAnywhere(op.id);
+            if (node) {
+                movedNodes.set(op.id, node);
+                pendingMoves.delete(i);
+                madeProgress = true;
+            }
+        }
+    }
+    if (pendingMoves.size > 0) {
+        const i = [...pendingMoves][0];
+        const op = ops[i];
+        throw new ApplyDiffError('entity not found (nothing to move)', i, 'move', op.id);
+    }
+    // --- Phase 2: removes (a not-found target is fine if it was already swept
+    //     up as a descendant of an earlier remove, OR if it hangs off a node
+    //     that was itself moved in phase 1 — see `detachFromAnywhere` above) ---
+    const sweptIds = new Set();
+    ops.forEach((op, i) => {
+        if (op.type !== 'remove')
+            return;
+        const node = detachFromAnywhere(op.id);
+        if (node) {
+            collectIds(node, sweptIds);
+            return;
+        }
+        if (sweptIds.has(op.id))
+            return;
+        throw new ApplyDiffError('entity not found (already removed via an ancestor, or an invalid id)', i, 'remove', op.id);
+    });
+    // --- Phase 3: build the complete id -> node resolution map ---
+    const byId = new Map();
+    const indexStationary = (list) => {
+        for (const node of list) {
+            if (node.id)
+                byId.set(node.id, node);
+            if (node.children)
+                indexStationary(node.children);
+        }
+    };
+    indexStationary(working.entities);
+    const addNodes = new Map(); // opIndex -> freshly created node
+    ops.forEach((op, i) => {
+        if (op.type !== 'add')
+            return;
+        const entity = cloneEntity(op.entity);
+        delete entity.children; // children are position-managed by their own add/move ops
+        if (!entity.id)
+            entity.id = crypto.randomUUID();
+        if (byId.has(entity.id)) {
+            throw new ApplyDiffError('duplicate id — an entity with this id already exists', i, 'add', entity.id);
+        }
+        byId.set(entity.id, entity);
+        addNodes.set(i, entity);
+    });
+    ops.forEach((op, i) => {
+        if (op.type !== 'move')
+            return;
+        if (byId.has(op.id)) {
+            throw new ApplyDiffError('duplicate id — conflicts with an added entity', i, 'move', op.id);
+        }
+        byId.set(op.id, movedNodes.get(op.id));
+    });
+    // --- Phase 4: placement — group add+move ops by target parent, insert ascending by index ---
+    const groups = new Map();
+    ops.forEach((op, i) => {
+        if (op.type === 'add') {
+            const node = addNodes.get(i);
+            const list = groups.get(op.parentId) ?? [];
+            list.push({ index: op.index, node, opIndex: i, opType: 'add', entityId: node.id });
+            groups.set(op.parentId, list);
+        }
+        else if (op.type === 'move') {
+            const node = movedNodes.get(op.id);
+            const list = groups.get(op.parentId) ?? [];
+            list.push({ index: op.index, node, opIndex: i, opType: 'move', entityId: op.id });
+            groups.set(op.parentId, list);
+        }
+    });
+    for (const [parentId, placements] of groups) {
+        let targetArray;
+        if (parentId === null) {
+            targetArray = working.entities;
+        }
+        else {
+            const parentNode = byId.get(parentId);
+            if (!parentNode) {
+                const bad = placements[0];
+                throw new ApplyDiffError(`parent entity "${parentId}" not found`, bad.opIndex, bad.opType, bad.entityId);
+            }
+            parentNode.children ??= [];
+            targetArray = parentNode.children;
+        }
+        const sorted = [...placements].sort((a, b) => a.index - b.index);
+        for (const p of sorted) {
+            if (p.index < 0) {
+                throw new ApplyDiffError(`negative target index (${p.index})`, p.opIndex, p.opType, p.entityId);
+            }
+            const clamped = Math.min(p.index, targetArray.length);
+            targetArray.splice(clamped, 0, p.node);
+        }
+    }
+    // --- Phase 5: updates — full field replace (except id/children), deleting omitted fields ---
+    ops.forEach((op, i) => {
+        if (op.type !== 'update')
+            return;
+        const node = byId.get(op.id);
+        if (!node) {
+            throw new ApplyDiffError('entity not found', i, 'update', op.id);
+        }
+        const { id: _id, children: _children, ...fields } = op.entity;
+        for (const key of Object.keys(node)) {
+            if (key === 'id' || key === 'children')
+                continue;
+            if (!(key in fields))
+                delete node[key];
+        }
+        Object.assign(node, fields);
+    });
+    stripEmptyChildrenArrays(working.entities);
+    return working;
+}

package/dist/scene/scene-diff-schema.d.ts

@@ -0,0 +1,285 @@
+/**
+ * Zod schema for a `SceneDiff` JSON patch (T4.5 — `vgai apply-diff`).
+ *
+ * Validates the SHAPE of a hand-authored or `diffScene`-computed patch before
+ * `applyDiff` (./scene-apply.ts) touches it. Not wired into
+ * `scripts/generate-schema.ts` — that script's output feeds the *scene file*
+ * JSON Schema (autocomplete/reference for `.vscn.json`/`.prefab.json`/
+ * `vgai.game.json`), a different artifact from a diff/patch file. Adding a
+ * 5th line there would be mechanically trivial, but a generated
+ * `scene-diff.schema.json` has no current consumer (no editor autocomplete
+ * targets *.json patch files) — left undone; revisit if one appears.
+ *
+ * `SceneEntitySchema` is reused as-is for `add`/`update` payloads even though
+ * both operations ignore any `children` the payload carries (children are
+ * position-managed exclusively by their own `add`/`move` ops — see
+ * `applyDiff`'s jsdoc). Rejecting `children` at the schema level would need
+ * an `.omit()` off a plain object schema, but `SceneEntitySchema` is a
+ * `z.lazy()`-wrapped discriminated union (recursive type), so this schema
+ * takes the more permissive-but-documented path: allow it through and let
+ * `applyDiff` silently drop it, rather than add a second near-duplicate
+ * entity schema just to forbid one field.
+ */
+import { z } from 'zod';
+export declare const DiffOpSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"add">;
+    entity: z.ZodType<import("./schema").SceneEntity, unknown, z.core.$ZodTypeInternals<import("./schema").SceneEntity, unknown>>;
+    parentId: z.ZodNullable<z.ZodString>;
+    index: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"remove">;
+    id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"update">;
+    id: z.ZodString;
+    entity: z.ZodType<import("./schema").SceneEntity, unknown, z.core.$ZodTypeInternals<import("./schema").SceneEntity, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"move">;
+    id: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+    index: z.ZodNumber;
+}, z.core.$strip>], "type">;
+export declare const SceneDiffSchema: z.ZodObject<{
+    ops: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"add">;
+        entity: z.ZodType<import("./schema").SceneEntity, unknown, z.core.$ZodTypeInternals<import("./schema").SceneEntity, unknown>>;
+        parentId: z.ZodNullable<z.ZodString>;
+        index: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"remove">;
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"update">;
+        id: z.ZodString;
+        entity: z.ZodType<import("./schema").SceneEntity, unknown, z.core.$ZodTypeInternals<import("./schema").SceneEntity, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"move">;
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        index: z.ZodNumber;
+    }, z.core.$strip>], "type">>;
+    environmentChanged: z.ZodBoolean;
+    newEnvironment: z.ZodOptional<z.ZodObject<{
+        background: z.ZodOptional<z.ZodString>;
+        ambient: z.ZodOptional<z.ZodObject<{
+            color: z.ZodString;
+            intensity: z.ZodNumber;
+        }, z.core.$strip>>;
+        fog: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                linear: "linear";
+                exponential: "exponential";
+            }>;
+            color: z.ZodString;
+            near: z.ZodOptional<z.ZodNumber>;
+            far: z.ZodOptional<z.ZodNumber>;
+            density: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        skybox: z.ZodOptional<z.ZodString>;
+        envMapIntensity: z.ZodOptional<z.ZodNumber>;
+        toneMapping: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                linear: "linear";
+                reinhard: "reinhard";
+                cineon: "cineon";
+                aces: "aces";
+                agx: "agx";
+            }>>;
+            exposure: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        postProcessing: z.ZodOptional<z.ZodObject<{
+            bloom: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                intensity: z.ZodOptional<z.ZodNumber>;
+                luminanceThreshold: z.ZodOptional<z.ZodNumber>;
+                luminanceSmoothing: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            vignette: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                darkness: z.ZodOptional<z.ZodNumber>;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            brightnessContrast: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                brightness: z.ZodOptional<z.ZodNumber>;
+                contrast: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            hueSaturation: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                hue: z.ZodOptional<z.ZodNumber>;
+                saturation: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            sepia: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                intensity: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            colorDepth: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                bits: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            chromaticAberration: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                offsetX: z.ZodOptional<z.ZodNumber>;
+                offsetY: z.ZodOptional<z.ZodNumber>;
+                radialModulation: z.ZodOptional<z.ZodBoolean>;
+                modulationOffset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            lensDistortion: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                distortionX: z.ZodOptional<z.ZodNumber>;
+                distortionY: z.ZodOptional<z.ZodNumber>;
+                focalLengthX: z.ZodOptional<z.ZodNumber>;
+                focalLengthY: z.ZodOptional<z.ZodNumber>;
+                skew: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            depthOfField: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                worldFocusDistance: z.ZodOptional<z.ZodNumber>;
+                worldFocusRange: z.ZodOptional<z.ZodNumber>;
+                bokehScale: z.ZodOptional<z.ZodNumber>;
+                focalLength: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            tiltShift: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                offset: z.ZodOptional<z.ZodNumber>;
+                rotation: z.ZodOptional<z.ZodNumber>;
+                focusArea: z.ZodOptional<z.ZodNumber>;
+                feather: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            noise: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                premultiply: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            scanline: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                density: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            dotScreen: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                angle: z.ZodOptional<z.ZodNumber>;
+                scale: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            grid: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                scale: z.ZodOptional<z.ZodNumber>;
+                lineWidth: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            pixelation: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                granularity: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            glitch: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                delayX: z.ZodOptional<z.ZodNumber>;
+                delayY: z.ZodOptional<z.ZodNumber>;
+                durationX: z.ZodOptional<z.ZodNumber>;
+                durationY: z.ZodOptional<z.ZodNumber>;
+                strengthX: z.ZodOptional<z.ZodNumber>;
+                strengthY: z.ZodOptional<z.ZodNumber>;
+                columns: z.ZodOptional<z.ZodNumber>;
+                ratio: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            shockWave: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                speed: z.ZodOptional<z.ZodNumber>;
+                maxRadius: z.ZodOptional<z.ZodNumber>;
+                waveSize: z.ZodOptional<z.ZodNumber>;
+                amplitude: z.ZodOptional<z.ZodNumber>;
+                positionX: z.ZodOptional<z.ZodNumber>;
+                positionY: z.ZodOptional<z.ZodNumber>;
+                positionZ: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            smaa: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                preset: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    ultra: "ultra";
+                }>>;
+            }, z.core.$strip>>;
+            ssao: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                radius: z.ZodOptional<z.ZodNumber>;
+                intensity: z.ZodOptional<z.ZodNumber>;
+                bias: z.ZodOptional<z.ZodNumber>;
+                samples: z.ZodOptional<z.ZodNumber>;
+                rings: z.ZodOptional<z.ZodNumber>;
+                fade: z.ZodOptional<z.ZodNumber>;
+                color: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            n8ao: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                aoSamples: z.ZodOptional<z.ZodNumber>;
+                aoRadius: z.ZodOptional<z.ZodNumber>;
+                intensity: z.ZodOptional<z.ZodNumber>;
+                denoiseSamples: z.ZodOptional<z.ZodNumber>;
+                denoiseRadius: z.ZodOptional<z.ZodNumber>;
+                distanceFalloff: z.ZodOptional<z.ZodNumber>;
+                screenSpaceRadius: z.ZodOptional<z.ZodBoolean>;
+                color: z.ZodOptional<z.ZodString>;
+                halfRes: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            godRays: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                sourceEntity: z.ZodOptional<z.ZodString>;
+                density: z.ZodOptional<z.ZodNumber>;
+                decay: z.ZodOptional<z.ZodNumber>;
+                weight: z.ZodOptional<z.ZodNumber>;
+                exposure: z.ZodOptional<z.ZodNumber>;
+                samples: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            outline: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                edgeStrength: z.ZodOptional<z.ZodNumber>;
+                pulseSpeed: z.ZodOptional<z.ZodNumber>;
+                visibleEdgeColor: z.ZodOptional<z.ZodString>;
+                hiddenEdgeColor: z.ZodOptional<z.ZodString>;
+                xRay: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            ssr: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                intensity: z.ZodOptional<z.ZodNumber>;
+                exponent: z.ZodOptional<z.ZodNumber>;
+                distance: z.ZodOptional<z.ZodNumber>;
+                thickness: z.ZodOptional<z.ZodNumber>;
+                maxRoughness: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            ssgi: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                intensity: z.ZodOptional<z.ZodNumber>;
+                distance: z.ZodOptional<z.ZodNumber>;
+                thickness: z.ZodOptional<z.ZodNumber>;
+                maxRoughness: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            motionBlur: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                intensity: z.ZodOptional<z.ZodNumber>;
+                jitter: z.ZodOptional<z.ZodNumber>;
+                samples: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        navigation: z.ZodOptional<z.ZodObject<{
+            cellSize: z.ZodOptional<z.ZodNumber>;
+            cellHeight: z.ZodOptional<z.ZodNumber>;
+            walkableSlopeAngle: z.ZodOptional<z.ZodNumber>;
+            walkableHeight: z.ZodOptional<z.ZodNumber>;
+            walkableClimb: z.ZodOptional<z.ZodNumber>;
+            walkableRadius: z.ZodOptional<z.ZodNumber>;
+            maxEdgeLen: z.ZodOptional<z.ZodNumber>;
+            maxSimplificationError: z.ZodOptional<z.ZodNumber>;
+            minRegionArea: z.ZodOptional<z.ZodNumber>;
+            mergeRegionArea: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        physics: z.ZodOptional<z.ZodObject<{
+            collisionLayers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        rendering: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    }, z.core.$strip>>;
+    metaChanged: z.ZodBoolean;
+    newName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SceneDiffPatch = z.infer<typeof SceneDiffSchema>;
+//# sourceMappingURL=scene-diff-schema.d.ts.map

package/dist/scene/scene-diff-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-diff-schema.d.ts","sourceRoot":"","sources":["../../src/scene/scene-diff-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkBxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;2BA0CvB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BzB,CAAC;AAEJ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}