@pascal-app/core 1.0.3 → 1.0.5

package/dist/lib/absorb-wall-separators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"absorb-wall-separators.d.ts","sourceRoot":"","sources":["../../src/lib/absorb-wall-separators.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAE/D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmE5F"}

package/dist/lib/absorb-wall-separators.js

@@ -0,0 +1,65 @@
+import { SeparatorNode } from '../schema/nodes/separator.js';
+import { omitUndefined } from '../utils/omit-undefined.js';
+import { sampleWallPointsForRoomDetection } from './room-graph.js';
+export function absorbWallSeparators(nodes, levelId, mintId) {
+    const walls = Object.values(nodes).filter((n) => n.type === 'wall' && n.parentId === levelId);
+    const lines = walls.flatMap((wall) => {
+        const points = sampleWallPointsForRoomDetection(wall);
+        return points.slice(1).map((end, i) => [points[i], end]);
+    });
+    const patches = [];
+    const next = { ...nodes };
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'separator' || node.parentId !== levelId)
+            continue;
+        const [x, y] = node.start, dx = node.end[0] - x, dy = node.end[1] - y;
+        const length = Math.hypot(dx, dy);
+        if (length < 1e-7)
+            continue;
+        let ranges = [[0, 1]];
+        for (const [a, b] of lines) {
+            if ([a, b].some((p) => Math.abs((p.x - x) * dy - (p.y - y) * dx) / length > 1e-6))
+                continue;
+            const ts = [a, b].map((p) => ((p.x - x) * dx + (p.y - y) * dy) / (length * length));
+            const lo = Math.min(...ts), hi = Math.max(...ts);
+            ranges = ranges.flatMap(([start, end]) => {
+                if (hi <= start + 1e-7 || lo >= end - 1e-7)
+                    return [[start, end]];
+                return [
+                    ...(lo > start + 1e-7 ? [[start, lo]] : []),
+                    ...(hi < end - 1e-7 ? [[hi, end]] : []),
+                ];
+            });
+        }
+        if (ranges.length === 1 && ranges[0][0] === 0 && ranges[0][1] === 1)
+            continue;
+        if (!ranges.length) {
+            delete next[node.id];
+            patches.push({ op: 'delete', id: node.id });
+        }
+        for (const [i, [a, b]] of ranges.entries()) {
+            const separator = omitUndefined(SeparatorNode.parse({
+                ...node,
+                id: i ? mintId() : node.id,
+                start: [x + dx * a, y + dy * a],
+                end: [x + dx * b, y + dy * b],
+            }));
+            next[separator.id] = separator;
+            patches.push(i
+                ? { op: 'create', node: separator }
+                : { op: 'update', id: node.id, data: { start: separator.start, end: separator.end } });
+        }
+    }
+    if (patches.length) {
+        const level = next[levelId];
+        if (level?.type === 'level') {
+            const children = [
+                ...level.children.filter((id) => !!next[id]),
+                ...patches.flatMap((p) => p.op === 'create' && p.node.type === 'separator' ? [p.node.id] : []),
+            ];
+            next[levelId] = { ...level, children };
+            patches.push({ op: 'update', id: level.id, data: { children } });
+        }
+    }
+    return { nodes: patches.length ? next : nodes, patches };
+}

package/dist/lib/angle-accumulator.d.ts

@@ -0,0 +1,3 @@
+/** Unwrap consecutive pointer bearings into a continuous gesture angle. */
+export declare function createAngleAccumulator(initialAngle: number): (angle: number) => number;
+//# sourceMappingURL=angle-accumulator.d.ts.map

package/dist/lib/angle-accumulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angle-accumulator.d.ts","sourceRoot":"","sources":["../../src/lib/angle-accumulator.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,WAG1C,MAAM,YAOtB"}

package/dist/lib/angle-accumulator.js

@@ -0,0 +1,13 @@
+/** Unwrap consecutive pointer bearings into a continuous gesture angle. */
+export function createAngleAccumulator(initialAngle) {
+    let previous = initialAngle;
+    let total = 0;
+    return (angle) => {
+        if (!Number.isFinite(angle))
+            return total;
+        const change = angle - previous;
+        total += Math.atan2(Math.sin(change), Math.cos(change));
+        previous = angle;
+        return total;
+    };
+}

package/dist/lib/artifact-store.d.ts

@@ -0,0 +1,31 @@
+import type { GeometryArtifactMetadata } from '../schema/geometry-metadata.js';
+/**
+ * Content-addressed geometry artifacts. Nodes reference an artifact as
+ * `artifact://<sha256>` and never by URL, so where the bytes live is the
+ * host's choice: the hosted app stores them per project behind an access
+ * check; the default keeps them in memory for the session.
+ */
+export declare const ARTIFACT_URL_PREFIX = "artifact://";
+export type ArtifactStore = {
+    /** A loadable URL for a stored artifact, or null when this store does not have it. */
+    url: (sha256: string) => string | null;
+    /** Stores bytes and returns their stored hash, which may change if the host compresses them. */
+    put: (sha256: string, bytes: ArrayBuffer | Uint8Array, mimeType: string, context?: {
+        nodeId: string;
+        metadata: GeometryArtifactMetadata;
+    }) => Promise<string>;
+    /** A stored text artifact (an authored object's script), or null when it is missing or unreadable here. */
+    text: (sha256: string) => Promise<string | null>;
+    /**
+     * Brings artifacts another project holds into this store's project (a paste
+     * from that project), under the reader's access there. Resolves to the
+     * hashes it could not bring. Absent where artifacts are not kept per project.
+     */
+    copyFrom?: (projectId: string, sha256s: string[]) => Promise<string[]>;
+};
+export declare function configureArtifactStore(next: ArtifactStore | null): void;
+export declare function getArtifactStore(): ArtifactStore;
+export declare const artifactUrl: (sha256: string) => string;
+export declare function artifactHash(url: string): string | null;
+export declare function resolveArtifactUrl(url: string): string | null;
+//# sourceMappingURL=artifact-store.d.ts.map

package/dist/lib/artifact-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-store.d.ts","sourceRoot":"","sources":["../../src/lib/artifact-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAA;AAE3E;;;;;GAKG;AAEH,eAAO,MAAM,mBAAmB,gBAAgB,CAAA;AAEhD,MAAM,MAAM,aAAa,GAAG;IAC1B,sFAAsF;IACtF,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IACtC,gGAAgG;IAChG,GAAG,EAAE,CACH,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,WAAW,GAAG,UAAU,EAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,wBAAwB,CAAA;KAAE,KAC7D,OAAO,CAAC,MAAM,CAAC,CAAA;IACpB,2GAA2G;IAC3G,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAChD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;CACvE,CAAA;AAsBD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,IAAI,CAEvE;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAED,eAAO,MAAM,WAAW,WAAY,MAAM,WAAsC,CAAA;AAEhF,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIvD;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG7D"}

package/dist/lib/artifact-store.js

@@ -0,0 +1,42 @@
+/**
+ * Content-addressed geometry artifacts. Nodes reference an artifact as
+ * `artifact://<sha256>` and never by URL, so where the bytes live is the
+ * host's choice: the hosted app stores them per project behind an access
+ * check; the default keeps them in memory for the session.
+ */
+export const ARTIFACT_URL_PREFIX = 'artifact://';
+const memory = new Map();
+const memoryStore = {
+    url: (sha256) => memory.get(sha256)?.url ?? null,
+    put: async (sha256, bytes, mimeType) => {
+        if (memory.has(sha256))
+            return sha256;
+        memory.set(sha256, {
+            url: URL.createObjectURL(new Blob([bytes], { type: mimeType })),
+            bytes,
+        });
+        return sha256;
+    },
+    text: async (sha256) => {
+        const stored = memory.get(sha256);
+        return stored ? new TextDecoder().decode(stored.bytes) : null;
+    },
+};
+let store = memoryStore;
+export function configureArtifactStore(next) {
+    store = next ?? memoryStore;
+}
+export function getArtifactStore() {
+    return store;
+}
+export const artifactUrl = (sha256) => `${ARTIFACT_URL_PREFIX}${sha256}`;
+export function artifactHash(url) {
+    if (!url.startsWith(ARTIFACT_URL_PREFIX))
+        return null;
+    const sha = url.slice(ARTIFACT_URL_PREFIX.length);
+    return /^[0-9a-f]{64}$/.test(sha) ? sha : null;
+}
+export function resolveArtifactUrl(url) {
+    const sha = artifactHash(url);
+    return sha ? store.url(sha) : null;
+}

package/dist/lib/assembly-stack.d.ts

@@ -0,0 +1,54 @@
+import { type Assembly, type LayerRole } from '../schema/assembly.js';
+export type AssemblyDiagnosticCode = 
+/**
+ * The host's stored thickness is not the sum of its layers (a stale or
+ * hand-edited value). The stack wins; hosts that draw from the stored
+ * thickness keep their plain body until a writer re-derives it.
+ */
+'assembly.thickness-mismatch'
+/** Nothing to stack: body and backing both sum to 0. */
+ | 'assembly.empty'
+/** `backing` on a host that refuses it: ignored. */
+ | 'assembly.backing-refused';
+export type AssemblyDiagnostic = {
+    code: AssemblyDiagnosticCode;
+    message: string;
+};
+export type ResolvedAssemblyLayer = {
+    id: string;
+    role: LayerRole;
+    /** Depth of the layer's reference-side face below the stack's first face, metres. */
+    depth: number;
+    thickness: number;
+    core: boolean;
+    material?: string;
+    slot?: string;
+    src?: string;
+    /** Backing only: as declared (`inset`, `bottom`, `lift`). */
+    inset?: number;
+    bottom?: number;
+    lift?: number;
+};
+export type ResolvedAssembly = {
+    layers: ResolvedAssemblyLayer[];
+    /** Σ layer thickness: the host's body, which a wall stores as `thickness`. */
+    total: number;
+    /**
+     * Backing layers on a host that accepts them, `depth` measured from the
+     * body's far face outward; empty otherwise.
+     */
+    backing: ResolvedAssemblyLayer[];
+    diagnostics: AssemblyDiagnostic[];
+};
+/**
+ * Resolves the body stack of `assembly`, in the order it lists its layers.
+ * The stack sets the body, so `total` is the thickness the host must store;
+ * `host.body` is the value it stores today (`null` when it stores none, as a
+ * roof) and only produces a diagnostic when it disagrees. Pure and total: it
+ * never throws and never changes a declared thickness.
+ */
+export declare function resolveAssemblyStack(assembly: Assembly, host: {
+    body: number | null;
+    backing?: boolean;
+}): ResolvedAssembly;
+//# sourceMappingURL=assembly-stack.d.ts.map

package/dist/lib/assembly-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembly-stack.d.ts","sourceRoot":"","sources":["../../src/lib/assembly-stack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAEtF,MAAM,MAAM,sBAAsB;AAChC;;;;GAIG;AACD,6BAA6B;AAC/B,wDAAwD;GACtD,gBAAgB;AAClB,oDAAoD;GAClD,0BAA0B,CAAA;AAE9B,MAAM,MAAM,kBAAkB,GAAG;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAElF,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,SAAS,CAAA;IACf,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,qBAAqB,EAAE,CAAA;IAC/B,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAA;IACb;;;OAGG;IACH,OAAO,EAAE,qBAAqB,EAAE,CAAA;IAChC,WAAW,EAAE,kBAAkB,EAAE,CAAA;CAClC,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAC/C,gBAAgB,CAyBlB"}

package/dist/lib/assembly-stack.js

@@ -0,0 +1,52 @@
+import { ASSEMBLY_TOLERANCE } from '../schema/assembly.js';
+/**
+ * Resolves the body stack of `assembly`, in the order it lists its layers.
+ * The stack sets the body, so `total` is the thickness the host must store;
+ * `host.body` is the value it stores today (`null` when it stores none, as a
+ * roof) and only produces a diagnostic when it disagrees. Pure and total: it
+ * never throws and never changes a declared thickness.
+ */
+export function resolveAssemblyStack(assembly, host) {
+    const diagnostics = [];
+    if (assembly.backing?.length && !host.backing) {
+        diagnostics.push({
+            code: 'assembly.backing-refused',
+            message: 'This host has no backing; its backing layers are ignored.',
+        });
+    }
+    const layers = stackLayers(assembly.layers);
+    const total = layers.reduce((sum, layer) => sum + layer.thickness, 0);
+    const backing = host.backing ? stackLayers(assembly.backing ?? []) : [];
+    const backingTotal = backing.reduce((sum, layer) => sum + layer.thickness, 0);
+    if (!(total > 0) && !(backingTotal > 0)) {
+        diagnostics.push({ code: 'assembly.empty', message: 'The layers sum to 0.' });
+        return { layers: [], total: 0, backing: [], diagnostics };
+    }
+    if (host.body !== null && Math.abs(host.body - total) > ASSEMBLY_TOLERANCE) {
+        diagnostics.push({
+            code: 'assembly.thickness-mismatch',
+            message: `The layers sum to ${total} m but the host stores ${host.body} m.`,
+        });
+    }
+    return { layers, total, backing, diagnostics };
+}
+function stackLayers(layers) {
+    let depth = 0;
+    return layers.map((layer) => {
+        const resolved = {
+            id: layer.id,
+            role: layer.role,
+            depth,
+            thickness: layer.thickness,
+            core: layer.core === true,
+            ...(layer.material === undefined ? {} : { material: layer.material }),
+            ...(layer.slot === undefined ? {} : { slot: layer.slot }),
+            ...(layer.src === undefined ? {} : { src: layer.src }),
+            ...(layer.inset === undefined ? {} : { inset: layer.inset }),
+            ...(layer.bottom === undefined ? {} : { bottom: layer.bottom }),
+            ...(layer.lift === undefined ? {} : { lift: layer.lift }),
+        };
+        depth += layer.thickness;
+        return resolved;
+    });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"asset-storage.d.ts","sourceRoot":"","sources":["../../src/lib/asset-storage.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,gBAAgB,CAAA;AAQzC;;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"}
+{"version":3,"file":"asset-storage.d.ts","sourceRoot":"","sources":["../../src/lib/asset-storage.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,gBAAgB,CAAA;AAQzC;;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,CAoCtE"}

package/dist/lib/asset-storage.js

@@ -1,5 +1,6 @@
 import { get, set } from 'idb-keyval';
 import { customAlphabet } from 'nanoid';
+import { ARTIFACT_URL_PREFIX, resolveArtifactUrl } from './artifact-store.js';
 export const ASSET_PREFIX = 'asset_data:';
 // Cache for active object URLs to prevent leaks and flickering
 const urlCache = new Map();
@@ -24,6 +25,8 @@ export async function loadAssetUrl(url) {
     if (url.startsWith('blob:') || url.startsWith('http')) {
         return url;
     }
+    if (url.startsWith(ARTIFACT_URL_PREFIX))
+        return resolveArtifactUrl(url);
     // Handle our custom asset protocol
     if (url.startsWith('asset://')) {
         const id = url.replace('asset://', '');

package/dist/lib/below-grade-footprints.d.ts

@@ -0,0 +1,65 @@
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+import { type Point2D } from './polygon-union.js';
+/**
+ * Where the ground meets the levels below grade, in the site's plan: each such level's floor slabs
+ * placed where its building stands and joined into outlines, the levels' together as one set (a
+ * deeper level wider than the one over it, or under part of it, gives one outline, not overlapping
+ * ones). The 3D view cuts its hole in the ground and draws its grade ring along them while the
+ * ground is veiled. An automatic floor follows the walls' centrelines, so an outline runs half a
+ * wall inside the outer faces. A level only partly below grade (a walk-out on a hillside) gives
+ * the part of its floor the ground stands over by more than {@link BELOW_GRADE_TOLERANCE}, the
+ * edge following the slope; fully buried levels give their whole floor.
+ *
+ * With `shownLevelId`, only what the level display needs open over that level: the level itself and
+ * the levels between it and grade (the ones the display hides above it: `level` index at or over
+ * its own, in every building, as the display decides from the index alone), the levels the author
+ * has hidden left out. The levels deeper than the one shown stay under the ground. Without it,
+ * every level below grade.
+ */
+export declare function belowGradeFootprints(nodes: Record<AnyNodeId, AnyNode>, shownLevelId?: string | null): Point2D[][];
+/**
+ * The part of the ground that lies over the house itself: what is below grade under the footprint
+ * of the levels above it, in the site's plan. The house covers it, so the ground can stand open
+ * there whatever level is shown: from outside nothing changes (the storeys are over it), and the
+ * stairwells and floor openings of the stacked view, and the walkthrough on a stair, meet the
+ * basement and not a sheet of ground across it. A below-grade level reaching out under the garden
+ * gives only the part the house stands over; the rest stays closed, no pit in the garden.
+ *
+ * Per building, a level below grade is covered by the floor slabs of the visible levels over it
+ * (`level` index above its own) that are not themselves fully buried: the ones at grade, and the
+ * part of a floor only partly below grade that stands out of the hill. A hidden level covers
+ * nothing and is covered by nothing. Of a level only partly below grade, only the part the ground
+ * stands over is open. A slab's own openings do not count: the stairwell is where the ground
+ * should be open.
+ *
+ * Outlines with an inner outline (a courtyard the house wraps round) are left out: the ground
+ * cannot be cut around an island of itself, and closed is the safe side.
+ */
+export declare function coveredBelowGradeFootprints(nodes: Record<AnyNodeId, AnyNode>): Point2D[][];
+/**
+ * How deep the pit under the hole goes: the world Y of the top of the lowest floor of the level
+ * shown (the sunken room of a split level, not its raised part), the deepest of the levels the hole
+ * is cut over (`belowGradeFootprints` with the same id). `null` when no level is shown or it is
+ * not below grade.
+ */
+export declare function belowGradeFloorY(nodes: Record<AnyNodeId, AnyNode>, shownLevelId?: string | null): number | null;
+/** How far under the top of the floor plate the pit hangs its own floor: the default plate's thickness. */
+export declare const GROUND_PIT_FLOOR_DROP = 0.05;
+/**
+ * How far the pit's floor keeps from the plane of the plate's underside. The foundation under the
+ * level tops out on that plane (`genericFoundation`), and seen through the hole it has to stand
+ * on the pit's floor, not share its plane: two faces on one plane flicker. 2 cm is what a 24-bit
+ * depth buffer with the viewer's 0.3 m near plane tells apart out to about 300 m, further than
+ * the hole is ever looked into from.
+ */
+export declare const GROUND_PIT_PLATE_CLEARANCE = 0.02;
+/**
+ * The world Y the pit under the hole draws its dark floor at, over the level shown: under the top
+ * of its lowest floor (`belowGradeFloorY`) by {@link GROUND_PIT_FLOOR_DROP}, which for the default
+ * plate is exactly its underside, where the footing and the walls on it stop. When that lands
+ * within {@link GROUND_PIT_PLATE_CLEARANCE} of the underside (the default plate, a thinner one, a
+ * plate whose top is the level plane) the floor lies that far under it instead; anywhere else it
+ * keeps to its place. `null` when `belowGradeFloorY` is.
+ */
+export declare function groundPitFloorY(nodes: Record<AnyNodeId, AnyNode>, shownLevelId?: string | null): number | null;
+//# sourceMappingURL=below-grade-footprints.d.ts.map

package/dist/lib/below-grade-footprints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"below-grade-footprints.d.ts","sourceRoot":"","sources":["../../src/lib/below-grade-footprints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAgBnD,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,iBAAiB,CAAA;AAoE7D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,OAAO,EAAE,EAAE,CAUb;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,OAAO,EAAE,EAAE,CA8B1F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,GAAG,IAAI,CAGf;AAED,2GAA2G;AAC3G,eAAO,MAAM,qBAAqB,OAAO,CAAA;AACzC;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,OAAO,CAAA;AAE9C;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,GAAG,IAAI,CAQf"}

package/dist/lib/below-grade-footprints.js

@@ -0,0 +1,181 @@
+import { BELOW_GRADE_TOLERANCE, getLevelElevations, levelLowestFloorWorldY, levelPlaneWorldY, levelPlateUndersideWorldY, } from '../services/storey.js';
+import { floorBuriedOnFlatSite, levelGradeStanding, terrainFieldOverLevel, } from './grade-standing.js';
+import { groundOverPart } from './ground-over-part.js';
+import { difference, intersection, union } from './polygon-boolean.js';
+import { unionPolygons } from './polygon-union.js';
+import { isSiteFlatwork } from './site-flatwork.js';
+import { levelLocalToWorldXZ } from './terrain-support-query.js';
+// Identity-keyed memo (`nodes` is an immutable store slice): the standing of every level is worked
+// out once per scene state, however many sets the callers ask for (the hole and the ring ask for
+// the shown stack, the materials for whether any level is buried at all, the ground for what the
+// house covers).
+const platesMemo = new WeakMap();
+function levelPlates(nodes) {
+    const hit = platesMemo.get(nodes);
+    if (hit)
+        return hit;
+    const elevations = getLevelElevations(nodes);
+    const levels = [];
+    for (const level of Object.values(nodes)) {
+        if (level.type !== 'level')
+            continue;
+        const standing = levelGradeStanding(nodes, level.id);
+        const buildingId = elevations.get(level.id)?.buildingId;
+        const building = buildingId ? nodes[buildingId] : undefined;
+        const placed = building?.type === 'building' ? building : null;
+        // A partly buried level is cut slab by slab, each over the ground that stands above its own
+        // floor: a split level's sunken room is buried by ground the raised part's top is above.
+        const plane = standing === 'partly-below-grade' ? levelPlaneWorldY(nodes, level.id) : null;
+        const field = plane === null ? null : terrainFieldOverLevel(nodes, level);
+        const plates = [];
+        const buried = [];
+        for (const childId of level.children) {
+            const slab = nodes[childId];
+            if (slab?.type !== 'slab' || slab.recessed === true || isSiteFlatwork(slab))
+                continue;
+            const plate = slab.polygon.map(([x, z]) => levelLocalToWorldXZ(placed, x, z));
+            plates.push(plate);
+            if (standing === 'at-grade')
+                continue;
+            if (field && plane !== null)
+                buried.push(...groundOverPart(plate, field, plane + slab.elevation + BELOW_GRADE_TOLERANCE));
+            else if (plane !== null) {
+                // A flat site, a level of floors at different heights: a floor is buried or it is not.
+                if (floorBuriedOnFlatSite(plane + slab.elevation))
+                    buried.push(plate);
+            }
+            else
+                buried.push(plate);
+        }
+        levels.push({
+            buildingId,
+            index: level.level,
+            visible: level.visible !== false,
+            standing,
+            plates,
+            buried,
+        });
+    }
+    platesMemo.set(nodes, levels);
+    return levels;
+}
+/**
+ * Where the ground meets the levels below grade, in the site's plan: each such level's floor slabs
+ * placed where its building stands and joined into outlines, the levels' together as one set (a
+ * deeper level wider than the one over it, or under part of it, gives one outline, not overlapping
+ * ones). The 3D view cuts its hole in the ground and draws its grade ring along them while the
+ * ground is veiled. An automatic floor follows the walls' centrelines, so an outline runs half a
+ * wall inside the outer faces. A level only partly below grade (a walk-out on a hillside) gives
+ * the part of its floor the ground stands over by more than {@link BELOW_GRADE_TOLERANCE}, the
+ * edge following the slope; fully buried levels give their whole floor.
+ *
+ * With `shownLevelId`, only what the level display needs open over that level: the level itself and
+ * the levels between it and grade (the ones the display hides above it: `level` index at or over
+ * its own, in every building, as the display decides from the index alone), the levels the author
+ * has hidden left out. The levels deeper than the one shown stay under the ground. Without it,
+ * every level below grade.
+ */
+export function belowGradeFootprints(nodes, shownLevelId) {
+    const shown = shownLevelId ? nodes[shownLevelId] : undefined;
+    const fromIndex = shown?.type === 'level' ? shown.level : Number.NEGATIVE_INFINITY;
+    const floors = [];
+    for (const level of levelPlates(nodes)) {
+        if (level.standing === 'at-grade')
+            continue;
+        if (level.index < fromIndex || (shown && !level.visible))
+            continue;
+        floors.push(...level.buried);
+    }
+    return unionPolygons(floors);
+}
+const coveredMemo = new WeakMap();
+/**
+ * The part of the ground that lies over the house itself: what is below grade under the footprint
+ * of the levels above it, in the site's plan. The house covers it, so the ground can stand open
+ * there whatever level is shown: from outside nothing changes (the storeys are over it), and the
+ * stairwells and floor openings of the stacked view, and the walkthrough on a stair, meet the
+ * basement and not a sheet of ground across it. A below-grade level reaching out under the garden
+ * gives only the part the house stands over; the rest stays closed, no pit in the garden.
+ *
+ * Per building, a level below grade is covered by the floor slabs of the visible levels over it
+ * (`level` index above its own) that are not themselves fully buried: the ones at grade, and the
+ * part of a floor only partly below grade that stands out of the hill. A hidden level covers
+ * nothing and is covered by nothing. Of a level only partly below grade, only the part the ground
+ * stands over is open. A slab's own openings do not count: the stairwell is where the ground
+ * should be open.
+ *
+ * Outlines with an inner outline (a courtyard the house wraps round) are left out: the ground
+ * cannot be cut around an island of itself, and closed is the safe side.
+ */
+export function coveredBelowGradeFootprints(nodes) {
+    const hit = coveredMemo.get(nodes);
+    if (hit)
+        return hit;
+    const levels = levelPlates(nodes);
+    const covered = [];
+    for (const level of levels) {
+        if (level.standing === 'at-grade' || !level.visible || level.buried.length === 0)
+            continue;
+        if (!level.buildingId)
+            continue;
+        const over = [];
+        for (const upper of levels) {
+            if (upper === level ||
+                upper.buildingId !== level.buildingId ||
+                !upper.visible ||
+                upper.index <= level.index ||
+                upper.standing === 'below-grade' ||
+                upper.plates.length === 0)
+                continue;
+            const plates = union(upper.plates);
+            over.push(upper.standing === 'at-grade' ? plates : difference(plates, union(upper.buried)));
+        }
+        if (over.length === 0)
+            continue;
+        covered.push(intersection(union(level.buried), union(over)));
+    }
+    const rings = union(covered.flat().map((polygon) => [polygon]))
+        .filter((polygon) => polygon.holes.length === 0)
+        .map((polygon) => polygon.outer);
+    coveredMemo.set(nodes, rings);
+    return rings;
+}
+/**
+ * How deep the pit under the hole goes: the world Y of the top of the lowest floor of the level
+ * shown (the sunken room of a split level, not its raised part), the deepest of the levels the hole
+ * is cut over (`belowGradeFootprints` with the same id). `null` when no level is shown or it is
+ * not below grade.
+ */
+export function belowGradeFloorY(nodes, shownLevelId) {
+    if (!shownLevelId || levelGradeStanding(nodes, shownLevelId) === 'at-grade')
+        return null;
+    return levelLowestFloorWorldY(nodes, shownLevelId);
+}
+/** How far under the top of the floor plate the pit hangs its own floor: the default plate's thickness. */
+export const GROUND_PIT_FLOOR_DROP = 0.05;
+/**
+ * How far the pit's floor keeps from the plane of the plate's underside. The foundation under the
+ * level tops out on that plane (`genericFoundation`), and seen through the hole it has to stand
+ * on the pit's floor, not share its plane: two faces on one plane flicker. 2 cm is what a 24-bit
+ * depth buffer with the viewer's 0.3 m near plane tells apart out to about 300 m, further than
+ * the hole is ever looked into from.
+ */
+export const GROUND_PIT_PLATE_CLEARANCE = 0.02;
+/**
+ * The world Y the pit under the hole draws its dark floor at, over the level shown: under the top
+ * of its lowest floor (`belowGradeFloorY`) by {@link GROUND_PIT_FLOOR_DROP}, which for the default
+ * plate is exactly its underside, where the footing and the walls on it stop. When that lands
+ * within {@link GROUND_PIT_PLATE_CLEARANCE} of the underside (the default plate, a thinner one, a
+ * plate whose top is the level plane) the floor lies that far under it instead; anywhere else it
+ * keeps to its place. `null` when `belowGradeFloorY` is.
+ */
+export function groundPitFloorY(nodes, shownLevelId) {
+    const floorY = belowGradeFloorY(nodes, shownLevelId);
+    const underside = shownLevelId ? levelPlateUndersideWorldY(nodes, shownLevelId) : null;
+    if (floorY === null || underside === null)
+        return null;
+    const hung = floorY - GROUND_PIT_FLOOR_DROP;
+    return Math.abs(hung - underside) < GROUND_PIT_PLATE_CLEARANCE
+        ? underside - GROUND_PIT_PLATE_CLEARANCE
+        : hung;
+}

package/dist/lib/building-footprint.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Where a building stands on its site: the building node's pose turns its levels' plan
+ * coordinates into site metres, and its walls' bands, unioned, are the footprint the site plan
+ * draws and the setbacks are measured to. Pure: no store.
+ */
+import type { AnyNode, BuildingNode, LevelNode } from '../schema/index.js';
+type Pt = readonly [number, number];
+type Nodes = Readonly<Record<string, AnyNode>>;
+/** A three.js Y rotation of a plan point: local (x, z) turned by `yaw`. */
+export declare function turnPlanPoint(x: number, z: number, yaw: number): Pt;
+export declare function yawOf(rotation: unknown): number;
+/**
+ * Level-local plan (x, z) → site metres, through the building's placement: three.js Y rotation,
+ * the convention BuildingRenderer applies, `site = position + (c·x + s·z, −s·x + c·z)`.
+ */
+export declare function siteFrame(building: Pick<BuildingNode, 'position' | 'rotation'> | null): (x: number, z: number) => Pt;
+/** Site metres → the building's level-local plan (x, z): `siteFrame` inverted. */
+export declare function levelFrame(building: Pick<BuildingNode, 'position' | 'rotation'> | null): (x: number, z: number) => Pt;
+/**
+ * Per-wall plan footprints for a level, mitred, then transformed by the building's site
+ * placement (`siteFrame`); with no building, in the level's own coordinates. `only` keeps the
+ * named walls, still mitred against every wall on the level.
+ */
+export declare function levelFootprintLoops(nodes: Nodes, level: LevelNode | null, building: BuildingNode | null, only?: ReadonlySet<string>): Pt[][];
+/**
+ * The outer ring(s) of a set of wall bands: their union, minus any ring that
+ * lies inside another (a room enclosed by partitions is a hole in the union,
+ * not a second building). Falls back to the bands themselves when the union
+ * yields nothing.
+ */
+export declare function footprintOutline(loops: readonly (readonly Pt[])[]): Pt[][];
+export {};
+//# sourceMappingURL=building-footprint.d.ts.map

package/dist/lib/building-footprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"building-footprint.d.ts","sourceRoot":"","sources":["../../src/lib/building-footprint.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAY,MAAM,WAAW,CAAA;AAK3E,KAAK,EAAE,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACnC,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAE9C,2EAA2E;AAC3E,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,EAAE,CAInE;AAED,wBAAgB,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,CAI/C;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,UAAU,CAAC,GAAG,IAAI,GAC3D,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,EAAE,CAQ9B;AAED,kFAAkF;AAClF,wBAAgB,UAAU,CACxB,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,UAAU,CAAC,GAAG,IAAI,GAC3D,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,EAAE,CAK9B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,SAAS,GAAG,IAAI,EACvB,QAAQ,EAAE,YAAY,GAAG,IAAI,EAC7B,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GACzB,EAAE,EAAE,EAAE,CAmBR;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,SAAS,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAqB1E"}