@field/cascade 0.8.0 → 0.11.0

package/dist/cli/chunk-35D343DC.js

@@ -0,0 +1,1447 @@
+import {
+  projectionMatrix,
+  viewMatrix
+} from "./chunk-DEQSEFFH.js";
+import {
+  GeometryBuilder,
+  attributeSet,
+  copyAttributeArray,
+  createAttribute,
+  createStringAttribute,
+  geometryError,
+  getPosition,
+  numericAttribute,
+  positionAttribute,
+  positionSize,
+  readComponent,
+  readElement,
+  readString,
+  setAttribute,
+  withAttributeSet
+} from "./chunk-HSNOBIVT.js";
+import {
+  BEZIER_STRIDE,
+  POSITION_ATTRIBUTE,
+  PRIMITIVE_KINDS,
+  attributeArray,
+  createGeometry,
+  emptyGeometry,
+  isStringAttribute,
+  levelCount
+} from "./chunk-J7VK7MNF.js";
+
+// packages/contracts/src/color.ts
+var HEX = /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+function clamp(value) {
+  return !Number.isFinite(value) ? 0 : value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function byte(value) {
+  return Math.round(clamp(value) * 255);
+}
+function pair(value) {
+  return byte(value).toString(16).padStart(2, "0");
+}
+function unit(value) {
+  return String(Number(clamp(value).toFixed(4)));
+}
+function expand(digits) {
+  const wide = digits.length <= 4 ? [...digits].map((digit) => `${digit}${digit}`) : digits.match(/../g) ?? [];
+  return wide.map((component) => Number.parseInt(component, 16) / 255);
+}
+var Color = Object.freeze({
+  /**
+   * `#rgb`, `#rgba`, `#rrggbb` or `#rrggbbaa` to a colour. Alpha defaults to 1
+   * when the string carries none. The three- and four-digit shorthands are
+   * accepted because CSS accepts them and hand-written palettes use them;
+   * anything else throws, since a colour that silently parses to black is the
+   * failure this whole ruling exists to remove.
+   */
+  fromHex(value) {
+    if (!HEX.test(value))
+      throw new TypeError(
+        `color/invalid-hex: ${value} is not #rgb, #rgba, #rrggbb or #rrggbbaa`
+      );
+    const components = expand(value.slice(1));
+    return [
+      components[0],
+      components[1],
+      components[2],
+      components[3] ?? 1
+    ];
+  },
+  /** Whether `fromHex` would accept this string. */
+  isHex(value) {
+    return typeof value === "string" && HEX.test(value);
+  },
+  /**
+   * `#rrggbb`, or `#rrggbbaa` with `includeAlpha`. The default drops alpha
+   * because eight-digit hex is CSS Color 4 and plotter and vector-editor
+   * software of the kind this library exists to feed does not read it. Callers
+   * that need the alpha to survive emit it as a separate opacity, which is what
+   * the SVG writer does.
+   */
+  toHex(color, includeAlpha = false) {
+    return `#${pair(color[0])}${pair(color[1])}${pair(color[2])}${includeAlpha ? pair(color[3]) : ""}`;
+  },
+  /**
+   * A CSS colour: `rgb(255, 128, 0)`, or `rgba(255, 128, 0, 0.5)` when alpha is
+   * below 1. The legacy comma forms rather than the modern space-separated
+   * ones, for the same compatibility reason `toHex` drops alpha by default.
+   */
+  toString(color) {
+    const channels = `${byte(color[0])}, ${byte(color[1])}, ${byte(color[2])}`;
+    return clamp(color[3]) >= 1 ? `rgb(${channels})` : `rgba(${channels}, ${unit(color[3])})`;
+  },
+  /** Alpha on its own, for a renderer that carries opacity separately. */
+  alpha(color) {
+    return clamp(color[3]);
+  },
+  /** The same colour at full alpha. */
+  opaque(color) {
+    return [clamp(color[0]), clamp(color[1]), clamp(color[2]), 1];
+  },
+  /**
+   * Four unit components from anything indexable, clamping and defaulting a
+   * missing alpha to 1. The reader for a `Cd` attribute's flat array, and the
+   * one place that decides what an under-sized colour means.
+   */
+  fromComponents(components, offset = 0, size = 4) {
+    const at = (component) => component < size ? clamp(components[offset + component] ?? 0) : 0;
+    return [at(0), at(1), at(2), size < 4 ? 1 : at(3)];
+  }
+});
+
+// packages/contracts/src/scene.ts
+var LIGHT_DEFAULTS = {
+  type: "point",
+  translate: [0, 0, 0],
+  direction: [0, 0, -1],
+  color: [1, 1, 1, 1],
+  intensity: 1,
+  coneangle: 45
+};
+var EMPTY_SCENE = { geometry: [], camera: null, lights: [] };
+function isLight(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const light = value;
+  return (light.type === "point" || light.type === "distant" || light.type === "ambient" || light.type === "spot") && Array.isArray(light.translate) && Array.isArray(light.direction) && Array.isArray(light.color) && typeof light.intensity === "number";
+}
+function isScene(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const scene = value;
+  return Array.isArray(scene.geometry) && Array.isArray(scene.lights) && "camera" in scene && (scene.camera === null || typeof scene.camera === "object");
+}
+function sceneFromGeometry(geometry) {
+  return { geometry: [geometry], camera: null, lights: [] };
+}
+function asScene(value) {
+  if (value === void 0 || value === null) return EMPTY_SCENE;
+  if (isScene(value)) return value;
+  if (typeof value === "object" && value.kind === "geometry")
+    return sceneFromGeometry(value);
+  return EMPTY_SCENE;
+}
+
+// packages/runtime/src/geometry/groups.ts
+var KEYS = {
+  point: "pointGroups",
+  primitive: "primitiveGroups"
+};
+function groupMask(geometry, level, name) {
+  return geometry[KEYS[level]][name];
+}
+function groupIndices(mask) {
+  const indices = [];
+  for (let index = 0; index < mask.length; index += 1)
+    if (mask[index]) indices.push(index);
+  return indices;
+}
+function groupNames(geometry, level) {
+  return Object.keys(geometry[KEYS[level]]);
+}
+
+// packages/runtime/src/geometry/matrix.ts
+function transformMatrix(parameters) {
+  const [tx, ty] = parameters.translate ?? [0, 0];
+  const [sx, sy] = parameters.scale ?? [1, 1];
+  const [px, py] = parameters.pivot ?? [0, 0];
+  const rotate = parameters.rotate ?? 0;
+  if (![tx, ty, sx, sy, px, py, rotate].every(Number.isFinite))
+    throw new TypeError("geometry/transform: transform parameters must be finite");
+  const radians = rotate * Math.PI / 180;
+  const cos = Math.cos(radians);
+  const sin = Math.sin(radians);
+  const a00 = cos * sx;
+  const a10 = sin * sx;
+  const a01 = -sin * sy;
+  const a11 = cos * sy;
+  return [
+    a00,
+    a10,
+    0,
+    a01,
+    a11,
+    0,
+    tx + px - (a00 * px + a01 * py),
+    ty + py - (a10 * px + a11 * py),
+    1
+  ];
+}
+
+// packages/runtime/src/geometry/merge.ts
+function mergeGeometries(inputs) {
+  if (inputs.length === 0) return emptyGeometry(2);
+  if (inputs.length === 1) return inputs[0];
+  const pointCount = sum(inputs, (input) => input.pointCount);
+  const vertexCount = sum(inputs, (input) => input.vertexCount);
+  const primitiveCount = sum(inputs, (input) => input.primitiveCount);
+  const vertexPoints = new Int32Array(vertexCount);
+  const offsets = new Int32Array(primitiveCount + 1);
+  const kinds = new Uint8Array(primitiveCount);
+  const closed = new Uint8Array(primitiveCount);
+  let pointBase = 0;
+  let vertexBase = 0;
+  let primitiveBase = 0;
+  for (const input of inputs) {
+    for (let vertex = 0; vertex < input.vertexCount; vertex += 1)
+      vertexPoints[vertexBase + vertex] = input.topology.vertexPoints[vertex] + pointBase;
+    for (let primitive = 0; primitive < input.primitiveCount; primitive += 1) {
+      offsets[primitiveBase + primitive] = input.topology.offsets[primitive] + vertexBase;
+      kinds[primitiveBase + primitive] = input.topology.kinds[primitive];
+      closed[primitiveBase + primitive] = input.topology.closed[primitive];
+    }
+    pointBase += input.pointCount;
+    vertexBase += input.vertexCount;
+    primitiveBase += input.primitiveCount;
+  }
+  offsets[primitiveCount] = vertexCount;
+  const detail = {};
+  for (const input of inputs)
+    for (const [name, value] of Object.entries(input.detail))
+      if (!Object.prototype.hasOwnProperty.call(detail, name))
+        detail[name] = value;
+  return createGeometry({
+    pointCount,
+    point: mergeLevel(inputs, "point"),
+    vertex: mergeLevel(inputs, "vertex"),
+    primitive: mergeLevel(inputs, "primitive"),
+    detail,
+    topology: { vertexPoints, offsets, kinds, closed },
+    pointGroups: mergeGroups(inputs, "point"),
+    primitiveGroups: mergeGroups(inputs, "primitive")
+  });
+}
+function sum(inputs, read) {
+  let total = 0;
+  for (const input of inputs) total += read(input);
+  return total;
+}
+var STORAGE_RANK = {
+  u8: 0,
+  i32: 1,
+  f32: 2,
+  f64: 3
+};
+function widerStorage(a, b) {
+  if (a === b) return a;
+  if (a === "f64" || b === "f64") return "f64";
+  if (a === "i32" && b === "f32" || a === "f32" && b === "i32") return "f64";
+  return STORAGE_RANK[a] > STORAGE_RANK[b] ? a : b;
+}
+function mergeLevel(inputs, level) {
+  const names = [];
+  for (const input of inputs)
+    for (const name of Object.keys(input[level]))
+      if (!names.includes(name)) names.push(name);
+  const total = sum(inputs, (input) => levelCount(input, level));
+  const result = {};
+  for (const name of names) {
+    const present = inputs.map((input) => input[level][name]).filter((attribute) => attribute !== void 0);
+    const strings = present.filter(isStringAttribute).length;
+    if (strings !== 0 && strings !== present.length)
+      geometryError(
+        "attribute-conflict",
+        `${level}.${name} is a string attribute on one input and numeric on another`
+      );
+    result[name] = strings === present.length ? mergeStringAttribute(inputs, level, name, total) : mergeNumericAttribute(inputs, level, name, total);
+  }
+  return result;
+}
+function mergeNumericAttribute(inputs, level, name, total) {
+  let size = 1;
+  let storage;
+  for (const input of inputs) {
+    const attribute = input[level][name];
+    if (attribute === void 0 || isStringAttribute(attribute)) continue;
+    size = Math.max(size, attribute.size);
+    storage = storage === void 0 ? attribute.storage : widerStorage(storage, attribute.storage);
+  }
+  const data = attributeArray(storage ?? "f64", size * total);
+  let base = 0;
+  for (const input of inputs) {
+    const count = levelCount(input, level);
+    const attribute = input[level][name];
+    if (attribute !== void 0 && !isStringAttribute(attribute))
+      for (let index = 0; index < count; index += 1)
+        for (let component = 0; component < attribute.size; component += 1)
+          data[(base + index) * size + component] = attribute.data[index * attribute.size + component];
+    base += count;
+  }
+  return { storage: storage ?? "f64", size, data };
+}
+function mergeStringAttribute(inputs, level, name, total) {
+  const values = new Array(total).fill("");
+  let base = 0;
+  for (const input of inputs) {
+    const count = levelCount(input, level);
+    const attribute = input[level][name];
+    if (attribute !== void 0 && isStringAttribute(attribute))
+      for (let index = 0; index < count; index += 1)
+        values[base + index] = readString(attribute, index);
+    base += count;
+  }
+  return createStringAttribute(values);
+}
+function mergeGroups(inputs, level) {
+  const key = level === "point" ? "pointGroups" : "primitiveGroups";
+  const names = [];
+  for (const input of inputs)
+    for (const name of Object.keys(input[key]))
+      if (!names.includes(name)) names.push(name);
+  const total = sum(inputs, (input) => levelCount(input, level));
+  const result = {};
+  for (const name of names) {
+    const mask = new Uint8Array(total);
+    let base = 0;
+    for (const input of inputs) {
+      const count = levelCount(input, level);
+      const source = input[key][name];
+      if (source !== void 0)
+        for (let index = 0; index < count; index += 1)
+          mask[base + index] = source[index];
+      base += count;
+    }
+    result[name] = mask;
+  }
+  return result;
+}
+
+// packages/runtime/src/geometry/transform.ts
+function transformGeometry(geometry, matrix) {
+  if (matrix.length !== 9 && matrix.length !== 16)
+    geometryError("matrix", "transform needs a mat3 or a mat4");
+  if (!matrix.every(Number.isFinite))
+    geometryError("matrix", "transform matrix values must be finite");
+  if (geometry.pointCount === 0) return geometry;
+  const position = positionAttribute(geometry);
+  const size = position.size;
+  const data = copyAttributeArray(position);
+  if (matrix.length === 9) {
+    const m = matrix;
+    for (let point = 0; point < geometry.pointCount; point += 1) {
+      const base = point * size;
+      const x = data[base];
+      const y = data[base + 1];
+      data[base] = m[0] * x + m[3] * y + m[6];
+      data[base + 1] = m[1] * x + m[4] * y + m[7];
+    }
+  } else {
+    const m = matrix;
+    for (let point = 0; point < geometry.pointCount; point += 1) {
+      const base = point * size;
+      const x = data[base];
+      const y = data[base + 1];
+      const z = size === 3 ? data[base + 2] : 0;
+      data[base] = m[0] * x + m[4] * y + m[8] * z + m[12];
+      data[base + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+      if (size === 3)
+        data[base + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+    }
+  }
+  return withAttributeSet(geometry, "point", {
+    ...attributeSet(geometry, "point"),
+    [POSITION_ATTRIBUTE]: { storage: position.storage, size, data }
+  });
+}
+
+// packages/runtime/src/geometry/copy.ts
+function copyToPoints(source, target, options = {}) {
+  const width = positionSize(source) === 3 ? 3 : 2;
+  const selection = options.targetGroup === void 0 || options.targetGroup === "" ? void 0 : groupMask(target, "point", options.targetGroup) ?? geometryError(
+    "missing-group",
+    `point group ${options.targetGroup} is not present on the target`
+  );
+  const indices = selection === void 0 ? range(target.pointCount) : groupIndices(selection);
+  if (indices.length === 0 || source.pointCount === 0)
+    return emptyGeometry(width);
+  const orient = options.useTargetOrientations ?? true;
+  const pscale = orient ? numericAttribute(target.point.pscale, "point.pscale", [1]) : void 0;
+  const normal = orient ? numericAttribute(target.point.N, "point.N", [2, 3]) : void 0;
+  const copyNumber = options.copyNumberAttribute ?? "copynum";
+  const transfer = options.transferTargetAttributes ?? true ? Object.keys(target.point).filter(
+    (name) => name !== POSITION_ATTRIBUTE && !Object.prototype.hasOwnProperty.call(source.point, name)
+  ) : [];
+  const copies = [];
+  for (const index of indices) {
+    const position = getPosition(target, index);
+    const scale = pscale === void 0 ? 1 : readComponent(pscale, index);
+    const rotate = normal === void 0 ? 0 : Math.atan2(
+      readComponent(normal, index, 1),
+      readComponent(normal, index, 0)
+    ) * 180 / Math.PI;
+    let copy = transformGeometry(
+      source,
+      transformMatrix({
+        translate: [position[0], position[1]],
+        rotate,
+        scale: [scale, scale]
+      })
+    );
+    if (copyNumber !== "")
+      copy = setAttribute(copy, "primitive", copyNumber, {
+        storage: "i32",
+        size: 1,
+        data: new Int32Array(copy.primitiveCount).fill(index)
+      });
+    for (const name of transfer)
+      copy = setAttribute(
+        copy,
+        "point",
+        name,
+        spread(target.point[name], index, copy.pointCount)
+      );
+    copies.push(copy);
+  }
+  return mergeGeometries(copies);
+}
+function range(count) {
+  const indices = new Array(count);
+  for (let index = 0; index < count; index += 1) indices[index] = index;
+  return indices;
+}
+function spread(attribute, index, count) {
+  if (isStringAttribute(attribute))
+    return createStringAttribute(
+      new Array(count).fill(readString(attribute, index))
+    );
+  return createAttribute(
+    count,
+    attribute.size,
+    attribute.storage,
+    readElement(attribute, index)
+  );
+}
+
+// packages/runtime/src/geometry/rects.ts
+function coordinates(rect) {
+  if (Array.isArray(rect.rect)) {
+    const box = rect.rect;
+    if (box.length < 4 || box.some((value) => typeof value !== "number")) return null;
+    return [box[0], box[1], box[2], box[3]];
+  }
+  const declared = rect;
+  if (typeof declared?.x !== "number" || typeof declared?.y !== "number" || typeof declared?.width !== "number" || typeof declared?.height !== "number")
+    return null;
+  return [declared.x, declared.y, declared.width, declared.height];
+}
+function rectsToGeometry(value, options = {}) {
+  const list = Array.isArray(value) ? value : value?.rects ?? [];
+  const flip = options.origin === "top-left" ? options.height ?? 0 : 0;
+  const builder = new GeometryBuilder();
+  const tags = [];
+  let skipped = 0;
+  let tagged = false;
+  for (const rect of list) {
+    const box = coordinates(rect);
+    if (!box || box.some((component) => !Number.isFinite(component))) {
+      skipped += 1;
+      continue;
+    }
+    const [x, y, width, height] = box;
+    const bottom = flip > 0 ? flip - (y + height) : y;
+    const top = bottom + height;
+    builder.addPolygon([x, bottom, x + width, bottom, x + width, top, x, top], {
+      closed: true
+    });
+    const tag = rect.tag;
+    tags.push(typeof tag === "string" ? tag : "");
+    if (typeof tag === "string" && tag.length > 0) tagged = true;
+  }
+  if (tagged) builder.setStringAttribute("primitive", "tag", tags);
+  if (skipped > 0) builder.setDetail("rects_skipped", skipped);
+  return builder.build();
+}
+
+// packages/runtime/src/builtins/geo/definitions.ts
+var rectangleDefinition = {
+  apiVersion: 1,
+  label: "Rectangle",
+  description: "A closed four-point polygon, counter-clockwise from bottom-left.",
+  icon: "Square",
+  runsOn: "portable",
+  inputs: {
+    size: { kind: "data", type: "vec2", default: [1, 1] },
+    center: { kind: "data", type: "vec2", default: [0, 0] }
+  },
+  outputs: { geometry: { kind: "data", type: "geometry" } }
+};
+var circleDefinition = {
+  apiVersion: 1,
+  label: "Circle",
+  description: "A closed circle, as one cubic Bezier chain or as a polygon of divisions segments.",
+  icon: "Circle",
+  runsOn: "portable",
+  inputs: {
+    center: { kind: "data", type: "vec2", default: [0, 0] },
+    radius: { kind: "data", type: "vec2", default: [1, 1] },
+    divisions: {
+      kind: "data",
+      type: "int",
+      default: 32,
+      min: 3,
+      step: 1,
+      description: "Segments of the polygonal form. Ignored by the Bezier form."
+    }
+  },
+  outputs: { geometry: { kind: "data", type: "geometry" } },
+  props: {
+    type: {
+      type: "string",
+      default: "bezier",
+      label: "Primitive Type",
+      control: "select",
+      options: ["bezier", "poly"],
+      description: "A Bezier circle is a circle; a polygon of any division count is visibly a polygon in print."
+    }
+  }
+};
+var transformDefinition = {
+  apiVersion: 1,
+  label: "Transform",
+  description: "Translate, rotate and scale geometry about a pivot.",
+  icon: "Move",
+  runsOn: "portable",
+  inputs: {
+    geometry: { kind: "data", type: "geometry" },
+    translate: { kind: "data", type: "vec2", default: [0, 0] },
+    rotate: {
+      kind: "data",
+      type: "float",
+      default: 0,
+      description: "Degrees, counter-clockwise."
+    },
+    scale: { kind: "data", type: "vec2", default: [1, 1] },
+    pivot: { kind: "data", type: "vec2", default: [0, 0] }
+  },
+  outputs: { geometry: { kind: "data", type: "geometry" } }
+};
+var mergeDefinition = {
+  apiVersion: 1,
+  label: "Merge",
+  description: "Concatenate geometries, taking the union of their attributes.",
+  icon: "GitMerge",
+  runsOn: "portable",
+  inputs: { inputs: { kind: "data", type: "geometry", variadic: true } },
+  outputs: { geometry: { kind: "data", type: "geometry" } }
+};
+var copyToPointsDefinition = {
+  apiVersion: 1,
+  label: "Copy to Points",
+  description: "Instance one geometry onto every point of another.",
+  icon: "Copy",
+  runsOn: "portable",
+  inputs: {
+    source: { kind: "data", type: "geometry" },
+    target: { kind: "data", type: "geometry" }
+  },
+  outputs: { geometry: { kind: "data", type: "geometry" } },
+  props: {
+    targetGroup: {
+      type: "string",
+      default: "",
+      label: "Target Group",
+      description: "Copy onto this point group only; empty means every point."
+    },
+    useTargetOrientations: {
+      type: "bool",
+      default: true,
+      label: "Transform Using Target Point Orientations",
+      description: "Read pscale and N from the target points."
+    }
+  }
+};
+var svgExportDefinition = {
+  apiVersion: 1,
+  label: "SVG Export",
+  description: "Write geometry as an SVG document, one group element per group.",
+  icon: "FileDown",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  inputs: { geometry: { kind: "data", type: "geometry" } },
+  outputs: {
+    svg: { kind: "data", type: "string" },
+    asset: { kind: "data", type: "asset" }
+  },
+  props: {
+    filename: { type: "string", default: "geometry.svg", label: "Filename" },
+    width: {
+      type: "float",
+      default: 0,
+      min: 0,
+      label: "Width",
+      description: "0 derives the width from the geometry bounds."
+    },
+    height: { type: "float", default: 0, min: 0, label: "Height" },
+    margin: { type: "float", default: 0, label: "Margin" },
+    /**
+     * An explicit world rectangle, `[minX, minY, maxX, maxY]`, instead of the
+     * geometry's own bounds. All zero derives them as before.
+     *
+     * A frame sequence needs it: derived bounds give every frame its own
+     * viewBox, so a growing drawing appears to zoom out over the animation.
+     */
+    bounds: { type: "vec4", default: [0, 0, 0, 0], label: "Bounds" },
+    /** A ground behind the drawing. Fully transparent leaves the document
+     *  transparent, which is what plotter work wants. */
+    background: {
+      type: "color",
+      default: [0, 0, 0, 0],
+      label: "Background",
+      description: "A ground behind the drawing. Transparent by default, because a plotter wants paper."
+    },
+    stroke: {
+      type: "color",
+      default: [0, 0, 0, 1],
+      label: "Stroke",
+      description: "Fallback for a primitive with no Cd attribute."
+    },
+    strokeWidth: {
+      type: "float",
+      default: 1,
+      min: 0,
+      label: "Stroke Width",
+      description: "Fallback for a primitive with no width attribute."
+    },
+    opacity: {
+      type: "float",
+      default: 1,
+      min: 0,
+      max: 1,
+      label: "Opacity",
+      description: "Fallback for a primitive with no opacity attribute."
+    },
+    fillMode: {
+      type: "string",
+      default: "none",
+      label: "Fill Mode",
+      control: "select",
+      options: ["none", "solid"],
+      description: "none leaves primitives unfilled, which is what plotter work wants."
+    },
+    fill: {
+      type: "color",
+      default: [1, 1, 1, 1],
+      label: "Fill",
+      description: "Fill colour, used only when Fill Mode is solid."
+    },
+    pointRadius: {
+      type: "float",
+      default: 0.5,
+      min: 0,
+      label: "Point Radius",
+      description: "Fallback radius for a loose point with no pscale."
+    },
+    precision: {
+      type: "int",
+      default: 3,
+      min: 0,
+      max: 15,
+      step: 1,
+      label: "Precision",
+      description: "Decimal places on emitted coordinates."
+    }
+  }
+};
+var renderDefinition = {
+  apiVersion: 1,
+  label: "Render",
+  description: "Draw a scene through a camera, as a raster.",
+  icon: "Camera",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  inputs: {
+    /**
+     * A scene, or a geometry — `geometry` widens to `scene`, so wiring a
+     * geometry straight in still works and arrives through `asScene`.
+     *
+     * Taking a scene rather than a geometry is what makes the viewport and this
+     * node incapable of disagreeing about framing: both read the same object,
+     * so the picture on screen and the picture in the PNG come from one camera
+     * and one list of geometry rather than from two paths that have to be kept
+     * in step by hand.
+     */
+    scene: { kind: "data", type: "scene" },
+    /**
+     * The camera, and required in the sense that matters: it may come from the
+     * scene instead, but it may not be invented. A render with an implicit
+     * camera is a render nobody can reproduce, and `cascade.core.Camera` is one
+     * node away.
+     *
+     * Wired here it **overrides** the scene's own camera, which is what lets one
+     * scene be rendered from several viewpoints without rebuilding it — and is
+     * also why the viewport's navigated camera never reaches this node. A view
+     * you dragged is not a document.
+     */
+    camera: { kind: "data", type: "camera" }
+  },
+  outputs: {
+    image: { kind: "data", type: "image" },
+    asset: { kind: "data", type: "asset" }
+  },
+  props: {
+    /** Pixels. Separate from the camera's own `resolution`, which describes
+     *  the frame the projection assumes — so a preview renders small and frames
+     *  identically to the full-size render. */
+    size: { type: "vec2i", default: [1280, 720], min: 16, max: 8192 },
+    filename: { type: "string", default: "render.png", label: "Filename" },
+    background: { type: "color", default: [0, 0, 0, 0], label: "Background" },
+    /** Fallback for a primitive with no `Cd`, exactly as SvgExport's is. */
+    stroke: { type: "color", default: [0, 0, 0, 1], label: "Stroke" },
+    strokeWidth: { type: "float", default: 1, min: 0, max: 200, step: 0.05 },
+    opacity: { type: "float", default: 1, min: 0, max: 1, step: 0.01 },
+    /** Points no primitive claimed. Off by default: a trail system has
+     *  thousands of vertices and a dot on every one buries the strokes. */
+    drawPoints: { type: "bool", default: false, label: "Draw Loose Points" },
+    pointRadius: { type: "float", default: 1.5, min: 0, max: 50, step: 0.1 }
+  }
+};
+var fromRectsDefinition = {
+  apiVersion: 1,
+  label: "From Rects",
+  description: "Convert rects into geometry, one closed polygon each, keeping the tag.",
+  icon: "Frame",
+  runsOn: "portable",
+  inputs: {
+    rects: { kind: "data", type: "rects" },
+    /** The frame the rects were measured against, for the flip. */
+    height: {
+      kind: "data",
+      type: "float",
+      default: 0,
+      min: 0,
+      description: "Image height, for Top Left. Zero means no flip."
+    }
+  },
+  outputs: { geometry: { kind: "data", type: "geometry" } },
+  props: {
+    origin: {
+      type: "string",
+      default: "top-left",
+      control: "select",
+      options: [
+        { value: "top-left", label: "Top Left - raster, needs a height" },
+        { value: "bottom-left", label: "Bottom Left - already +Y up" }
+      ],
+      label: "Origin",
+      description: "Where y is measured from. Raster rects need flipping or the SVG comes out mirrored."
+    }
+  }
+};
+function executeFromRects(context) {
+  const incoming = context.inputs.rects;
+  const origin = context.props.origin === "bottom-left" ? "bottom-left" : "top-left";
+  const height = context.inputs.height ?? 0;
+  if (origin === "top-left" && height <= 0 && rectCount(incoming) > 0)
+    throw new Error(
+      "cascade.geo.FromRects needs the image height to flip raster rects \u2014 wire it, or set Origin to Bottom Left if the rects are already +Y up"
+    );
+  context.outputs.geometry.set(
+    rectsToGeometry(incoming, { origin, height })
+  );
+}
+function rectCount(value) {
+  if (Array.isArray(value)) return value.length;
+  const rects = value?.rects;
+  return Array.isArray(rects) ? rects.length : 0;
+}
+var fromRectsRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.geo.FromRects",
+  definition: fromRectsDefinition,
+  loadExecute: async () => executeFromRects
+};
+var geoNodeDefinitions = Object.freeze([
+  ["cascade.geo.Rectangle", rectangleDefinition],
+  ["cascade.geo.Circle", circleDefinition],
+  ["cascade.geo.Transform", transformDefinition],
+  ["cascade.geo.Merge", mergeDefinition],
+  ["cascade.geo.CopyToPoints", copyToPointsDefinition],
+  ["cascade.geo.SvgExport", svgExportDefinition],
+  ["cascade.geo.Render", renderDefinition],
+  ["cascade.geo.FromRects", fromRectsDefinition]
+]);
+
+// packages/runtime/src/builtins/geo/namespace.ts
+var GEO_NAMESPACE = "cascade.geo";
+function geoModuleId(name) {
+  return `${GEO_NAMESPACE}.${name}`;
+}
+
+// packages/runtime/src/builtins/geo/copyToPoints.ts
+function executeCopyToPoints(context) {
+  const source = context.inputs.source;
+  const target = context.inputs.target;
+  if (source === void 0 || target === void 0) {
+    context.outputs.geometry.set(emptyGeometry(2));
+    return;
+  }
+  context.outputs.geometry.set(
+    copyToPoints(source, target, {
+      targetGroup: context.props.targetGroup,
+      useTargetOrientations: context.props.useTargetOrientations
+    })
+  );
+}
+var copyToPointsRegistration = {
+  kind: "definition-v1",
+  moduleId: geoModuleId("CopyToPoints"),
+  definition: copyToPointsDefinition,
+  loadExecute: async () => executeCopyToPoints
+};
+
+// packages/runtime/src/geometry/generate.ts
+function finitePair(value, code) {
+  if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]))
+    geometryError(code, "both components must be finite");
+}
+function rectangleGeometry(options = {}) {
+  const [width, height] = options.size ?? [1, 1];
+  const [cx, cy] = options.center ?? [0, 0];
+  finitePair([width, height], "rectangle-size");
+  finitePair([cx, cy], "rectangle-center");
+  if (width < 0 || height < 0)
+    geometryError("rectangle-size", "rectangle size must not be negative");
+  const x0 = cx - width / 2;
+  const x1 = cx + width / 2;
+  const y0 = cy - height / 2;
+  const y1 = cy + height / 2;
+  const builder = new GeometryBuilder();
+  builder.addPolygon([x0, y0, x1, y0, x1, y1, x0, y1], { closed: true });
+  return builder.build();
+}
+function circleGeometry(options = {}) {
+  const [cx, cy] = options.center ?? [0, 0];
+  const [rx, ry] = options.radius ?? [1, 1];
+  finitePair([cx, cy], "circle-center");
+  finitePair([rx, ry], "circle-radius");
+  if (rx < 0 || ry < 0)
+    geometryError("circle-radius", "circle radius must not be negative");
+  const builder = new GeometryBuilder();
+  if ((options.type ?? "bezier") === "poly") {
+    const divisions = options.divisions ?? 32;
+    if (!Number.isSafeInteger(divisions) || divisions < 3)
+      geometryError(
+        "circle-divisions",
+        "a polygonal circle needs an integer division count of at least 3"
+      );
+    const flat2 = [];
+    for (let index = 0; index < divisions; index += 1) {
+      const angle = 2 * Math.PI * index / divisions;
+      flat2.push(cx + rx * Math.cos(angle), cy + ry * Math.sin(angle));
+    }
+    builder.addPolygon(flat2, { closed: true });
+    return builder.build();
+  }
+  const k = 4 / 3 * Math.tan(Math.PI / 8);
+  const kx = rx * k;
+  const ky = ry * k;
+  const flat = [
+    cx + rx,
+    cy,
+    cx + rx,
+    cy + ky,
+    cx + kx,
+    cy + ry,
+    cx,
+    cy + ry,
+    cx - kx,
+    cy + ry,
+    cx - rx,
+    cy + ky,
+    cx - rx,
+    cy,
+    cx - rx,
+    cy - ky,
+    cx - kx,
+    cy - ry,
+    cx,
+    cy - ry,
+    cx + kx,
+    cy - ry,
+    cx + rx,
+    cy - ky
+  ];
+  builder.addPolygon(flat, { closed: true, kind: "bezier" });
+  return builder.build();
+}
+
+// packages/runtime/src/builtins/geo/generators.ts
+function executeRectangle(context) {
+  context.outputs.geometry.set(
+    rectangleGeometry({
+      size: context.inputs.size,
+      center: context.inputs.center
+    })
+  );
+}
+var rectangleRegistration = {
+  kind: "definition-v1",
+  moduleId: geoModuleId("Rectangle"),
+  definition: rectangleDefinition,
+  loadExecute: async () => executeRectangle
+};
+function executeCircle(context) {
+  context.outputs.geometry.set(
+    circleGeometry({
+      center: context.inputs.center,
+      radius: context.inputs.radius,
+      divisions: context.inputs.divisions,
+      type: context.props.type === "poly" ? "poly" : "bezier"
+    })
+  );
+}
+var circleRegistration = {
+  kind: "definition-v1",
+  moduleId: geoModuleId("Circle"),
+  definition: circleDefinition,
+  loadExecute: async () => executeCircle
+};
+
+// packages/runtime/src/builtins/geo/merge.ts
+function executeMerge(context) {
+  context.outputs.geometry.set(
+    mergeGeometries(context.inputs.inputs.filter((input) => input !== void 0))
+  );
+}
+var mergeRegistration = {
+  kind: "definition-v1",
+  moduleId: geoModuleId("Merge"),
+  definition: mergeDefinition,
+  loadExecute: async () => executeMerge
+};
+
+// packages/runtime/src/geometry/render.ts
+function css(colour) {
+  const [r, g, b, a = 1] = colour;
+  return `rgba(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)}, ${a})`;
+}
+function multiply(matrix, x, y, z) {
+  return [0, 1, 2, 3].map(
+    (row) => matrix[row] * x + matrix[4 + row] * y + matrix[8 + row] * z + matrix[12 + row]
+  );
+}
+function renderScene(geometry, options) {
+  const [width, height] = options.size;
+  const canvas = options.surface(
+    Math.max(1, Math.round(width)),
+    Math.max(1, Math.round(height))
+  );
+  const context = canvas.getContext("2d");
+  if (!context) throw new Error("no 2D context on this surface");
+  if (options.background && options.background[3] > 0) {
+    context.fillStyle = css(options.background);
+    context.fillRect(0, 0, canvas.width, canvas.height);
+  }
+  for (const one of geometry) drawGeometry(context, canvas, one, options);
+  return canvas;
+}
+function drawGeometry(context, canvas, geometry, options) {
+  const view = viewMatrix(options.camera);
+  const projection = projectionMatrix(options.camera);
+  const position = geometry.point[POSITION_ATTRIBUTE];
+  if (!position || position.storage === "string") return;
+  const size = position.size;
+  const points = position.data;
+  const projected = [];
+  for (let index = 0; index < geometry.pointCount; index += 1) {
+    const world = multiply(
+      view,
+      Number(points[index * size]),
+      Number(points[index * size + 1]),
+      size >= 3 ? Number(points[index * size + 2]) : 0
+    );
+    const clip = multiply(projection, world[0], world[1], world[2]);
+    const w = clip[3];
+    projected.push({
+      x: (clip[0] / w + 1) * 0.5 * canvas.width,
+      y: (1 - (clip[1] / w + 1) * 0.5) * canvas.height,
+      w
+    });
+  }
+  const colours = numericAttribute(geometry.primitive.Cd, "primitive.Cd", [4]);
+  const widths = numericAttribute(geometry.primitive.width, "primitive.width", [1]);
+  context.lineCap = "round";
+  context.lineJoin = "round";
+  context.globalAlpha = options.opacity;
+  const { vertexPoints, offsets, closed } = geometry.topology;
+  const drawn = /* @__PURE__ */ new Set();
+  for (let primitive = 0; primitive < geometry.primitiveCount; primitive += 1) {
+    const from = offsets[primitive];
+    const to = offsets[primitive + 1];
+    if (to - from < 2) continue;
+    context.strokeStyle = colours ? css(readElement(colours, primitive)) : css(options.stroke);
+    context.lineWidth = widths ? readElement(widths, primitive)[0] : options.strokeWidth;
+    context.beginPath();
+    let open = false;
+    for (let vertex = from; vertex < to; vertex += 1) {
+      const point = vertexPoints[vertex];
+      drawn.add(point);
+      const at = projected[point];
+      if (!at || at.w <= 0) {
+        open = false;
+        continue;
+      }
+      if (open) context.lineTo(at.x, at.y);
+      else {
+        context.moveTo(at.x, at.y);
+        open = true;
+      }
+    }
+    if (closed[primitive] === 1 && open) {
+      const first = projected[vertexPoints[from]];
+      if (first && first.w > 0) context.lineTo(first.x, first.y);
+    }
+    context.stroke();
+  }
+  if (options.drawPoints && options.pointRadius > 0) {
+    context.fillStyle = css(options.stroke);
+    for (let index = 0; index < projected.length; index += 1) {
+      if (drawn.has(index)) continue;
+      const at = projected[index];
+      if (at.w <= 0) continue;
+      context.beginPath();
+      context.arc(at.x, at.y, options.pointRadius, 0, Math.PI * 2);
+      context.fill();
+    }
+  }
+}
+async function renderToPng(surface) {
+  const blob = await surface.convertToBlob({ type: "image/png" });
+  return new Uint8Array(await blob.arrayBuffer());
+}
+
+// packages/runtime/src/builtins/geo/render.ts
+function hostSurface(width, height) {
+  const factory = globalThis.OffscreenCanvas;
+  if (!factory) {
+    throw new Error(
+      "cascade.geo.Render needs OffscreenCanvas, which this host does not provide"
+    );
+  }
+  return new factory(width, height);
+}
+async function executeRender(context) {
+  const { props } = context;
+  const scene = asScene(context.inputs.scene);
+  const camera = context.inputs.camera ?? scene.camera;
+  if (!camera) {
+    throw new Error(
+      "cascade.geo.Render has no camera \u2014 wire a cascade.core.Camera to its camera input, or into the scene"
+    );
+  }
+  const surface = renderScene(scene.geometry, {
+    camera,
+    size: [props.size[0], props.size[1]],
+    ...props.background[3] > 0 ? { background: props.background } : {},
+    stroke: props.stroke,
+    strokeWidth: props.strokeWidth,
+    opacity: props.opacity,
+    pointRadius: props.pointRadius,
+    drawPoints: props.drawPoints,
+    surface: hostSurface
+  });
+  const bytes = await renderToPng(surface);
+  const asset = await context.capabilities.assets.write(
+    bytes,
+    { mediaType: "image/png", suggestedName: props.filename },
+    { signal: context.signal }
+  );
+  context.outputs.asset.set(asset);
+  context.outputs.image.set({
+    path: asset.path ?? props.filename,
+    size: [surface.width, surface.height],
+    channels: "rgba",
+    depth: "u8",
+    space: "srgb"
+  });
+}
+var renderRegistration = {
+  kind: "definition-v1",
+  moduleId: geoModuleId("Render"),
+  definition: renderDefinition,
+  loadExecute: async () => executeRender
+};
+
+// packages/runtime/src/geometry/primitives.ts
+function primitiveKind(geometry, primitive) {
+  return PRIMITIVE_KINDS[geometry.topology.kinds[primitive]] ?? "poly";
+}
+function isClosed(geometry, primitive) {
+  return geometry.topology.closed[primitive] === 1;
+}
+function isBezier(geometry, primitive) {
+  return primitiveKind(geometry, primitive) === "bezier";
+}
+function bezierSegments(geometry, primitive) {
+  const points = primitivePoints(geometry, primitive);
+  const closed = isClosed(geometry, primitive);
+  const count = closed ? points.length / BEZIER_STRIDE : (points.length - 1) / BEZIER_STRIDE;
+  const segments = [];
+  for (let index = 0; index < count; index += 1) {
+    const base = index * BEZIER_STRIDE;
+    segments.push([
+      points[base],
+      points[base + 1],
+      points[base + 2],
+      points[(base + BEZIER_STRIDE) % points.length]
+    ]);
+  }
+  return segments;
+}
+function vertexRange(geometry, primitive) {
+  return [
+    geometry.topology.offsets[primitive],
+    geometry.topology.offsets[primitive + 1]
+  ];
+}
+function primitivePoints(geometry, primitive) {
+  const [start, end] = vertexRange(geometry, primitive);
+  const points = new Array(end - start);
+  for (let vertex = start; vertex < end; vertex += 1)
+    points[vertex - start] = geometry.topology.vertexPoints[vertex];
+  return points;
+}
+function loosePointMask(geometry) {
+  const used = new Uint8Array(geometry.pointCount);
+  for (const point of geometry.topology.vertexPoints) used[point] = 1;
+  const loose = new Uint8Array(geometry.pointCount);
+  for (let index = 0; index < loose.length; index += 1)
+    loose[index] = used[index] ? 0 : 1;
+  return loose;
+}
+function geometryBounds(geometry) {
+  if (geometry.pointCount === 0) return void 0;
+  const position = positionAttribute(geometry);
+  const size = positionSize(geometry);
+  const min = new Array(size).fill(Number.POSITIVE_INFINITY);
+  const max = new Array(size).fill(Number.NEGATIVE_INFINITY);
+  for (let point = 0; point < geometry.pointCount; point += 1)
+    for (let component = 0; component < size; component += 1) {
+      const value = position.data[point * size + component];
+      if (value < min[component]) min[component] = value;
+      if (value > max[component]) max[component] = value;
+    }
+  return { min, max };
+}
+
+// packages/runtime/src/geometry/svg.ts
+var UNGROUPED = "ungrouped";
+var BLACK = [0, 0, 0, 1];
+function geometryToSvg(geometry, options = {}) {
+  validateOptions(options);
+  const margin = options.margin ?? 0;
+  const explicit = options.bounds;
+  const bounds = explicit ? void 0 : geometryBounds(geometry);
+  const minX = explicit ? explicit[0] - margin : bounds === void 0 ? 0 : bounds.min[0] - margin;
+  const minY = explicit ? explicit[1] - margin : bounds === void 0 ? 0 : bounds.min[1] - margin;
+  const maxX = explicit ? explicit[2] + margin : bounds === void 0 ? 1 : bounds.max[0] + margin;
+  const maxY = explicit ? explicit[3] + margin : bounds === void 0 ? 1 : bounds.max[1] + margin;
+  const spanX = Math.max(maxX - minX, Number.EPSILON);
+  const spanY = Math.max(maxY - minY, Number.EPSILON);
+  const width = options.width && options.width > 0 ? options.width : spanX;
+  const height = options.height && options.height > 0 ? options.height : spanY;
+  const precision = options.precision ?? 3;
+  const number = (value) => format(value, precision);
+  const stroke = options.stroke ?? BLACK;
+  const strokeWidth = options.strokeWidth ?? 1;
+  const fill = options.fill ?? BLACK;
+  const filled = (options.fillMode ?? "none") === "solid";
+  const colour = geometry.primitive.Cd;
+  const strokeWidths = numericAttribute(geometry.primitive.width, "primitive.width", [1]);
+  const opacities = numericAttribute(geometry.primitive.opacity, "primitive.opacity", [1]);
+  const pointScale = numericAttribute(geometry.point.pscale, "point.pscale", [1]);
+  const pointColour = geometry.point.Cd;
+  validateRange(strokeWidths, "primitive.width", (value) => value >= 0, "non-negative");
+  validateRange(opacities, "primitive.opacity", (value) => value >= 0 && value <= 1, "between 0 and 1");
+  validateRange(pointScale, "point.pscale", (value) => value >= 0, "non-negative");
+  const names = groupNames(geometry, "primitive");
+  const assigned = new Int32Array(geometry.primitiveCount).fill(-1);
+  for (let index = 0; index < names.length; index += 1) {
+    const mask = geometry.primitiveGroups[names[index]];
+    for (let primitive = 0; primitive < geometry.primitiveCount; primitive += 1)
+      if (mask[primitive] === 1 && assigned[primitive] === -1)
+        assigned[primitive] = index;
+  }
+  const path = (primitive) => {
+    const attributes = [`d="${pathData(geometry, primitive, number)}"`];
+    const paint = paintOf(colour, primitive, "primitive");
+    if (paint !== void 0) {
+      attributes.push(`stroke="${Color.toHex(paint)}"`);
+      if (Color.alpha(paint) < 1)
+        attributes.push(`stroke-opacity="${number(Color.alpha(paint))}"`);
+    }
+    if (strokeWidths !== void 0)
+      attributes.push(
+        `stroke-width="${number(readComponent(strokeWidths, primitive))}"`
+      );
+    if (opacities !== void 0)
+      attributes.push(`opacity="${number(readComponent(opacities, primitive))}"`);
+    return `<path ${attributes.join(" ")} />`;
+  };
+  const body = [];
+  if (names.length === 0) {
+    for (let primitive = 0; primitive < geometry.primitiveCount; primitive += 1)
+      body.push(indent(path(primitive), 2));
+  } else {
+    for (let index = 0; index < names.length; index += 1) {
+      const members = [];
+      for (let primitive = 0; primitive < geometry.primitiveCount; primitive += 1)
+        if (assigned[primitive] === index)
+          members.push(indent(path(primitive), 3));
+      body.push(
+        indent(`<g id="${escapeXml(names[index])}">`, 2),
+        ...members,
+        indent("</g>", 2)
+      );
+    }
+    const rest = [];
+    for (let primitive = 0; primitive < geometry.primitiveCount; primitive += 1)
+      if (assigned[primitive] === -1) rest.push(indent(path(primitive), 3));
+    if (rest.length > 0)
+      body.push(
+        indent(`<g id="${UNGROUPED}">`, 2),
+        ...rest,
+        indent("</g>", 2)
+      );
+  }
+  const loose = loosePointMask(geometry);
+  const position = positionAttribute(geometry);
+  for (let point = 0; point < geometry.pointCount; point += 1) {
+    if (loose[point] !== 1) continue;
+    const radius = pointScale === void 0 ? options.pointRadius ?? 0.5 : readComponent(pointScale, point);
+    const paint = paintOf(pointColour, point, "point") ?? stroke;
+    const transparent = Color.alpha(paint) < 1;
+    body.push(
+      indent(
+        `<circle cx="${number(readComponent(position, point, 0))}" cy="${number(
+          readComponent(position, point, 1)
+        )}" r="${number(radius)}" fill="${Color.toHex(paint)}"${transparent ? ` fill-opacity="${number(Color.alpha(paint))}"` : ""} stroke="none" />`,
+        2
+      )
+    );
+  }
+  const root = [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${number(width)}" height="${number(height)}" viewBox="${number(minX)} ${number(-maxY)} ${number(spanX)} ${number(spanY)}">`,
+    ...options.background ? [indent(
+      `<rect x="${number(minX)}" y="${number(-maxY)}" width="${number(spanX)}" height="${number(spanY)}" fill="${Color.toHex(options.background)}" />`,
+      1
+    )] : [],
+    indent("<!-- Geometry is +Y up; SVG is +Y down. This is the one flip. -->", 1),
+    indent(
+      `<g transform="scale(1,-1)" fill="${filled ? Color.toHex(fill) : "none"}"${filled && Color.alpha(fill) < 1 ? ` fill-opacity="${number(Color.alpha(fill))}"` : ""} stroke="${Color.toHex(stroke)}"${Color.alpha(stroke) < 1 ? ` stroke-opacity="${number(Color.alpha(stroke))}"` : ""} stroke-width="${number(strokeWidth)}"${options.opacity !== void 0 && options.opacity !== 1 ? ` opacity="${number(options.opacity)}"` : ""}>`,
+      1
+    ),
+    ...body,
+    indent("</g>", 1),
+    "</svg>"
+  ];
+  return `${root.join("\n")}
+`;
+}
+function pathData(geometry, primitive, number) {
+  const position = positionAttribute(geometry);
+  const at = (point) => `${number(readComponent(position, point, 0))} ${number(
+    readComponent(position, point, 1)
+  )}`;
+  const closed = isClosed(geometry, primitive);
+  if (isBezier(geometry, primitive)) {
+    const segments = bezierSegments(geometry, primitive);
+    if (segments.length === 0) return "";
+    const commands2 = [`M ${at(segments[0][0])}`];
+    for (const [, first, second, end] of segments)
+      commands2.push(`C ${at(first)} ${at(second)} ${at(end)}`);
+    if (closed) commands2.push("Z");
+    return commands2.join(" ");
+  }
+  const points = primitivePoints(geometry, primitive);
+  if (points.length === 0) return "";
+  const commands = [`M ${at(points[0])}`];
+  for (let index = 1; index < points.length; index += 1)
+    commands.push(`L ${at(points[index])}`);
+  if (closed) commands.push("Z");
+  return commands.join(" ");
+}
+function paintOf(attribute, index, level) {
+  if (attribute === void 0) return void 0;
+  if (isStringAttribute(attribute))
+    geometryError(
+      "colour-storage",
+      `${level}.Cd is a string attribute; colour is a vec4. Convert with Color.fromHex at the boundary.`
+    );
+  if (attribute.size !== 4)
+    geometryError(
+      "colour-size",
+      `${level}.Cd has size ${attribute.size}; colour is a vec4`
+    );
+  return Color.fromComponents(attribute.data, index * 4, 4);
+}
+function format(value, precision) {
+  if (!Number.isFinite(value))
+    geometryError("svg-number", `cannot format non-finite value ${String(value)}`);
+  const rounded = Number.parseFloat(value.toFixed(precision));
+  return Object.is(rounded, -0) ? "0" : String(rounded);
+}
+function validateOptions(options) {
+  for (const [name, value] of [
+    ["width", options.width],
+    ["height", options.height],
+    ["margin", options.margin],
+    ["strokeWidth", options.strokeWidth],
+    ["opacity", options.opacity],
+    ["pointRadius", options.pointRadius]
+  ]) {
+    if (value !== void 0 && !Number.isFinite(value))
+      geometryError("svg-option", `${name} must be finite`);
+  }
+  if ((options.width ?? 0) < 0 || (options.height ?? 0) < 0)
+    geometryError("svg-option", "width and height must not be negative");
+  if ((options.strokeWidth ?? 0) < 0 || (options.pointRadius ?? 0) < 0)
+    geometryError("svg-option", "strokeWidth and pointRadius must not be negative");
+  if (options.opacity !== void 0 && (options.opacity < 0 || options.opacity > 1))
+    geometryError("svg-option", "opacity must be between 0 and 1");
+  const precision = options.precision ?? 3;
+  if (!Number.isSafeInteger(precision) || precision < 0 || precision > 15)
+    geometryError("svg-precision", "precision must be an integer from 0 to 15");
+}
+function validateRange(attribute, path, accepts, expectation) {
+  if (attribute === void 0) return;
+  for (const value of attribute.data)
+    if (!accepts(value))
+      geometryError("attribute-value", `${path} values must be ${expectation}`);
+}
+function indent(line, depth) {
+  return `${"  ".repeat(depth)}${line}`;
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function utf8Bytes(value) {
+  const bytes = [];
+  for (const character of value) {
+    let code = character.codePointAt(0);
+    if (code < 128) bytes.push(code);
+    else if (code < 2048) bytes.push(192 | code >> 6, 128 | code & 63);
+    else if (code < 65536)
+      bytes.push(
+        224 | code >> 12,
+        128 | code >> 6 & 63,
+        128 | code & 63
+      );
+    else
+      bytes.push(
+        240 | code >> 18,
+        128 | code >> 12 & 63,
+        128 | code >> 6 & 63,
+        128 | code & 63
+      );
+    code = 0;
+  }
+  return Uint8Array.from(bytes);
+}
+
+// packages/runtime/src/builtins/geo/svgExport.ts
+async function executeSvgExport(context) {
+  const { props } = context;
+  const svg = geometryToSvg(context.inputs.geometry ?? emptyGeometry(2), {
+    width: props.width,
+    height: props.height,
+    margin: props.margin,
+    // All-zero means "derive", because a zero-area rectangle is not a frame
+    // anyone would ask for and a separate boolean for it would be a second
+    // way to say the same thing.
+    ...props.bounds.some((value) => value !== 0) ? { bounds: [props.bounds[0], props.bounds[1], props.bounds[2], props.bounds[3]] } : {},
+    // Only when it would show: a fully transparent ground and no ground at all
+    // are the same document, and emitting a rect for it would put a shape in
+    // the file that a plotter would try to draw.
+    ...props.background[3] > 0 ? { background: props.background } : {},
+    stroke: props.stroke,
+    strokeWidth: props.strokeWidth,
+    opacity: props.opacity,
+    fill: props.fill,
+    fillMode: props.fillMode === "solid" ? "solid" : "none",
+    pointRadius: props.pointRadius,
+    precision: props.precision
+  });
+  context.outputs.svg.set(svg);
+  const asset = await context.capabilities.assets.write(
+    utf8Bytes(svg),
+    { mediaType: "image/svg+xml", suggestedName: props.filename },
+    { signal: context.signal }
+  );
+  context.outputs.asset.set(asset);
+}
+var svgExportRegistration = {
+  kind: "definition-v1",
+  moduleId: geoModuleId("SvgExport"),
+  definition: svgExportDefinition,
+  loadExecute: async () => executeSvgExport
+};
+
+// packages/runtime/src/builtins/geo/transform.ts
+function executeTransform(context) {
+  const geometry = context.inputs.geometry ?? emptyGeometry(2);
+  context.outputs.geometry.set(
+    transformGeometry(
+      geometry,
+      transformMatrix({
+        translate: context.inputs.translate,
+        rotate: context.inputs.rotate,
+        scale: context.inputs.scale,
+        pivot: context.inputs.pivot
+      })
+    )
+  );
+}
+var transformRegistration = {
+  kind: "definition-v1",
+  moduleId: geoModuleId("Transform"),
+  definition: transformDefinition,
+  loadExecute: async () => executeTransform
+};
+
+// packages/runtime/src/builtins/geo/index.ts
+var geoNodeRegistrations = Object.freeze([
+  rectangleRegistration,
+  circleRegistration,
+  transformRegistration,
+  mergeRegistration,
+  copyToPointsRegistration,
+  renderRegistration,
+  svgExportRegistration,
+  fromRectsRegistration
+]);
+var registrationsById = new Map(
+  geoNodeRegistrations.map((registration) => [
+    registration.moduleId,
+    registration
+  ])
+);
+
+export {
+  LIGHT_DEFAULTS,
+  isLight,
+  isScene,
+  geoNodeDefinitions,
+  geoNodeRegistrations
+};
+//# sourceMappingURL=chunk-35D343DC.js.map