@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/wall/move-tool.js

@@ -1,11 +1,11 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { detectSpacesForLevel, emitter, getCeilingClampBound, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, getStoredLevelHeight, pauseSceneHistory, planAutoCeilingsForLevel, planAutoSlabsForLevel, planWallMoveJunctions, resolveMovedWallSupportSlabPatch, resumeSceneHistory, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { CursorSphere, EDITOR_LAYER, getSegmentGridStep, isSegmentLongEnough, markToolCancelConsumed, snapBuildingLocalToWorldGrid, snapScalarToGrid, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { beginSceneHistoryPauseSession, createLevelStructurePreview, emitter, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planWallEndRejoins, planWallMoveJunctions, resolveMovedWallSupportSlabPatch, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { CursorSphere, EDITOR_LAYER, getSegmentGridStep, isSegmentLongEnough, isTypingTarget, markToolCancelConsumed, snapBuildingLocalToWorldGrid, snapScalarToGrid, triggerSFX, useEditor, WALL_CONNECT_SNAP_RADIUS, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { BufferGeometry, DoubleSide, Float32BufferAttribute } from 'three';
-import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots, getWallsAfterUpdates, stripWallIsNewMetadata, } from './move-shared';
+import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots, getWallsAfterUpdates, stripWallIsNewMetadata, } from './move-shared.js';
 /**
  * Phase 5 Stage D — wall whole-move tool (kind-owned).
  *
@@ -18,11 +18,11 @@ import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots
  *    move with the dragged wall via `planWallMoveJunctions`.
  *  - **Bridge wall ghost previews** — when a corner separates, a
  *    translucent ghost shows the new wall that would be inserted.
- *  - **Auto-slab live preview** — `planAutoSlabsForLevel` runs every
- *    tick so room slabs adapt to the new wall layout in real time.
- *  - **Single-undo dance** — paused history during drag, restore +
- *    resume + reapply on commit so one Ctrl-Z rolls back the whole
- *    operation.
+ *  - **Auto-slab live preview** — the structure kernel previews the level's
+ *    rooms every tick, so room slabs adapt to the new wall layout live.
+ *  - **One undo step** — the drag writes no history; the drop writes walls,
+ *    supports and the sync's derived rooms as one step, through a pause
+ *    session shared with the 2D move overlay (`commitStep`).
  *  - **`isNew` metadata strip** — first commit after a fresh wall
  *    placement clears the placement marker.
  *  - **Activation grace** (150ms).
@@ -34,12 +34,6 @@ function rotateVector([x, z], angle) {
     const sin = Math.sin(angle);
     return [x * cos - z * sin, x * sin + z * cos];
 }
-function getLevelSlabs(levelId, nodes) {
-    return Object.values(nodes).filter((entry) => entry?.type === 'slab' && (entry.parentId ?? null) === levelId);
-}
-function getLevelCeilings(levelId, nodes) {
-    return Object.values(nodes).filter((entry) => entry?.type === 'ceiling' && (entry.parentId ?? null) === levelId);
-}
 function setPreviewGeometryAttributes(geometry, positions, normals, uvs) {
     geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
     geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
@@ -58,9 +52,7 @@ function GhostWallPreviewMesh({ preview }) {
     const dz = preview.end[1] - preview.start[1];
     const length = Math.hypot(dx, dz);
     const angle = -Math.atan2(dz, dx);
-    const geometry = useMemo(() => {
-        return length < 0.01 ? null : createWallPreviewGeometry(length, preview.height);
-    }, [length, preview.height]);
+    const geometry = useMemo(() => (length < 0.01 ? null : createWallPreviewGeometry(length, preview.height)), [length, preview.height]);
     useEffect(() => () => geometry?.dispose(), [geometry]);
     if (!geometry) {
         return null;
@@ -119,7 +111,6 @@ export const MoveWallTool = ({ node }) => {
         const originalCenter = originalCenterRef.current;
         const originalHalfVector = originalHalfVectorRef.current;
         const levelId = node.parentId ?? null;
-        pauseSceneHistory(useScene);
         let shouldRestoreOnCleanup = true;
         let active = true;
         // Wall ids that currently carry a live position override. Cleared on commit
@@ -136,71 +127,74 @@ export const MoveWallTool = ({ node }) => {
             // the final plan is written once, atomically, on commit.
             const overrides = useLiveNodeOverrides.getState();
             const sceneState = useScene.getState();
+            const previewIds = new Set(updates.map((entry) => entry.id));
+            for (const id of touchedWallIds) {
+                if (previewIds.has(id))
+                    continue;
+                overrides.clear(id);
+                if (sceneState.nodes[id])
+                    sceneState.markDirty(id);
+                touchedWallIds.delete(id);
+            }
             overrides.setMany(updates.map((entry) => [entry.id, { start: entry.start, end: entry.end }]));
             for (const entry of updates) {
                 touchedWallIds.add(entry.id);
                 sceneState.markDirty(entry.id);
             }
         };
-        // Live auto-slab / auto-ceiling preview. Calculates the new
-        // surfaces from the moving wall configuration each tick, then
-        // sends polygon overrides to `useLiveNodeOverrides` (and marks
-        // the slab / ceiling dirty) so `GeometrySystem` / `CeilingSystem`
-        // rebuild the mesh through the existing `getEffectiveNode` merge
-        // path. *Nothing* is written to the scene store during the drag —
-        // the store stays at pre-drag values; commit writes the final
-        // plan in one atomic `applyNodeChanges`. Mirrors the wall's own
-        // 2D drag pattern (`useLiveNodeOverrides` → mesh, store on
-        // commit).
-        //
-        // Creates / deletes from the plan are *deferred* to commit. We
-        // can't represent a "node that doesn't exist yet" through
-        // overrides, so newly-detected rooms only get their slab/ceiling
-        // materialised on release; rooms whose closing wall pulls away
-        // keep their slab/ceiling visible (at the original polygon) until
-        // commit clears them. UX-wise this trades the previous "ghost
-        // appears/disappears mid-drag" feedback for atomic, undoable
-        // commits — which is what the user asked for.
-        //
-        // `latestSurfacePlans` holds the most recent plan from the last
-        // live tick. `commitSurfacesToStore` flushes it (creates,
-        // updates, deletes) into the scene as part of the commit-time
-        // atomic write, then `clearSurfaceOverrides` drops the override
-        // map so the system reads from the now-committed store.
-        let latestSurfacePlans = null;
-        const touchedSlabIds = new Set();
-        const touchedCeilingIds = new Set();
+        // Live auto-slab / auto-ceiling preview: the structure kernel's plan for the
+        // moved walls, published as polygon overrides so `GeometrySystem` /
+        // `CeilingSystem` rebuild through the `getEffectiveNode` merge while the
+        // store stays at pre-drag values. Surfaces a new, merged or split room
+        // needs appear at commit.
+        // The drag writes nothing to the store, so a new `nodes` reference means someone else
+        // changed the scene (a collaborator, an agent). Linked walls and the structure preview
+        // are read again from it: the drop must commit a linked wall's other end as it is now,
+        // and pick up a newly connected wall the same way the arm-time read would have.
+        const levelNodesOf = (nodes) => Object.fromEntries(Object.values(nodes)
+            .filter((entry) => entry.parentId === levelId)
+            .map((entry) => [entry.id, entry]));
+        let linkedNodes = useScene.getState().nodes;
+        let previewStructure = levelId ? createLevelStructurePreview(levelId, linkedNodes) : null;
+        let dragNodes = levelNodesOf(linkedNodes);
+        const refreshLinkedWalls = () => {
+            const nodes = useScene.getState().nodes;
+            if (nodes === linkedNodes)
+                return;
+            linkedNodes = nodes;
+            previewStructure = levelId ? createLevelStructurePreview(levelId, nodes) : null;
+            dragNodes = levelNodesOf(nodes);
+            if (isNew)
+                return;
+            linkedOriginalsRef.current = getLinkedWallSnapshots({
+                wallId: nodeId,
+                wallParentId: node.parentId ?? null,
+                originalStart,
+                originalEnd,
+            });
+        };
+        const touchedStructureIds = new Set();
         const publishLiveSurfaceOverrides = (walls) => {
-            if (!levelId)
+            if (!(levelId && previewStructure))
                 return;
             const levelWalls = walls.filter((wall) => (wall.parentId ?? null) === levelId);
             const sceneState = useScene.getState();
-            const { roomPolygons } = detectSpacesForLevel(levelId, levelWalls);
-            // Plan against the pre-drag scene — `getLevelSlabs/Ceilings`
-            // reads from the unchanged store, so the matcher's "remap
-            // existing room → existing slab" logic sees stable IDs across
-            // ticks. Without this anchor, IDs would drift as overrides
-            // re-flowed through the planner.
-            const existingSlabs = getLevelSlabs(levelId, sceneState.nodes);
-            const slabPlan = planAutoSlabsForLevel(roomPolygons, existingSlabs);
-            const levelNode = sceneState.nodes[levelId];
-            const ceilingPlan = planAutoCeilingsForLevel(roomPolygons, getLevelCeilings(levelId, sceneState.nodes), {
-                storeyHeight: levelNode?.type === 'level' ? getStoredLevelHeight(levelNode) : undefined,
-                ceilingClampBound: (polygon) => getCeilingClampBound(levelId, sceneState.nodes, polygon),
-            });
-            latestSurfacePlans = { slabs: slabPlan, ceilings: ceilingPlan };
+            const structurePlan = previewStructure(levelWalls);
             const overrideEntries = [];
-            for (const update of slabPlan.update) {
-                if (update.data.polygon === undefined)
+            for (const update of structurePlan) {
+                if (!('polygon' in update.data || 'holes' in update.data))
                     continue;
-                overrideEntries.push([update.id, { polygon: update.data.polygon }]);
-                touchedSlabIds.add(update.id);
+                overrideEntries.push([update.id, update.data]);
+                touchedStructureIds.add(update.id);
             }
-            for (const update of ceilingPlan.update) {
-                if (update.data.polygon === undefined && update.data.height === undefined)
+            const previewIds = new Set(overrideEntries.map(([id]) => id));
+            for (const id of touchedStructureIds) {
+                if (previewIds.has(id))
                     continue;
-                overrideEntries.push([update.id, update.data]);
-                touchedCeilingIds.add(update.id);
+                useLiveNodeOverrides.getState().clear(id);
+                if (sceneState.nodes[id])
+                    sceneState.markDirty(id);
+                touchedStructureIds.delete(id);
             }
             if (overrideEntries.length > 0) {
                 useLiveNodeOverrides.getState().setMany(overrideEntries);
@@ -209,56 +203,16 @@ export const MoveWallTool = ({ node }) => {
                 }
             }
         };
-        // Commit-time: flush the last live plan into the scene store as
-        // one atomic write, then drop overrides so the renderer reads
-        // from the now-current store state. Called from `commitPreview`
-        // *while history is resumed*, so the entire surface delta is one
-        // undoable step alongside the wall update.
-        const commitSurfacesToStore = () => {
-            if (!levelId || !latestSurfacePlans)
-                return;
-            const { slabs, ceilings } = latestSurfacePlans;
-            const update = [
-                ...slabs.update.map((entry) => ({
-                    id: entry.id,
-                    data: entry.data,
-                })),
-                ...ceilings.update.map((entry) => ({
-                    id: entry.id,
-                    data: entry.data,
-                })),
-            ];
-            const create = [
-                ...slabs.create.map((slab) => ({
-                    node: slab,
-                    parentId: levelId,
-                })),
-                ...ceilings.create.map((ceiling) => ({
-                    node: ceiling,
-                    parentId: levelId,
-                })),
-            ];
-            const deleteIds = [
-                ...slabs.delete.map((id) => id),
-                ...ceilings.delete.map((id) => id),
-            ];
-            if (update.length === 0 && create.length === 0 && deleteIds.length === 0)
-                return;
-            useScene.getState().applyNodeChanges({
-                update,
-                create,
-                delete: deleteIds,
-            });
-        };
         const clearSurfaceOverrides = () => {
             const overrides = useLiveNodeOverrides.getState();
-            for (const id of touchedSlabIds)
-                overrides.clear(id);
-            for (const id of touchedCeilingIds)
+            const sceneState = useScene.getState();
+            for (const id of touchedStructureIds) {
                 overrides.clear(id);
-            touchedSlabIds.clear();
-            touchedCeilingIds.clear();
-            latestSurfacePlans = null;
+                // A surface the commit deleted (rooms merged) has nothing left to rebuild.
+                if (sceneState.nodes[id])
+                    sceneState.markDirty(id);
+            }
+            touchedStructureIds.clear();
         };
         // Drop the wall position overrides and mark the walls dirty so they rebuild
         // from the now-authoritative store value (after commit) or the unchanged
@@ -268,7 +222,8 @@ export const MoveWallTool = ({ node }) => {
             const sceneState = useScene.getState();
             for (const id of touchedWallIds) {
                 overrides.clear(id);
-                sceneState.markDirty(id);
+                if (sceneState.nodes[id])
+                    sceneState.markDirty(id);
             }
             touchedWallIds.clear();
         };
@@ -286,7 +241,8 @@ export const MoveWallTool = ({ node }) => {
         };
         const applyPreview = (nextStart, nextEnd) => {
             const previous = previewRef.current ?? { start: originalStart, end: originalEnd };
-            if (nextStart[0] === previous.start[0] &&
+            if (useScene.getState().nodes === linkedNodes &&
+                nextStart[0] === previous.start[0] &&
                 nextStart[1] === previous.start[1] &&
                 nextEnd[0] === previous.end[0] &&
                 nextEnd[1] === previous.end[1])
@@ -296,6 +252,7 @@ export const MoveWallTool = ({ node }) => {
             const centerX = (nextStart[0] + nextEnd[0]) / 2;
             const centerZ = (nextStart[1] + nextEnd[1]) / 2;
             setCursorLocalPos([centerX, 0, centerZ]);
+            refreshLinkedWalls();
             const previewPlan = getMovePlan(nextStart, nextEnd);
             const previewUpdates = [
                 { id: nodeId, start: nextStart, end: nextEnd },
@@ -307,7 +264,7 @@ export const MoveWallTool = ({ node }) => {
                     .map((entry) => entry.id),
                 ...previewPlan.wallsToDelete.map((wall) => wall.id),
             ]);
-            const previewSceneWalls = getWallsAfterUpdates(useScene.getState().nodes, previewUpdates.map((entry) => ({
+            const previewSceneWalls = getWallsAfterUpdates(dragNodes, previewUpdates.map((entry) => ({
                 id: entry.id,
                 data: { start: entry.start, end: entry.end },
             }))).filter((wall) => !previewCollapsedWallIds.has(wall.id));
@@ -318,10 +275,12 @@ export const MoveWallTool = ({ node }) => {
                 existingWalls: previewSceneWalls,
             });
             const nextGhostWalls = bridgePreviews.map((preview) => preview.ghost);
-            const virtualBridgeWalls = bridgePreviews.map((preview) => preview.wall);
             setGhostWallPreviews(nextGhostWalls);
             applyNodePreview(previewUpdates);
-            publishLiveSurfaceOverrides([...previewSceneWalls, ...virtualBridgeWalls]);
+            publishLiveSurfaceOverrides([
+                ...previewSceneWalls,
+                ...bridgePreviews.map((preview) => preview.wall),
+            ]);
         };
         const restoreOriginal = () => {
             setGhostWallPreviews([]);
@@ -400,12 +359,8 @@ export const MoveWallTool = ({ node }) => {
         const commitPreview = () => {
             const preview = previewRef.current ?? { start: originalStart, end: originalEnd };
             shouldRestoreOnCleanup = false;
-            // The store was never touched during the drag (the preview was
-            // override-driven for both walls and surfaces), so there is no baseline to
-            // restore before the tracked commit — just resume history and write the
-            // final plan as one undoable change.
             setGhostWallPreviews([]);
-            resumeSceneHistory(useScene);
+            refreshLinkedWalls();
             const commitPlan = getMovePlan(preview.start, preview.end);
             const linkedWallUpdates = getPlannedLinkedWallUpdates(commitPlan, originalStart, originalEnd, preview.start, preview.end);
             const collapsedLinkedWallIds = new Set([
@@ -441,31 +396,46 @@ export const MoveWallTool = ({ node }) => {
                 existingWalls,
                 wallCount: Object.values(sceneState.nodes).filter((entry) => entry?.type === 'wall').length,
             });
-            sceneState.applyNodeChanges({
-                update: commitUpdates,
-                create: bridgeCreates,
+            // Elect each moved wall's support from its final line (keeping its current
+            // slab while that still carries it) and put any change in the same batch,
+            // so the live sync reconciles the drop in one pass.
+            const withSupport = (wall) => {
+                const patch = resolveMovedWallSupportSlabPatch(wall, sceneState.nodes);
+                return patch.supportSlabId === wall.supportSlabId ? {} : patch;
+            };
+            const wallUpdates = commitUpdates.map((entry) => ({
+                id: entry.id,
+                data: {
+                    ...entry.data,
+                    ...withSupport({ ...sceneState.nodes[entry.id], ...entry.data }),
+                },
+            }));
+            const wallCreates = bridgeCreates.map((entry) => ({
+                ...entry,
+                node: {
+                    ...entry.node,
+                    ...withSupport({ ...entry.node, parentId: entry.parentId ?? null }),
+                },
+            }));
+            // One history step, one write. The live structure sync reconciles sides,
+            // rooms, slabs and ceilings inside it, and its derived writes join the step.
+            // The drag writes nothing to the store (the preview is live overrides), so history is
+            // paused only for this drop. Keyed by the moving wall: in split view the 2D move overlay
+            // co-owns the gesture, and commitStep lifts its pause too.
+            const changes = planWallEndRejoins(sceneState.nodes, commitUpdates.map(({ id }) => id), WALL_CONNECT_SNAP_RADIUS, {
+                update: wallUpdates,
+                create: wallCreates,
                 delete: Array.from(collapsedLinkedWallIds),
             });
-            // Flush the last live surface plan (slab + ceiling creates,
-            // updates, deletes) into the store while history is still
-            // resumed, so the surface delta joins the wall change as one
-            // undoable step. Then drop the live overrides — the renderer
-            // now reads the committed walls + polygons directly.
-            commitSurfacesToStore();
-            const affectedWallIds = [
-                ...commitUpdates.map((entry) => entry.id),
-                ...bridgeCreates.map((entry) => entry.node.id),
-            ];
-            const committedNodes = useScene.getState().nodes;
-            useScene.getState().updateNodes(affectedWallIds.flatMap((id) => {
-                const wall = committedNodes[id];
-                return wall?.type === 'wall'
-                    ? [{ id, data: resolveMovedWallSupportSlabPatch(wall, committedNodes) }]
-                    : [];
-            }));
+            const drop = beginSceneHistoryPauseSession(useScene, { gesture: nodeId });
+            try {
+                drop.commitStep(() => useScene.getState().applyNodeChanges(changes));
+            }
+            finally {
+                drop.end();
+            }
             clearSurfaceOverrides();
             clearWallOverrides();
-            pauseSceneHistory(useScene);
             // Claim teardown ownership so the 2D overlay's cleanup skips its
             // own revert when split-view has both mounted — see
             // `movingNodeOrigin` in `use-editor.tsx`.
@@ -490,9 +460,10 @@ export const MoveWallTool = ({ node }) => {
             commitPreview();
         };
         const onKeyDown = (event) => {
-            if (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement) {
+            if (!active)
+                return;
+            if (isTypingTarget(event.target))
                 return;
-            }
             const ROTATION_STEP = Math.PI / 4;
             let rotationDelta = 0;
             if (event.key === 'r' || event.key === 'R')
@@ -521,7 +492,6 @@ export const MoveWallTool = ({ node }) => {
             shouldRestoreOnCleanup = false;
             restoreOriginal();
             useViewer.getState().setSelection({ selectedIds: [nodeId] });
-            resumeSceneHistory(useScene);
             markToolCancelConsumed();
             // Claim teardown ownership so the 2D overlay doesn't redundantly
             // revert the same baseline on its own cleanup.
@@ -545,7 +515,6 @@ export const MoveWallTool = ({ node }) => {
                     restoreOriginal();
                 }
             }
-            resumeSceneHistory(useScene);
             emitter.off('grid:move', onGridMove);
             emitter.off('tool:cancel', onCancel);
             window.removeEventListener('pointerup', onPointerUp);

package/dist/wall/paint.d.ts

@@ -1,15 +1,19 @@
-import { type PaintCapability, type WallNode } from '@pascal-app/core';
-import { type Ray } from 'three';
+import { type AnyNode, type WallPaintRole as CoreWallPaintRole, type PaintCapability, type WallFace, type WallNode, type WallSurfaceSlotId, wallRegionRole, wallRoomFaceRole, wallRoomFinishRole } from '@pascal-app/core';
+import { type BufferGeometry, type Ray } from 'three';
+type ResolvedWallPaintRole = {
+    kind: 'slot';
+    slotId: WallSurfaceSlotId | CurtainWallRole;
+} | Exclude<CoreWallPaintRole, {
+    kind: 'slot';
+}>;
+declare const CURTAIN_WALL_ROLES: readonly ['curtain-frame', 'curtain-glass', 'curtain-solid'];
+type CurtainWallRole = (typeof CURTAIN_WALL_ROLES)[number];
+export { wallRegionRole, wallRoomFaceRole, wallRoomFinishRole };
+export declare function parseWallPaintRole(role: string): ResolvedWallPaintRole | null;
 /**
- * Resolve which wall face band the user clicked. The side comes from:
- *   1. Material-slot index from the renderer's groups. Cheap reference path.
- *   2. Falls back to the hit-surface normal + local-Z when the
- *      groups aren't conclusive. Front/back of the wall maps to the
- *      node's `frontSide` / `backSide` semantic; absent that, front
- *      → interior, back → exterior.
- *
- * Returns null when the click is too oblique (or lands on the wall's
- * end-cap, etc.) to confidently assign a side.
+ * Resolve which wall surface the user clicked: a trim slot, a paint region,
+ * the room finish on that face, or the face slot itself. Returns null when the
+ * click is too oblique (or lands on the wall's end-cap, etc.) to pick a face.
  */
 export declare function resolveWallRole(args: {
     node: WallNode;
@@ -22,12 +26,19 @@ export declare function resolveWallRole(args: {
     normal: readonly [number, number, number] | undefined;
     localPosition: readonly [number, number, number] | undefined;
     ray?: Ray;
+    nodes?: Readonly<Record<string, AnyNode | undefined>>;
 }): string | null;
 /**
- * Capability binding for the wall kind on the unified slot model. Painting
- * writes `node.slots[bandSide]` (a `library:` ref or a minted `scene:`
- * material) exactly like every other kind; `legacyEffective` reads the
- * whole-side fallback so old scenes still show the current value.
+ * The wall's face triangles regrouped by the material index `indexFor` gives
+ * each (the face and station its centre lies at); caps keep theirs. Null when
+ * nothing moves.
+ */
+export declare function regroupWallFaces(geometry: BufferGeometry, wall: WallNode, indexFor: (face: WallFace, u: number, v: number) => number | null): BufferGeometry['groups'] | null;
+/**
+ * Capability binding for the wall kind on the unified slot model. Face and trim
+ * slots write `node.slots[slotId]` like every other kind; regions write the
+ * region's finish and room roles write the zone, because a room's wall finish
+ * belongs to the room, not to one of its walls.
  */
 export declare const wallPaint: PaintCapability;
 //# sourceMappingURL=paint.d.ts.map

package/dist/wall/paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/wall/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,eAAe,EAOpB,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAA2C,KAAK,GAAG,EAAa,MAAM,OAAO,CAAA;AAqDpF;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAA;IAC/C,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IACrD,aAAa,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IAC5D,GAAG,CAAC,EAAE,GAAG,CAAA;CACV,GAAG,MAAM,GAAG,IAAI,CAwEhB;AAsCD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,eA8DtB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/wall/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,aAAa,IAAI,iBAAiB,EAMvC,KAAK,eAAe,EAapB,KAAK,QAAQ,EAEb,KAAK,QAAQ,EACb,KAAK,iBAAiB,EAEtB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAEnB,MAAM,kBAAkB,CAAA;AAQzB,OAAO,EACL,KAAK,cAAc,EAInB,KAAK,GAAG,EAGT,MAAM,OAAO,CAAA;AAgBd,KAAK,qBAAqB,GACtB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,iBAAiB,GAAG,eAAe,CAAA;CAAE,GAC7D,OAAO,CAAC,iBAAiB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAIhD,QAAA,MAAM,kBAAkB,YAAI,eAAe,EAAE,eAAe,EAAE,eAAe,CAAU,CAAA;AACvF,KAAK,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAA;AAM1D,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,CAAA;AAE/D,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAK7E;AA6BD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAA;IAC/C,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IACrD,aAAa,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IAC5D,GAAG,CAAC,EAAE,GAAG,CAAA;IACT,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,CAAA;CACtD,GAAG,MAAM,GAAG,IAAI,CAsChB;AA8ID;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAChE,cAAc,CAAC,QAAQ,CAAC,GAAG,IAAI,CA4CjC;AA2FD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,eAkCvB,CAAA"}