@hatiolab/figure-model 0.1.30 → 0.1.32

package/dist/v3-graph.js

@@ -0,0 +1,631 @@
+// V3 experimental graph evaluator. Operator semantics are checked at compile and evaluation boundaries.
+import { V3ContractError as ContractError } from "./v3-contract.js";
+export { ContractError };
+const fail = (c, p, d) => {
+    throw new ContractError(c, p, d);
+};
+const units = {
+    mm: [[1, 0, 0], 1],
+    cm: [[1, 0, 0], 10],
+    m: [[1, 0, 0], 1000],
+    rad: [[0, 1, 0], 1],
+    deg: [[0, 1, 0], Math.PI / 180],
+    s: [[0, 0, 1], 1],
+    ratio: [[0, 0, 0], 1],
+    percent: [[0, 0, 0], 0.01]
+};
+const length = [1, 0, 0], ratio = [0, 0, 0], angle = [0, 1, 0];
+const countType = { kind: 'count' };
+units.count = [countType, 1];
+const eq = (a, b) => Array.isArray(a) && Array.isArray(b)
+    ? a.length === b.length && a.every((v, i) => v === b[i])
+    : JSON.stringify(a) === JSON.stringify(b);
+function fields(o, required, optional, path) {
+    if (!o || typeof o !== 'object' || Array.isArray(o))
+        fail('SCHEMA', path, 'object required');
+    for (const k of required)
+        if (!Object.hasOwn(o, k))
+            fail('SCHEMA', path, `missing ${k}`);
+    for (const k of Object.keys(o))
+        if (![...required, ...optional].includes(k))
+            fail('SCHEMA', path, `unknown ${k}`);
+}
+function id(x, path) {
+    if (typeof x !== 'string' || !/^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(x))
+        fail('ID', path, 'invalid id');
+    return x;
+}
+function num(x, path) {
+    if (typeof x !== 'number' || !Number.isFinite(x))
+        fail('NON_FINITE', path, String(x));
+    return x;
+}
+function unit(x, path) {
+    if (!Object.hasOwn(units, x))
+        fail('UNIT', path, String(x));
+    return units[x];
+}
+function requireTypes(actual, expected, path) {
+    if (actual.length !== expected.length || actual.some((t, i) => !eq(t, expected[i])))
+        fail('TYPE', path, `expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+}
+// Output keys are part of each versioned operator contract.
+const ops = {
+    'add@1': {
+        ports: ['value'],
+        types(t, p) {
+            if (t.length !== 2 || !t.every(Array.isArray) || !eq(t[0], t[1]))
+                fail('TYPE', p, 'addition needs same scalar dimensions');
+            return [t[0]];
+        },
+        run: ([a, b]) => [a + b]
+    },
+    'mul@1': {
+        ports: ['value'],
+        types(t, p) {
+            if (t.length !== 2 || !t.every(Array.isArray))
+                fail('TYPE', p, 'two scalar arguments');
+            return [t[0].map((x, i) => x + t[1][i])];
+        },
+        run: ([a, b]) => [a * b]
+    },
+    'div@1': {
+        ports: ['value'],
+        types(t, p) {
+            if (t.length !== 2 || !t.every(Array.isArray))
+                fail('TYPE', p, 'two scalar arguments');
+            return [t[0].map((x, i) => x - t[1][i])];
+        },
+        run: ([a, b], p) => {
+            if (b === 0)
+                fail('DOMAIN', p, 'zero denominator');
+            return [a / b];
+        }
+    },
+    'sin@1': {
+        ports: ['value'],
+        types(t, p) {
+            requireTypes(t, [angle], p);
+            return [ratio];
+        },
+        run: ([a]) => [Math.sin(a)]
+    },
+    'between@1': {
+        ports: ['length', 'center'],
+        types(t, p) {
+            requireTypes(t, [length, length, length, length], p);
+            return [length, length];
+        },
+        run: ([lo, hi, a, b], p) => {
+            if (a < 0 || b < 0)
+                fail('DOMAIN', p, 'negative margin');
+            const size = hi - lo - a - b;
+            if (!(size > 0))
+                fail('NO_SPACE', p, `available=${hi - lo}; margins=${a + b}; deficit=${Math.max(0, -size)}; positive length required`);
+            return [size, (lo + hi + a - b) / 2];
+        }
+    },
+    'box@1': {
+        ports: ['xMin', 'xMax', 'yMin', 'yMax', 'zMin', 'zMax'],
+        types(t, p) {
+            requireTypes(t, [length, length, length], p);
+            return Array(6).fill(length);
+        },
+        run: ([w, h, d], p) => {
+            if ([w, h, d].some(x => !(x > 0)))
+                fail('GEOMETRY_DOMAIN', p, 'positive width,height,depth required');
+            return [-w / 2, w / 2, -h / 2, h / 2, -d / 2, d / 2];
+        },
+        geometry: ([width, height, depth]) => ({ provider: 'box@1', dimensions: { width, height, depth } })
+    },
+    'cylinder@1': {
+        ports: ['start', 'end', 'radialMin', 'radialMax'],
+        types(t, p) {
+            requireTypes(t, [length, length], p);
+            return Array(4).fill(length);
+        },
+        run: ([r, l], p) => {
+            if (!(r > 0 && l > 0))
+                fail('GEOMETRY_DOMAIN', p, 'positive radius,length required');
+            return [-l / 2, l / 2, -r, r];
+        },
+        geometry: ([radius, length]) => ({ provider: 'cylinder@1', axis: 'Y', dimensions: { radius, length } })
+    }
+};
+const transformType = (from, to) => ({ kind: 'transform', from, to });
+const identity = () => [
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]
+];
+const transpose = (a) => a[0].map((_, i) => a.map(r => r[i]));
+const dot = (a, b) => a.reduce((s, x, i) => s + x * b[i], 0);
+const mv = (a, v) => a.map(r => dot(r, v));
+const mm = (a, b) => a.map(r => transpose(b).map(c => dot(r, c)));
+const plus = (a, b) => a.map((x, i) => x + b[i]);
+const compose = (a, b) => ({ r: mm(a.r, b.r), t: plus(mv(a.r, b.t), a.t) });
+const inverse = (a) => {
+    const r = transpose(a.r);
+    return {
+        r,
+        t: mv(r, a.t.map((x) => -x))
+    };
+};
+function config(n, keys) {
+    fields(n.params, keys, [], n.id);
+    for (const k of keys)
+        id(n.params[k], n.id);
+}
+function transforms(t, p, count) {
+    if (t.length !== count || t.some(x => x.kind !== 'transform'))
+        fail('TYPE', p, 'rigid transforms required');
+}
+Object.assign(ops, {
+    'rounded-box@1': {
+        ports: ['shape'],
+        params: ['frame'],
+        types(t, p, n) {
+            requireTypes(t, Array(4).fill(length), p);
+            return [{ kind: 'shape', provider: 'roundedBox', frame: n.params.frame }];
+        },
+        run: ([width, height, depth, round], p) => {
+            if (!(width > 0 && height > 0 && depth > 0 && round >= 0 && round <= Math.min(width, depth) / 2))
+                fail('GEOMETRY_DOMAIN', p, 'positive dimensions and valid XZ corner radius required');
+            return [{ provider: 'roundedBox', dimensions: { width, height, depth, round } }];
+        }
+    },
+    'fit-pitch@1': {
+        ports: ['layout'],
+        types(t, p) {
+            requireTypes(t, [length, length, length, length, length, ratio, countType], p);
+            return [{ kind: 'layout' }];
+        },
+        run: ([L, a, b, e, pitch, alpha, limit], p) => {
+            if (!(L >= 0 &&
+                a >= 0 &&
+                b >= 0 &&
+                e > 0 &&
+                pitch > 0 &&
+                alpha >= 0 &&
+                alpha <= 1 &&
+                Number.isSafeInteger(limit) &&
+                limit >= 0 &&
+                limit <= 10000))
+                fail('LAYOUT_DOMAIN', p, 'invalid length, margins, extent, pitch, alignment or limit');
+            const usable = L - a - b, count = usable < e ? 0 : 1 + Math.floor((usable - e) / pitch);
+            if (count > limit)
+                fail('RESOURCE_LIMIT', p, `count=${count}, limit=${limit}`);
+            const slack = count ? usable - e - (count - 1) * pitch : 0;
+            return [{ centers: Array.from({ length: count }, (_, i) => a + e / 2 + alpha * slack + i * pitch), count }];
+        }
+    },
+    'fixed-count@1': {
+        ports: ['layout'],
+        types(t, p) {
+            requireTypes(t, [countType, length, length, length, length, ratio, countType], p);
+            return [{ kind: 'layout' }];
+        },
+        run: ([count, L, a, b, e, alpha, limit], p) => {
+            if (!(Number.isSafeInteger(count) &&
+                count >= 0 &&
+                Number.isSafeInteger(limit) &&
+                limit >= 0 &&
+                limit <= 10000 &&
+                L >= 0 &&
+                a >= 0 &&
+                b >= 0 &&
+                e > 0 &&
+                alpha >= 0 &&
+                alpha <= 1))
+                fail('LAYOUT_DOMAIN', p, 'invalid fixed count layout');
+            if (count > limit)
+                fail('RESOURCE_LIMIT', p, 'fixed count exceeds limit');
+            if (!count)
+                return [{ centers: [], count: 0 }];
+            const room = L - a - b - e;
+            if (room < 0 || (count > 1 && room / (count - 1) < e))
+                fail('NO_SPACE', p, 'fixed count non-overlapping items do not fit');
+            return [
+                {
+                    centers: count === 1
+                        ? [a + e / 2 + alpha * room]
+                        : Array.from({ length: count }, (_, i) => a + e / 2 + (i * room) / (count - 1)),
+                    count
+                }
+            ];
+        }
+    },
+    'assembly@1': {
+        ports: ['assembly'],
+        types(t, p) {
+            if (!t.length || t.some(x => x.kind !== 'placed' || x.frame !== t[0].frame))
+                fail('FRAME_TYPE', p, 'assembly members need one common frame');
+            return [{ kind: 'assembly', frame: t[0].frame }];
+        },
+        run: (a, p, n) => [{ members: a.map((placed, i) => ({ key: n.args[i], ...placed })) }]
+    },
+    'repeat@1': {
+        ports: ['collection'],
+        params: ['axis'],
+        types(t, p, n) {
+            if (!['x', 'y', 'z'].includes(n.params.axis))
+                fail('AXIS', p, n.params.axis);
+            if (t.length !== 3 ||
+                t[0].kind !== 'layout' ||
+                t[1].kind !== 'assembly' ||
+                t[2].kind !== 'transform' ||
+                t[2].from !== t[1].frame)
+                fail('FRAME_TYPE', p, 'layout, assembly and compatible placement required');
+            return [{ kind: 'collection', frame: t[2].to }];
+        },
+        run: ([layout, assembly, pose], p, n) => {
+            if (layout.count * assembly.members.length > 10000)
+                fail('RESOURCE_LIMIT', p, 'expanded geometry count > 10000');
+            const axis = ['x', 'y', 'z'].indexOf(n.params.axis), items = [];
+            for (let i = 0; i < layout.count; i++)
+                for (const member of assembly.members) {
+                    const t = [0, 0, 0];
+                    t[axis] = layout.centers[i];
+                    items.push({
+                        id: JSON.stringify([n.id, i, member.key]),
+                        key: member.key,
+                        index: i,
+                        shape: member.shape,
+                        pose: compose(compose(pose, { r: identity(), t }), member.pose)
+                    });
+                }
+            return [{ items }];
+        },
+        geometry: (_, out) => out[0].items
+    },
+    'select-item@1': {
+        ports: ['placed'],
+        params: ['member'],
+        types(t, p) {
+            if (t.length !== 2 || t[0].kind !== 'collection' || !eq(t[1], countType))
+                fail('TYPE', p, 'collection and count index required');
+            return [{ kind: 'placed', frame: t[0].frame }];
+        },
+        run: ([collection, index], p, n) => {
+            const item = collection.items.find((x) => x.index === index && x.key === n.params.member);
+            if (!item)
+                fail('TARGET_ABSENT', p, `${n.params.member}[${index}]`);
+            return [{ shape: item.shape, pose: item.pose }];
+        }
+    },
+    'portal-profile@1': {
+        ports: ['shape'],
+        params: ['frame'],
+        types(t, p, n) {
+            requireTypes(t, Array(8).fill(length), p);
+            return [{ kind: 'shape', provider: 'portal', frame: n.params.frame }];
+        },
+        run: ([left, right, bottom, top, openingLeft, openingRight, openingTop, depth], p) => {
+            if (!(left < openingLeft &&
+                openingLeft < openingRight &&
+                openingRight < right &&
+                bottom < openingTop &&
+                openingTop < top &&
+                depth > 0))
+                fail('GEOMETRY_DOMAIN', p, 'ordered outer/opening boundaries and positive depth required');
+            const path = [
+                [left, bottom],
+                [openingLeft, bottom],
+                [openingLeft, openingTop],
+                [openingRight, openingTop],
+                [openingRight, bottom],
+                [right, bottom],
+                [right, top],
+                [left, top]
+            ];
+            return [
+                {
+                    provider: 'portal',
+                    dimensions: { left, right, bottom, top, openingLeft, openingRight, openingTop, depth },
+                    profile: path.map(([x, y], i) => ({
+                        id: [
+                            'outerLeftBottom',
+                            'innerLeftBottom',
+                            'innerLeftTop',
+                            'innerRightTop',
+                            'innerRightBottom',
+                            'outerRightBottom',
+                            'outerRightTop',
+                            'outerLeftTop'
+                        ][i],
+                        x,
+                        y
+                    }))
+                }
+            ];
+        }
+    },
+    'rigid@1': {
+        ports: ['pose'],
+        params: ['from', 'to'],
+        types(t, p, n) {
+            requireTypes(t, [length, length, length, angle, angle, angle], p);
+            return [transformType(n.params.from, n.params.to)];
+        },
+        run: ([x, y, z, rx, ry, rz]) => {
+            const cx = Math.cos(rx), sx = Math.sin(rx), cy = Math.cos(ry), sy = Math.sin(ry), cz = Math.cos(rz), sz = Math.sin(rz);
+            return [
+                {
+                    r: mm(mm([
+                        [1, 0, 0],
+                        [0, cx, -sx],
+                        [0, sx, cx]
+                    ], [
+                        [cy, 0, sy],
+                        [0, 1, 0],
+                        [-sy, 0, cy]
+                    ]), [
+                        [cz, -sz, 0],
+                        [sz, cz, 0],
+                        [0, 0, 1]
+                    ]),
+                    t: [x, y, z]
+                }
+            ];
+        }
+    },
+    'compose@1': {
+        ports: ['pose'],
+        types(t, p) {
+            transforms(t, p, 2);
+            if (t[1].to !== t[0].from)
+                fail('FRAME_TYPE', p, 'composition intermediate frame mismatch');
+            return [transformType(t[1].from, t[0].to)];
+        },
+        run: ([a, b]) => [compose(a, b)]
+    },
+    'attach@1': {
+        ports: ['pose'],
+        types(t, p) {
+            transforms(t, p, 3);
+            const [a, o, b] = t;
+            if (a.from !== o.to || o.from !== b.from)
+                fail('FRAME_TYPE', p, 'A O inverse(B) frame mismatch');
+            return [transformType(b.to, a.to)];
+        },
+        run: ([a, o, b]) => [compose(compose(a, o), inverse(b))]
+    },
+    'point@1': {
+        ports: ['point'],
+        params: ['frame'],
+        types(t, p, n) {
+            requireTypes(t, [length, length, length], p);
+            return [{ kind: 'point', frame: n.params.frame }];
+        },
+        run: a => [a]
+    },
+    'map-point@1': {
+        ports: ['point'],
+        types(t, p) {
+            if (t.length !== 2 || t[0].kind !== 'transform' || t[1].kind !== 'point' || t[0].from !== t[1].frame)
+                fail('FRAME_TYPE', p, 'point frame must match transform source');
+            return [{ kind: 'point', frame: t[0].to }];
+        },
+        run: ([pose, pt]) => [plus(mv(pose.r, pt), pose.t)]
+    },
+    'distance@1': {
+        ports: ['length'],
+        types(t, p) {
+            if (t.length !== 2 || t[0].kind !== 'point' || !eq(t[0], t[1]))
+                fail('FRAME_TYPE', p, 'distance requires points in same frame');
+            return [length];
+        },
+        run: ([a, b]) => [Math.hypot(...a.map((x, i) => x - b[i]))]
+    },
+    'box-shape@1': {
+        ports: ['shape'],
+        params: ['frame'],
+        types(t, p, n) {
+            requireTypes(t, [length, length, length], p);
+            return [{ kind: 'shape', provider: 'box', frame: n.params.frame }];
+        },
+        run: ([width, height, depth], p) => {
+            if ([width, height, depth].some(x => !(x > 0)))
+                fail('GEOMETRY_DOMAIN', p, 'positive box dimensions');
+            return [{ provider: 'box', dimensions: { width, height, depth } }];
+        }
+    },
+    'cylinder-shape@1': {
+        ports: ['shape'],
+        params: ['frame'],
+        types(t, p, n) {
+            requireTypes(t, [length, length], p);
+            return [{ kind: 'shape', provider: 'cylinder', frame: n.params.frame }];
+        },
+        run: ([radius, length], p) => {
+            if (!(radius > 0 && length > 0))
+                fail('GEOMETRY_DOMAIN', p, 'positive cylinder dimensions');
+            return [{ provider: 'cylinder', dimensions: { radius, length } }];
+        }
+    },
+    'feature@1': {
+        ports: ['pose'],
+        params: ['frame', 'name'],
+        types(t, p, n) {
+            if (t.length !== 1 || t[0].kind !== 'shape')
+                fail('TYPE', p, 'shape required');
+            const names = t[0].provider === 'portal'
+                ? ['top', 'bottomLeft', 'bottomRight', 'openingTop', 'frontTop']
+                : ['box', 'roundedBox'].includes(t[0].provider)
+                    ? ['left', 'right', 'bottom', 'top', 'back', 'front']
+                    : ['start', 'end', 'radialBottom'];
+            if (!names.includes(n.params.name))
+                fail('UNKNOWN_FEATURE', p, n.params.name);
+            // Provider-aligned feature axes, not outward-normal mating axes.
+            return [transformType(n.params.frame, t[0].frame)];
+        },
+        run: ([s], p, n) => {
+            const d = s.dimensions, points = s.provider === 'portal'
+                ? {
+                    top: [(d.left + d.right) / 2, d.top, 0],
+                    bottomLeft: [(d.left + d.openingLeft) / 2, d.bottom, 0],
+                    bottomRight: [(d.right + d.openingRight) / 2, d.bottom, 0],
+                    openingTop: [(d.openingLeft + d.openingRight) / 2, d.openingTop, 0],
+                    frontTop: [(d.left + d.right) / 2, d.top, d.depth / 2]
+                }
+                : ['box', 'roundedBox'].includes(s.provider)
+                    ? {
+                        left: [-d.width / 2, 0, 0],
+                        right: [d.width / 2, 0, 0],
+                        bottom: [0, -d.height / 2, 0],
+                        top: [0, d.height / 2, 0],
+                        back: [0, 0, -d.depth / 2],
+                        front: [0, 0, d.depth / 2]
+                    }
+                    : { start: [0, -d.length / 2, 0], end: [0, d.length / 2, 0], radialBottom: [0, 0, -d.radius] };
+            return [{ r: identity(), t: points[n.params.name] }];
+        }
+    },
+    'place@1': {
+        ports: ['placed'],
+        types(t, p) {
+            if (t.length !== 2 || t[0].kind !== 'shape' || t[1].kind !== 'transform' || t[0].frame !== t[1].from)
+                fail('FRAME_TYPE', p, 'shape local frame mismatch');
+            return [{ kind: 'placed', frame: t[1].to }];
+        },
+        run: ([shape, pose]) => [{ shape, pose }],
+        geometry: ([shape, pose]) => ({ shape, pose })
+    }
+});
+// Template members are values, not separately rendered placements.
+ops['member@1'] = { ...ops['place@1'], geometry: undefined };
+function checkedValue(value, type, path) {
+    if (Array.isArray(type))
+        return num(value, path);
+    if (type.kind === 'count') {
+        if (!Number.isSafeInteger(value) || value < 0)
+            fail('COUNT', path, 'nonnegative safe integer required');
+        return value;
+    }
+    const check = (v) => {
+        if (typeof v === 'number')
+            num(v, path);
+        else if (Array.isArray(v))
+            v.forEach(check);
+        else if (v && typeof v === 'object')
+            Object.values(v).forEach(check);
+    };
+    check(value);
+    return value;
+}
+export function compileV3Graph(source) {
+    return compileInternal(source);
+}
+function compileInternal(source) {
+    fields(source, ['version', 'inputs', 'constants', 'nodes'], [], 'model');
+    if (!['r3-scalar-1', 'r3-spatial-1'].includes(source.version))
+        fail('VERSION', 'model', source.version);
+    for (const k of ['inputs', 'constants', 'nodes'])
+        if (!Array.isArray(source[k]))
+            fail('SCHEMA', k, 'array required');
+    // Snapshot protects a compiled plan from later authoring mutations.
+    const m = structuredClone(source), writers = new Map(), types = new Map(), stateful = new Set(), nodes = new Map(), order = [], active = [];
+    const assign = (name, owner) => {
+        id(name, owner);
+        if (writers.has(name))
+            fail('DUPLICATE_WRITER', name, `${writers.get(name)} and ${owner}`);
+        writers.set(name, owner);
+    };
+    for (const p of m.inputs) {
+        fields(p, ['id', 'unit', 'min', 'max'], ['role'], 'input');
+        assign(p.id, 'input');
+        types.set(p.id, unit(p.unit, p.id)[0]);
+        if (p.role && !['design', 'state'].includes(p.role))
+            fail('SCHEMA', p.id, 'unknown input role');
+        if (p.role === 'state')
+            stateful.add(p.id);
+        if (num(p.min, p.id) > num(p.max, p.id))
+            fail('RANGE', p.id, 'min > max');
+        if (p.unit === 'count') {
+            checkedValue(p.min, countType, p.id);
+            checkedValue(p.max, countType, p.id);
+        }
+    }
+    for (const p of m.constants) {
+        fields(p, ['id', 'unit', 'value'], [], 'constant');
+        assign(p.id, 'constant');
+        types.set(p.id, unit(p.unit, p.id)[0]);
+        checkedValue(p.value, types.get(p.id), p.id);
+    }
+    for (const n of m.nodes) {
+        fields(n, ['id', 'op', 'args', 'outputs'], ['params'], 'node');
+        id(n.id, 'node');
+        if (nodes.has(n.id))
+            fail('DUPLICATE_NODE', n.id, 'node id');
+        if (!Object.hasOwn(ops, n.op))
+            fail('OPERATOR', n.id, n.op);
+        if (ops[n.op].params)
+            config(n, ops[n.op].params);
+        else if (Object.hasOwn(n, 'params'))
+            fail('SCHEMA', n.id, 'unexpected params');
+        if (!Array.isArray(n.args))
+            fail('SCHEMA', n.id, 'args array required');
+        n.args.forEach(a => id(a, n.id));
+        fields(n.outputs, ops[n.op].ports, [], n.id);
+        for (const output of Object.values(n.outputs))
+            assign(output, n.id);
+        nodes.set(n.id, n);
+    }
+    const visited = new Set();
+    function visit(name) {
+        if (visited.has(name))
+            return;
+        if (active.includes(name))
+            fail('CYCLE', name, [...active, name].join(' -> '));
+        active.push(name);
+        const n = nodes.get(name), op = ops[n.op];
+        const inputTypes = n.args.map(ref => {
+            if (!writers.has(ref))
+                fail('UNKNOWN_REFERENCE', n.id, ref);
+            if (!types.has(ref))
+                visit(writers.get(ref));
+            return types.get(ref);
+        });
+        const resultTypes = op.types(inputTypes, n.id, n);
+        const dependsOnState = n.args.some(ref => stateful.has(ref));
+        if (dependsOnState && ['fit-pitch@1', 'fixed-count@1'].includes(n.op))
+            fail('TOPOLOGY_STATE', n.id, 'layout must depend on design inputs only');
+        op.ports.forEach((p, i) => types.set(n.outputs[p], resultTypes[i]));
+        if (dependsOnState)
+            Object.values(n.outputs).forEach(ref => stateful.add(ref));
+        active.pop();
+        visited.add(name);
+        order.push(n);
+    }
+    for (const name of nodes.keys())
+        visit(name);
+    return {
+        outputTypes: Object.fromEntries([...types].map(([k, v]) => [k, structuredClone(v)])),
+        order: order.map(n => n.id),
+        evaluate(input) {
+            fields(input, m.inputs.map(p => p.id), [], 'input values');
+            const values = new Map(), geometry = [];
+            for (const p of m.inputs) {
+                const raw = num(input[p.id], p.id);
+                if (raw < p.min || raw > p.max)
+                    fail('INPUT_RANGE', p.id, `${raw} outside [${p.min},${p.max}]`);
+                values.set(p.id, checkedValue(raw * unit(p.unit, p.id)[1], types.get(p.id), p.id));
+            }
+            for (const p of m.constants)
+                values.set(p.id, num(p.value * unit(p.unit, p.id)[1], p.id));
+            for (const n of order) {
+                const op = ops[n.op], args = n.args.map(k => values.get(k)), out = op.run(args, n.id, n);
+                op.ports.forEach((p, i) => values.set(n.outputs[p], checkedValue(out[i], types.get(n.outputs[p]), n.id)));
+                if (op.geometry) {
+                    const g = op.geometry(args, out);
+                    if (Array.isArray(g))
+                        geometry.push(...g);
+                    else
+                        geometry.push({ id: n.id, ...g });
+                }
+            }
+            return { values: Object.fromEntries(values), geometry };
+        }
+    };
+}
+//# sourceMappingURL=v3-graph.js.map