@field/cascade 0.10.0 → 0.11.0

package/dist/cli/chunk-ICH7N5PN.js

@@ -0,0 +1,26 @@
+// src/cli/sequence.ts
+import path from "node:path";
+function sequenceWidth(end) {
+  return Math.max(4, String(Math.floor(end)).length);
+}
+function sequenceFileName(nodeId, frame, source, width, port) {
+  const extension = path.extname(source) || ".png";
+  const safe = (text) => text.replace(/[^a-zA-Z0-9_-]/g, "_");
+  const stem = port ? `${safe(nodeId)}.${safe(port)}` : safe(nodeId);
+  return `${stem}.${String(Math.floor(frame)).padStart(width, "0")}${extension}`;
+}
+function imagePath(value) {
+  if (typeof value === "string") return value || null;
+  if (value && typeof value === "object") {
+    const candidate = value.path;
+    if (typeof candidate === "string" && candidate) return candidate;
+  }
+  return null;
+}
+
+export {
+  sequenceWidth,
+  sequenceFileName,
+  imagePath
+};
+//# sourceMappingURL=chunk-ICH7N5PN.js.map

package/dist/cli/chunk-J7VK7MNF.js

@@ -0,0 +1,418 @@
+// packages/contracts/src/geometry.ts
+var POSITION_ATTRIBUTE = "P";
+var PRIMITIVE_KINDS = ["poly", "bezier", "mesh", "packed"];
+var BEZIER_STRIDE = 3;
+var STORAGES = /* @__PURE__ */ new Set(["f32", "f64", "i32", "u8"]);
+var NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var RESERVED_NAMES = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function fail(code, message) {
+  throw new TypeError(`geometry/${code}: ${message}`);
+}
+function emptyTopology() {
+  return {
+    vertexPoints: new Int32Array(0),
+    offsets: Int32Array.of(0),
+    kinds: new Uint8Array(0),
+    closed: new Uint8Array(0)
+  };
+}
+function arrayType(storage) {
+  if (storage === "f64") return Float64Array;
+  if (storage === "f32") return Float32Array;
+  if (storage === "i32") return Int32Array;
+  return Uint8Array;
+}
+function validStoredNumber(storage, value) {
+  if (!Number.isFinite(value)) return false;
+  if (storage === "f64" || storage === "f32") return true;
+  if (!Number.isInteger(value)) return false;
+  return storage === "u8" ? value >= 0 && value <= 255 : value >= -2147483648 && value <= 2147483647;
+}
+function attributeArray(storage, length) {
+  if (!Number.isSafeInteger(length) || length < 0)
+    fail("attribute-length", "attribute array length must be a non-negative safe integer");
+  if (storage === "f64") return new Float64Array(length);
+  if (storage === "f32") return new Float32Array(length);
+  if (storage === "i32") return new Int32Array(length);
+  return new Uint8Array(length);
+}
+function attributeArrayFrom(storage, values) {
+  const array = attributeArray(storage, values.length);
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    if (!validStoredNumber(storage, value))
+      fail(
+        "attribute-value",
+        `${String(value)} cannot be represented as ${storage}`
+      );
+    array[index] = value;
+    if (!Number.isFinite(array[index]))
+      fail("attribute-value", `${String(value)} overflows ${storage}`);
+  }
+  return array;
+}
+function isStringAttribute(attribute) {
+  return attribute.storage === "string";
+}
+function levelCount(geometry, level) {
+  if (level === "point") return geometry.pointCount;
+  if (level === "vertex") return geometry.vertexCount;
+  if (level === "primitive") return geometry.primitiveCount;
+  return 1;
+}
+function checkName(name, path) {
+  if (!NAME.test(name) || RESERVED_NAMES.has(name))
+    fail("invalid-name", `${path}.${name} is not a valid attribute name`);
+}
+function checkAttributeSet(set, count, level) {
+  for (const [name, attribute] of Object.entries(set)) {
+    checkName(name, level);
+    if (isStringAttribute(attribute)) {
+      if (!(attribute.data instanceof Int32Array))
+        fail("attribute-storage", `${level}.${name} string indices must be Int32Array`);
+      if (attribute.size !== 1)
+        fail("string-size", `${level}.${name} string attributes have size 1`);
+      if (attribute.data.length !== count)
+        fail(
+          "attribute-length",
+          `${level}.${name} has ${attribute.data.length} entries for ${count} elements`
+        );
+      for (const index of attribute.data)
+        if (index < -1 || index >= attribute.table.length)
+          fail(
+            "string-index",
+            `${level}.${name} references table entry ${index}`
+          );
+      if (!Array.isArray(attribute.table) || attribute.table.some((item) => typeof item !== "string"))
+        fail("string-table", `${level}.${name} needs a string table`);
+      continue;
+    }
+    if (!Number.isInteger(attribute.size) || attribute.size < 1)
+      fail("attribute-size", `${level}.${name} needs a size of at least 1`);
+    if (!STORAGES.has(attribute.storage))
+      fail(
+        "attribute-storage",
+        `${level}.${name} has an unknown storage ${String(attribute.storage)}`
+      );
+    if (!(attribute.data instanceof arrayType(attribute.storage)))
+      fail(
+        "attribute-storage",
+        `${level}.${name} declares ${attribute.storage} but uses ${attribute.data?.constructor?.name ?? "unknown storage"}`
+      );
+    if (attribute.data.length !== attribute.size * count)
+      fail(
+        "attribute-length",
+        `${level}.${name} has ${attribute.data.length} values for ${count} elements of size ${attribute.size}`
+      );
+    for (const value of attribute.data)
+      if (!Number.isFinite(value))
+        fail("non-finite", `${level}.${name} contains ${String(value)}`);
+  }
+}
+function checkGroups(groups, count, level) {
+  for (const [name, mask] of Object.entries(groups)) {
+    checkName(name, level);
+    if (mask.length !== count)
+      fail(
+        "group-length",
+        `${level}.${name} covers ${mask.length} of ${count} elements`
+      );
+    for (const member of mask)
+      if (member !== 0 && member !== 1)
+        fail("group-mask", `${level}.${name} contains ${member}; masks contain only 0 or 1`);
+  }
+}
+function createGeometry(parts) {
+  const pointCount = parts.pointCount;
+  if (!Number.isSafeInteger(pointCount) || pointCount < 0)
+    fail("point-count", "pointCount must be a non-negative safe integer");
+  const topology = parts.topology ?? emptyTopology();
+  if (!(topology.vertexPoints instanceof Int32Array) || !(topology.offsets instanceof Int32Array) || !(topology.kinds instanceof Uint8Array) || !(topology.closed instanceof Uint8Array))
+    fail("topology-storage", "topology uses Int32Array indices and Uint8Array flags");
+  const primitiveCount = topology.offsets.length - 1;
+  if (primitiveCount < 0)
+    fail("offsets", "topology.offsets needs primitiveCount + 1 entries");
+  if (topology.offsets[0] !== 0)
+    fail("offsets", "topology.offsets starts at 0");
+  for (let index = 1; index <= primitiveCount; index += 1)
+    if (topology.offsets[index] < topology.offsets[index - 1])
+      fail("offsets", "topology.offsets must not decrease");
+  const vertexCount = topology.offsets[primitiveCount];
+  if (vertexCount !== topology.vertexPoints.length)
+    fail(
+      "offsets",
+      `topology.offsets ends at ${vertexCount} for ${topology.vertexPoints.length} vertices`
+    );
+  if (topology.kinds.length !== primitiveCount || topology.closed.length !== primitiveCount)
+    fail(
+      "topology-length",
+      `topology.kinds and topology.closed need ${primitiveCount} entries`
+    );
+  for (const point2 of topology.vertexPoints)
+    if (point2 < 0 || point2 >= pointCount)
+      fail("vertex-point", `vertex references point ${point2}`);
+  for (const kind of topology.kinds)
+    if (kind >= PRIMITIVE_KINDS.length)
+      fail("primitive-kind", `unknown primitive kind ${kind}`);
+  for (const closed of topology.closed)
+    if (closed !== 0 && closed !== 1)
+      fail("closed-mask", `topology.closed contains ${closed}; flags contain only 0 or 1`);
+  const bezier = PRIMITIVE_KINDS.indexOf("bezier");
+  for (let index = 0; index < primitiveCount; index += 1) {
+    if (topology.kinds[index] !== bezier) continue;
+    const count = topology.offsets[index + 1] - topology.offsets[index];
+    const closed = topology.closed[index] === 1;
+    const minimum = closed ? BEZIER_STRIDE : BEZIER_STRIDE + 1;
+    if (count < minimum || (count - (closed ? 0 : 1)) % BEZIER_STRIDE !== 0)
+      fail(
+        "bezier-arity",
+        `primitive ${index} has ${count} vertices, and a ${closed ? "closed" : "open"} bezier needs ${closed ? "3n" : "3n + 1"}`
+      );
+  }
+  const point = parts.point;
+  const position = point[POSITION_ATTRIBUTE];
+  if (position === void 0)
+    fail("missing-position", "point.P is required on every geometry");
+  if (isStringAttribute(position))
+    fail("position-storage", "point.P must be a numeric attribute");
+  if (position.size !== 2 && position.size !== 3)
+    fail("position-size", "point.P must have a size of 2 or 3");
+  checkAttributeSet(point, pointCount, "point");
+  const vertex = parts.vertex ?? {};
+  checkAttributeSet(vertex, vertexCount, "vertex");
+  const primitive = parts.primitive ?? {};
+  checkAttributeSet(primitive, primitiveCount, "primitive");
+  const pointGroups = parts.pointGroups ?? {};
+  checkGroups(pointGroups, pointCount, "pointGroups");
+  const primitiveGroups = parts.primitiveGroups ?? {};
+  checkGroups(primitiveGroups, primitiveCount, "primitiveGroups");
+  const detail = parts.detail ?? {};
+  for (const [name, value] of Object.entries(detail)) {
+    checkName(name, "detail");
+    if (typeof value === "number") {
+      if (!Number.isFinite(value))
+        fail("non-finite", `detail.${name} contains ${String(value)}`);
+    } else if (typeof value !== "string") {
+      if (!Array.isArray(value) || value.some((item) => !Number.isFinite(item)))
+        fail("detail-value", `detail.${name} must be a finite number, string, or finite number array`);
+    }
+  }
+  return freezeGeometry({
+    kind: "geometry",
+    pointCount,
+    vertexCount,
+    primitiveCount,
+    topology,
+    point,
+    vertex,
+    primitive,
+    detail,
+    pointGroups,
+    primitiveGroups
+  });
+}
+function freezeGeometry(geometry) {
+  for (const level of ["point", "vertex", "primitive"]) {
+    const set = geometry[level];
+    for (const attribute of Object.values(set)) {
+      if (isStringAttribute(attribute)) Object.freeze(attribute.table);
+      Object.freeze(attribute);
+    }
+    Object.freeze(set);
+  }
+  Object.freeze(geometry.topology);
+  for (const value of Object.values(geometry.detail))
+    if (Array.isArray(value)) Object.freeze(value);
+  Object.freeze(geometry.detail);
+  Object.freeze(geometry.pointGroups);
+  Object.freeze(geometry.primitiveGroups);
+  return Object.freeze(geometry);
+}
+function emptyGeometry(positionSize = 2) {
+  return createGeometry({
+    pointCount: 0,
+    point: {
+      [POSITION_ATTRIBUTE]: {
+        storage: "f64",
+        size: positionSize,
+        data: new Float64Array(0)
+      }
+    }
+  });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function finiteNumbers(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "number" && Number.isFinite(item));
+}
+function fromJsonAttributeSet(raw, level) {
+  if (raw === void 0) return {};
+  const result = {};
+  for (const [name, attribute] of Object.entries(raw)) {
+    if (!isRecord(attribute))
+      fail("attribute-shape", `${level}.${name} must be an object`);
+    if (attribute.storage === "string") {
+      const table = attribute.table;
+      if (!Array.isArray(table) || table.some((item) => typeof item !== "string"))
+        fail("string-table", `${level}.${name} needs a string table`);
+      if (!int32Numbers(attribute.data))
+        fail("attribute-data", `${level}.${name} needs 32-bit integer indices`);
+      result[name] = {
+        storage: "string",
+        size: 1,
+        table: [...table],
+        data: Int32Array.from(attribute.data)
+      };
+      continue;
+    }
+    if (typeof attribute.storage !== "string" || !STORAGES.has(attribute.storage))
+      fail(
+        "attribute-storage",
+        `${level}.${name} has an unknown storage ${String(attribute.storage)}`
+      );
+    if (!finiteNumbers(attribute.data))
+      fail("attribute-data", `${level}.${name} needs finite numeric data`);
+    const size = attribute.size;
+    if (typeof size !== "number" || !Number.isInteger(size) || size < 1)
+      fail("attribute-size", `${level}.${name} needs a size of at least 1`);
+    result[name] = {
+      storage: attribute.storage,
+      size,
+      data: attributeArrayFrom(
+        attribute.storage,
+        attribute.data
+      )
+    };
+  }
+  return result;
+}
+function groupsFromJson(raw, count, level) {
+  if (raw === void 0) return {};
+  const result = {};
+  for (const [name, indices] of Object.entries(raw)) {
+    if (!finiteNumbers(indices))
+      fail("group-indices", `${level}.${name} must be a list of indices`);
+    const mask = new Uint8Array(count);
+    for (const index of indices) {
+      if (!Number.isInteger(index) || index < 0 || index >= count)
+        fail("group-indices", `${level}.${name} references element ${index}`);
+      mask[index] = 1;
+    }
+    result[name] = mask;
+  }
+  return result;
+}
+function geometryFromJson(value) {
+  if (!isRecord(value) || value.kind !== "geometry")
+    fail("not-geometry", "a geometry literal needs kind: 'geometry'");
+  const pointCount = value.pointCount;
+  if (!Number.isSafeInteger(pointCount) || pointCount < 0)
+    fail("point-count", "pointCount must be a non-negative safe integer");
+  const rawTopology = value.topology;
+  let topology = emptyTopology();
+  if (rawTopology !== void 0) {
+    if (!isRecord(rawTopology))
+      fail("topology-shape", "topology must be an object");
+    if (!int32Numbers(rawTopology.vertexPoints) || !int32Numbers(rawTopology.offsets))
+      fail("topology-shape", "topology needs vertexPoints and offsets");
+    const primitiveCount = rawTopology.offsets.length - 1;
+    if (primitiveCount < 0)
+      fail("offsets", "topology.offsets needs primitiveCount + 1 entries");
+    const kinds = rawTopology.kinds;
+    const closed = rawTopology.closed;
+    if (kinds !== void 0 && !byteNumbers(kinds))
+      fail("topology-shape", "topology.kinds must be numeric");
+    if (closed !== void 0 && (!byteNumbers(closed) || closed.some((item) => item !== 0 && item !== 1)))
+      fail("topology-shape", "topology.closed must be numeric");
+    topology = {
+      vertexPoints: Int32Array.from(rawTopology.vertexPoints),
+      offsets: Int32Array.from(rawTopology.offsets),
+      kinds: kinds === void 0 ? new Uint8Array(primitiveCount) : Uint8Array.from(kinds),
+      closed: closed === void 0 ? new Uint8Array(primitiveCount) : Uint8Array.from(closed)
+    };
+  }
+  const detail = {};
+  for (const [name, item] of Object.entries(value.detail ?? {})) {
+    if (typeof item === "number" || typeof item === "string")
+      detail[name] = item;
+    else if (finiteNumbers(item)) detail[name] = [...item];
+    else
+      fail(
+        "detail-value",
+        `detail.${name} must be a number, string, or number array`
+      );
+  }
+  return createGeometry({
+    pointCount,
+    point: fromJsonAttributeSet(value.point, "point"),
+    vertex: fromJsonAttributeSet(value.vertex, "vertex"),
+    primitive: fromJsonAttributeSet(value.primitive, "primitive"),
+    detail,
+    topology,
+    pointGroups: groupsFromJson(value.pointGroups, pointCount, "pointGroups"),
+    primitiveGroups: groupsFromJson(
+      value.primitiveGroups,
+      topology.offsets.length - 1,
+      "primitiveGroups"
+    )
+  });
+}
+function isGeometryJson(value) {
+  try {
+    geometryFromJson(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGeometryFileRef(value) {
+  if (!isRecord(value) || value.kind !== "geometry-file") return false;
+  if (typeof value.path !== "string" || value.path.length === 0) return false;
+  if (value.format !== "npy" && value.format !== "json") return false;
+  if (value.format === "npy" && value.attribute === void 0) return false;
+  if (value.attribute !== void 0) {
+    const attribute = value.attribute;
+    if (!isRecord(attribute)) return false;
+    if (attribute.level !== "point" && attribute.level !== "vertex" && attribute.level !== "primitive")
+      return false;
+    if (typeof attribute.name !== "string" || !NAME.test(attribute.name) || RESERVED_NAMES.has(attribute.name))
+      return false;
+    if (typeof attribute.size !== "number" || !Number.isInteger(attribute.size) || attribute.size < 1)
+      return false;
+    if (typeof attribute.storage !== "string" || !STORAGES.has(attribute.storage))
+      return false;
+  }
+  for (const key of ["pointCount", "primitiveCount"]) {
+    const count = value[key];
+    if (count !== void 0 && (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0))
+      return false;
+  }
+  return true;
+}
+function isGeometrySerialized(value) {
+  return isGeometryJson(value) || isGeometryFileRef(value);
+}
+function integerNumbers(value) {
+  return finiteNumbers(value) && value.every(Number.isSafeInteger);
+}
+function int32Numbers(value) {
+  return integerNumbers(value) && value.every((item) => item >= -2147483648 && item <= 2147483647);
+}
+function byteNumbers(value) {
+  return integerNumbers(value) && value.every((item) => item >= 0 && item <= 255);
+}
+
+export {
+  POSITION_ATTRIBUTE,
+  PRIMITIVE_KINDS,
+  BEZIER_STRIDE,
+  attributeArray,
+  attributeArrayFrom,
+  isStringAttribute,
+  levelCount,
+  createGeometry,
+  emptyGeometry,
+  isGeometrySerialized
+};
+//# sourceMappingURL=chunk-J7VK7MNF.js.map