@pascal-app/core 1.0.3 → 1.0.5

package/dist/procedural-items/fixtures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/procedural-items/fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAA4B,MAAM,UAAU,CAAA;AAwB9D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEtB,CAAA;AACF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyFpB,CAAA;AACF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFzB,CAAA;AACF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqExB,CAAA;AACF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;EA+BnB,CAAA"}
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/procedural-items/fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAA4B,MAAM,UAAU,CAAA;AAwB9D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEtB,CAAA;AACF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyFpB,CAAA;AACF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFzB,CAAA;AACF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqExB,CAAA;AACF,eAAO,MAAM,gBAAgB;aAEzB,EAAE,EAAE,YAAY;aAChB,MAAM,EACJ,6LAA6L;;aAG/L,EAAE,EAAE,kBAAkB;aACtB,MAAM,EACJ,0NAA0N;;aAG5N,EAAE,EAAE,YAAY;aAChB,MAAM,EACJ,8PAA8P;;aAGhQ,EAAE,EAAE,iBAAiB;aACrB,MAAM,EACJ,0OAA0O;;aAG5O,EAAE,EAAE,OAAO;aACX,MAAM,EACJ,oNAAoN;;aAGtN,EAAE,EAAE,SAAS;aACb,MAAM,EACJ,mOAAmO;EAE/N,CAAA"}

package/dist/procedural-items/index.d.ts

@@ -1,10 +1,15 @@
+export * from './design.js';
+export * from './design-placement.js';
 export * from './fixtures.js';
 export * from './integration.js';
+export * from './joints.js';
 export * from './library-colors.js';
 export * from './materials.js';
+export * from './motion-controller.js';
 export * from './node.js';
 export * from './placement.js';
 export * from './query.js';
 export * from './recipe.js';
+export * from './section.js';
 export * from './spatial.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/procedural-items/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/procedural-items/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/procedural-items/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,UAAU,CAAA;AACxB,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA;AAC3B,cAAc,qBAAqB,CAAA;AACnC,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA"}

package/dist/procedural-items/index.js

@@ -1,9 +1,14 @@
+export * from './design.js';
+export * from './design-placement.js';
 export * from './fixtures.js';
 export * from './integration.js';
+export * from './joints.js';
 export * from './library-colors.js';
 export * from './materials.js';
+export * from './motion-controller.js';
 export * from './node.js';
 export * from './placement.js';
 export * from './query.js';
 export * from './recipe.js';
+export * from './section.js';
 export * from './spatial.js';

package/dist/procedural-items/integration.d.ts

@@ -6,15 +6,61 @@ export declare function prepareProceduralPlacement(recipe: Recipe, nodes: QueryN
     side?: 'front' | 'back';
 }): {
     object: "node";
+    name?: string | undefined;
     parentId: string | null;
     visible: boolean;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "orthographic" | "perspective";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
     metadata: Record<string, unknown>;
+    provenance?: {
+        refs: {
+            ns?: string | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+        }[];
+        lineage?: {
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
     id: `procedural-item_${string}`;
     type: "procedural-item";
     recipe: {
-        version: 1;
+        version: 1 | 2;
         name: string;
         description: string;
+        classification?: {
+            category: string;
+            functionTags: string[];
+            tags: string[];
+        } | undefined;
+        mounting?: {
+            attachTo: "ceiling" | "wall-side";
+            reference: string;
+        } | undefined;
+        base?: import("./recipe.js").Expr | undefined;
+        cuts?: ({
+            shape: "rect";
+            size: [import("./recipe.js").Expr, import("./recipe.js").Expr];
+            center?: [import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+        } | {
+            shape: "circle";
+            diameter: import("./recipe.js").Expr;
+            center?: [import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+        })[] | undefined;
+        surfaces?: {
+            id: string;
+            label: string;
+            part?: string | undefined;
+            position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+            rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+            size: [import("./recipe.js").Expr, import("./recipe.js").Expr];
+        }[] | undefined;
         parameters: {
             id: string;
             label: string;
@@ -22,7 +68,8 @@ export declare function prepareProceduralPlacement(recipe: Recipe, nodes: QueryN
             min: number;
             max: number;
             step: number;
-            unit: "count" | "m" | "rad";
+            unit: "bool" | "choice" | "count" | "m" | "rad" | "s";
+            options?: string[] | undefined;
             part?: string | undefined;
             axis?: "x" | "y" | "z" | undefined;
         }[];
@@ -30,63 +77,137 @@ export declare function prepareProceduralPlacement(recipe: Recipe, nodes: QueryN
             id: string;
             label: string;
             color: string;
-            finish?: "wood" | "glass" | "metal" | undefined;
+            finish?: "glass" | "metal" | "wood" | undefined;
         }[];
         parts: {
             id: string;
             label: string;
             count: import("./recipe.js").Expr;
-            shapes: {
+            parent?: string | undefined;
+            frame?: {
+                position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+            } | undefined;
+            when?: import("./recipe.js").Expr | undefined;
+            motion?: {
+                delay?: import("./recipe.js").Expr | undefined;
+                duration?: import("./recipe.js").Expr | undefined;
+                easing?: "linear" | "smooth" | "soft" | undefined;
+                kind: "hinge";
+                pivot: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                axis: "x" | "y" | "z";
+                angle: import("./recipe.js").Expr;
+            } | {
+                delay?: import("./recipe.js").Expr | undefined;
+                duration?: import("./recipe.js").Expr | undefined;
+                easing?: "linear" | "smooth" | "soft" | undefined;
+                kind: "slide";
+                axis: "x" | "y" | "z";
+                distance: import("./recipe.js").Expr;
+            } | {
+                kind: "spin";
+                pivot: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                axis: "x" | "y" | "z";
+                radiansPerSecond: import("./recipe.js").Expr;
+            } | undefined;
+            light?: {
+                position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                color: string;
+                intensity?: number | undefined;
+                distance?: number | undefined;
+                emissiveSlot?: string | undefined;
+            } | undefined;
+            shapes: ({
+                support?: boolean | undefined;
+                when?: import("./recipe.js").Expr | undefined;
                 id: string;
-                primitive: "box" | "roundedBox" | "cylinder";
+                primitive: "box" | "cylinder" | "ellipsoid" | "roundedBox";
                 slot: string;
                 size: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
                 position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
                 rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
                 radius?: import("./recipe.js").Expr | undefined;
+                topScale?: import("./recipe.js").Expr | undefined;
+                segments?: number | undefined;
+                open?: boolean | undefined;
+                inner?: import("./recipe.js").Expr | undefined;
+                arc?: import("./recipe.js").Expr | undefined;
+            } | {
                 support?: boolean | undefined;
-            }[];
+                when?: import("./recipe.js").Expr | undefined;
+                id: string;
+                primitive: "extrude";
+                slot: string;
+                section: {
+                    kind: "rectangle";
+                    width: import("./recipe.js").Expr;
+                    depth: import("./recipe.js").Expr;
+                    corner?: import("./recipe.js").Expr | undefined;
+                } | {
+                    kind: "round";
+                    radius: import("./recipe.js").Expr;
+                    wall?: import("./recipe.js").Expr | undefined;
+                } | {
+                    kind: "oval";
+                    width: import("./recipe.js").Expr;
+                    depth: import("./recipe.js").Expr;
+                } | {
+                    kind: "section";
+                    family: "C" | "I" | "L" | "T" | "Z" | "rect-tube";
+                    width: import("./recipe.js").Expr;
+                    depth: import("./recipe.js").Expr;
+                    web: import("./recipe.js").Expr;
+                    flange: import("./recipe.js").Expr;
+                } | {
+                    kind: "polygon";
+                    outer: [import("./recipe.js").Expr, import("./recipe.js").Expr][];
+                    holes?: [import("./recipe.js").Expr, import("./recipe.js").Expr][][] | undefined;
+                };
+                length: import("./recipe.js").Expr;
+                bevel?: import("./recipe.js").Expr | undefined;
+                position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+            } | {
+                support?: boolean | undefined;
+                when?: import("./recipe.js").Expr | undefined;
+                id: string;
+                primitive: "revolve";
+                slot: string;
+                profile: [import("./recipe.js").Expr, import("./recipe.js").Expr][];
+                segments?: number | undefined;
+                arc?: import("./recipe.js").Expr | undefined;
+                position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+            })[];
         }[];
+        joints?: {
+            delay?: import("./recipe.js").Expr | undefined;
+            duration?: import("./recipe.js").Expr | undefined;
+            easing?: "linear" | "smooth" | "soft" | undefined;
+            child: string;
+            kind: "continuous" | "fixed" | "prismatic" | "revolute";
+            origin: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+            axis: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+            open?: import("./recipe.js").Expr | undefined;
+            rest?: import("./recipe.js").Expr | undefined;
+            range?: [import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+            speed?: import("./recipe.js").Expr | undefined;
+        }[] | undefined;
         constraints: {
             left: import("./recipe.js").Expr;
-            relation: "lte" | "gte";
+            relation: "gte" | "lte";
             right: import("./recipe.js").Expr;
             message: string;
         }[];
-        classification?: {
-            category: string;
-            functionTags: string[];
-            tags: string[];
-        } | undefined;
-        mounting?: {
-            attachTo: "ceiling" | "wall-side";
-            reference: string;
-        } | undefined;
-        surfaces?: {
-            id: string;
-            label: string;
-            position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
-            size: [import("./recipe.js").Expr, import("./recipe.js").Expr];
-            part?: string | undefined;
-            rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
-        }[] | undefined;
     };
     parameters: Record<string, number>;
     slots: Record<string, string>;
     position: [number, number, number];
     rotation: [number, number, number];
-    children: string[];
-    attachments: Record<string, string>;
-    name?: string | undefined;
-    camera?: {
-        position: [number, number, number];
-        target: [number, number, number];
-        mode: "perspective" | "orthographic";
-        fov?: number | undefined;
-        zoom?: number | undefined;
-    } | undefined;
     wallId?: string | undefined;
-    side?: "front" | "back" | undefined;
+    side?: "back" | "front" | undefined;
     supportSlabId?: string | undefined;
+    children: string[];
+    attachments: Record<string, string>;
 };
 //# sourceMappingURL=integration.d.ts.map

package/dist/procedural-items/integration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../src/procedural-items/integration.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAA+B,MAAM,SAAS,CAAA;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAE5C,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBzE"}
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../src/procedural-items/integration.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAA+B,MAAM,SAAS,CAAA;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAE5C,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBzE"}

package/dist/procedural-items/joints.d.ts

@@ -0,0 +1,56 @@
+import type { EvaluatedMotion, EvaluatedShape, Expr, Recipe, Vec3 } from './recipe.js';
+import { type Bounds, type Pose } from './spatial.js';
+export type PartPlacement = {
+    /** Rest pose of the part's frame in design space, joint included. */
+    pose: Pose;
+    /** The motion group the part's shapes and light ride in, if any. */
+    group?: string;
+    /** The group's motion, on the instance that owns the joint. */
+    motion?: EvaluatedMotion;
+};
+export declare function usesPartTree(recipe: Recipe): boolean;
+/** Structural checks that need no parameter values. */
+export declare function validatePartTree(recipe: Recipe): Map<string, {
+    delay?: Expr | undefined;
+    duration?: Expr | undefined;
+    easing?: "linear" | "smooth" | "soft" | undefined;
+    child: string;
+    kind: "continuous" | "fixed" | "prismatic" | "revolute";
+    origin: [Expr, Expr, Expr];
+    axis: [Expr, Expr, Expr];
+    open?: Expr | undefined;
+    rest?: Expr | undefined;
+    range?: [Expr, Expr] | undefined;
+    speed?: Expr | undefined;
+}>;
+/** True when the part or an ancestor moves (so it cannot carry supports or surfaces). */
+export declare function partMoves(recipe: Recipe, partId: string): boolean;
+/**
+ * Rest poses, groups and motions of every part instance of a v2 part tree, keyed
+ * `${part}:${index}`. A missing key means the instance is not built (its own or an
+ * ancestor's `when` is zero).
+ */
+export declare function placeParts(recipe: Recipe, value: (e: Expr, index: number) => number, counts: ReadonlyMap<string, number>): Map<string, PartPlacement>;
+/**
+ * Where each root joint group can reach: its shapes' box, grown by every nested group's
+ * reach, swept over its own travel (and range) interval. Intervals compose per joint, so
+ * nesting never multiplies samples.
+ */
+export declare function jointReach(motions: readonly EvaluatedMotion[], shapes: readonly EvaluatedShape[], shapeBounds: (shape: EvaluatedShape) => Bounds): {
+    motion: EvaluatedMotion;
+    bounds: Bounds;
+}[];
+export type OperablePart = {
+    id: string;
+    label: string;
+    kind: EvaluatedMotion['kind'];
+};
+/** Parts a person can operate (Play, E, controls): a flat motion or a non-fixed joint. */
+export declare function operableParts(recipe: Pick<Recipe, 'parts' | 'joints'>): OperablePart[];
+/** Where a motion group sits in its parent group at rest: its pivot less the parent's. */
+export declare function motionRestOffset(motion: EvaluatedMotion, motions: readonly EvaluatedMotion[]): Vec3;
+/** A motion's unit axis in its parent group's frame, which has design axes at rest. */
+export declare function motionAxis(motion: EvaluatedMotion): Vec3;
+/** The operable part that moves `partId`: itself, or its nearest operable ancestor. */
+export declare function operablePartFor(recipe: Pick<Recipe, 'parts' | 'joints'>, partId: string): OperablePart | undefined;
+//# sourceMappingURL=joints.d.ts.map

package/dist/procedural-items/joints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"joints.d.ts","sourceRoot":"","sources":["../../src/procedural-items/joints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AACnF,OAAO,EACL,KAAK,MAAM,EAOX,KAAK,IAAI,EAIV,MAAM,WAAW,CAAA;AAUlB,MAAM,MAAM,aAAa,GAAG;IAC1B,qEAAqE;IACrE,IAAI,EAAE,IAAI,CAAA;IACV,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,+DAA+D;IAC/D,MAAM,CAAC,EAAE,eAAe,CAAA;CACzB,CAAA;AAID,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAKpD;AAED,uDAAuD;AACvD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;GAuC9C;AAED,yFAAyF;AACzF,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAQjE;AAQD;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,EACzC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CA6H5B;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,MAAM,EAAE,SAAS,cAAc,EAAE,EACjC,WAAW,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,MAAM,GAC7C;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,CAmC/C;AAED,MAAM,MAAM,YAAY,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,eAAe,CAAC,MAAM,CAAC,CAAA;CAAE,CAAA;AACvF,0FAA0F;AAC1F,wBAAgB,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAAC,GAAG,YAAY,EAAE,CAOtF;AACD,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,IAAI,CAGN;AACD,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAIxD;AACD,uFAAuF;AACvF,wBAAgB,eAAe,CAC7B,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAAC,EACxC,MAAM,EAAE,MAAM,GACb,YAAY,GAAG,SAAS,CAQ1B"}

package/dist/procedural-items/joints.js

@@ -0,0 +1,251 @@
+import { boundsOf, boxCorners, composePoses, eulerPose, hingePose, IDENTITY_POSE, poseDirection, posePoint, sweptHingeBounds, } from './spatial.js';
+const LIMITS = { hinge: Math.PI, slide: 5, spin: 20 };
+const KIND = { revolute: 'hinge', prismatic: 'slide', continuous: 'spin' };
+export function usesPartTree(recipe) {
+    // An explicitly present joints array, even empty, is v2 content.
+    return Boolean(recipe.joints !== undefined || recipe.parts.some((part) => part.parent || part.frame));
+}
+/** Structural checks that need no parameter values. */
+export function validatePartTree(recipe) {
+    const parts = new Map(recipe.parts.map((part) => [part.id, part]));
+    const joints = new Map();
+    for (const joint of recipe.joints ?? []) {
+        const part = parts.get(joint.child);
+        if (!part)
+            throw new Error(`Unknown joint part ${joint.child}`);
+        if (joints.has(joint.child))
+            throw new Error(`Part ${joint.child} has more than one joint`);
+        if (part.motion)
+            throw new Error(`Part ${joint.child} has both a motion and a joint`);
+        joints.set(joint.child, joint);
+        const timed = [joint.delay, joint.duration, joint.easing].some((v) => v !== undefined);
+        const valued = [joint.open, joint.rest, joint.range].some((v) => v !== undefined);
+        if (joint.kind === 'fixed' && (valued || timed || joint.speed !== undefined))
+            throw new Error(`Fixed joint ${joint.child} takes no values, speed or timing`);
+        if ((joint.kind === 'revolute' || joint.kind === 'prismatic') &&
+            (joint.open === undefined || joint.speed !== undefined))
+            throw new Error(`Joint ${joint.child} needs an open value and no speed`);
+        if (joint.kind === 'continuous' &&
+            (joint.speed === undefined || joint.open !== undefined || joint.range || timed))
+            throw new Error(`Continuous joint ${joint.child} needs a speed and no open value, range or timing`);
+    }
+    for (const part of recipe.parts) {
+        if (part.motion && (part.parent || part.frame))
+            throw new Error(`Part ${part.id} with a flat motion cannot sit in a part tree`);
+        if (!part.parent)
+            continue;
+        if (part.parent === part.id || !parts.has(part.parent))
+            throw new Error(`Unknown parent ${part.parent} for ${part.id}`);
+        if (parts.get(part.parent).motion)
+            throw new Error(`Part ${part.id} cannot hang from ${part.parent}, which has a flat motion`);
+        let depth = 0;
+        for (let at = part; at?.parent; at = parts.get(at.parent))
+            if (++depth > 8)
+                throw new Error(`Part tree around ${part.id} is cyclic or deeper than 8`);
+    }
+    return joints;
+}
+/** True when the part or an ancestor moves (so it cannot carry supports or surfaces). */
+export function partMoves(recipe, partId) {
+    const parts = new Map(recipe.parts.map((part) => [part.id, part]));
+    for (let at = parts.get(partId); at; at = at.parent ? parts.get(at.parent) : undefined) {
+        if (at.motion)
+            return true;
+        const joint = recipe.joints?.find((j) => j.child === at.id);
+        if (joint && joint.kind !== 'fixed')
+            return true;
+    }
+    return false;
+}
+function unit(axis, part) {
+    const length = Math.hypot(...axis);
+    if (!(length > 1e-9))
+        throw new Error(`Joint ${part} needs a nonzero axis`);
+    return axis.map((v) => v / length);
+}
+/**
+ * Rest poses, groups and motions of every part instance of a v2 part tree, keyed
+ * `${part}:${index}`. A missing key means the instance is not built (its own or an
+ * ancestor's `when` is zero).
+ */
+export function placeParts(recipe, value, counts) {
+    const parts = new Map(recipe.parts.map((part) => [part.id, part]));
+    const joints = new Map((recipe.joints ?? []).map((joint) => [joint.child, joint]));
+    const placed = new Map();
+    const vec = (v, i) => v.map((e) => value(e, i));
+    const place = (part, i) => {
+        const key = `${part.id}:${i}`;
+        if (placed.has(key))
+            return placed.get(key);
+        // A parent repeat that does not exist (count 0, or fewer repeats) carries no children.
+        if (i >= counts.get(part.id))
+            return null;
+        let parent = { pose: IDENTITY_POSE };
+        if (part.parent) {
+            const host = parts.get(part.parent);
+            // A single child rides repeat 0 of its parent; equal counts bind by index.
+            const single = counts.get(part.id) === 1;
+            if (!single && counts.get(part.id) !== counts.get(host.id))
+                throw new Error(`Part ${part.id} must repeat once or exactly as often as its parent ${host.id}`);
+            parent = place(host, single ? 0 : i);
+        }
+        if (!parent || (part.when !== undefined && value(part.when, i) === 0)) {
+            placed.set(key, null);
+            return null;
+        }
+        const frame = part.frame
+            ? composePoses(parent.pose, eulerPose(vec(part.frame.position, i), vec(part.frame.rotation ?? [0, 0, 0], i)))
+            : parent.pose;
+        const joint = joints.get(part.id);
+        let result = { pose: frame, group: parent.group };
+        if (joint) {
+            const origin = vec(joint.origin, i);
+            const axis = unit(vec(joint.axis, i), part.id);
+            const rest = joint.rest === undefined ? 0 : value(joint.rest, i);
+            const move = (amount) => joint.kind === 'prismatic'
+                ? { r: IDENTITY_POSE.r, t: axis.map((v) => v * amount) }
+                : hingePose(origin, axis, amount);
+            result = {
+                pose: joint.kind === 'fixed' || rest === 0 ? frame : composePoses(frame, move(rest)),
+                group: parent.group,
+            };
+            if (joint.kind !== 'fixed') {
+                const kind = KIND[joint.kind];
+                const open = joint.kind === 'continuous' ? value(joint.speed, i) : value(joint.open, i);
+                const range = joint.range?.map((e) => value(e, i));
+                if (range &&
+                    !(range[0] <= range[1] &&
+                        [rest, open].every((v) => v >= range[0] - 1e-9 && v <= range[1] + 1e-9)))
+                    throw new Error(`Joint ${part.id} rest and open values must lie within its range`);
+                if (range &&
+                    joint.kind !== 'continuous' &&
+                    range.some((end) => Math.abs(end - rest) > LIMITS[kind] + 1e-9))
+                    throw new Error(`Joint ${part.id} range must lie within ${LIMITS[kind]} of its rest value`);
+                let amount = joint.kind === 'continuous' ? open : open - rest;
+                if (!(Math.abs(amount) > 0 && Math.abs(amount) <= LIMITS[kind]))
+                    throw new Error(`Invalid ${kind} amount for ${part.id}: expected 0 < absolute value <= ${LIMITS[kind]}`);
+                const delay = joint.kind === 'continuous' ? 0 : value(joint.delay ?? 0, i);
+                const duration = joint.kind === 'continuous' ? 0 : value(joint.duration ?? 0.45, i);
+                const easing = joint.kind === 'continuous' ? 'linear' : (joint.easing ?? 'smooth');
+                if (!Number.isFinite(delay) ||
+                    !Number.isFinite(duration) ||
+                    delay < 0 ||
+                    delay > 1 ||
+                    (joint.kind !== 'continuous' && (duration < 0.1 || duration > 2)))
+                    throw new Error(`Invalid timing for ${part.id}`);
+                // Design-space axis at rest; a principal axis keeps today's flat form exactly.
+                let direction = unit(poseDirection(frame, axis), part.id);
+                const principal = direction.findIndex((v) => Math.abs(v) > 1 - 1e-9);
+                const flipped = principal >= 0 && direction[principal] < 0;
+                if (flipped)
+                    amount = -amount;
+                const letter = ['x', 'y', 'z'][principal >= 0
+                    ? principal
+                    : direction.map(Math.abs).indexOf(Math.max(...direction.map(Math.abs)))];
+                if (principal >= 0)
+                    direction = [0, 0, 0].map((_, k) => (k === principal ? 1 : 0));
+                const id = i ? `${part.id}~${i}` : part.id;
+                result.group = id;
+                result.motion = {
+                    id,
+                    partId: part.id,
+                    kind,
+                    axis: letter,
+                    pivot: kind === 'slide' ? [0, 0, 0] : posePoint(frame, origin),
+                    amount,
+                    delay,
+                    duration,
+                    easing,
+                    ...(principal < 0 && { direction }),
+                    ...(parent.group && { parent: parent.group }),
+                    // Relative to rest, and about the stored (positive) axis when the joint's was negative.
+                    ...(range && {
+                        range: (flipped
+                            ? [rest - range[1], rest - range[0]]
+                            : [range[0] - rest, range[1] - rest]),
+                    }),
+                };
+            }
+        }
+        placed.set(key, result);
+        return result;
+    };
+    const out = new Map();
+    for (const part of recipe.parts)
+        for (let i = 0; i < counts.get(part.id); i++) {
+            const at = place(part, i);
+            if (at)
+                out.set(`${part.id}:${i}`, at);
+        }
+    return out;
+}
+/**
+ * Where each root joint group can reach: its shapes' box, grown by every nested group's
+ * reach, swept over its own travel (and range) interval. Intervals compose per joint, so
+ * nesting never multiplies samples.
+ */
+export function jointReach(motions, shapes, shapeBounds) {
+    const own = new Map();
+    for (const shape of shapes) {
+        if (!shape.motionGroup)
+            continue;
+        const b = shapeBounds(shape);
+        own.set(shape.motionGroup, [...(own.get(shape.motionGroup) ?? []), b.min, b.max]);
+    }
+    const reach = (motion) => {
+        const points = [...(own.get(motion.id) ?? [])];
+        for (const child of motions)
+            if (child.parent === motion.id) {
+                const b = reach(child);
+                if (b)
+                    points.push(b.min, b.max);
+            }
+        if (!points.length)
+            return null;
+        const box = boundsOf(points);
+        const axis = motionAxis(motion);
+        const travel = [0, motion.amount, ...(motion.range ?? [])];
+        const [from, to] = [Math.min(...travel), Math.max(...travel)];
+        if (motion.kind === 'slide') {
+            const corners = boxCorners(box.min, box.max);
+            return boundsOf([from, to].flatMap((d) => corners.map((c) => c.map((v, k) => v + axis[k] * d))));
+        }
+        return motion.kind === 'spin'
+            ? sweptHingeBounds(box, motion.pivot, axis, 0, 2 * Math.PI)
+            : sweptHingeBounds(box, motion.pivot, axis, from, to);
+    };
+    return motions
+        .filter((motion) => !motion.parent)
+        .flatMap((motion) => {
+        const bounds = reach(motion);
+        return bounds ? [{ motion, bounds }] : [];
+    });
+}
+/** Parts a person can operate (Play, E, controls): a flat motion or a non-fixed joint. */
+export function operableParts(recipe) {
+    return recipe.parts.flatMap((part) => {
+        const joint = recipe.joints?.find((entry) => entry.child === part.id);
+        const kind = part.motion?.kind ?? (joint && joint.kind !== 'fixed' ? KIND[joint.kind] : undefined);
+        return kind ? [{ id: part.id, label: part.label, kind }] : [];
+    });
+}
+/** Where a motion group sits in its parent group at rest: its pivot less the parent's. */
+export function motionRestOffset(motion, motions) {
+    const parent = motion.parent ? motions.find((entry) => entry.id === motion.parent) : undefined;
+    return motion.pivot.map((v, i) => v - (parent?.pivot[i] ?? 0));
+}
+/** A motion's unit axis in its parent group's frame, which has design axes at rest. */
+export function motionAxis(motion) {
+    return (motion.direction ?? [0, 1, 2].map((k) => (['x', 'y', 'z'][k] === motion.axis ? 1 : 0)));
+}
+/** The operable part that moves `partId`: itself, or its nearest operable ancestor. */
+export function operablePartFor(recipe, partId) {
+    const operable = new Map(operableParts(recipe).map((part) => [part.id, part]));
+    const parts = new Map(recipe.parts.map((part) => [part.id, part]));
+    for (let id = partId, depth = 0; id && depth <= 8; depth++) {
+        if (operable.has(id))
+            return operable.get(id);
+        id = parts.get(id)?.parent;
+    }
+    return undefined;
+}