@pascal-app/core 0.1.3

package/dist/hooks/spatial-grid/spatial-grid.js

@@ -0,0 +1,115 @@
+export class SpatialGrid {
+    config;
+    cells = new Map();
+    itemCells = new Map(); // reverse lookup
+    constructor(config) {
+        this.config = config;
+    }
+    posToCell(x, z) {
+        return [Math.floor(x / this.config.cellSize), Math.floor(z / this.config.cellSize)];
+    }
+    cellKey(cx, cz) {
+        return `${cx},${cz}`;
+    }
+    // Get all cells an item occupies based on its AABB
+    getItemCells(position, dimensions, rotation) {
+        // Simplified: axis-aligned bounding box
+        // For full rotation support, compute rotated corners
+        const [x, , z] = position;
+        const [w, , d] = dimensions;
+        const yRot = rotation[1]; // Y-axis rotation
+        // Compute rotated footprint (simplified for 90° increments)
+        const cos = Math.abs(Math.cos(yRot));
+        const sin = Math.abs(Math.sin(yRot));
+        const rotatedW = w * cos + d * sin;
+        const rotatedD = w * sin + d * cos;
+        const minX = x - rotatedW / 2;
+        const maxX = x + rotatedW / 2;
+        const minZ = z - rotatedD / 2;
+        const maxZ = z + rotatedD / 2;
+        const [minCx, minCz] = this.posToCell(minX, minZ);
+        // Use exclusive upper bound: subtract epsilon so exact boundaries don't overlap
+        // This allows adjacent items (touching but not overlapping) to not conflict
+        const epsilon = 1e-6;
+        const [maxCx, maxCz] = this.posToCell(maxX - epsilon, maxZ - epsilon);
+        const keys = [];
+        for (let cx = minCx; cx <= maxCx; cx++) {
+            for (let cz = minCz; cz <= maxCz; cz++) {
+                keys.push(this.cellKey(cx, cz));
+            }
+        }
+        return keys;
+    }
+    // Register an item
+    insert(itemId, position, dimensions, rotation) {
+        const cellKeys = this.getItemCells(position, dimensions, rotation);
+        this.itemCells.set(itemId, new Set(cellKeys));
+        for (const key of cellKeys) {
+            if (!this.cells.has(key)) {
+                this.cells.set(key, { itemIds: new Set() });
+            }
+            this.cells.get(key).itemIds.add(itemId);
+        }
+    }
+    // Remove an item
+    remove(itemId) {
+        const cellKeys = this.itemCells.get(itemId);
+        if (!cellKeys)
+            return;
+        for (const key of cellKeys) {
+            const cell = this.cells.get(key);
+            if (cell) {
+                cell.itemIds.delete(itemId);
+                if (cell.itemIds.size === 0) {
+                    this.cells.delete(key);
+                }
+            }
+        }
+        this.itemCells.delete(itemId);
+    }
+    // Update = remove + insert
+    update(itemId, position, dimensions, rotation) {
+        this.remove(itemId);
+        this.insert(itemId, position, dimensions, rotation);
+    }
+    // Query: is this placement valid?
+    canPlace(position, dimensions, rotation, ignoreIds = []) {
+        const cellKeys = this.getItemCells(position, dimensions, rotation);
+        const ignoreSet = new Set(ignoreIds);
+        const conflicts = new Set();
+        for (const key of cellKeys) {
+            const cell = this.cells.get(key);
+            if (cell) {
+                for (const id of cell.itemIds) {
+                    if (!ignoreSet.has(id)) {
+                        conflicts.add(id);
+                    }
+                }
+            }
+        }
+        return {
+            valid: conflicts.size === 0,
+            conflictIds: [...conflicts],
+        };
+    }
+    // Query: get all items near a point (for snapping, selection, etc.)
+    queryRadius(x, z, radius) {
+        const cellRadius = Math.ceil(radius / this.config.cellSize);
+        const [cx, cz] = this.posToCell(x, z);
+        const found = new Set();
+        for (let dx = -cellRadius; dx <= cellRadius; dx++) {
+            for (let dz = -cellRadius; dz <= cellRadius; dz++) {
+                const cell = this.cells.get(this.cellKey(cx + dx, cz + dz));
+                if (cell) {
+                    for (const id of cell.itemIds) {
+                        found.add(id);
+                    }
+                }
+            }
+        }
+        return [...found];
+    }
+    getItemCount() {
+        return this.itemCells.size;
+    }
+}

package/dist/hooks/spatial-grid/use-spatial-query.d.ts

@@ -0,0 +1,16 @@
+import type { CeilingNode, LevelNode, WallNode } from '../../schema';
+export declare function useSpatialQuery(): {
+    canPlaceOnFloor: (levelId: LevelNode["id"], position: [number, number, number], dimensions: [number, number, number], rotation: [number, number, number], ignoreIds?: string[]) => {
+        valid: boolean;
+        conflictIds: string[];
+    };
+    canPlaceOnWall: (levelId: LevelNode["id"], wallId: WallNode["id"], localX: number, localY: number, dimensions: [number, number, number], attachType?: "wall" | "wall-side", side?: "front" | "back", ignoreIds?: string[]) => {
+        valid: boolean;
+        conflictIds: string[];
+    };
+    canPlaceOnCeiling: (ceilingId: CeilingNode["id"], position: [number, number, number], dimensions: [number, number, number], rotation: [number, number, number], ignoreIds?: string[]) => {
+        valid: boolean;
+        conflictIds: string[];
+    };
+};
+//# sourceMappingURL=use-spatial-query.d.ts.map

package/dist/hooks/spatial-grid/use-spatial-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-spatial-query.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/use-spatial-query.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAGpE,wBAAgB,eAAe;+BAGhB,SAAS,CAAC,IAAI,CAAC,YACd,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,cACtB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,YAC1B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,cACtB,MAAM,EAAE;;;;8BASX,SAAS,CAAC,IAAI,CAAC,UAChB,QAAQ,CAAC,IAAI,CAAC,UACd,MAAM,UACN,MAAM,cACF,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,eACxB,MAAM,GAAG,WAAW,SACzB,OAAO,GAAG,MAAM,cACX,MAAM,EAAE;;;;mCAkBT,WAAW,CAAC,IAAI,CAAC,YAClB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,cACtB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,YAC1B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,cACtB,MAAM,EAAE;;;;EAQzB"}

package/dist/hooks/spatial-grid/use-spatial-query.js

@@ -0,0 +1,14 @@
+import { useCallback } from 'react';
+import { spatialGridManager } from './spatial-grid-manager';
+export function useSpatialQuery() {
+    const canPlaceOnFloor = useCallback((levelId, position, dimensions, rotation, ignoreIds) => {
+        return spatialGridManager.canPlaceOnFloor(levelId, position, dimensions, rotation, ignoreIds);
+    }, []);
+    const canPlaceOnWall = useCallback((levelId, wallId, localX, localY, dimensions, attachType = 'wall', side, ignoreIds) => {
+        return spatialGridManager.canPlaceOnWall(levelId, wallId, localX, localY, dimensions, attachType, side, ignoreIds);
+    }, []);
+    const canPlaceOnCeiling = useCallback((ceilingId, position, dimensions, rotation, ignoreIds) => {
+        return spatialGridManager.canPlaceOnCeiling(ceilingId, position, dimensions, rotation, ignoreIds);
+    }, []);
+    return { canPlaceOnFloor, canPlaceOnWall, canPlaceOnCeiling };
+}

package/dist/hooks/spatial-grid/wall-spatial-grid.d.ts

@@ -0,0 +1,47 @@
+type WallSide = 'front' | 'back';
+type AttachType = 'wall' | 'wall-side';
+interface WallItemPlacement {
+    itemId: string;
+    wallId: string;
+    tStart: number;
+    tEnd: number;
+    yStart: number;
+    yEnd: number;
+    attachType?: AttachType;
+    side?: WallSide;
+}
+export declare class WallSpatialGrid {
+    private wallItems;
+    private itemToWall;
+    /**
+     * Check if an item can be placed on a wall
+     * @param wallId - The wall to place on
+     * @param wallLength - Length of the wall
+     * @param wallHeight - Height of the wall
+     * @param tCenter - Parametric center position (0-1) along wall
+     * @param itemWidth - Width of the item
+     * @param yBottom - Bottom Y position of the item
+     * @param itemHeight - Height of the item
+     * @param attachType - 'wall' (blocks both sides) or 'wall-side' (blocks one side)
+     * @param side - Which side for 'wall-side' items
+     * @param ignoreIds - Item IDs to ignore in conflict check
+     */
+    canPlaceOnWall(wallId: string, wallLength: number, wallHeight: number, tCenter: number, itemWidth: number, yBottom: number, itemHeight: number, attachType?: AttachType, side?: WallSide, ignoreIds?: string[]): {
+        valid: boolean;
+        conflictIds: string[];
+    };
+    /**
+     * Check if two items conflict based on their attach types and sides
+     * - 'wall' items block both sides, so they conflict with everything
+     * - 'wall-side' items only conflict if they're on the same side or if the other is a 'wall' item
+     */
+    private checkSideConflict;
+    insert(placement: WallItemPlacement): void;
+    remove(wallId: string, itemId: string): void;
+    removeByItemId(itemId: string): void;
+    removeWall(wallId: string): string[];
+    getWallForItem(itemId: string): string | undefined;
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=wall-spatial-grid.d.ts.map

package/dist/hooks/spatial-grid/wall-spatial-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-spatial-grid.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/wall-spatial-grid.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAA;AAChC,KAAK,UAAU,GAAG,MAAM,GAAG,WAAW,CAAA;AAKtC,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,IAAI,CAAC,EAAE,QAAQ,CAAA;CAChB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAAyC;IAC1D,OAAO,CAAC,UAAU,CAA4B;IAE9C;;;;;;;;;;;;OAYG;IACH,cAAc,CACZ,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,UAAU,GAAE,UAAmB,EAC/B,IAAI,CAAC,EAAE,QAAQ,EACf,SAAS,GAAE,MAAM,EAAO,GACvB;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE;IAoC5C;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IA0BzB,MAAM,CAAC,SAAS,EAAE,iBAAiB;IAUnC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IASrC,cAAc,CAAC,MAAM,EAAE,MAAM;IAQ7B,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAapC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIlD,KAAK;CAIN"}

package/dist/hooks/spatial-grid/wall-spatial-grid.js

@@ -0,0 +1,113 @@
+// Small tolerance for floating point comparison to allow adjacent items
+const EPSILON = 0.001;
+export class WallSpatialGrid {
+    wallItems = new Map(); // wallId -> placements
+    itemToWall = new Map(); // itemId -> wallId (reverse lookup)
+    /**
+     * Check if an item can be placed on a wall
+     * @param wallId - The wall to place on
+     * @param wallLength - Length of the wall
+     * @param wallHeight - Height of the wall
+     * @param tCenter - Parametric center position (0-1) along wall
+     * @param itemWidth - Width of the item
+     * @param yBottom - Bottom Y position of the item
+     * @param itemHeight - Height of the item
+     * @param attachType - 'wall' (blocks both sides) or 'wall-side' (blocks one side)
+     * @param side - Which side for 'wall-side' items
+     * @param ignoreIds - Item IDs to ignore in conflict check
+     */
+    canPlaceOnWall(wallId, wallLength, wallHeight, tCenter, itemWidth, yBottom, itemHeight, attachType = 'wall', side, ignoreIds = []) {
+        const halfW = itemWidth / wallLength / 2;
+        const tStart = tCenter - halfW;
+        const tEnd = tCenter + halfW;
+        // yBottom is the bottom of the item, so yEnd = yBottom + itemHeight
+        const yStart = yBottom;
+        const yEnd = yBottom + itemHeight;
+        // Check wall boundaries
+        if (tStart < 0 || tEnd > 1 || yStart < 0 || yEnd > wallHeight) {
+            return { valid: false, conflictIds: [] };
+        }
+        const existing = this.wallItems.get(wallId) ?? [];
+        const ignoreSet = new Set(ignoreIds);
+        const conflicts = [];
+        for (const placement of existing) {
+            if (ignoreSet.has(placement.itemId))
+                continue;
+            // Use EPSILON tolerance to allow items to be exactly adjacent
+            const tOverlap = tStart < placement.tEnd - EPSILON && tEnd > placement.tStart + EPSILON;
+            const yOverlap = yStart < placement.yEnd - EPSILON && yEnd > placement.yStart + EPSILON;
+            if (tOverlap && yOverlap) {
+                // Check side conflicts based on attach types
+                const hasConflict = this.checkSideConflict(attachType, side, placement);
+                if (hasConflict) {
+                    conflicts.push(placement.itemId);
+                }
+            }
+        }
+        return { valid: conflicts.length === 0, conflictIds: conflicts };
+    }
+    /**
+     * Check if two items conflict based on their attach types and sides
+     * - 'wall' items block both sides, so they conflict with everything
+     * - 'wall-side' items only conflict if they're on the same side or if the other is a 'wall' item
+     */
+    checkSideConflict(newAttachType, newSide, existing) {
+        // Treat undefined/legacy attachType as 'wall' (blocks both sides)
+        const existingAttachType = existing.attachType ?? 'wall';
+        // If new item is 'wall' type, it conflicts with everything (needs both sides)
+        if (newAttachType === 'wall') {
+            return true;
+        }
+        // If existing item is 'wall' type, it blocks both sides
+        if (existingAttachType === 'wall') {
+            return true;
+        }
+        // Both are 'wall-side' - only conflict if they're on the same side
+        // If either side is undefined, be conservative and assume conflict
+        if (!newSide || !existing.side) {
+            return true;
+        }
+        return newSide === existing.side;
+    }
+    insert(placement) {
+        const { wallId, itemId } = placement;
+        if (!this.wallItems.has(wallId)) {
+            this.wallItems.set(wallId, []);
+        }
+        this.wallItems.get(wallId).push(placement);
+        this.itemToWall.set(itemId, wallId);
+    }
+    remove(wallId, itemId) {
+        const items = this.wallItems.get(wallId);
+        if (items) {
+            const idx = items.findIndex((p) => p.itemId === itemId);
+            if (idx !== -1)
+                items.splice(idx, 1);
+        }
+        this.itemToWall.delete(itemId);
+    }
+    removeByItemId(itemId) {
+        const wallId = this.itemToWall.get(itemId);
+        if (wallId) {
+            this.remove(wallId, itemId);
+        }
+    }
+    // Useful for when a wall is deleted - remove all items on it
+    removeWall(wallId) {
+        const items = this.wallItems.get(wallId) ?? [];
+        const removedIds = items.map((p) => p.itemId);
+        for (const itemId of removedIds) {
+            this.itemToWall.delete(itemId);
+        }
+        this.wallItems.delete(wallId);
+        return removedIds; // Return removed item IDs in case you need to delete them from scene
+    }
+    // Get which wall an item is on
+    getWallForItem(itemId) {
+        return this.itemToWall.get(itemId);
+    }
+    clear() {
+        this.wallItems.clear();
+        this.itemToWall.clear();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export type { BuildingEvent, CameraControlEvent, EventSuffix, GridEvent, ItemEvent, LevelEvent, NodeEvent, SlabEvent, WallEvent, ZoneEvent, CeilingEvent, RoofEvent, } from './events/bus';
+export { emitter, eventSuffixes } from './events/bus';
+export { sceneRegistry, useRegistry, } from './hooks/scene-registry/scene-registry';
+export { initSpatialGridSync, resolveLevelId, } from './hooks/spatial-grid/spatial-grid-sync';
+export { useSpatialQuery } from './hooks/spatial-grid/use-spatial-query';
+export { pointInPolygon } from './hooks/spatial-grid/spatial-grid-manager';
+export * from './schema';
+export { default as useScene } from './store/use-scene';
+export { CeilingSystem } from './systems/ceiling/ceiling-system';
+export { ItemSystem } from './systems/item/item-system';
+export { RoofSystem } from './systems/roof/roof-system';
+export { SlabSystem } from './systems/slab/slab-system';
+export { WallSystem } from './systems/wall/wall-system';
+export { isObject } from './utils/types';
+export { saveAsset, loadAssetUrl } from './lib/asset-storage';
+export { detectSpacesForLevel, wallTouchesOthers, initSpaceDetectionSync, type Space } from './lib/space-detection';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,WAAW,EACX,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,YAAY,EACZ,SAAS,GACV,MAAM,cAAc,CAAA;AAErB,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAErD,OAAO,EACL,aAAa,EACb,WAAW,GACZ,MAAM,uCAAuC,CAAA;AAC9C,OAAO,EACL,mBAAmB,EACnB,cAAc,GACf,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AACxE,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAA;AAE1E,cAAc,UAAU,CAAA;AACxB,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAEvD,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAEvD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAE7D,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,KAAK,KAAK,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/index.js

@@ -0,0 +1,22 @@
+// Store
+// Events
+export { emitter, eventSuffixes } from './events/bus';
+// Hooks
+export { sceneRegistry, useRegistry, } from './hooks/scene-registry/scene-registry';
+export { initSpatialGridSync, resolveLevelId, } from './hooks/spatial-grid/spatial-grid-sync';
+export { useSpatialQuery } from './hooks/spatial-grid/use-spatial-query';
+export { pointInPolygon } from './hooks/spatial-grid/spatial-grid-manager';
+// Schema
+export * from './schema';
+export { default as useScene } from './store/use-scene';
+// Systems
+export { CeilingSystem } from './systems/ceiling/ceiling-system';
+export { ItemSystem } from './systems/item/item-system';
+export { RoofSystem } from './systems/roof/roof-system';
+export { SlabSystem } from './systems/slab/slab-system';
+export { WallSystem } from './systems/wall/wall-system';
+export { isObject } from './utils/types';
+// Asset storage
+export { saveAsset, loadAssetUrl } from './lib/asset-storage';
+// Space detection
+export { detectSpacesForLevel, wallTouchesOthers, initSpaceDetectionSync } from './lib/space-detection';

package/dist/lib/asset-storage.d.ts

@@ -0,0 +1,11 @@
+export declare const ASSET_PREFIX = "asset_data:";
+/**
+ * Save a file to IndexedDB and return a custom protocol URL
+ */
+export declare function saveAsset(file: File): Promise<string>;
+/**
+ * Load a file from IndexedDB and return an object URL
+ * If the URL is not a custom protocol URL, return it as is
+ */
+export declare function loadAssetUrl(url: string): Promise<string | null>;
+//# sourceMappingURL=asset-storage.d.ts.map

package/dist/lib/asset-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-storage.d.ts","sourceRoot":"","sources":["../../src/lib/asset-storage.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,gBAAgB,CAAA;AAKzC;;GAEG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAI3D;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkCtE"}

package/dist/lib/asset-storage.js

@@ -0,0 +1,48 @@
+import { get, set } from 'idb-keyval';
+export const ASSET_PREFIX = 'asset_data:';
+// Cache for active object URLs to prevent leaks and flickering
+const urlCache = new Map();
+/**
+ * Save a file to IndexedDB and return a custom protocol URL
+ */
+export async function saveAsset(file) {
+    const id = crypto.randomUUID();
+    await set(`${ASSET_PREFIX}${id}`, file);
+    return `asset://${id}`;
+}
+/**
+ * Load a file from IndexedDB and return an object URL
+ * If the URL is not a custom protocol URL, return it as is
+ */
+export async function loadAssetUrl(url) {
+    if (!url)
+        return null;
+    // If it's already a blob or http URL, return as is
+    if (url.startsWith('blob:') || url.startsWith('http')) {
+        return url;
+    }
+    // Handle our custom asset protocol
+    if (url.startsWith('asset://')) {
+        const id = url.replace('asset://', '');
+        // Check cache first
+        if (urlCache.has(id)) {
+            return urlCache.get(id);
+        }
+        try {
+            const file = await get(`${ASSET_PREFIX}${id}`);
+            if (!file) {
+                console.warn(`Asset not found: ${id}`);
+                return null;
+            }
+            const objectUrl = URL.createObjectURL(file);
+            urlCache.set(id, objectUrl);
+            return objectUrl;
+        }
+        catch (error) {
+            console.error('Failed to load asset:', error);
+            return null;
+        }
+    }
+    // Legacy data URLs are returned as is
+    return url;
+}

package/dist/lib/space-detection.d.ts

@@ -0,0 +1,34 @@
+import type { WallNode } from '../schema';
+export type Space = {
+    id: string;
+    levelId: string;
+    polygon: Array<[number, number]>;
+    wallIds: string[];
+    isExterior: boolean;
+};
+/**
+ * Initializes space detection sync with scene and editor stores
+ * Call this once during app initialization
+ */
+export declare function initSpaceDetectionSync(sceneStore: any, // useScene store
+editorStore: any): () => void;
+type WallSideUpdate = {
+    wallId: string;
+    frontSide: 'interior' | 'exterior' | 'unknown';
+    backSide: 'interior' | 'exterior' | 'unknown';
+};
+/**
+ * Detects spaces for a level by flood-filling a grid from the edges
+ * Returns wall side updates and detected spaces
+ */
+export declare function detectSpacesForLevel(levelId: string, walls: WallNode[], gridResolution?: number): {
+    wallUpdates: WallSideUpdate[];
+    spaces: Space[];
+};
+/**
+ * Checks if a wall touches any other walls
+ * Used to determine if space detection should run
+ */
+export declare function wallTouchesOthers(wall: WallNode, otherWalls: WallNode[]): boolean;
+export {};
+//# sourceMappingURL=space-detection.d.ts.map

package/dist/lib/space-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"space-detection.d.ts","sourceRoot":"","sources":["../../src/lib/space-detection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAMzC,MAAM,MAAM,KAAK,GAAG;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChC,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAMD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,GAAG,EAAE,iBAAiB;AAClC,WAAW,EAAE,GAAG,GACf,MAAM,IAAI,CAgGZ;AA+DD,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;IAC9C,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;CAC9C,CAAA;AAMD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,QAAQ,EAAE,EACjB,cAAc,GAAE,MAAY,GAC3B;IACD,WAAW,EAAE,cAAc,EAAE,CAAA;IAC7B,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB,CAqBA;AAsWD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,OAAO,CAkBjF"}