@pascal-app/core 1.0.3 → 1.0.5

package/dist/lib/unit-containment.js

@@ -1,7 +1,7 @@
 import { pointOnPolygonBoundary, wallOverlapsSlabFootprint } from '../systems/slab/slab-support.js';
 import { measurementCentroid } from './measurement-geometry.js';
 import { pointInPolygon } from './polygon-relations.js';
-import { detectSpacesForLevel, resolveAutoZonePolygon } from './space-detection.js';
+import { detectSpacesForLevel } from './space-detection.js';
 function footprintCentroid(node) {
     if ('position' in node && Array.isArray(node.position) && node.position.length === 3) {
         return [node.position[0], node.position[2]];
@@ -44,7 +44,7 @@ export function deriveUnit(unit, nodes) {
             continue;
         levels.set(level.id, level);
         const polygons = polygonsByLevel.get(level.id) ?? [];
-        polygons.push(resolveAutoZonePolygon(zone, (id) => nodes[id]));
+        polygons.push(zone.polygon);
         polygonsByLevel.set(level.id, polygons);
     }
     const levelIds = [...levels.values()]

package/dist/lib/unit-report.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unit-report.d.ts","sourceRoot":"","sources":["../../src/lib/unit-report.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAIlF,MAAM,MAAM,UAAU,GAAG;IACvB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IAC3E,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,KAAK,CAAC;QACb,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;QACtB,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;QAC/B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;QAC3B,MAAM,EAAE,MAAM,CAAA;KACf,CAAC,CAAA;CACH,CAAA;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,UAAU,CAgCZ"}
+{"version":3,"file":"unit-report.d.ts","sourceRoot":"","sources":["../../src/lib/unit-report.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAGlF,MAAM,MAAM,UAAU,GAAG;IACvB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IAC3E,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,KAAK,CAAC;QACb,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;QACtB,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;QAC/B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;QAC3B,MAAM,EAAE,MAAM,CAAA;KACf,CAAC,CAAA;CACH,CAAA;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,UAAU,CAmCZ"}

package/dist/lib/unit-report.js

@@ -1,5 +1,4 @@
-import { measurementArea } from './measurement-geometry.js';
-import { resolveAutoZonePolygon } from './space-detection.js';
+import { area } from './polygon-boolean.js';
 export function buildUnitReport(unit, nodes) {
     const levels = new Map();
     const members = [...new Set(unit.members)].flatMap((id) => {
@@ -9,14 +8,16 @@ export function buildUnitReport(unit, nodes) {
         const level = zone.parentId ? nodes[zone.parentId] : undefined;
         if (level?.type === 'level')
             levels.set(level.id, level.level);
-        const polygon = resolveAutoZonePolygon(zone, (nodeId) => nodes[nodeId]);
+        const { polygon, holes } = zone;
         return [
             {
                 zoneId: zone.id,
                 name: zone.name,
                 levelId: level?.type === 'level' ? level.id : null,
                 levelOrdinal: level?.type === 'level' ? level.level : null,
-                areaM2: measurementArea(polygon.map(([x, z]) => [x, 0, z])),
+                areaM2: zone.autoFromWalls && zone.enclosureStatus === 'open'
+                    ? 0
+                    : area([{ outer: polygon, holes }]),
             },
         ];
     });

package/dist/lib/wall-face-script.d.ts

@@ -0,0 +1,66 @@
+import type { AnyNode, CompiledGeometryScript, WallFaceScript } from '../schema/index.js';
+import type { WallFace } from '../schema/nodes/wall.js';
+import type { WallSlabSupport } from '../systems/slab/slab-support.js';
+type SceneNodes = Readonly<Record<string, AnyNode>>;
+/** A rectangle on a wall face, in the face's frame and metres. */
+export type WallFaceRect = {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/**
+ * What a wall face's script is built for, in the face's frame and metres: x along the wall from
+ * its start, y up from the face's base (its lowest floor), z out of the face. `outline` is the
+ * face's rectangle (its mitred ends, up to the wall's top or the script's `toHeight`); `holes` the
+ * doors and windows cutting it, clipped to it (a door from the floor under it, a window from its
+ * sill); `base` the face's floor from end to end as `[x, y]` points (one level run on a flat floor,
+ * a jump where a raised room meets it); `thickness` the wall's. The build stays in this frame.
+ */
+export type WallFaceScriptInputs = {
+    outline: WallFaceRect;
+    holes: WallFaceRect[];
+    base: [number, number][];
+    thickness: number;
+};
+/** How far the face's frame stands above the wall's own origin: its lowest floor, wall-local. */
+export declare function wallFaceBaseOffset(support: WallSlabSupport, face: WallFace): number;
+/**
+ * The face a script builds on, or null when it has none: a curved or curtain wall, a wall with no
+ * level, or a face with no height above its floor.
+ */
+export declare function wallFaceScriptInputs(nodes: SceneNodes, wallId: string, face: WallFace, toHeight?: number): WallFaceScriptInputs | null;
+/** The key a face script keeps of the face it was built for (`WallFaceScript.inputs`). */
+export declare function wallFaceScriptInputsKey(inputs: WallFaceScriptInputs): string;
+/** A compile as the wall keeps it on a face: its script source, its face's key, its `toHeight`. */
+export declare function wallFaceScriptRecord(compiled: CompiledGeometryScript, inputs: WallFaceScriptInputs, toHeight: number | undefined, previous?: WallFaceScript): WallFaceScript;
+/**
+ * Where a face's build goes in the wall's local frame (x along the wall from its start, z toward
+ * face a): its frame's origin at the face's base, 1 mm proud of the face. Face b's frame has z out
+ * of face b, so the build is mirrored through the wall (`scale` z −1; three.js flips the winding of
+ * a mirrored mesh) and its x still runs from the wall's start. Null when the face has no frame.
+ */
+export declare function wallFaceScriptPlacement(nodes: SceneNodes, wallId: string, face: WallFace): {
+    position: [number, number, number];
+    scale: [number, number, number];
+} | null;
+/**
+ * Where a face's skirting gives way to its script, as it does at a door: the build's span along
+ * the wall when the build comes down into the skirting's band (its bottom below `bandTop`, in the
+ * face's frame), else null. The script wins visually where it covers the band; a splashback above
+ * the skirting leaves it whole.
+ */
+export declare function wallFaceScriptSkirtingGap(script: WallFaceScript, bandTop: number): [number, number] | null;
+export type WallFacePaintRefusal = {
+    status: 'refused';
+    code: 'wall-face-built-by-script';
+    message: string;
+};
+/**
+ * Why a paint on a wall's `role` is refused: it lands on a face (the face itself, a region of it,
+ * the room's finish on it) that a script builds to the top, and the script owns its colours. A
+ * script stopping at `toHeight` leaves its face paintable, since the paint shows above it.
+ */
+export declare function wallFaceScriptPaintRefusal(wall: AnyNode | undefined, role: string): WallFacePaintRefusal | undefined;
+export {};
+//# sourceMappingURL=wall-face-script.d.ts.map

package/dist/lib/wall-face-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-face-script.d.ts","sourceRoot":"","sources":["../../src/lib/wall-face-script.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,sBAAsB,EAEtB,cAAc,EAGf,MAAM,WAAW,CAAA;AAClB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAenE,KAAK,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAEnD,kEAAkE;AAClE,MAAM,MAAM,YAAY,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7E;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,YAAY,CAAA;IACrB,KAAK,EAAE,YAAY,EAAE,CAAA;IACrB,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAKD,iGAAiG;AACjG,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAOnF;AAgID;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,QAAQ,EACd,QAAQ,CAAC,EAAE,MAAM,GAChB,oBAAoB,GAAG,IAAI,CAgC7B;AAED,0FAA0F;AAC1F,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,oBAAoB,GAAG,MAAM,CAI5E;AAED,mGAAmG;AACnG,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,sBAAsB,EAChC,MAAM,EAAE,oBAAoB,EAC5B,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,QAAQ,CAAC,EAAE,cAAc,GACxB,cAAc,CAMhB;AAKD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,QAAQ,GACb;IAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,IAAI,CAYhF;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,MAAM,GACd,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAGzB;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,SAAS,CAAA;IACjB,IAAI,EAAE,2BAA2B,CAAA;IACjC,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,OAAO,GAAG,SAAS,EACzB,IAAI,EAAE,MAAM,GACX,oBAAoB,GAAG,SAAS,CAkBlC"}

package/dist/lib/wall-face-script.js

@@ -0,0 +1,235 @@
+import { getWallTop } from '../services/storey.js';
+import { isCurvedWall } from '../systems/wall/wall-curve.js';
+import { parseWallPaintRole } from '../systems/wall/wall-finish.js';
+import { getWallThickness } from '../systems/wall/wall-footprint.js';
+import { getWallLocalFaceZ } from '../systems/wall/wall-frame.js';
+import { calculateLevelMiters, getWallMiterBoundaryPoints, } from '../systems/wall/wall-mitering.js';
+import { isFloorAnchoredOpening } from './floor-opening-footprints.js';
+import { scriptSource } from './geometry-script-node.js';
+import { getOpeningFloorDatum, wallSupportForNodes } from './opening-floor-datum.js';
+import { scriptInputsKey } from './script-inputs-key.js';
+const EPS = 1e-6;
+const round = (value) => Math.round(value * 1e4) / 1e4;
+/** How far the face's frame stands above the wall's own origin: its lowest floor, wall-local. */
+export function wallFaceBaseOffset(support, face) {
+    const runs = support.faceDatum[face];
+    if (!runs.length)
+        return 0;
+    const lowest = Math.min(...runs.map((run) => Math.min(run.elevation, run.endElevation ?? run.elevation)));
+    return lowest - support.elevation;
+}
+const mitersByNodes = new WeakMap();
+function levelMiters(nodes, levelId) {
+    let levels = mitersByNodes.get(nodes);
+    if (!levels) {
+        levels = new Map();
+        mitersByNodes.set(nodes, levels);
+    }
+    let miters = levels.get(levelId);
+    if (!miters) {
+        const walls = Object.values(nodes)
+            .filter((node) => node.type === 'wall' && node.parentId === levelId)
+            .sort((a, b) => a.id.localeCompare(b.id));
+        miters = calculateLevelMiters(walls);
+        levels.set(levelId, miters);
+    }
+    return miters;
+}
+/** A wall whose faces a script can build on: straight, not a curtain wall, standing on a level. */
+function scriptableWall(nodes, wallId) {
+    const wall = nodes[wallId];
+    if (wall?.type !== 'wall' || !wall.parentId)
+        return null;
+    if (wall.wallType === 'curtain' || isCurvedWall(wall))
+        return null;
+    return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]) < EPS ? null : wall;
+}
+function faceFrame(nodes, wallId, face) {
+    const wall = scriptableWall(nodes, wallId);
+    if (!wall?.parentId)
+        return null;
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dz);
+    const support = wallSupportForNodes(wall, nodes);
+    const offset = wallFaceBaseOffset(support, face);
+    const top = getWallTop(wall, wall.parentId, nodes, support.elevation) -
+        support.elevation -
+        offset;
+    const station = (point) => ((point.x - wall.start[0]) * dx + (point.y - wall.start[1]) * dz) / length;
+    const ends = getWallMiterBoundaryPoints(wall, levelMiters(nodes, wall.parentId));
+    const x0 = ends ? station(face === 'a' ? ends.startLeft : ends.startRight) : 0;
+    const x1 = ends ? station(face === 'a' ? ends.endLeft : ends.endRight) : length;
+    if (top <= EPS || x1 - x0 <= EPS)
+        return null;
+    return { wall, length, support, offset, x0, x1, top };
+}
+/** The face's floor as `[x, y]` points from `x0` to `x1`, in the face's frame. */
+function faceBase(frame, face) {
+    const { support, length, offset, x0, x1 } = frame;
+    const runs = [...support.faceDatum[face]].sort((a, b) => a.start - b.start);
+    const points = runs.length
+        ? runs.flatMap((run) => [
+            [run.start * length, run.elevation - support.elevation - offset],
+            [run.end * length, (run.endElevation ?? run.elevation) - support.elevation - offset],
+        ])
+        : [
+            [0, 0],
+            [length, 0],
+        ];
+    const yAt = (x) => {
+        if (x <= points[0][0])
+            return points[0][1];
+        for (let index = 1; index < points.length; index += 1) {
+            const [ax, ay] = points[index - 1];
+            const [bx, by] = points[index];
+            if (x <= bx)
+                return bx - ax < EPS ? by : ay + ((x - ax) / (bx - ax)) * (by - ay);
+        }
+        return points[points.length - 1][1];
+    };
+    const kept = [
+        [x0, yAt(x0)],
+        ...points.filter(([x]) => x > x0 + EPS && x < x1 - EPS),
+        [x1, yAt(x1)],
+    ];
+    const base = kept.map(([x, y]) => [round(x), round(y)]);
+    // A point on the straight line between its neighbours (a run's end where the next runs on
+    // level) says nothing; a jump (two points at one x) or a bend stays.
+    const simplified = [];
+    for (const point of base) {
+        const previous = simplified[simplified.length - 1];
+        if (previous && previous[0] === point[0] && previous[1] === point[1])
+            continue;
+        const before = simplified[simplified.length - 2];
+        if (before &&
+            previous &&
+            before[0] < previous[0] &&
+            previous[0] < point[0] &&
+            Math.abs((previous[0] - before[0]) * (point[1] - before[1]) -
+                (previous[1] - before[1]) * (point[0] - before[0])) < EPS)
+            simplified.pop();
+        simplified.push(point);
+    }
+    return simplified;
+}
+/** The lowest point of `base` over `[x0, x1]`. */
+function baseLowUnder(base, x0, x1) {
+    let low = Number.POSITIVE_INFINITY;
+    for (let index = 1; index < base.length; index += 1) {
+        const [ax, ay] = base[index - 1];
+        const [bx, by] = base[index];
+        if (bx < x0 || ax > x1)
+            continue;
+        const at = (x) => bx - ax < EPS ? Math.min(ay, by) : ay + ((x - ax) / (bx - ax)) * (by - ay);
+        low = Math.min(low, at(Math.max(ax, x0)), at(Math.min(bx, x1)));
+    }
+    return Number.isFinite(low) ? low : 0;
+}
+/**
+ * The face a script builds on, or null when it has none: a curved or curtain wall, a wall with no
+ * level, or a face with no height above its floor.
+ */
+export function wallFaceScriptInputs(nodes, wallId, face, toHeight) {
+    const frame = faceFrame(nodes, wallId, face);
+    if (!frame)
+        return null;
+    const { wall, support, offset, x0, x1, top } = frame;
+    const outline = {
+        x0: round(x0),
+        y0: 0,
+        x1: round(x1),
+        y1: round(toHeight === undefined ? top : Math.min(toHeight, top)),
+    };
+    const base = faceBase(frame, face);
+    const holes = (wall.children ?? []).flatMap((childId) => {
+        const opening = nodes[childId];
+        if (opening?.type !== 'door' && opening?.type !== 'window')
+            return [];
+        const { position, width, height } = opening;
+        const centre = getOpeningFloorDatum(wall, opening, nodes, support) - support.elevation - offset + position[1];
+        const left = position[0] - width / 2;
+        const right = position[0] + width / 2;
+        const bottom = isFloorAnchoredOpening(opening)
+            ? Math.min(centre - height / 2, baseLowUnder(base, left, right))
+            : centre - height / 2;
+        const hole = {
+            x0: round(Math.max(left, outline.x0)),
+            y0: round(Math.max(bottom, outline.y0)),
+            x1: round(Math.min(right, outline.x1)),
+            y1: round(Math.min(centre + height / 2, outline.y1)),
+        };
+        return hole.x1 - hole.x0 > EPS && hole.y1 - hole.y0 > EPS ? [hole] : [];
+    });
+    holes.sort((a, b) => a.x0 - b.x0 || a.y0 - b.y0);
+    return { outline, holes, base, thickness: round(getWallThickness(wall)) };
+}
+/** The key a face script keeps of the face it was built for (`WallFaceScript.inputs`). */
+export function wallFaceScriptInputsKey(inputs) {
+    return scriptInputsKey(JSON.stringify([inputs.outline, inputs.holes, inputs.base, inputs.thickness]));
+}
+/** A compile as the wall keeps it on a face: its script source, its face's key, its `toHeight`. */
+export function wallFaceScriptRecord(compiled, inputs, toHeight, previous) {
+    return {
+        ...scriptSource(compiled, {}, previous),
+        inputs: wallFaceScriptInputsKey(inputs),
+        ...(toHeight === undefined ? {} : { toHeight }),
+    };
+}
+/** Over the face, so the face's own finish never shows through the tiles. */
+const WALL_FACE_SCRIPT_PROUD = 0.001;
+/**
+ * Where a face's build goes in the wall's local frame (x along the wall from its start, z toward
+ * face a): its frame's origin at the face's base, 1 mm proud of the face. Face b's frame has z out
+ * of face b, so the build is mirrored through the wall (`scale` z −1; three.js flips the winding of
+ * a mirrored mesh) and its x still runs from the wall's start. Null when the face has no frame.
+ */
+export function wallFaceScriptPlacement(nodes, wallId, face) {
+    const wall = scriptableWall(nodes, wallId);
+    if (!wall)
+        return null;
+    const out = face === 'a' ? 1 : -1;
+    return {
+        position: [
+            0,
+            wallFaceBaseOffset(wallSupportForNodes(wall, nodes), face),
+            getWallLocalFaceZ(wall, face) + out * WALL_FACE_SCRIPT_PROUD,
+        ],
+        scale: [1, 1, out],
+    };
+}
+/**
+ * Where a face's skirting gives way to its script, as it does at a door: the build's span along
+ * the wall when the build comes down into the skirting's band (its bottom below `bandTop`, in the
+ * face's frame), else null. The script wins visually where it covers the band; a splashback above
+ * the skirting leaves it whole.
+ */
+export function wallFaceScriptSkirtingGap(script, bandTop) {
+    const { min, max } = script.manifest.bounds;
+    return min[1] < bandTop - EPS ? [min[0], max[0]] : null;
+}
+/**
+ * Why a paint on a wall's `role` is refused: it lands on a face (the face itself, a region of it,
+ * the room's finish on it) that a script builds to the top, and the script owns its colours. A
+ * script stopping at `toHeight` leaves its face paintable, since the paint shows above it.
+ */
+export function wallFaceScriptPaintRefusal(wall, role) {
+    if (wall?.type !== 'wall')
+        return;
+    const parsed = parseWallPaintRole(role, (slotId) => slotId === 'a' || slotId === 'b');
+    const face = parsed?.kind === 'slot'
+        ? parsed.slotId
+        : parsed?.kind === 'room-face'
+            ? parsed.face
+            : parsed?.kind === 'region'
+                ? wall.faceRegions?.find((region) => region.id === parsed.regionId)?.face
+                : undefined;
+    const script = face && wall.finishScripts?.[face];
+    if (!face || !script || script.toHeight !== undefined)
+        return;
+    return {
+        status: 'refused',
+        code: 'wall-face-built-by-script',
+        message: `${wall.name?.trim() || 'This wall'}'s side ${face.toUpperCase()} is built by a script, which owns its colours. Remove the script to paint that side.`,
+    };
+}

package/dist/lib/zone-colors.d.ts

@@ -0,0 +1,11 @@
+/** The colour picker's swatches, in hue order. */
+export declare const ZONE_COLOR_PALETTE: readonly ['#ef4444', '#f97316', '#f59e0b', '#84cc16', '#22c55e', '#10b981', '#06b6d4', '#3b82f6', '#6366f1', '#a855f7', '#64748b', '#cccccc'];
+/**
+ * The colour a new zone is created with: a palette hue picked from a seed —
+ * the zone's id, or for an imported room a value of its source that survives
+ * re-import (a capture's id). Seeded rather than random, so every creator of
+ * the same room — the browser's reconciler, the hosted MCP bridge, a capture
+ * re-run — writes the same colour.
+ */
+export declare function zoneColorForSeed(seed: string): string;
+//# sourceMappingURL=zone-colors.d.ts.map

package/dist/lib/zone-colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone-colors.d.ts","sourceRoot":"","sources":["../../src/lib/zone-colors.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,eAAO,MAAM,kBAAkB,YAC7B,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,CACD,CAAA;AAKV;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOrD"}

package/dist/lib/zone-colors.js

@@ -0,0 +1,32 @@
+/** The colour picker's swatches, in hue order. */
+export const ZONE_COLOR_PALETTE = [
+    '#ef4444', // Red        0°
+    '#f97316', // Orange    30°
+    '#f59e0b', // Amber     45°
+    '#84cc16', // Lime      85°
+    '#22c55e', // Green    142°
+    '#10b981', // Emerald  160°
+    '#06b6d4', // Cyan     190°
+    '#3b82f6', // Blue     217°
+    '#6366f1', // Indigo   239°
+    '#a855f7', // Violet   270°
+    '#64748b', // Dark gray
+    '#cccccc', // Light gray
+];
+// Greys read as "no colour", so new rooms get one of the hues.
+const ROOM_HUES = ZONE_COLOR_PALETTE.slice(0, 10);
+/**
+ * The colour a new zone is created with: a palette hue picked from a seed —
+ * the zone's id, or for an imported room a value of its source that survives
+ * re-import (a capture's id). Seeded rather than random, so every creator of
+ * the same room — the browser's reconciler, the hosted MCP bridge, a capture
+ * re-run — writes the same colour.
+ */
+export function zoneColorForSeed(seed) {
+    let h = 2166136261;
+    for (let i = 0; i < seed.length; i++) {
+        h ^= seed.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return ROOM_HUES[(h >>> 0) % ROOM_HUES.length];
+}

package/dist/lib/zone-quantities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zone-quantities.d.ts","sourceRoot":"","sources":["../../src/lib/zone-quantities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAmC,QAAQ,EAAE,MAAM,WAAW,CAAA;AAYnF,MAAM,MAAM,iBAAiB,GACzB;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,WAAW,GAAG,eAAe,CAAA;IAC7C,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,eAAe,EAAE,MAAM,EAAE,CAAA;IACzB,WAAW,EAAE,iBAAiB,CAAA;IAC9B,YAAY,EAAE,iBAAiB,CAAA;IAC/B,MAAM,EAAE,iBAAiB,CAAA;CAC1B,CAAA;AA8bD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC5C,kBAAkB,CAmGpB"}
+{"version":3,"file":"zone-quantities.d.ts","sourceRoot":"","sources":["../../src/lib/zone-quantities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAmC,QAAQ,EAAE,MAAM,WAAW,CAAA;AAuBnF,MAAM,MAAM,iBAAiB,GACzB;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,WAAW,GAAG,eAAe,CAAA;IAC7C,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,eAAe,EAAE,MAAM,EAAE,CAAA;IACzB,WAAW,EAAE,iBAAiB,CAAA;IAC9B,YAAY,EAAE,iBAAiB,CAAA;IAC/B,MAAM,EAAE,iBAAiB,CAAA;CAC1B,CAAA;AAsQD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC5C,kBAAkB,CA0IpB"}