@pascal-app/core 1.0.3 → 1.0.4

package/dist/systems/wall/wall-topology.js

@@ -1,10 +1,15 @@
 import { GROUND_SUPPORT_ID } from '../../hooks/spatial-grid/support-host-id.js';
+import { detectOpenWallEnds, wallEndJoinCandidates } from '../../lib/room-graph.js';
 import { terrainSupportLift } from '../../lib/terrain-support.js';
 import { getScaledDimensions, WallNode as WallSchema, } from '../../schema/index.js';
 import { getWallArcData, getWallCurveFrameAt, getWallCurveLength, isCurvedWall } from './wall-curve.js';
-const WALL_MIN_LENGTH = 0.01;
+export const WALL_MIN_LENGTH = 0.01;
 const WALL_SPLIT_ENDPOINT_EPSILON = 0.02;
 const WALL_INTERSECTION_EPSILON = 1e-6;
+const WALL_JOIN_ANGLE_TOLERANCE = (5 * Math.PI) / 180;
+const WALL_JOIN_CORNER_STEP = Math.PI / 4;
+const WALL_JOIN_CORNER_MOVE_FLOOR = 0.15;
+const WALL_JOIN_CORNER_LENGTH_RATIO = 0.03;
 function distanceSquared(a, b) {
     const dx = a[0] - b[0];
     const dz = a[1] - b[1];
@@ -142,7 +147,7 @@ export function planWallSplitAtPoint(nodes, args) {
             plan: { point: projection.point, changes: { create: [], update: [], delete: [] } },
         };
     }
-    const split = splitWall(projection.wall, [projection.wallT], nodes);
+    const split = splitWall(projection.wall, [projection.wallT], nodes, args.mintId);
     if (!split) {
         return {
             ok: true,
@@ -308,7 +313,7 @@ function remapAttachment(node, wall, nextLocalX) {
         ...(node.type === 'item' ? { wallT: nextLength > 1e-6 ? clampedX / nextLength : 0 } : {}),
     };
 }
-function splitWall(wall, splitParameters, nodes) {
+function splitWall(wall, splitParameters, nodes, mintId) {
     const parameters = [
         0,
         ...splitParameters
@@ -321,6 +326,7 @@ function splitWall(wall, splitParameters, nodes) {
         const endT = parameters[index + 1];
         return WallSchema.parse({
             ...properties,
+            id: mintId?.(),
             start: wallPointAt(wall, startT),
             end: wallPointAt(wall, endT),
             curveOffset: segmentCurveOffset(wall, startT, endT),
@@ -399,6 +405,7 @@ export function planWallInsertion(nodes, args) {
     const existingWallCount = Object.values(nodes).filter((node) => node.type === 'wall').length;
     const insertedWalls = vertices.slice(0, -1).map((start, index) => WallSchema.parse({
         ...wallProperties,
+        id: args.mintId?.(),
         name: `Wall ${existingWallCount + index + 1}`,
         start,
         end: vertices[index + 1],
@@ -425,7 +432,7 @@ export function planWallInsertion(nodes, args) {
     }
     const splitPlans = [...splitWalls].flatMap(([wallId, parameters]) => {
         const wall = walls.find((candidate) => candidate.id === wallId);
-        const split = wall ? splitWall(wall, parameters, nodes) : null;
+        const split = wall ? splitWall(wall, parameters, nodes, args.mintId) : null;
         return split ? [[wallId, split]] : [];
     });
     const replacementWalls = splitPlans.flatMap(([, split]) => split.create);
@@ -460,3 +467,397 @@ export function planWallInsertion(nodes, args) {
     };
     return { ok: true, plan };
 }
+function distanceToLine(point, a, b) {
+    const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    return Math.abs((point[0] - a[0]) * (b[1] - a[1]) - (point[1] - a[1]) * (b[0] - a[0])) / length;
+}
+/** Where two straight walls' lines meet, if they meet at a real angle, and where along `target`. */
+function lineMeeting(wall, target) {
+    const r = [wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]];
+    const u = [target.end[0] - target.start[0], target.end[1] - target.start[1]];
+    const denominator = r[0] * u[1] - r[1] * u[0];
+    if (Math.abs(denominator) < 0.5 * Math.hypot(r[0], r[1]) * Math.hypot(u[0], u[1]))
+        return null;
+    const qp = [target.start[0] - wall.start[0], target.start[1] - wall.start[1]];
+    const t = (qp[0] * u[1] - qp[1] * u[0]) / denominator;
+    return {
+        point: [wall.start[0] + t * r[0], wall.start[1] + t * r[1]],
+        targetT: (qp[0] * r[1] - qp[1] * r[0]) / denominator,
+    };
+}
+function planWallEndJoin(nodes, openEnd, cornerPoint) {
+    const wall = nodes[openEnd.wallId];
+    if (wall?.type !== 'wall' ||
+        !wall.parentId ||
+        distanceSquared(wall[openEnd.end], openEnd.point) > 1e-12)
+        return { ok: false, reason: 'stale-end' };
+    const candidate = openEnd.candidate;
+    const target = candidate ? nodes[candidate.wallId] : undefined;
+    if (!candidate ||
+        target?.type !== 'wall' ||
+        target.id === wall.id ||
+        target.parentId !== wall.parentId)
+        return { ok: false, reason: 'no-target' };
+    const straight = !isCurvedWall(wall) && !isCurvedWall(target);
+    // Where the wall, run on or cut back along its own axis, meets the target's line: joining
+    // there never tilts it.
+    const meet = straight ? lineMeeting(wall, target) : null;
+    const near = (a, b) => distanceSquared(a, b) <= 0.35 ** 2;
+    let point = candidate.point;
+    // The target's open end slides along its own axis to the meeting point too.
+    let targetEnd = null;
+    if (candidate.kind === 'endpoint') {
+        const endpoint = [target.start, target.end].some((end) => distanceSquared(end, point) <= 1e-12)
+            ? point
+            : wallEndJoinCandidates(nodes, wall.parentId).find((end) => end.wallId === wall.id &&
+                end.end === openEnd.end &&
+                end.candidate?.wallId === target.id)?.candidate?.point;
+        const key = ['start', 'end'].find((end) => endpoint && distanceSquared(target[end], endpoint) <= 1e-12);
+        if (!key)
+            return { ok: false, reason: 'no-target' };
+        point = target[key];
+        const onOwnAxis = straight && distanceToLine(point, wall.start, wall.end) <= 1e-4;
+        if (!onOwnAxis && meet && near(meet.point, openEnd.point) && near(meet.point, point)) {
+            const shared = Object.values(nodes).some((node) => node.type === 'wall' &&
+                node.id !== target.id &&
+                node.id !== wall.id &&
+                node.parentId === wall.parentId &&
+                (distanceSquared(node.start, point) <= 1e-12 ||
+                    distanceSquared(node.end, point) <= 1e-12));
+            if (!shared)
+                targetEnd = key;
+            if (!shared || (meet.targetT > 0 && meet.targetT < 1))
+                point = meet.point;
+        }
+    }
+    else if (meet && meet.targetT > 0 && meet.targetT < 1 && near(meet.point, openEnd.point)) {
+        point = meet.point;
+    }
+    else {
+        const projection = nearestWallProjection(point, [target], isCurvedWall(target) ? 0.04 : WALL_INTERSECTION_EPSILON);
+        if (!projection)
+            return { ok: false, reason: 'no-target' };
+        point = projection.point;
+    }
+    // A squared corner keeps the straight join's shape: the target's open end, if it slides, slides
+    // to the corner too.
+    if (cornerPoint)
+        point = cornerPoint;
+    if (!near(point, openEnd.point))
+        return { ok: false, reason: 'no-target' };
+    const nextWall = { ...wall, [openEnd.end]: point };
+    const nextTarget = targetEnd ? { ...target, [targetEnd]: point } : null;
+    if (!isSegmentLongEnough(nextWall.start, nextWall.end) ||
+        (nextTarget && !isSegmentLongEnough(nextTarget.start, nextTarget.end)))
+        return { ok: false, reason: 'segment-too-short' };
+    const nextLength = wallLength(nextWall);
+    const adjusted = { ...nodes };
+    const attachmentUpdates = [];
+    const remapAttachments = (before, after) => {
+        const length = wallLength(after);
+        const dx = (after.end[0] - after.start[0]) / length;
+        const dz = (after.end[1] - after.start[1]) / length;
+        const oldLength = wallLength(before);
+        for (const attachment of wallAttachments(before, adjusted)) {
+            const span = attachmentSpan(attachment);
+            if (!span)
+                return false;
+            const oldPoint = getWallCurveFrameAt(before, span.center / oldLength).point;
+            const projection = isCurvedWall(after)
+                ? projectPointOntoWallCenterline([oldPoint.x, oldPoint.y], after)
+                : null;
+            if (isCurvedWall(after) && !projection)
+                return false;
+            const center = projection
+                ? projection.wallT * length
+                : (oldPoint.x - after.start[0]) * dx + (oldPoint.y - after.start[1]) * dz;
+            if (center - (span.center - span.min) < -1e-4 ||
+                center + (span.max - span.center) > length + 1e-4)
+                return false;
+            const data = remapAttachment(attachment, after, center);
+            adjusted[attachment.id] = { ...attachment, ...data };
+            attachmentUpdates.push({ id: attachment.id, data });
+        }
+        return true;
+    };
+    if (!remapAttachments(wall, nextWall) || (nextTarget && !remapAttachments(target, nextTarget)))
+        return { ok: false, reason: 'attachment-outside-wall' };
+    if (nextTarget)
+        adjusted[target.id] = nextTarget;
+    delete adjusted[wall.id];
+    let insertion;
+    if (isCurvedWall(wall)) {
+        const split = candidate.kind === 'body'
+            ? planWallSplitAtPoint(adjusted, {
+                levelId: wall.parentId,
+                point,
+                radius: WALL_INTERSECTION_EPSILON,
+            })
+            : {
+                ok: true,
+                plan: { point, changes: { create: [], update: [], delete: [] } },
+            };
+        if (!split.ok)
+            return { ok: false, reason: 'no-target' };
+        const replacementIds = split.plan.changes.create.map(({ node }) => node.id);
+        if (split.plan.changes.delete.includes(target.id))
+            for (const node of Object.values(nodes)) {
+                if (node.type === 'zone' && node.boundaryWallIds.includes(target.id))
+                    split.plan.changes.update.push({
+                        id: node.id,
+                        data: {
+                            boundaryWallIds: node.boundaryWallIds.flatMap((id) => id === target.id ? replacementIds : [id]),
+                        },
+                    });
+            }
+        insertion = {
+            ok: true,
+            plan: {
+                changes: split.plan.changes,
+                insertedWalls: [nextWall],
+                terminalWallId: wall.id,
+                resolvedStart: nextWall.start,
+                resolvedEnd: nextWall.end,
+            },
+        };
+    }
+    else
+        insertion = planWallInsertion(adjusted, {
+            levelId: wall.parentId,
+            start: nextWall.start,
+            end: nextWall.end,
+            joinRadius: WALL_INTERSECTION_EPSILON,
+            wallDefaults: nextWall,
+        });
+    if (!insertion.ok)
+        return insertion;
+    const insertedIds = new Set(insertion.plan.insertedWalls.map((segment) => segment.id));
+    let replacements;
+    let updates = attachmentUpdates;
+    if (insertion.plan.insertedWalls.length === 1) {
+        replacements = [nextWall];
+    }
+    else {
+        const parameters = insertion.plan.insertedWalls
+            .slice(0, -1)
+            .map((segment) => Math.hypot(segment.end[0] - nextWall.start[0], segment.end[1] - nextWall.start[1]) /
+            nextLength);
+        let index = 0;
+        const split = splitWall(nextWall, parameters, adjusted, () => index++ === 0 ? wall.id : insertion.plan.insertedWalls[index - 1].id);
+        if (!split)
+            return { ok: false, reason: 'attachment-straddles-junction' };
+        replacements = split.create.map((segment) => ({ ...segment, parentId: wall.parentId }));
+        updates = split.update;
+    }
+    const zoneUpdates = replacements.length > 1
+        ? Object.values(nodes).flatMap((node) => node.type === 'zone' && node.boundaryWallIds.includes(wall.id)
+            ? [
+                {
+                    id: node.id,
+                    data: {
+                        boundaryWallIds: (insertion.plan.changes.update.find((update) => update.id === node.id)
+                            ?.data?.boundaryWallIds ?? node.boundaryWallIds).flatMap((id) => id === wall.id ? replacements.map((segment) => segment.id) : [id]),
+                    },
+                },
+            ]
+            : [])
+        : [];
+    const mergedUpdates = new Map();
+    for (const update of [
+        ...(nextTarget && targetEnd && !insertion.plan.changes.delete.includes(target.id)
+            ? [{ id: target.id, data: { [targetEnd]: point } }]
+            : []),
+        ...insertion.plan.changes.update,
+        ...zoneUpdates,
+        ...updates,
+        { id: wall.id, data: replacements[0] },
+    ])
+        mergedUpdates.set(update.id, {
+            ...mergedUpdates.get(update.id),
+            ...update.data,
+        });
+    return {
+        ok: true,
+        plan: {
+            changes: {
+                create: [
+                    ...insertion.plan.changes.create.filter(({ node }) => !insertedIds.has(node.id)),
+                    ...replacements.slice(1).map((node) => ({ node, parentId: wall.parentId })),
+                ],
+                update: [...mergedUpdates].map(([id, data]) => ({ id, data })),
+                delete: insertion.plan.changes.delete,
+            },
+            insertedWalls: replacements,
+            terminalWallId: replacements.at(-1).id,
+            resolvedStart: nextWall.start,
+            resolvedEnd: nextWall.end,
+        },
+    };
+}
+/**
+ * Where `line` meets a wall turning about `pivot` once their corner, now at `through`, snaps to the
+ * nearest 45° step. Null when it is already exact, more than the tolerance off, or the meeting
+ * leaves `line`'s segment on a side that `lineEnd` (the end of `line` that may slide) cannot reach.
+ */
+function squaredCorner(pivot, through, line, lineEnd) {
+    const ux = line.end[0] - line.start[0];
+    const uz = line.end[1] - line.start[1];
+    const rx = through[0] - pivot[0];
+    const rz = through[1] - pivot[1];
+    const angle = Math.atan2(ux * rz - uz * rx, ux * rx + uz * rz);
+    const exactAngle = Math.round(angle / WALL_JOIN_CORNER_STEP) * WALL_JOIN_CORNER_STEP;
+    if (Math.abs(Math.sin(exactAngle)) < WALL_INTERSECTION_EPSILON ||
+        Math.abs(angle - exactAngle) < WALL_INTERSECTION_EPSILON ||
+        Math.abs(angle - exactAngle) > WALL_JOIN_ANGLE_TOLERANCE + 1e-12)
+        return null;
+    const lineLength = Math.hypot(ux, uz);
+    const dx = (ux * Math.cos(exactAngle) - uz * Math.sin(exactAngle)) / lineLength;
+    const dz = (ux * Math.sin(exactAngle) + uz * Math.cos(exactAngle)) / lineLength;
+    const denominator = dx * uz - dz * ux;
+    const qx = line.start[0] - pivot[0];
+    const qz = line.start[1] - pivot[1];
+    const reach = (qx * uz - qz * ux) / denominator;
+    const lineT = (qx * dz - qz * dx) / denominator;
+    if (reach <= WALL_MIN_LENGTH)
+        return null;
+    if (lineEnd === null ? lineT < 0 || lineT > 1 : lineEnd === 'end' ? lineT <= 0 : lineT >= 1)
+        return null;
+    return [pivot[0] + reach * dx, pivot[1] + reach * dz];
+}
+const otherEnd = (end) => (end === 'start' ? 'end' : 'start');
+/** Repair one reference endpoint, including host splits and opening rehosting, in one scene batch. */
+export function planJoinOpenWallEnd(nodes, openEnd) {
+    const straight = planWallEndJoin(nodes, openEnd);
+    if (!straight.ok)
+        return straight;
+    const wall = nodes[openEnd.wallId];
+    const target = nodes[openEnd.candidate.wallId];
+    if (isCurvedWall(wall) || isCurvedWall(target))
+        return straight;
+    const fixedEnd = otherEnd(openEnd.end);
+    const point = openEnd.end === 'start' ? straight.plan.resolvedStart : straight.plan.resolvedEnd;
+    // An L near miss: the straight join slid the target's open end onto the corner as well.
+    const slid = straight.plan.changes.update.find(({ id }) => id === target.id)?.data;
+    const targetEnd = ['start', 'end'].find((end) => {
+        const moved = slid?.[end];
+        return moved !== undefined && distanceSquared(moved, point) <= 1e-12;
+    }) ?? null;
+    // Square by turning one wall about its anchored end. In an L either wall may turn; the one that
+    // moves the corner least wins (then the lower id), so both ends of the gap plan the same join.
+    const options = [
+        { turned: wall, corner: squaredCorner(wall[fixedEnd], point, target, targetEnd) },
+        ...(targetEnd
+            ? [
+                {
+                    turned: target,
+                    corner: squaredCorner(target[otherEnd(targetEnd)], point, wall, openEnd.end),
+                },
+            ]
+            : []),
+    ]
+        .flatMap(({ turned, corner }) => {
+        if (!corner)
+            return [];
+        const move = distanceSquared(corner, point);
+        const maxMove = Math.max(WALL_JOIN_CORNER_MOVE_FLOOR, WALL_JOIN_CORNER_LENGTH_RATIO * wallLength(turned));
+        return move <= maxMove ** 2 ? [{ turned, corner, move }] : [];
+    })
+        .sort((a, b) => Math.abs(a.move - b.move) > 1e-9 ? a.move - b.move : a.turned.id.localeCompare(b.turned.id));
+    for (const { corner } of options) {
+        const squared = planWallEndJoin(nodes, openEnd, corner);
+        if (!squared.ok || squared.plan.insertedWalls.length !== 1)
+            continue;
+        const joined = squared.plan.insertedWalls[0];
+        // Only the open ends move: anchored junctions and every other wall keep their geometry.
+        if (distanceSquared(joined[fixedEnd], wall[fixedEnd]) > 1e-12 ||
+            distanceSquared(joined[openEnd.end], corner) > 1e-12 ||
+            squared.plan.changes.delete.some((id) => id !== target.id) ||
+            squared.plan.changes.update.some(({ id, data }) => {
+                if (id === wall.id || nodes[id]?.type !== 'wall')
+                    return false;
+                const moved = data;
+                if (!(moved.start || moved.end))
+                    return false;
+                return !(id === target.id &&
+                    targetEnd &&
+                    !moved[otherEnd(targetEnd)] &&
+                    distanceSquared(moved[targetEnd], corner) <= 1e-12);
+            }))
+            continue;
+        return squared;
+    }
+    return straight;
+}
+/**
+ * The level's open wall ends, each candidate moved to where Join walls will put the end, so a
+ * preview draws the join it makes. `nodes` must hold what the walls host: an opening can turn
+ * a squared corner back into a straight join. Room detection (room-graph) stays planner-free.
+ */
+export function findOpenWallEnds(nodes, levelId) {
+    return detectOpenWallEnds(nodes, levelId).map((end) => {
+        if (!end.candidate)
+            return end;
+        const result = planJoinOpenWallEnd(nodes, end);
+        if (!result.ok)
+            return end;
+        const point = end.end === 'start' ? result.plan.resolvedStart : result.plan.resolvedEnd;
+        return { ...end, candidate: { ...end.candidate, point } };
+    });
+}
+/** Fold drop-time connections into the move's atomic batch, including linked moved walls. */
+export function planWallEndRejoins(nodes, wallIds, radius, changes) {
+    const draft = { ...nodes };
+    const creates = new Map();
+    const updates = new Map();
+    const deletes = new Set();
+    const fold = (patch) => {
+        for (const id of patch.delete) {
+            delete draft[id];
+            updates.delete(id);
+            if (!creates.delete(id))
+                deletes.add(id);
+        }
+        for (const entry of patch.create) {
+            creates.set(entry.node.id, entry);
+            draft[entry.node.id] = {
+                ...entry.node,
+                parentId: entry.parentId ?? entry.node.parentId,
+            };
+        }
+        for (const { id, data } of patch.update) {
+            if (!draft[id])
+                continue;
+            draft[id] = { ...draft[id], ...data };
+            const created = creates.get(id);
+            if (created)
+                creates.set(id, { ...created, node: draft[id] });
+            else
+                updates.set(id, { ...updates.get(id), ...data });
+        }
+    };
+    fold(changes);
+    for (const wallId of wallIds)
+        for (const end of ['start', 'end']) {
+            const wall = draft[wallId];
+            const original = nodes[wallId];
+            if (wall?.type !== 'wall' || !wall.parentId)
+                continue;
+            // A linked wall's far end stays put; the drop only connects ends it moved.
+            if (original?.type === 'wall' && distanceSquared(original[end], wall[end]) <= 1e-12)
+                continue;
+            const openEnd = wallEndJoinCandidates(draft, wall.parentId).find((entry) => entry.wallId === wallId && entry.end === end);
+            if (!openEnd?.candidate || openEnd.reason === 'parallel')
+                continue;
+            const distance = distanceSquared(openEnd.point, openEnd.candidate.point);
+            if (distance > radius ** 2 || (distance < 1e-12 && openEnd.candidate.kind === 'endpoint'))
+                continue;
+            const result = planJoinOpenWallEnd(draft, openEnd);
+            if (result.ok)
+                fold(result.plan.changes);
+        }
+    return {
+        create: [...creates.values()],
+        update: [...updates].map(([id, data]) => ({ id, data })),
+        delete: [...deletes],
+    };
+}

package/dist/utils/clone-scene-graph.d.ts

@@ -8,10 +8,16 @@ export type SceneGraph = {
     materials?: Record<SceneMaterialId, SceneMaterial>;
     installedPlugins?: string[];
 };
+export declare function remapNodeReferences(node: AnyNode, ids: Map<string, string>): AnyNode;
 /**
  * Deep clones a scene graph with all node IDs regenerated while preserving
  * parent-child relationships and other internal references.
  *
+ * The hand-written remaps here and in `cloneLevelSubtree` are inventoried in
+ * `contracts/reference-inventory.ts`, which records the references they miss;
+ * `contracts/fidelity.test.ts` fails when either drifts from the inventory.
+ * P-03 replaces both passes with the one extractor over `capabilities.refs`.
+ *
  * This is useful for:
  * - Duplicating a project (host app creates a new project record, then loads the cloned scene)
  * - Copying nodes between different projects

package/dist/utils/clone-scene-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE9E,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;IAClD,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAqKlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAqH/E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,qBAA0B,GAClC,UAAU,CA0EZ"}
+{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE9E,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;IAClD,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAwDD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAgBpF;AA4CD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAkKlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA+H/E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,qBAA0B,GAClC,UAAU,CA0EZ"}