@pascal-app/core 0.1.3

package/dist/lib/space-detection.js

@@ -0,0 +1,499 @@
+// ============================================================================
+// SYNC INITIALIZATION
+// ============================================================================
+/**
+ * Initializes space detection sync with scene and editor stores
+ * Call this once during app initialization
+ */
+export function initSpaceDetectionSync(sceneStore, // useScene store
+editorStore) {
+    const prevWallsByLevel = new Map();
+    let isProcessing = false; // Prevent re-entrant calls
+    // Subscribe to scene changes (standard Zustand subscribe, not selector-based)
+    const unsubscribe = sceneStore.subscribe((state) => {
+        // Skip if already processing to avoid infinite loops
+        if (isProcessing)
+            return;
+        const nodes = state.nodes;
+        const currentWallsByLevel = new Map();
+        // Group walls by level
+        for (const node of Object.values(nodes)) {
+            if (node.type === 'wall' && node.parentId) {
+                const levelId = node.parentId;
+                if (!currentWallsByLevel.has(levelId)) {
+                    currentWallsByLevel.set(levelId, new Set());
+                }
+                currentWallsByLevel.get(levelId).add(node.id);
+            }
+        }
+        // Check each level for changes
+        const levelsToUpdate = new Set();
+        // Check for new walls (created)
+        for (const [levelId, wallIds] of currentWallsByLevel.entries()) {
+            const prevWallIds = prevWallsByLevel.get(levelId);
+            if (!prevWallIds) {
+                // New level with walls - run detection if there are multiple walls
+                if (wallIds.size > 1) {
+                    levelsToUpdate.add(levelId);
+                }
+                continue;
+            }
+            // Find newly added walls
+            for (const wallId of wallIds) {
+                if (!prevWallIds.has(wallId)) {
+                    // Wall was added - check if it touches other walls
+                    const wall = nodes[wallId];
+                    const otherWalls = Array.from(wallIds)
+                        .filter((id) => id !== wallId)
+                        .map((id) => nodes[id])
+                        .filter(Boolean);
+                    if (wallTouchesOthers(wall, otherWalls)) {
+                        levelsToUpdate.add(levelId);
+                        break;
+                    }
+                }
+            }
+        }
+        // Check for deleted walls
+        for (const [levelId, prevWallIds] of prevWallsByLevel.entries()) {
+            const currentWallIds = currentWallsByLevel.get(levelId);
+            if (!currentWallIds) {
+                // All walls deleted from level - clear spaces
+                if (prevWallIds.size > 0) {
+                    levelsToUpdate.add(levelId);
+                }
+                continue;
+            }
+            // Check if any walls were deleted
+            for (const wallId of prevWallIds) {
+                if (!currentWallIds.has(wallId)) {
+                    // Wall was deleted - run detection
+                    levelsToUpdate.add(levelId);
+                    break;
+                }
+            }
+        }
+        // Run detection for affected levels
+        if (levelsToUpdate.size > 0) {
+            isProcessing = true;
+            try {
+                runSpaceDetection(Array.from(levelsToUpdate), sceneStore, editorStore, nodes);
+            }
+            finally {
+                isProcessing = false;
+            }
+        }
+        // Update previous walls reference
+        prevWallsByLevel.clear();
+        for (const [levelId, wallIds] of currentWallsByLevel.entries()) {
+            prevWallsByLevel.set(levelId, wallIds);
+        }
+    });
+    return unsubscribe;
+}
+/**
+ * Runs space detection for the given levels
+ * Updates wall nodes and editor spaces
+ */
+function runSpaceDetection(levelIds, sceneStore, editorStore, nodes) {
+    const { updateNode } = sceneStore.getState();
+    const { setSpaces } = editorStore.getState();
+    const allSpaces = {};
+    for (const levelId of levelIds) {
+        // Get walls for this level
+        const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === levelId);
+        if (walls.length === 0) {
+            // No walls - clear any spaces for this level
+            continue;
+        }
+        // Run detection
+        const { wallUpdates, spaces } = detectSpacesForLevel(levelId, walls);
+        // Update wall nodes (only if values changed to avoid infinite loop)
+        for (const update of wallUpdates) {
+            const wall = nodes[update.wallId];
+            if (wall.frontSide !== update.frontSide || wall.backSide !== update.backSide) {
+                updateNode(update.wallId, {
+                    frontSide: update.frontSide,
+                    backSide: update.backSide,
+                });
+            }
+        }
+        // Store spaces
+        for (const space of spaces) {
+            allSpaces[space.id] = space;
+        }
+    }
+    // Update editor spaces
+    setSpaces(allSpaces);
+}
+// ============================================================================
+// MAIN DETECTION FUNCTION
+// ============================================================================
+/**
+ * Detects spaces for a level by flood-filling a grid from the edges
+ * Returns wall side updates and detected spaces
+ */
+export function detectSpacesForLevel(levelId, walls, gridResolution = 0.5) {
+    if (walls.length === 0) {
+        return { wallUpdates: [], spaces: [] };
+    }
+    // Build grid from walls
+    const grid = buildGrid(walls, gridResolution);
+    // Flood fill from edges to mark exterior
+    floodFillFromEdges(grid);
+    // Find interior spaces
+    const interiorSpaces = findInteriorSpaces(grid, levelId);
+    // Assign wall sides
+    const wallUpdates = assignWallSides(walls, grid);
+    return {
+        wallUpdates,
+        spaces: interiorSpaces,
+    };
+}
+// ============================================================================
+// GRID BUILDING
+// ============================================================================
+/**
+ * Builds a discrete grid and marks cells occupied by walls
+ */
+function buildGrid(walls, resolution) {
+    // Find bounds
+    let minX = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const wall of walls) {
+        minX = Math.min(minX, wall.start[0], wall.end[0]);
+        minZ = Math.min(minZ, wall.start[1], wall.end[1]);
+        maxX = Math.max(maxX, wall.start[0], wall.end[0]);
+        maxZ = Math.max(maxZ, wall.start[1], wall.end[1]);
+    }
+    // Add padding around bounds
+    const padding = 2; // meters
+    minX -= padding;
+    minZ -= padding;
+    maxX += padding;
+    maxZ += padding;
+    const width = Math.ceil((maxX - minX) / resolution);
+    const height = Math.ceil((maxZ - minZ) / resolution);
+    const grid = {
+        cells: new Map(),
+        resolution,
+        minX,
+        minZ,
+        maxX,
+        maxZ,
+        width,
+        height,
+    };
+    // Mark wall cells
+    for (const wall of walls) {
+        markWallCells(grid, wall);
+    }
+    return grid;
+}
+/**
+ * Marks all grid cells occupied by a wall using line rasterization
+ * Uses denser sampling to ensure continuous barriers
+ */
+function markWallCells(grid, wall) {
+    const thickness = wall.thickness ?? 0.2;
+    const halfThickness = thickness / 2;
+    const [x1, z1] = wall.start;
+    const [x2, z2] = wall.end;
+    // Wall direction vector
+    const dx = x2 - x1;
+    const dz = z2 - z1;
+    const len = Math.sqrt(dx * dx + dz * dz);
+    if (len < 0.001)
+        return;
+    // Normalized direction and perpendicular
+    const dirX = dx / len;
+    const dirZ = dz / len;
+    const perpX = -dirZ;
+    const perpZ = dirX;
+    // Denser sampling along wall length (at least 2x resolution)
+    const steps = Math.max(Math.ceil(len / (grid.resolution * 0.5)), 2);
+    for (let i = 0; i <= steps; i++) {
+        const t = i / steps;
+        const x = x1 + dx * t;
+        const z = z1 + dz * t;
+        // Denser sampling across wall thickness
+        const thicknessSteps = Math.max(Math.ceil(thickness / (grid.resolution * 0.5)), 2);
+        for (let j = 0; j <= thicknessSteps; j++) {
+            const offset = (j / thicknessSteps - 0.5) * thickness;
+            const wx = x + perpX * offset;
+            const wz = z + perpZ * offset;
+            const key = getCellKey(grid, wx, wz);
+            if (key) {
+                grid.cells.set(key, 'wall');
+            }
+        }
+    }
+}
+// ============================================================================
+// FLOOD FILL
+// ============================================================================
+/**
+ * Flood fills from all edge cells to mark exterior space
+ */
+function floodFillFromEdges(grid) {
+    const queue = [];
+    // Add all edge cells to queue
+    for (let x = 0; x < grid.width; x++) {
+        for (let z = 0; z < grid.height; z++) {
+            // Only process edge cells
+            if (x === 0 || x === grid.width - 1 || z === 0 || z === grid.height - 1) {
+                const key = getCellKeyFromIndex(x, z, grid.width);
+                const cell = grid.cells.get(key);
+                if (cell !== 'wall') {
+                    grid.cells.set(key, 'exterior');
+                    queue.push(key);
+                }
+            }
+        }
+    }
+    // Flood fill
+    while (queue.length > 0) {
+        const key = queue.shift();
+        const [x, z] = parseCellKey(key);
+        // Check 4 neighbors
+        const neighbors = [
+            [x + 1, z],
+            [x - 1, z],
+            [x, z + 1],
+            [x, z - 1],
+        ];
+        for (const [nx, nz] of neighbors) {
+            if (nx < 0 || nx >= grid.width || nz < 0 || nz >= grid.height)
+                continue;
+            const nKey = getCellKeyFromIndex(nx, nz, grid.width);
+            const cell = grid.cells.get(nKey);
+            if (cell !== 'wall' && cell !== 'exterior') {
+                grid.cells.set(nKey, 'exterior');
+                queue.push(nKey);
+            }
+        }
+    }
+}
+// ============================================================================
+// INTERIOR SPACE DETECTION
+// ============================================================================
+/**
+ * Finds all interior spaces (connected regions not marked as exterior or wall)
+ */
+function findInteriorSpaces(grid, levelId) {
+    const spaces = [];
+    const visited = new Set();
+    // Scan grid for interior cells
+    for (let x = 0; x < grid.width; x++) {
+        for (let z = 0; z < grid.height; z++) {
+            const key = getCellKeyFromIndex(x, z, grid.width);
+            if (visited.has(key))
+                continue;
+            const cell = grid.cells.get(key);
+            if (cell === 'wall' || cell === 'exterior') {
+                visited.add(key);
+                continue;
+            }
+            // Found interior cell - flood fill to find full space
+            const spaceCells = new Set();
+            const queue = [key];
+            visited.add(key);
+            spaceCells.add(key);
+            // Mark the seed cell as interior in the grid
+            grid.cells.set(key, 'interior');
+            while (queue.length > 0) {
+                const curKey = queue.shift();
+                const [cx, cz] = parseCellKey(curKey);
+                const neighbors = [
+                    [cx + 1, cz],
+                    [cx - 1, cz],
+                    [cx, cz + 1],
+                    [cx, cz - 1],
+                ];
+                for (const [nx, nz] of neighbors) {
+                    if (nx < 0 || nx >= grid.width || nz < 0 || nz >= grid.height)
+                        continue;
+                    const nKey = getCellKeyFromIndex(nx, nz, grid.width);
+                    if (visited.has(nKey))
+                        continue;
+                    const nCell = grid.cells.get(nKey);
+                    if (nCell === 'wall' || nCell === 'exterior') {
+                        visited.add(nKey);
+                        continue;
+                    }
+                    visited.add(nKey);
+                    spaceCells.add(nKey);
+                    // Mark as interior in grid
+                    grid.cells.set(nKey, 'interior');
+                    queue.push(nKey);
+                }
+            }
+            // Create space from cells
+            const polygon = extractPolygonFromCells(spaceCells, grid);
+            spaces.push({
+                id: `space-${spaces.length}`,
+                levelId,
+                polygon,
+                wallIds: [],
+                isExterior: false,
+            });
+        }
+    }
+    return spaces;
+}
+/**
+ * Extracts a simplified polygon from a set of grid cells
+ * Returns bounding box for now (can be improved to trace actual boundary)
+ */
+function extractPolygonFromCells(cells, grid) {
+    let minX = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const key of cells) {
+        const [x, z] = parseCellKey(key);
+        const worldX = grid.minX + x * grid.resolution;
+        const worldZ = grid.minZ + z * grid.resolution;
+        minX = Math.min(minX, worldX);
+        minZ = Math.min(minZ, worldZ);
+        maxX = Math.max(maxX, worldX);
+        maxZ = Math.max(maxZ, worldZ);
+    }
+    // Return bounding box as polygon
+    return [
+        [minX, minZ],
+        [maxX, minZ],
+        [maxX, maxZ],
+        [minX, maxZ],
+    ];
+}
+// ============================================================================
+// WALL SIDE ASSIGNMENT
+// ============================================================================
+/**
+ * Assigns front/back side classification to each wall based on grid
+ */
+function assignWallSides(walls, grid) {
+    const updates = [];
+    for (const wall of walls) {
+        const thickness = wall.thickness ?? 0.2;
+        const [x1, z1] = wall.start;
+        const [x2, z2] = wall.end;
+        // Wall direction and perpendicular
+        const dx = x2 - x1;
+        const dz = z2 - z1;
+        const len = Math.sqrt(dx * dx + dz * dz);
+        if (len < 0.001)
+            continue;
+        const perpX = -dz / len;
+        const perpZ = dx / len;
+        // Sample point on front side (perpendicular direction)
+        const midX = (x1 + x2) / 2;
+        const midZ = (z1 + z2) / 2;
+        // Sample beyond wall thickness + one full grid cell to ensure we're in the next cell
+        const offset = thickness / 2 + grid.resolution;
+        const frontX = midX + perpX * offset;
+        const frontZ = midZ + perpZ * offset;
+        const backX = midX - perpX * offset;
+        const backZ = midZ - perpZ * offset;
+        // Check what space each side faces
+        const frontKey = getCellKey(grid, frontX, frontZ);
+        const backKey = getCellKey(grid, backX, backZ);
+        const frontCell = frontKey ? grid.cells.get(frontKey) : undefined;
+        const backCell = backKey ? grid.cells.get(backKey) : undefined;
+        const frontSide = classifySide(frontCell);
+        const backSide = classifySide(backCell);
+        updates.push({
+            wallId: wall.id,
+            frontSide,
+            backSide,
+        });
+    }
+    return updates;
+}
+/**
+ * Classifies a cell as interior, exterior, or unknown
+ */
+function classifySide(cell) {
+    if (cell === 'exterior')
+        return 'exterior';
+    if (cell === 'interior')
+        return 'interior';
+    // Wall cells or out-of-bounds (undefined) are unknown
+    return 'unknown';
+}
+// ============================================================================
+// GRID UTILITIES
+// ============================================================================
+/**
+ * Gets grid cell key from world coordinates
+ */
+function getCellKey(grid, x, z) {
+    const cellX = Math.floor((x - grid.minX) / grid.resolution);
+    const cellZ = Math.floor((z - grid.minZ) / grid.resolution);
+    if (cellX < 0 || cellX >= grid.width || cellZ < 0 || cellZ >= grid.height) {
+        return null;
+    }
+    return `${cellX},${cellZ}`;
+}
+/**
+ * Gets cell key from grid indices
+ */
+function getCellKeyFromIndex(x, z, width) {
+    return `${x},${z}`;
+}
+/**
+ * Parses cell key back to indices
+ */
+function parseCellKey(key) {
+    const parts = key.split(',');
+    return [Number.parseInt(parts[0], 10), Number.parseInt(parts[1], 10)];
+}
+// ============================================================================
+// WALL CONNECTIVITY DETECTION
+// ============================================================================
+/**
+ * Checks if a wall touches any other walls
+ * Used to determine if space detection should run
+ */
+export function wallTouchesOthers(wall, otherWalls) {
+    const threshold = 0.1; // 10cm connection threshold
+    for (const other of otherWalls) {
+        if (other.id === wall.id)
+            continue;
+        // Check if any endpoint of wall is close to any endpoint or segment of other
+        if (distanceToSegment(wall.start, other.start, other.end) < threshold ||
+            distanceToSegment(wall.end, other.start, other.end) < threshold ||
+            distanceToSegment(other.start, wall.start, wall.end) < threshold ||
+            distanceToSegment(other.end, wall.start, wall.end) < threshold) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Distance from point to line segment
+ */
+function distanceToSegment(point, segStart, segEnd) {
+    const [px, pz] = point;
+    const [x1, z1] = segStart;
+    const [x2, z2] = segEnd;
+    const dx = x2 - x1;
+    const dz = z2 - z1;
+    const lenSq = dx * dx + dz * dz;
+    if (lenSq < 0.0001) {
+        // Segment is a point
+        const dpx = px - x1;
+        const dpz = pz - z1;
+        return Math.sqrt(dpx * dpx + dpz * dpz);
+    }
+    // Project point onto line
+    const t = Math.max(0, Math.min(1, ((px - x1) * dx + (pz - z1) * dz) / lenSq));
+    const projX = x1 + t * dx;
+    const projZ = z1 + t * dz;
+    const distX = px - projX;
+    const distZ = pz - projZ;
+    return Math.sqrt(distX * distX + distZ * distZ);
+}

package/dist/schema/base.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+/**
+ * Material preset name reference
+ * @example 'white', 'brick', 'wood', 'glass', 'preview-valid'
+ */
+export declare const Material: z.ZodOptional<z.ZodString>;
+export declare const generateId: <T extends string>(prefix: T) => `${T}_${string}`;
+export declare const objectId: <T extends string>(prefix: T) => z.ZodDefault<z.ZodTemplateLiteral<`${`${T}_` extends infer T_1 ? T_1 extends `${T}_` ? T_1 extends string | number | bigint | boolean | null | undefined ? `${T_1 extends infer T_2 ? T_2 extends T_1 ? T_2 extends undefined ? "" : T_2 : never : never}` : T_1 extends z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? `${z.core.output<T_1> extends infer T_3 extends string | number | bigint | boolean | null | undefined ? T_3 extends undefined ? "" : T_3 : never}` : never : never : never}${string}`>>;
+export declare const nodeType: <T extends string>(type: T) => z.ZodDefault<z.ZodLiteral<T>>;
+export declare const BaseNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    id: z.ZodString;
+    type: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+}, z.core.$strip>;
+export type BaseNode = z.infer<typeof BaseNode>;
+//# sourceMappingURL=base.d.ts.map

package/dist/schema/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/schema/base.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;GAGG;AACH,eAAO,MAAM,QAAQ,4BAAwB,CAAA;AAC7C,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,CAAC,KAAG,GAAG,CAAC,IAAI,MAAM,EACxB,CAAA;AAC/C,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,CAAC,qhBAInD,CAAA;AACD,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,MAAM,EAAE,MAAM,CAAC,kCAAkC,CAAA;AAEpF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;iBASnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/base.js

@@ -0,0 +1,25 @@
+import { customAlphabet } from 'nanoid';
+import { z } from 'zod';
+import { CameraSchema } from './camera';
+const customId = customAlphabet('0123456789abcdefghijklmnopqrstuvwxyz', 16);
+/**
+ * Material preset name reference
+ * @example 'white', 'brick', 'wood', 'glass', 'preview-valid'
+ */
+export const Material = z.string().optional();
+export const generateId = (prefix) => `${prefix}_${customId()}`;
+export const objectId = (prefix) => {
+    const schema = z.templateLiteral([`${prefix}_`, z.string()]);
+    return schema.default(() => generateId(prefix));
+};
+export const nodeType = (type) => z.literal(type).default(type);
+export const BaseNode = z.object({
+    object: z.literal('node').default('node'),
+    id: z.string(), // objectId('node'), @Aymericr: Thing is if we specify objectId here, when using BaseNode.extend, TS complains that the id is not assignable to the more specific type in the extended node
+    type: nodeType('node'),
+    name: z.string().optional(),
+    parentId: z.string().nullable().default(null),
+    visible: z.boolean().optional().default(true),
+    camera: CameraSchema.optional(),
+    metadata: z.json().optional().default({}),
+});

package/dist/schema/camera.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const CameraSchema: z.ZodObject<{
+    position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        perspective: "perspective";
+        orthographic: "orthographic";
+    }>>;
+    fov: z.ZodOptional<z.ZodNumber>;
+    zoom: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type Camera = z.infer<typeof CameraSchema>;
+//# sourceMappingURL=camera.d.ts.map

package/dist/schema/camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../../src/schema/camera.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,YAAY;;;;;;;;;iBAMvB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/schema/camera.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+const Vector3Schema = z.tuple([z.number(), z.number(), z.number()]);
+export const CameraSchema = z.object({
+    position: Vector3Schema,
+    target: Vector3Schema,
+    mode: z.enum(['perspective', 'orthographic']).default('perspective'),
+    fov: z.number().optional(), // For perspective
+    zoom: z.number().optional(), // For orthographic
+});

package/dist/schema/index.d.ts

@@ -0,0 +1,17 @@
+export { BaseNode, generateId, Material, nodeType, objectId } from './base';
+export { CameraSchema } from './camera';
+export type { AssetInput } from './nodes/item';
+export { ItemNode } from './nodes/item';
+export { LevelNode } from './nodes/level';
+export { SiteNode } from './nodes/site';
+export { SlabNode } from './nodes/slab';
+export { WallNode } from './nodes/wall';
+export { BuildingNode } from './nodes/building';
+export { CeilingNode } from './nodes/ceiling';
+export { ZoneNode } from './nodes/zone';
+export { RoofNode } from './nodes/roof';
+export { ScanNode } from './nodes/scan';
+export { GuideNode } from './nodes/guide';
+export type { AnyNodeId, AnyNodeType } from './types';
+export { AnyNode } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAE3E,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACvC,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAEzC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAE7C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA"}

package/dist/schema/index.js

@@ -0,0 +1,18 @@
+// Base
+export { BaseNode, generateId, Material, nodeType, objectId } from './base';
+// Camera
+export { CameraSchema } from './camera';
+export { ItemNode } from './nodes/item';
+export { LevelNode } from './nodes/level';
+// Nodes
+export { SiteNode } from './nodes/site';
+export { SlabNode } from './nodes/slab';
+export { WallNode } from './nodes/wall';
+export { BuildingNode } from './nodes/building';
+export { CeilingNode } from './nodes/ceiling';
+export { ZoneNode } from './nodes/zone';
+export { RoofNode } from './nodes/roof';
+export { ScanNode } from './nodes/scan';
+export { GuideNode } from './nodes/guide';
+// Union types
+export { AnyNode } from './types';

package/dist/schema/nodes/building.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const BuildingNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`building_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"building">>;
+    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>>>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strip>;
+export type BuildingNode = z.infer<typeof BuildingNode>;
+//# sourceMappingURL=building.d.ts.map

package/dist/schema/nodes/building.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"building.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/building.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;iBAaxB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/schema/nodes/building.js

@@ -0,0 +1,16 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { LevelNode } from './level';
+export const BuildingNode = BaseNode.extend({
+    id: objectId('building'),
+    type: nodeType('building'),
+    children: z.array(LevelNode.shape.id).default([]),
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+}).describe(dedent `
+  Building node - used to represent a building
+  - position: position in site coordinate system
+  - rotation: rotation in site coordinate system
+  - children: array of level nodes (each level is a tree of floor and wall nodes) 
+  `);