@pascal-app/core 1.0.0 → 1.0.3

package/dist/procedural-items/query.js

@@ -0,0 +1,342 @@
+import { getFloorPlacedFootprints } from '../hooks/spatial-grid/floor-placed-footprints.js';
+import { itemOverlapsPolygon } from '../lib/item-polygon-overlap.js';
+import { pointInPolygon as containsPoint, polygonsOverlap, } from '../lib/polygon-relations.js';
+import { getRenderableSlabPolygon } from '../lib/slab-polygon.js';
+import { levelBaseElevationAt } from '../lib/terrain-support.js';
+import { nodeRegistry } from '../registry/registry.js';
+import { getBlockFaceFrame } from '../schema/nodes/block.js';
+import { getRoofWallFaceFrame, roofFacePointToSegment } from '../schema/nodes/roof-segment-walls.js';
+import { resolveCeilingHeight } from '../services/level-height.js';
+import { getStoredLevelHeight } from '../services/storey.js';
+import { surfaceRegionContainsPoint } from '../services/surface-region.js';
+import { computeWallSlabSupport, pointInPolygon } from '../systems/slab/slab-support.js';
+import { getWallThickness } from '../systems/wall/wall-footprint.js';
+import { evaluateRecipe } from './recipe.js';
+import { boundsOf, boxCorners, composeFrames, frame, IDENTITY_FRAME, transformPoint, } from './spatial.js';
+export function isProceduralItem(node) {
+    return Boolean(node && typeof node === 'object' && 'type' in node && node.type === 'procedural-item');
+}
+function levelSurfaces(nodes, levelId) {
+    const siblings = Object.values(nodes).filter((n) => n.parentId === levelId);
+    return {
+        slabs: siblings.filter((n) => n.type === 'slab'),
+        walls: siblings.filter((n) => n.type === 'wall'),
+    };
+}
+export function proceduralLocalPose(node, nodes) {
+    const position = [...node.position], rotation = [...node.rotation];
+    if (node.recipe.mounting?.attachTo === 'ceiling' &&
+        node.parentId &&
+        nodes[node.parentId]?.type === 'ceiling') {
+        const reference = evaluateRecipe(node.recipe, node.parameters).surfaces.find((s) => s.id === node.recipe.mounting?.reference);
+        if (!reference)
+            throw new Error('Missing mounting reference');
+        const offset = transformPoint(frame([0, 0, 0], rotation), reference.position);
+        for (let i = 0; i < 3; i++)
+            position[i] = position[i] - offset[i];
+        return { position, rotation };
+    }
+    if (!node.wallId)
+        return { position, rotation };
+    const wall = nodes[node.wallId];
+    if (wall?.type !== 'wall')
+        throw new Error('Missing wall host');
+    const reference = evaluateRecipe(node.recipe, node.parameters).surfaces.find((s) => s.id === node.recipe.mounting?.reference);
+    if (!reference)
+        throw new Error('Missing mounting reference');
+    const sign = node.side === 'back' ? -1 : 1;
+    rotation[1] = sign < 0 ? Math.PI : 0;
+    position[0] -= reference.position[0] * sign;
+    position[1] -= reference.position[1];
+    position[2] = sign * (getWallThickness(wall) / 2 - reference.position[2] + node.position[2]);
+    return { position, rotation };
+}
+export function proceduralFootprint(node) {
+    const e = evaluateRecipe(node.recipe, node.parameters);
+    const center = e.min.map((v, i) => (v + e.max[i]) / 2);
+    const position = transformPoint(frame(node.position, node.rotation), center);
+    return { position, rotation: node.rotation, dimensions: e.dimensions };
+}
+function floorLift(node, nodes) {
+    if (!node.parentId || nodes[node.parentId]?.type !== 'level' || !('position' in node))
+        return 0;
+    const position = node.position;
+    const supportSlabId = node.supportSlabId;
+    const capability = nodeRegistry.get(node.type)?.capabilities.floorPlaced;
+    const { slabs, walls } = levelSurfaces(nodes, node.parentId);
+    const ground = levelBaseElevationAt(nodes, node.parentId, position[0], position[2]);
+    if (supportSlabId === 'ground')
+        return ground;
+    if (capability || node.type === 'cabinet' || node.type === 'cabinet-module') {
+        const footprints = capability
+            ? getFloorPlacedFootprints(capability, node, { nodes: nodes })
+            : [];
+        const candidatesFor = (footprint) => slabs.filter((slab) => {
+            const footprintPosition = footprint.position ?? position;
+            return (itemOverlapsPolygon(footprintPosition, footprint.dimensions, footprint.rotation, getRenderableSlabPolygon(slab, { walls, siblingSlabs: slabs }), 0.005) &&
+                !(slab.holes ?? []).some((hole) => pointInPolygon(footprintPosition[0], footprintPosition[2], hole)));
+        });
+        const candidates = footprints.map(candidatesFor);
+        const pinned = candidates.flat().find((slab) => slab.id === supportSlabId);
+        if (pinned)
+            return pinned.elevation ?? 0.05;
+        return candidates.length
+            ? Math.max(...candidates.map((slabs) => slabs.length ? Math.max(...slabs.map((slab) => slab.elevation ?? 0.05)) : ground))
+            : ground;
+    }
+    if (!(isProceduralItem(node) || node.type === 'item' || node.type === 'shelf'))
+        return 0;
+    const footprint = isProceduralItem(node)
+        ? proceduralFootprint(node)
+        : {
+            position: position,
+            dimensions: node.type === 'shelf'
+                ? [node.width, node.height, node.depth]
+                : node.asset.dimensions.map((v, i) => v * node.scale[i]),
+            rotation: node.rotation,
+        };
+    const candidates = slabs.filter((s) => {
+        const polygon = getRenderableSlabPolygon(s, { walls, siblingSlabs: slabs });
+        return (itemOverlapsPolygon(footprint.position, footprint.dimensions, footprint.rotation, polygon, 0.005) &&
+            !(s.holes ?? []).some((h) => pointInPolygon(footprint.position[0], footprint.position[2], h)));
+    });
+    const pinned = candidates.find((s) => s.id === supportSlabId);
+    return pinned
+        ? (pinned.elevation ?? 0.05)
+        : candidates.length
+            ? Math.max(...candidates.map((s) => s.elevation ?? 0.05))
+            : ground;
+}
+function nodeParentFrame(node, nodes, seen) {
+    if (!node.parentId)
+        return IDENTITY_FRAME;
+    let parentFrame = nodeLevelFrame(node.parentId, nodes, seen);
+    const parent = nodes[node.parentId];
+    if (isProceduralItem(parent) && parent.attachments[node.id] !== undefined) {
+        const surface = evaluateRecipe(parent.recipe, parent.parameters).surfaces.find((s) => s.id === parent.attachments[node.id]);
+        if (!surface)
+            throw new Error('Missing attachment surface');
+        parentFrame = composeFrames(parentFrame, frame(surface.position, surface.rotation));
+    }
+    return parentFrame;
+}
+export function nodeLevelFrame(id, nodes, seen = new Set()) {
+    if (seen.has(id) || seen.size > 32)
+        throw new Error('Cyclic or excessively deep hosting graph');
+    const node = nodes[id];
+    if (!node)
+        throw new Error(`Missing node ${id}`);
+    if (node.type === 'level')
+        return IDENTITY_FRAME;
+    seen.add(id);
+    if (node.type === 'ceiling') {
+        // Match the ceiling renderer's underside frame, including its 1 cm inset.
+        return frame([0, resolveCeilingHeight(node, nodes) - 0.01, 0], [0, 0, 0]);
+    }
+    if (node.type === 'wall') {
+        const { slabs, walls } = levelSurfaces(nodes, node.parentId ?? '');
+        const ground = levelBaseElevationAt(nodes, node.parentId ?? '', node.start[0], node.start[1]);
+        const support = computeWallSlabSupport(node, slabs, walls, node.supportSlabId, undefined, ground);
+        return frame([node.start[0], support.elevation + (node.supportOffset ?? 0), node.start[1]], [0, -Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0]), 0]);
+    }
+    if (!(isProceduralItem(node) ||
+        node.type === 'item' ||
+        node.type === 'shelf' ||
+        node.type === 'cabinet' ||
+        node.type === 'cabinet-module')) {
+        const transform = node;
+        const rotation = typeof transform.rotation === 'number'
+            ? [0, transform.rotation, 0]
+            : transform.rotation;
+        const position = [...(transform.position ?? [0, 0, 0])];
+        const capability = nodeRegistry.get(node.type)?.capabilities.floorPlaced;
+        if (!capability?.applies || capability.applies(node)) {
+            position[1] += floorLift(node, nodes);
+        }
+        const local = node.type === 'slab' ? IDENTITY_FRAME : frame(position, rotation ?? [0, 0, 0]);
+        return node.parentId ? composeFrames(nodeParentFrame(node, nodes, seen), local) : local;
+    }
+    const pose = isProceduralItem(node)
+        ? proceduralLocalPose(node, nodes)
+        : {
+            position: [...node.position],
+            rotation: typeof node.rotation === 'number' ? [0, node.rotation, 0] : node.rotation,
+        };
+    const parent = node.parentId ? nodes[node.parentId] : undefined;
+    if (!node.parentId)
+        return frame(pose.position, pose.rotation);
+    if (node.type === 'item' && parent?.type === 'roof-segment' && node.roofFace) {
+        const face = getRoofWallFaceFrame(parent, node.roofFace);
+        const local = frame(roofFacePointToSegment(parent, node.roofFace, pose.position), pose.rotation);
+        local.axes = composeFrames(frame([0, 0, 0], [0, face.yaw, 0]), frame([0, 0, 0], pose.rotation)).axes;
+        return composeFrames(nodeLevelFrame(parent.id, nodes, seen), local);
+    }
+    if (node.type === 'item' && parent?.type === 'block' && node.blockFaceId) {
+        const face = getBlockFaceFrame(parent.topology, node.blockFaceId);
+        if (face) {
+            const host = nodeLevelFrame(parent.id, nodes, seen);
+            return composeFrames(host, composeFrames({ position: face.origin, axes: [face.xAxis, face.yAxis, face.normal] }, frame(pose.position, pose.rotation)));
+        }
+    }
+    const parentFrame = nodeParentFrame(node, nodes, seen);
+    if (parent?.type === 'level')
+        pose.position[1] += floorLift(node, nodes);
+    return composeFrames(parentFrame, frame(pose.position, pose.rotation));
+}
+function localBounds(node) {
+    if (isProceduralItem(node))
+        return evaluateRecipe(node.recipe, node.parameters);
+    const d = node.asset.dimensions.map((v, i) => v * node.scale[i]);
+    return { min: [-d[0] / 2, 0, -d[2] / 2], max: [d[0] / 2, d[1], d[2] / 2] };
+}
+export function attachmentBounds(child) {
+    const b = localBounds(child);
+    return boundsOf(boxCorners(b.min, b.max).map((p) => transformPoint(frame(child.position, child.rotation), p)));
+}
+export function attachmentRegionsOverlap(a, b) {
+    return (a.min[0] < b.max[0] - 1e-6 &&
+        a.max[0] > b.min[0] + 1e-6 &&
+        a.min[2] < b.max[2] - 1e-6 &&
+        a.max[2] > b.min[2] + 1e-6);
+}
+function ceilingContainsFootprint(outer, footprint) {
+    if (!footprint.every((p) => containsPoint(p, outer)))
+        return false;
+    // A concave boundary can cross a footprint whose corners all lie inside.
+    // Clip each boundary segment against the open, convex footprint interior.
+    return !outer.some((a, i) => {
+        const b = outer[(i + 1) % outer.length];
+        let enter = 0;
+        let exit = 1;
+        for (let j = 0; j < footprint.length; j++) {
+            const c = footprint[j], d = footprint[(j + 1) % footprint.length];
+            const distance = (p) => ((d[0] - c[0]) * (p[1] - c[1]) - (d[1] - c[1]) * (p[0] - c[0])) /
+                Math.hypot(d[0] - c[0], d[1] - c[1]) -
+                1e-6;
+            const start = distance(a), end = distance(b);
+            if (start <= 0 && end <= 0)
+                return false;
+            if (start <= 0)
+                enter = Math.max(enter, -start / (end - start));
+            else if (end <= 0)
+                exit = Math.min(exit, start / (start - end));
+            if (enter >= exit)
+                return false;
+        }
+        return enter < exit;
+    });
+}
+export function validateProceduralRelations(raw, nodes) {
+    if (!isProceduralItem(raw))
+        return;
+    const node = raw, evaluation = evaluateRecipe(node.recipe, node.parameters);
+    const draft = node.metadata;
+    const awaitingHost = (draft?.isNew || draft?.isTransient) &&
+        !node.wallId &&
+        node.parentId &&
+        nodes[node.parentId]?.type === 'level';
+    if (node.recipe.mounting?.attachTo === 'ceiling' && !awaitingHost) {
+        const ceiling = node.parentId ? nodes[node.parentId] : undefined;
+        if (ceiling?.type !== 'ceiling' || node.wallId || node.side)
+            throw new Error('This design needs a ceiling host');
+        if (Math.abs(node.rotation[0]) > 1e-8 || Math.abs(node.rotation[2]) > 1e-8)
+            throw new Error('Ceiling designs allow Y rotation only');
+        if (Math.abs(node.position[1]) > 1e-6)
+            throw new Error('The top reference must be flush with the ceiling');
+        const pose = proceduralLocalPose(node, nodes);
+        const f = frame(pose.position, pose.rotation);
+        const b = boundsOf(boxCorners(evaluation.min, evaluation.max).map((p) => transformPoint(f, p)));
+        const height = nodeLevelFrame(ceiling.id, nodes).position[1];
+        const level = ceiling.parentId ? nodes[ceiling.parentId] : undefined;
+        if (b.min[1] + height < -1e-6 ||
+            b.max[1] > 1e-6 ||
+            b.max[1] + height > getStoredLevelHeight(level?.type === 'level' ? level : {}) + 1e-6)
+            throw new Error('The hanging design must fit below the ceiling within the level height');
+        const footprint = [
+            [evaluation.min[0], evaluation.min[2]],
+            [evaluation.max[0], evaluation.min[2]],
+            [evaluation.max[0], evaluation.max[2]],
+            [evaluation.min[0], evaluation.max[2]],
+        ].map(([x, z]) => {
+            const p = transformPoint(f, [x, 0, z]);
+            return [p[0], p[2]];
+        });
+        if (!ceilingContainsFootprint(ceiling.polygon, footprint) ||
+            ceiling.holes.some((hole) => polygonsOverlap(hole, footprint)))
+            throw new Error('The hanging design must fit inside the ceiling, outside its holes');
+    }
+    else if (node.recipe.mounting?.attachTo === 'wall-side' && !awaitingHost) {
+        const wall = node.wallId ? nodes[node.wallId] : undefined;
+        if (wall?.type !== 'wall' || node.parentId !== wall.id)
+            throw new Error('This design needs a wall host');
+        if (wall.curveOffset)
+            throw new Error('Curved wall mounting is not supported yet');
+        if (node.rotation.some((v) => Math.abs(v) > 1e-8))
+            throw new Error('Move the item onto a wall face or press R to flip it');
+        const pose = proceduralLocalPose(node, nodes);
+        const b = boundsOf(boxCorners(evaluation.min, evaluation.max).map((p) => transformPoint(frame(pose.position, pose.rotation), p)));
+        const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+        const level = wall.parentId ? nodes[wall.parentId] : undefined;
+        const height = wall.height ?? (level?.type === 'level' ? level.height : 2.5) ?? 2.5;
+        if (b.min[0] < -1e-6 ||
+            b.max[0] > length + 1e-6 ||
+            b.min[1] < -1e-6 ||
+            b.max[1] > height + 1e-6 ||
+            node.position[2] < 0)
+            throw new Error('The mounted item must fit on the wall');
+    }
+    else if (node.wallId ||
+        (node.parentId && ['wall', 'ceiling'].includes(nodes[node.parentId]?.type ?? '')))
+        throw new Error('A floor design cannot be attached to a wall or ceiling');
+    const regions = new Map();
+    for (const childId of node.children) {
+        const child = nodes[childId];
+        if (!child || child.parentId !== node.id)
+            throw new Error('Invalid hosted child link');
+        if (!(isProceduralItem(child) || child.type === 'item'))
+            throw new Error('Unsupported hosted child');
+        if (node.attachments[childId] === undefined)
+            continue;
+        const surface = evaluation.surfaces.find((s) => s.id === node.attachments[childId]);
+        if (!surface)
+            throw new Error('Choose a named attachment surface for the child');
+        const b = attachmentBounds(child);
+        if (!surfaceRegionContainsPoint({ kind: 'rect', size: [surface.size[0] / 2, surface.size[1] / 2] }, [(b.min[0] + b.max[0]) / 2, (b.min[2] + b.max[2]) / 2]) ||
+            Math.abs(b.min[1]) > 1e-6)
+            throw new Error(`The hosted item does not fit on ${surface.label}`);
+        // A fresh duplicate initially overlaps its source; only committed children occupy a surface.
+        if (child.metadata?.isNew === true)
+            continue;
+        const occupied = regions.get(surface.id) ?? [];
+        if (occupied.some((a) => attachmentRegionsOverlap(a, b)))
+            throw new Error(`Another item occupies ${surface.label}`);
+        occupied.push(b);
+        regions.set(surface.id, occupied);
+    }
+}
+export function queryProceduralItem(node, nodes) {
+    const e = evaluateRecipe(node.recipe, node.parameters), f = nodeLevelFrame(node.id, nodes[node.id] === node ? nodes : { ...nodes, [node.id]: node });
+    const bounds = boundsOf(boxCorners(e.min, e.max).map((p) => transformPoint(f, p)));
+    return {
+        id: node.id,
+        kind: node.type,
+        classification: node.recipe.classification ?? null,
+        hostId: node.parentId,
+        wallId: node.wallId ?? null,
+        parameters: e.parameters,
+        localBounds: { min: e.min, max: e.max, dimensions: e.dimensions },
+        levelBounds: bounds,
+        frame: f,
+        footprint: [
+            [bounds.min[0], bounds.min[2]],
+            [bounds.max[0], bounds.min[2]],
+            [bounds.max[0], bounds.max[2]],
+            [bounds.min[0], bounds.max[2]],
+        ],
+        surfaces: e.surfaces.map((s) => ({
+            ...s,
+            frame: composeFrames(f, frame(s.position, s.rotation)),
+        })),
+        children: node.children,
+    };
+}

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

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+export type Expr = number | string | {
+    op: 'add' | 'sub' | 'mul' | 'div' | 'min' | 'max';
+    args: Expr[];
+} | {
+    op: 'floor' | 'ceil' | 'round' | 'abs';
+    args: [Expr];
+} | {
+    op: 'mod';
+    args: [Expr, Expr];
+};
+export type Vec3 = [number, number, number];
+export declare const RecipeSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    name: z.ZodString;
+    description: z.ZodString;
+    classification: z.ZodOptional<z.ZodObject<{
+        category: z.ZodString;
+        functionTags: z.ZodArray<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    mounting: z.ZodOptional<z.ZodObject<{
+        attachTo: z.ZodEnum<{
+            ceiling: "ceiling";
+            "wall-side": "wall-side";
+        }>;
+        reference: z.ZodString;
+    }, z.core.$strict>>;
+    surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        part: z.ZodOptional<z.ZodString>;
+        position: z.ZodTuple<[z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>, z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>, z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>], null>;
+        rotation: z.ZodOptional<z.ZodTuple<[z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>, z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>, z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>], null>>;
+        size: z.ZodTuple<[z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>, z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>], null>;
+    }, z.core.$strict>>>;
+    parameters: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        default: z.ZodNumber;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        step: z.ZodNumber;
+        unit: z.ZodEnum<{
+            count: "count";
+            m: "m";
+            rad: "rad";
+        }>;
+        part: z.ZodOptional<z.ZodString>;
+        axis: z.ZodOptional<z.ZodEnum<{
+            x: "x";
+            y: "y";
+            z: "z";
+        }>>;
+    }, z.core.$strict>>;
+    slots: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        color: z.ZodString;
+        finish: z.ZodOptional<z.ZodEnum<{
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+        }>>;
+    }, z.core.$strict>>;
+    parts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        count: z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>;
+        shapes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            primitive: z.ZodEnum<{
+                box: "box";
+                roundedBox: "roundedBox";
+                cylinder: "cylinder";
+            }>;
+            slot: z.ZodString;
+            size: z.ZodTuple<[z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>, z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>, z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>], null>;
+            position: z.ZodTuple<[z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>, z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>, z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>], null>;
+            rotation: z.ZodOptional<z.ZodTuple<[z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>, z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>, z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>], null>>;
+            radius: z.ZodOptional<z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>>;
+            support: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    constraints: z.ZodArray<z.ZodObject<{
+        left: z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>;
+        relation: z.ZodEnum<{
+            lte: "lte";
+            gte: "gte";
+        }>;
+        right: z.ZodType<Expr, unknown, z.core.$ZodTypeInternals<Expr, unknown>>;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Recipe = z.infer<typeof RecipeSchema>;
+export type EvaluatedShape = {
+    id: string;
+    partId: string;
+    primitive: 'box' | 'roundedBox' | 'cylinder';
+    slot: string;
+    size: Vec3;
+    position: Vec3;
+    rotation: Vec3;
+    radius: number;
+};
+export type Surface = {
+    id: string;
+    label: string;
+    position: Vec3;
+    rotation: Vec3;
+    normal: Vec3;
+    size: [number, number];
+};
+export type Evaluation = {
+    shapes: EvaluatedShape[];
+    surfaces: Surface[];
+    min: Vec3;
+    max: Vec3;
+    dimensions: Vec3;
+    parameters: Record<string, number>;
+    triangles: number;
+};
+export declare const RECIPE_LIMITS: {
+    readonly bytes: 131072;
+    readonly depth: 24;
+    readonly expressions: 50000;
+    readonly shapes: 256;
+    readonly triangles: 100000;
+    readonly dimension: 30;
+};
+export declare function parseRecipe(input: unknown): Recipe;
+export declare function evaluateRecipe(recipe: Recipe, values?: Record<string, number>): Evaluation;
+export declare function sweepRecipe(recipe: Recipe): ({
+    index: number;
+    values: Record<string, number>;
+    valid: boolean;
+    error: null;
+} | {
+    index: number;
+    values: Record<string, number>;
+    valid: boolean;
+    error: string;
+})[];
+//# sourceMappingURL=recipe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recipe.d.ts","sourceRoot":"","sources":["../../src/procedural-items/recipe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,MAAM,MAAM,IAAI,GACZ,MAAM,GACN,MAAM,GACN;IAAE,EAAE,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;IAAC,IAAI,EAAE,IAAI,EAAE,CAAA;CAAE,GACnE;IAAE,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;IAAC,IAAI,EAAE,CAAC,IAAI,CAAC,CAAA;CAAE,GACxD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;CAAE,CAAA;AACrC,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAsB3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyFvB,CAAA;AACF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,KAAK,GAAG,YAAY,GAAG,UAAU,CAAA;IAC5C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,IAAI,CAAA;IACV,QAAQ,EAAE,IAAI,CAAA;IACd,QAAQ,EAAE,IAAI,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AACD,MAAM,MAAM,OAAO,GAAG;IACpB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,IAAI,CAAA;IACd,QAAQ,EAAE,IAAI,CAAA;IACd,MAAM,EAAE,IAAI,CAAA;IACZ,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACvB,CAAA;AACD,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,GAAG,EAAE,IAAI,CAAA;IACT,GAAG,EAAE,IAAI,CAAA;IACT,UAAU,EAAE,IAAI,CAAA;IAChB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AACD,eAAO,MAAM,aAAa;;;;;;;CAOhB,CAAA;AAYV,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAsClD;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAAG,UAAU,CAqL9F;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;KA0BzC"}