@field/cascade 0.2.22

package/dist/contracts/geometry.d.ts

@@ -0,0 +1,301 @@
+/**
+ * The `geometry` core type: one attribute table with four addressing levels.
+ *
+ * Houdini's model without the pointers. A geometry holds points, vertices,
+ * primitives and one detail record, and every named attribute lives at one of
+ * those levels as a flat parallel array. The value of the type is the number of
+ * operations that understand it, so it is deliberately one type rather than a
+ * family of them: a point cloud is a geometry whose primitive count is zero,
+ * and a bundle of strokes is a geometry whose points are covered by primitives.
+ * There is nothing to convert between the two.
+ *
+ * Three forms live here:
+ *
+ * `Geometry` is the in-memory form over typed arrays. Struct-of-arrays rather
+ * than array-of-structs, because the runtime's clone path copies nested plain
+ * arrays element by element and passes typed arrays through by reference, and
+ * because copy-on-write needs a granularity to share at.
+ *
+ * `GeometryJson` is the plain-array interchange form, for `.cascade` document
+ * literals and the Python bridge. Verbose on purpose and JSON-safe. It is
+ * lossless in both directions, including f64 precision, because JSON numbers
+ * are doubles and JavaScript prints the shortest round-trippable form.
+ *
+ * `GeometryFileRef` is the out-of-band form, following `ImageRef`: a path plus
+ * the metadata a consumer needs before it opens the file. It exists from day
+ * one because it is already in production and undeclared, as the Python
+ * stipple stage returns an `.npy` path on a `points`-typed port and the next
+ * stage reads it back. Resolving a ref into a `Geometry` needs host IO and so
+ * belongs to a host capability, exactly as reading `ImageRef` pixels does;
+ * neither contracts nor the runtime does it.
+ *
+ * ## Immutability
+ *
+ * A `Geometry` is frozen and every operation returns a new one, sharing the
+ * typed arrays it did not touch. `freezeGeometry` freezes the plain objects
+ * that hold the structure, and it cannot freeze the arrays themselves:
+ * `Object.freeze` on a non-empty typed array throws, because a typed array's
+ * elements are not configurable properties.
+ *
+ * So the copy-on-write guarantee is a convention this module keeps and the
+ * language cannot enforce, and there is one live interaction worth knowing
+ * about. `cloneValue` in `packages/runtime/src/runtime.ts`, the deep clone
+ * behind `snapshot`, returns any non-array object whose prototype is neither
+ * `Object.prototype` nor `null` by reference, uncloned and unfrozen. A
+ * `Geometry` is a plain object, so a snapshot of one is a fresh outer graph
+ * whose typed arrays are still the originals, shared with the value the node
+ * emitted. That makes emitting a geometry very cheap and it means the
+ * "inspection and output values are immutable snapshots" guarantee in
+ * ARCHITECTURE.md holds for the structure and not for the sample data. Nothing
+ * here relies on the runtime changing: operations never write into an input's
+ * array, and node code should reach for the read helpers and the builder rather
+ * than an attribute's `data` directly. Do not write into an array you did not
+ * allocate.
+ */
+/** Position attribute name, by convention rather than by privilege. */
+export declare const POSITION_ATTRIBUTE = "P";
+export declare const ATTRIBUTE_LEVELS: readonly ["point", "vertex", "primitive", "detail"];
+/** Where an attribute lives. `detail` holds one value per name, not an array. */
+export type AttributeLevel = (typeof ATTRIBUTE_LEVELS)[number];
+/** The three levels that are indexed by element number. */
+export type ElementLevel = "point" | "vertex" | "primitive";
+/**
+ * How an attribute's values are stored. `f64` is the default for positions,
+ * because the existing Python bridge already writes points as float64 `.npy`
+ * and emits full-precision doubles in JSON, while it explicitly casts raster
+ * fields to float32. Narrowing positions to f32 would save 1.4 MB on a
+ * 170,000-vertex cook and add a lossy step to a boundary that is lossless
+ * today.
+ */
+export type AttributeStorage = "f32" | "f64" | "i32" | "u8";
+export type AttributeArray = Float64Array | Float32Array | Int32Array | Uint8Array;
+/**
+ * One numeric attribute: a component count and a flat parallel array of
+ * `size * elementCount` values, indexed by element number at its level.
+ */
+export interface Attribute {
+    readonly storage: AttributeStorage;
+    /** Components per element. `P` is 2 or 3, `Cd` is 4, `width` is 1. */
+    readonly size: number;
+    readonly data: AttributeArray;
+}
+/**
+ * String attributes are a separate shape because a typed array cannot hold
+ * strings, and because Houdini's string attributes are indices into a table
+ * rather than per-element strings. The table is usually tiny: `cloud-plots`
+ * carries tags like `FORM_04` that repeat across a whole set.
+ */
+export interface StringAttribute {
+    readonly storage: "string";
+    readonly size: 1;
+    readonly table: readonly string[];
+    /** Index into `table`, or -1 for the empty string. */
+    readonly data: Int32Array;
+}
+export type AnyAttribute = Attribute | StringAttribute;
+export type AttributeSet = Readonly<Record<string, AnyAttribute>>;
+/** A detail value. One per name, for bounds, a seed, a page size, a name. */
+export type DetailValue = number | string | readonly number[];
+export type DetailSet = Readonly<Record<string, DetailValue>>;
+export declare const PRIMITIVE_KINDS: readonly ["poly", "bezier", "mesh", "packed"];
+/**
+ * Primitive kinds. A kind does not change what a primitive is made of: every
+ * primitive is a run of vertices over the same point list. It selects **how
+ * that run is interpolated**, which is why curves need no second geometry type
+ * and no parallel container, and why an operation that only reads positions
+ * keeps working when a curve arrives.
+ *
+ * Marcus, 2026-09-04, ruling on the plan's open question about curves:
+ * *"No, we want curves + polylines; very similar but different
+ * interpolations."*
+ *
+ * `poly` — the run is interpolated linearly. Vertex count is the point count of
+ * the outline, and `closed` adds the segment from the last vertex back to the
+ * first without repeating a vertex.
+ *
+ * `bezier` — the run is a chain of cubic Bézier segments in SVG's own order:
+ * anchor, handle, handle, anchor, handle, handle, anchor, and so on. An open
+ * primitive therefore has `3n + 1` vertices for `n` segments; a closed one has
+ * `3n`, its final two handles belonging to the segment that returns to the
+ * first anchor. This is the form a print or plotter pipeline actually wants,
+ * and it is affine-invariant, so `Transform` and `CopyToPoints` are exactly
+ * right on a curve without knowing it is one.
+ *
+ * `mesh` and `packed` are declared and unused, so that adding them later is a
+ * new case in a switch rather than a change to the document format. The list is
+ * deliberately open-ended rather than a closed pair: a volume is a primitive
+ * kind in Houdini and will be one here, which is the direction the plan records.
+ *
+ * Operations that measure along a primitive (arc length, resampling) are
+ * linear-only today and must refuse a `bezier` rather than read its handles as
+ * vertices, which would produce a subtly wrong shape instead of an error.
+ */
+export type PrimitiveKind = (typeof PRIMITIVE_KINDS)[number];
+/** Vertices per cubic Bézier segment after the first anchor. */
+export declare const BEZIER_STRIDE = 3;
+/**
+ * Primitive topology, CSR-style: `vertexPoints` is the flat vertex-to-point
+ * table and `offsets` slices it per primitive. Vertex `v` of primitive `i` is
+ * `vertexPoints[offsets[i] + v]`, and `offsets` has `primitiveCount + 1`
+ * entries so the last primitive's extent needs no special case. A geometry
+ * with no primitives still has a one-entry `offsets` of `[0]`.
+ *
+ * Keeping vertices as their own addressable level is what makes a per-corner
+ * value possible at all: two primitives meeting at a corner share one point and
+ * have two vertices, so a discontinuity across the seam is a vertex attribute
+ * while the shared position stays a point attribute.
+ */
+export interface Topology {
+    readonly vertexPoints: Int32Array;
+    readonly offsets: Int32Array;
+    /** Index into `PRIMITIVE_KINDS`, one per primitive. */
+    readonly kinds: Uint8Array;
+    /**
+     * 1 when the primitive's last vertex connects back to its first. Separate
+     * from `kinds` because open and closed polygons are the same kind of thing
+     * and every 2D operation cares about the difference.
+     */
+    readonly closed: Uint8Array;
+}
+/**
+ * A named subset at one level, as a bitmask rather than an index list because
+ * membership is tested far more often than it is enumerated.
+ */
+export type Groups = Readonly<Record<string, Uint8Array>>;
+export interface Geometry {
+    readonly kind: "geometry";
+    readonly pointCount: number;
+    readonly vertexCount: number;
+    readonly primitiveCount: number;
+    readonly topology: Topology;
+    /** Always contains `P` with a `size` of 2 or 3. */
+    readonly point: AttributeSet;
+    readonly vertex: AttributeSet;
+    readonly primitive: AttributeSet;
+    readonly detail: DetailSet;
+    readonly pointGroups: Groups;
+    readonly primitiveGroups: Groups;
+}
+/** The plain-array attribute forms used by `GeometryJson`. */
+export interface NumericAttributeJson {
+    readonly storage: AttributeStorage;
+    readonly size: number;
+    readonly data: readonly number[];
+}
+export interface StringAttributeJson {
+    readonly storage: "string";
+    readonly size?: 1;
+    readonly table: readonly string[];
+    readonly data: readonly number[];
+}
+export type AttributeJson = NumericAttributeJson | StringAttributeJson;
+export type AttributeSetJson = Readonly<Record<string, AttributeJson>>;
+export interface TopologyJson {
+    readonly vertexPoints: readonly number[];
+    readonly offsets: readonly number[];
+    /** Omitted when every primitive is a `poly`. */
+    readonly kinds?: readonly number[];
+    /** Omitted when no primitive is closed. */
+    readonly closed?: readonly number[];
+}
+/**
+ * The wire and document form. Plain arrays, JSON-safe, lossless. Verbose by
+ * design: a `.cascade` literal is authored by hand or by a small generator, and
+ * human-readable beats compact at that size. Groups are index lists here rather
+ * than masks, because a mask spelled out as JSON is mostly zeroes. Bulk
+ * geometry belongs in a `GeometryFileRef` instead.
+ */
+export interface GeometryJson {
+    readonly kind: "geometry";
+    /** Required, because a geometry may carry points that no attribute sizes. */
+    readonly pointCount: number;
+    readonly point?: AttributeSetJson;
+    readonly vertex?: AttributeSetJson;
+    readonly primitive?: AttributeSetJson;
+    readonly detail?: Readonly<Record<string, DetailValue>>;
+    readonly topology?: TopologyJson;
+    readonly pointGroups?: Readonly<Record<string, readonly number[]>>;
+    readonly primitiveGroups?: Readonly<Record<string, readonly number[]>>;
+}
+/**
+ * An out-of-band geometry, referenced the way `ImageRef` references pixels.
+ * `attribute` describes what a bare array file carries, and it is never
+ * inferred: a three-component `.npy` means `(x, y, radius)` in `cloud-plots`
+ * and would mean `(x, y, z)` under a 3D reading, and nothing in the file
+ * distinguishes them.
+ */
+export interface GeometryFileRef {
+    readonly kind: "geometry-file";
+    readonly path: string;
+    readonly format: "npy" | "json";
+    readonly attribute?: {
+        readonly level: ElementLevel;
+        readonly name: string;
+        readonly size: number;
+        readonly storage: AttributeStorage;
+    };
+    readonly pointCount?: number;
+    readonly primitiveCount?: number;
+}
+/** What a `geometry`-typed default, document literal, or bridge value may be. */
+export type GeometrySerialized = GeometryJson | GeometryFileRef;
+/** Allocate a zeroed array for a storage kind. */
+export declare function attributeArray(storage: AttributeStorage, length: number): AttributeArray;
+/** Copy values into a fresh array of a storage kind. */
+export declare function attributeArrayFrom(storage: AttributeStorage, values: ArrayLike<number>): AttributeArray;
+/** A plain-number copy of an attribute array, for the interchange form. */
+export declare function attributeNumbers(data: AttributeArray): number[];
+export declare function isStringAttribute(attribute: AnyAttribute): attribute is StringAttribute;
+/** How many elements an attribute covers, from its own arrays alone. */
+export declare function attributeElementCount(attribute: AnyAttribute): number;
+/** The number of elements at a level, or 1 for `detail`. */
+export declare function levelCount(geometry: Geometry, level: AttributeLevel): number;
+export interface GeometryParts {
+    readonly pointCount: number;
+    readonly point: AttributeSet;
+    readonly vertex?: AttributeSet;
+    readonly primitive?: AttributeSet;
+    readonly detail?: DetailSet;
+    readonly topology?: Topology;
+    readonly pointGroups?: Groups;
+    readonly primitiveGroups?: Groups;
+}
+/**
+ * The validating constructor. Every invariant the operations rely on is checked
+ * here once, so that no operation has to defend against a malformed input, and
+ * the result is frozen.
+ *
+ * This is the one piece of logic contracts owns for this type, because the
+ * codec below has to build a `Geometry` and a type whose invariants are
+ * enforced somewhere else is a type whose invariants are optional.
+ */
+export declare function createGeometry(parts: GeometryParts): Geometry;
+/**
+ * Freeze the plain objects that describe a geometry. The typed arrays are left
+ * alone because `Object.freeze` throws on a non-empty array buffer view, which
+ * is why the copy-on-write rule above is a convention rather than a guarantee.
+ */
+export declare function freezeGeometry(geometry: Geometry): Geometry;
+/** An empty geometry with a declared position width and no points. */
+export declare function emptyGeometry(positionSize?: 2 | 3): Geometry;
+/** In-memory to interchange. Lossless, and JSON-safe. */
+export declare function geometryToJson(geometry: Geometry): GeometryJson;
+/** Interchange to in-memory. Throws a `geometry/*` TypeError on bad input. */
+export declare function geometryFromJson(value: GeometryJson): Geometry;
+/**
+ * Validate an interchange value against the same constructor used to decode it.
+ * Keeping a second structural validator here previously accepted bad attribute
+ * lengths, fractional topology indices and out-of-range groups.
+ */
+export declare function isGeometryJson(value: unknown): value is GeometryJson;
+export declare function isGeometryFileRef(value: unknown): value is GeometryFileRef;
+/** Either serialized form is a valid `geometry` document value or default. */
+export declare function isGeometrySerialized(value: unknown): value is GeometrySerialized;
+/**
+ * Lift a bare path into a declared reference. The Python bridge returns a path
+ * string today, and this is the one place that knows how to read an extension;
+ * `attribute` is never guessed, because the third component of a points file
+ * means radius in one project and z in another.
+ */
+export declare function geometryFileRefFromPath(path: string, options?: Omit<GeometryFileRef, "kind" | "path" | "format">): GeometryFileRef;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/contracts/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../src/geometry.ts"],"names":[],"mappings":"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"}