@pascal-app/core 1.0.3 → 1.0.4

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

@@ -1 +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;;;;;;;;;;;;;;;;;;iBAgBnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/schema/base.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/base.js

@@ -1,6 +1,7 @@
 import { customAlphabet } from 'nanoid';
 import { z } from 'zod';
 import { CameraSchema } from './camera.js';
+import { Provenance } from './provenance.js';
 const customId = customAlphabet('0123456789abcdefghijklmnopqrstuvwxyz', 16);
 /**
  * Material preset name reference
@@ -29,4 +30,5 @@ export const BaseNode = z.object({
     // Metadata is a flat bag of per-node extras, so an open object with
     // unchecked values is the whole contract we need.
     metadata: z.record(z.string(), z.unknown()).optional().default({}),
+    provenance: Provenance.optional(),
 });

package/dist/schema/collection-templates.d.ts

@@ -0,0 +1,46 @@
+/** Collections a scene commonly needs, each with its default name and colour. */
+export declare const COLLECTION_TEMPLATES: {
+    readonly lights: {
+        readonly name: "Lights";
+        readonly color: "#f5b83d";
+    };
+    readonly windows: {
+        readonly name: "Windows";
+        readonly color: "#5aa9e6";
+    };
+    readonly doors: {
+        readonly name: "Doors";
+        readonly color: "#a0714f";
+    };
+    readonly electrical: {
+        readonly name: "Electrical";
+        readonly color: "#e5533d";
+    };
+    readonly plumbing: {
+        readonly name: "Plumbing";
+        readonly color: "#2f80c2";
+    };
+    readonly framing: {
+        readonly name: "Framing";
+        readonly color: "#c9a36a";
+    };
+    readonly masonry: {
+        readonly name: "Masonry";
+        readonly color: "#b5653f";
+    };
+    readonly roof: {
+        readonly name: "Roof";
+        readonly color: "#6b6f7a";
+    };
+    readonly cabinetry: {
+        readonly name: "Cabinetry";
+        readonly color: "#8a6bbf";
+    };
+    readonly 'kitchen-cabinetry': {
+        readonly name: "Kitchen cabinetry";
+        readonly color: "#4fae7f";
+    };
+};
+export type CollectionTemplateId = keyof typeof COLLECTION_TEMPLATES;
+export declare const COLLECTION_TEMPLATE_IDS: [CollectionTemplateId, ...CollectionTemplateId[]];
+//# sourceMappingURL=collection-templates.d.ts.map

package/dist/schema/collection-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-templates.d.ts","sourceRoot":"","sources":["../../src/schema/collection-templates.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWvB,CAAA;AAEV,MAAM,MAAM,oBAAoB,GAAG,MAAM,OAAO,oBAAoB,CAAA;AAEpE,eAAO,MAAM,uBAAuB,EAAwC,CAC1E,oBAAoB,EACpB,GAAG,oBAAoB,EAAE,CAC1B,CAAA"}

package/dist/schema/collection-templates.js

@@ -0,0 +1,14 @@
+/** Collections a scene commonly needs, each with its default name and colour. */
+export const COLLECTION_TEMPLATES = {
+    lights: { name: 'Lights', color: '#f5b83d' },
+    windows: { name: 'Windows', color: '#5aa9e6' },
+    doors: { name: 'Doors', color: '#a0714f' },
+    electrical: { name: 'Electrical', color: '#e5533d' },
+    plumbing: { name: 'Plumbing', color: '#2f80c2' },
+    framing: { name: 'Framing', color: '#c9a36a' },
+    masonry: { name: 'Masonry', color: '#b5653f' },
+    roof: { name: 'Roof', color: '#6b6f7a' },
+    cabinetry: { name: 'Cabinetry', color: '#8a6bbf' },
+    'kitchen-cabinetry': { name: 'Kitchen cabinetry', color: '#4fae7f' },
+};
+export const COLLECTION_TEMPLATE_IDS = Object.keys(COLLECTION_TEMPLATES);

package/dist/schema/collections.d.ts

@@ -1,11 +1,18 @@
+import type { CollectionTemplateId } from './collection-templates.js';
 import type { AnyNodeId } from './types.js';
 export type CollectionId = `collection_${string}`;
+/**
+ * A named set of scene elements of any kind. Membership is the `nodeIds` list; items mirror it in
+ * their `collectionIds`. Being in a collection says nothing about how elements connect.
+ */
 export type Collection = {
     id: CollectionId;
     name: string;
     color?: string;
     nodeIds: AnyNodeId[];
     controlNodeId?: AnyNodeId;
+    /** The template it was made from; asking for a template again finds this collection. */
+    template?: CollectionTemplateId;
 };
 export declare const generateCollectionId: () => CollectionId;
 //# sourceMappingURL=collections.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/schema/collections.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,MAAM,MAAM,YAAY,GAAG,cAAc,MAAM,EAAE,CAAA;AAEjD,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,YAAY,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,aAAa,CAAC,EAAE,SAAS,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,oBAAoB,QAAO,YAAwC,CAAA"}
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/schema/collections.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,MAAM,MAAM,YAAY,GAAG,cAAc,MAAM,EAAE,CAAA;AAEjD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,YAAY,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,aAAa,CAAC,EAAE,SAAS,CAAA;IACzB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,oBAAoB,CAAA;CAChC,CAAA;AAED,eAAO,MAAM,oBAAoB,QAAO,YAAwC,CAAA"}

package/dist/schema/cut.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const CutShape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"polygon">;
+    ring: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"circle">;
+    center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    radius: z.ZodNumber;
+}, z.core.$strip>], "kind">;
+export type CutShape = z.infer<typeof CutShape>;
+export declare const CutIntent: z.ZodObject<{
+    host: z.ZodObject<{
+        nodeId: z.ZodString;
+        surfaceId: z.ZodString;
+        partKey: z.ZodOptional<z.ZodTemplateLiteral<`${string}/${string}/${string}`>>;
+    }, z.core.$strip>;
+    shape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"polygon">;
+        ring: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"circle">;
+        center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        radius: z.ZodNumber;
+    }, z.core.$strip>], "kind">;
+    depth: z.ZodUnion<readonly [z.ZodLiteral<"through">, z.ZodNumber]>;
+    taper: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type CutIntent = z.infer<typeof CutIntent>;
+//# sourceMappingURL=cut.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cut.d.ts","sourceRoot":"","sources":["../../src/schema/cut.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwBvB,eAAO,MAAM,QAAQ;;;;;;;2BAInB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;iBAuBpB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/cut.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+/**
+ * Cut intents (F5b, `editor-fidelity-foundations.md` §2.2), frozen by plan
+ * item DT-03a. One contract for every cut: a cutter publishes what it removes
+ * from a face of its host through `capabilities.cuts`, and each host kernel
+ * intersects the intents with its own faces. No host reads them yet (DT-03b
+ * walls, ceilings and slabs; RL-02 roofs); today's cut paths are unchanged.
+ *
+ * Frames (frozen). `shape` is in the named patch's surface chart (F0
+ * `SurfaceAnchor`): [u, v] metres, u along the patch frame's +X and
+ * v = normal × u.
+ * - wall `front`: u = wall-local x (from `start`), v = wall-local y (the frame
+ *   door and window `position` use); the normal is +n.
+ * - wall `back`: the normal is −n, so u runs from `end`: u = length − x.
+ * - roof `facet:<id>:covering`: u along the facet's eave, v up the slope, both
+ *   measured on the slope.
+ * - Horizontal hosts are the one exception: a slab `top` and a ceiling
+ *   `underside` take plan [x, z] in the host's local plan, the space of its
+ *   `polygon` and stored `holes`, never the chart's mirrored [x, −z].
+ */
+const V2 = z.tuple([z.number().finite(), z.number().finite()]);
+export const CutShape = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('polygon'), ring: z.array(V2).min(3) }),
+    // A circle stays a circle in the face, so curved hosts can cut it exactly.
+    z.object({ kind: z.literal('circle'), center: V2, radius: z.number().finite().positive() }),
+]);
+export const CutIntent = z.object({
+    host: z.object({
+        nodeId: z.string().min(1),
+        /** A `SurfacePatchId` of the host, or a wider recipe surface id. */
+        surfaceId: z.string().min(1),
+        /** Cut one generated part (F3) of the host instead of its body. */
+        partKey: z.templateLiteral([z.string(), '/', z.string(), '/', z.string()]).optional(),
+    }),
+    shape: CutShape,
+    /**
+     * `through` removes the host's whole thickness; a number is metres along
+     * −normal from the named face, so a pocket keeps the backing behind it.
+     */
+    depth: z.union([z.literal('through'), z.number().finite().positive()]),
+    /**
+     * Radians between each side of the cut and the face normal. Positive
+     * narrows with depth (a splayed reveal is widest at the face).
+     */
+    taper: z
+        .number()
+        .gt(-Math.PI / 2)
+        .lt(Math.PI / 2)
+        .optional(),
+});

package/dist/schema/geometry-metadata.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare function capText(value: string, limit: number): string;
+export declare function capPrompt(value: string): string;
+export declare const geometryMetaFields: {
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+};
+/** What an agent tool says about a design, recorded in its artifacts' provenance. */
+export declare const GeometryReuseFields: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Reuse metadata on a scripted node's source. The name lives on the node and an
+ * item's category on its asset, so neither is repeated here.
+ */
+export declare const GeometrySourceMeta: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    parent: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GeometrySourceMeta = z.infer<typeof GeometrySourceMeta>;
+export declare const GeometryArtifactMetadata: z.ZodObject<{
+    prompt: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    operationId: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        column: "column";
+        door: "door";
+        window: "window";
+        item: "item";
+    }>>;
+    mount: z.ZodOptional<z.ZodEnum<{
+        wall: "wall";
+        ceiling: "ceiling";
+        "wall-side": "wall-side";
+        floor: "floor";
+    }>>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type GeometryArtifactMetadata = z.infer<typeof GeometryArtifactMetadata>;
+//# sourceMappingURL=geometry-metadata.d.ts.map

package/dist/schema/geometry-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-metadata.d.ts","sourceRoot":"","sources":["../../src/schema/geometry-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG5D;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAS/C;AAQD,eAAO,MAAM,kBAAkB;;;;;CAiB9B,CAAA;AAED,qFAAqF;AACrF,eAAO,MAAM,mBAAmB;;;;;iBAA+B,CAAA;AAE/D;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;iBAK7B,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;iBAQnC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

package/dist/schema/geometry-metadata.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+export function capText(value, limit) {
+    const text = value.trim().slice(0, limit);
+    return /[\uD800-\uDBFF]$/.test(text) ? text.slice(0, -1) : text;
+}
+export function capPrompt(value) {
+    let bytes = 0;
+    let result = '';
+    for (const char of value.trim()) {
+        bytes += new TextEncoder().encode(char).length;
+        if (bytes > 4096)
+            break;
+        result += char;
+    }
+    return result;
+}
+const text = (limit) => z
+    .string()
+    .overwrite((value) => capText(value, limit))
+    .max(limit);
+export const geometryMetaFields = {
+    name: text(120).optional().describe('What the user would call this design.'),
+    description: text(200)
+        .optional()
+        .describe('A short description of this design, at most 200 characters.'),
+    category: text(60).optional().describe('What this design is, in one or two words.'),
+    tags: z
+        .array(z
+        .string()
+        .overwrite((value) => capText(value.toLowerCase(), 32))
+        .max(32))
+        .overwrite((values) => values.slice(0, 5))
+        .max(5)
+        .optional()
+        .describe('Up to five short lowercase search tags, at most 32 characters each.'),
+};
+/** What an agent tool says about a design, recorded in its artifacts' provenance. */
+export const GeometryReuseFields = z.object(geometryMetaFields);
+/**
+ * Reuse metadata on a scripted node's source. The name lives on the node and an
+ * item's category on its asset, so neither is repeated here.
+ */
+export const GeometrySourceMeta = GeometryReuseFields.omit({ name: true }).extend({
+    parent: z
+        .string()
+        .regex(/^[0-9a-f]{64}$/)
+        .optional(),
+});
+export const GeometryArtifactMetadata = z.object({
+    ...geometryMetaFields,
+    prompt: z.string().overwrite(capPrompt).max(4096).optional(),
+    model: text(200).optional(),
+    sessionId: text(200).optional(),
+    operationId: text(200).optional(),
+    kind: z.enum(['item', 'door', 'window', 'column']).optional(),
+    mount: z.enum(['floor', 'wall', 'wall-side', 'ceiling']).optional(),
+});

package/dist/schema/geometry-source.d.ts

@@ -0,0 +1,250 @@
+import { z } from 'zod';
+/** Source code is stored separately from the scene; bound its upload size. */
+export declare const GEOMETRY_SCRIPT_MAX_BYTES: number;
+/** The manifest rides inline in the node; the compiler keeps it under this. */
+export declare const GEOMETRY_MANIFEST_MAX_BYTES: number;
+/** A three.js module (`export default function build`) or a Blender `bpy` module (`def build(params)`). */
+export declare const GeometryScriptLanguage: z.ZodEnum<{
+    three: "three";
+    bpy: "bpy";
+}>;
+export type GeometryScriptLanguage = z.infer<typeof GeometryScriptLanguage>;
+/** The artifact type each language's module text is stored as. */
+export declare const GEOMETRY_SCRIPT_MIME_TYPES: {
+    readonly three: "text/javascript";
+    readonly bpy: "text/x-python";
+};
+export declare const isGeometryScriptMimeType: (mimeType: string) => boolean;
+export declare const GeometryScriptParamValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+export type GeometryScriptParamValue = z.infer<typeof GeometryScriptParamValue>;
+/** A control the script declares in `export const params`. */
+export declare const GeometryScriptParamSpec: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+    }>;
+    default: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    step: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type GeometryScriptParamSpec = z.infer<typeof GeometryScriptParamSpec>;
+/**
+ * What the compiler read from the script's output, by naming convention:
+ * `part:<id>` objects, `slot_<id>` materials, `anchor:<id>` empties, lights
+ * (`light:<id>` empties or three.js lights), a `cutout` mesh and a `collider`
+ * mesh. Positions are in the artifact's frame (bottom-centre origin).
+ */
+export declare const GeometryArtifactManifest: z.ZodObject<{
+    bounds: z.ZodObject<{
+        min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>;
+    params: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        default: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        step: z.ZodOptional<z.ZodNumber>;
+        unit: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    parts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        bounds: z.ZodOptional<z.ZodObject<{
+            min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    surfaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        part: z.ZodOptional<z.ZodString>;
+        y: z.ZodNumber;
+        polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strip>>>;
+    slots: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        roughness: z.ZodOptional<z.ZodNumber>;
+        metalness: z.ZodOptional<z.ZodNumber>;
+        transparent: z.ZodOptional<z.ZodBoolean>;
+        emissive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    anchors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        normal: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strip>>>;
+    lights: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        color: z.ZodString;
+        intensity: z.ZodNumber;
+        distance: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        part: z.ZodOptional<z.ZodString>;
+        polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        plane: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>>>;
+    animations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        duration: z.ZodNumber;
+    }, z.core.$strip>>>;
+    cutters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        host: z.ZodEnum<{
+            wall: "wall";
+            slab: "slab";
+            ceiling: "ceiling";
+            mounted: "mounted";
+        }>;
+        polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+        minY: z.ZodNumber;
+        maxY: z.ZodNumber;
+    }, z.core.$strip>>>;
+    cutout: z.ZodDefault<z.ZodBoolean>;
+    collider: z.ZodDefault<z.ZodBoolean>;
+    triangles: z.ZodNumber;
+}, z.core.$strip>;
+export type GeometryArtifactManifest = z.infer<typeof GeometryArtifactManifest>;
+export declare const GeometryScriptMount: z.ZodEnum<{
+    wall: "wall";
+    ceiling: "ceiling";
+    "wall-side": "wall-side";
+    floor: "floor";
+}>;
+export type GeometryScriptMount = z.infer<typeof GeometryScriptMount>;
+/** What a compile hands the scene: the artifact's hash, how it mounts, the resolved params and the manifest. */
+export type CompiledGeometryScript = {
+    /** The destination identity reserved before artifact uploads. */
+    nodeId?: string;
+    /** sha256 of the GLB. */
+    sha256: string;
+    /** sha256 of the module text that produced it. */
+    script: string;
+    language: GeometryScriptLanguage;
+    mount: GeometryScriptMount;
+    params: Record<string, GeometryScriptParamValue>;
+    manifest: GeometryArtifactManifest;
+};
+/**
+ * Geometry authored as a plain three.js module (`export const params`,
+ * `export default function build({ params, inputs, THREE, lib })`) or a Blender
+ * `bpy` module (`PARAMS`, `def build(params)`). The compiled artifact is what
+ * renders; the code only re-runs on an edit.
+ */
+export declare const GeometryScriptSource: z.ZodObject<{
+    kind: z.ZodLiteral<"script">;
+    meta: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        parent: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    language: z.ZodDefault<z.ZodEnum<{
+        three: "three";
+        bpy: "bpy";
+    }>>;
+    script: z.ZodString;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
+    artifact: z.ZodString;
+    manifest: z.ZodObject<{
+        bounds: z.ZodObject<{
+            min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>;
+        params: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+            }>;
+            default: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            step: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        parts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            bounds: z.ZodOptional<z.ZodObject<{
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        surfaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            part: z.ZodOptional<z.ZodString>;
+            y: z.ZodNumber;
+            polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strip>>>;
+        slots: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodString>;
+            roughness: z.ZodOptional<z.ZodNumber>;
+            metalness: z.ZodOptional<z.ZodNumber>;
+            transparent: z.ZodOptional<z.ZodBoolean>;
+            emissive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        anchors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            normal: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strip>>>;
+        lights: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            color: z.ZodString;
+            intensity: z.ZodNumber;
+            distance: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            part: z.ZodOptional<z.ZodString>;
+            polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            plane: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>>>;
+        animations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            duration: z.ZodNumber;
+        }, z.core.$strip>>>;
+        cutters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            host: z.ZodEnum<{
+                wall: "wall";
+                slab: "slab";
+                ceiling: "ceiling";
+                mounted: "mounted";
+            }>;
+            polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+            minY: z.ZodNumber;
+            maxY: z.ZodNumber;
+        }, z.core.$strip>>>;
+        cutout: z.ZodDefault<z.ZodBoolean>;
+        collider: z.ZodDefault<z.ZodBoolean>;
+        triangles: z.ZodNumber;
+    }, z.core.$strip>;
+    images: z.ZodOptional<z.ZodObject<{
+        artifact: z.ZodString;
+        thumbnail: z.ZodString;
+        floorPlan: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GeometryScriptSource = z.infer<typeof GeometryScriptSource>;
+//# sourceMappingURL=geometry-source.d.ts.map

package/dist/schema/geometry-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-source.d.ts","sourceRoot":"","sources":["../../src/schema/geometry-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,8EAA8E;AAC9E,eAAO,MAAM,yBAAyB,QAAY,CAAA;AAClD,+EAA+E;AAC/E,eAAO,MAAM,2BAA2B,QAAY,CAAA;AAEpD,2GAA2G;AAC3G,eAAO,MAAM,sBAAsB;;;EAA2B,CAAA;AAC9D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,kEAAkE;AAClE,eAAO,MAAM,0BAA0B;;;CAGoB,CAAA;AAE3D,eAAO,MAAM,wBAAwB,GAAI,UAAU,MAAM,YACoB,CAAA;AAK7E,eAAO,MAAM,wBAAwB,+DAA6C,CAAA;AAClF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,8DAA8D;AAC9D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAUlC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiFnC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,eAAO,MAAM,mBAAmB;;;;;EAAoD,CAAA;AACpF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE,gHAAgH;AAChH,MAAM,MAAM,sBAAsB,GAAG;IACnC,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,yBAAyB;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,sBAAsB,CAAA;IAChC,KAAK,EAAE,mBAAmB,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAA;IAChD,QAAQ,EAAE,wBAAwB,CAAA;CACnC,CAAA;AAID;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB/B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}