Engine doors#

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { Keyframe } from "./Keyframe.js";

/**
 * One `engine_animation_set` row — the PARAMETER is the clip
 * (concepts.md §Animation), so a row names the parameter, not an arg or a
 * node id: `key` is model-wide unique (NODE LAW's one key namespace),
 * `method` rides alongside `keyframes` because a key carries no
 * `interpolation` field — the host derives playback interpolation from
 * `method` itself (linear for `length`/`number`/`angle`, step/hold for
 * `integer`).
 */
export type AnimatedParameter = { 
/**
 * identity — the parameter's key.
 */
key: string, 
/**
 * derived — the parameter's method (`length`/`number`/`angle`/`integer`).
 */
method: string, 
/**
 * derived — the evaluated keys.
 */
keyframes: Array<Keyframe>, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

export type ArgDefinition = { 
/**
 * identity — the arg's key on its node.
 */
key: string, 
/**
 * derived — the value type the arg's expression must evaluate to.
 */
valueType: string, 
/**
 * derived — the expression an absent arg takes.
 */
default: string, 
/**
 * derived — the default domain `min` expression.
 */
min?: string, 
/**
 * derived — the default domain `max` expression.
 */
max?: string, 
/**
 * derived — the default domain `options` expression.
 */
options?: string, 
/**
 * derived — the editor's one-line help.
 */
tooltip: string, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { OptionRow } from "./OptionRow.js";
import type { ValueSummary } from "./ValueSummary.js";

export type ArgState = { 
/**
 * identity — the arg's key on its node.
 */
key: string, 
/**
 * derived — the arg's current expression source (authored, or the
 * catalog default the node was built with).
 */
input: string, 
/**
 * derived — the domain's `min` expression source.
 */
min?: string, 
/**
 * derived — the domain's `max` expression source.
 */
max?: string, 
/**
 * derived — the domain's `options` expression source.
 */
options?: string, 
/**
 * derived — the domain's `keyframes` expression source (legal only on
 * a parameter's `value` arg — `spec/architecture/concepts.md`
 * §Animation).
 */
keyframes?: string, 
/**
 * derived — `Ast::is_literal` on `input`'s parsed tree: true exactly
 * when `input` is authored constant data, never a formula. The UI's
 * sole source for "show the ƒx badge / offer a plain value editor" —
 * no JS regex re-parses `input` to answer the same question.
 */
literal: boolean, 
/**
 * derived — `Ast::static_string_literals` on `input`'s parsed tree:
 * `Some` exactly when `input` is a bare text literal or an array
 * literal of text literals (`properties.visible`'s own shape), holding
 * the decoded strings themselves. A mirror that needs to read or extend
 * that list (SceneMenu's "New view" visibility
 * capture) uses this, never a second string-array parser; `None` means
 * the shape is anything else, including a single escaped/computed
 * element — that input is an authored expression and is left untouched.
 */
staticStringLiterals?: Array<string>, 
/**
 * derived — `domain.min` evaluated against the node's scope (the same
 * evaluation `graph::argument::enforce_domain` performs on the
 * identical expression, already carrying the catalog default through
 * `graph::builder::arg_slot`'s inheritance) — absent when there is no
 * `min` or it fails to evaluate to a number (the failure itself
 * surfaces as a `Diagnostic` from the arg's own evaluate, not
 * duplicated here).
 */
minValue?: number, 
/**
 * derived — same evaluation as `min_value`, for `domain.max`.
 */
maxValue?: number, 
/**
 * derived — `domain.options` evaluated against the node's scope: each
 * row of the resulting array, bare value or `{label, value}` record
 * alike, summarized as an `OptionRow`. Absent when there is no
 * `options`, it fails to evaluate, or it evaluates to something other
 * than an array.
 */
optionRows?: Array<OptionRow>, value: ValueSummary, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * One `expression::parser::BinaryOperatorDefinition`, mirrored for the wire.
 */
export type BinaryOperatorSignature = { 
/**
 * identity — the operator's token text (`+`, `**`, `===`, …).
 */
token: string, 
/**
 * derived — precedence tier; higher binds tighter.
 */
precedence: number, 
/**
 * derived — whether the operator groups right-to-left (`**` is the
 * only one).
 */
rightAssociative: boolean, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { ConstantSignature } from "./ConstantSignature.js";
import type { ExpressionBudgets } from "./ExpressionBudgets.js";
import type { FunctionSignature } from "./FunctionSignature.js";
import type { KeywordSignature } from "./KeywordSignature.js";
import type { NamespaceDefinition } from "./NamespaceDefinition.js";
import type { NodeDefinition } from "./NodeDefinition.js";
import type { OperatorsCatalog } from "./OperatorsCatalog.js";
import type { PropertySignature } from "./PropertySignature.js";
import type { ShadingCapability } from "./ShadingCapability.js";
import type { TypeSignature } from "./TypeSignature.js";

/**
 * `engine_catalog`'s wire shape: the node table, the shading→capability
 * table (`document::vocabulary::SHADINGS`) a shading picker reads to grey
 * out exposure for a mode that cannot meter, and the full expression
 * vocabulary — namespace/builtin function tables, constants, keyword
 * literals, array/string methods, operators, properties, blocked member
 * names, and the sandbox's numeric budgets. Session-free. Named
 * `ShadingCapability` because `scene::Shading` is the mode-name enum.
 */
export type Catalog = { 
/**
 * derived — every registered node's definition.
 */
nodes: Array<NodeDefinition>, 
/**
 * derived — the shading→capability table.
 */
shadings: Array<ShadingCapability>, 
/**
 * derived — every expression namespace's function table, in
 * `expression::namespaces::NAMES` order.
 */
namespaces: Array<NamespaceDefinition>, 
/**
 * derived — the five builtin function groups (`Math`, `Number`,
 * `Object`, `Array`, `Global`), in `expression::builtins::BUILTIN_NAMES`
 * order. `Number`/`Array` each appear twice across `builtins`/`Global`
 * when a root is both an object with members and itself callable — see
 * `expression::builtins::GLOBAL_FUNCTIONS`'s doc comment.
 */
builtins: Array<NamespaceDefinition>, 
/**
 * derived — `Math`'s and `Number`'s numeric constants (`Math.PI`,
 * `Number.EPSILON`, …), which are values, not functions, so `builtins`
 * cannot carry them.
 */
constants: Array<ConstantSignature>, 
/**
 * derived — every `Value::Array` method, in
 * `expression::eval::ARRAY_METHODS` order.
 */
arrayMethods: Array<FunctionSignature>, 
/**
 * derived — every `Value::Text` method, in
 * `expression::eval::STRING_METHODS` order.
 */
stringMethods: Array<FunctionSignature>, 
/**
 * derived — the binary and unary operator tables.
 */
operators: OperatorsCatalog, 
/**
 * derived — fixed member names `Value::member` (`expression/value.rs`)
 * resolves directly, outside every method/function table above (a
 * plain field read, no call) — `expression::value::PROPERTIES`.
 */
properties: Array<PropertySignature>, 
/**
 * derived — every keyword literal (`true`, `false`, `null`,
 * `undefined`) the parser/evaluator resolve without a scope lookup —
 * `expression::value::KEYWORD_LITERALS`.
 */
keywords: Array<KeywordSignature>, 
/**
 * derived — member names `Value::member` refuses outright (a JS
 * prototype sandbox-escape name) — what a stored expression is REFUSED,
 * not what it is granted — `expression::eval::BLOCKED_KEYS`.
 */
blockedMemberNames: Array<string>, 
/**
 * derived — the expression sandbox's numeric budgets (`eval.rs`/
 * `parser.rs`/`document::model`'s own `pub const`s).
 */
budgets: ExpressionBudgets, 
/**
 * derived — every value-type word, in `document::vocabulary::
 * TYPE_REGISTRY` order.
 */
types: Array<TypeSignature>, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { AngularDimensionRecord } from "./AngularDimensionRecord.js";
import type { HatchRecord } from "./HatchRecord.js";
import type { ImageRecord } from "./ImageRecord.js";
import type { LeaderRecord } from "./LeaderRecord.js";
import type { LinearDimensionRecord } from "./LinearDimensionRecord.js";
import type { RadialDimensionRecord } from "./RadialDimensionRecord.js";
import type { SectionRecord } from "./SectionRecord.js";

/**
 * What a cell draws. `Mesh`/`Curve` carry buffers on `RenderCell`; a record
 * variant's fields flatten alongside `type`.
 */
export type CellType = { "type": "mesh" } | { "type": "curve" } | { "type": "section" } & SectionRecord | { "type": "hatch" } & HatchRecord | { "type": "linearDimension" } & LinearDimensionRecord | { "type": "radialDimension" } & RadialDimensionRecord | { "type": "angularDimension" } & AngularDimensionRecord | { "type": "leader" } & LeaderRecord | { "type": "image" } & ImageRecord;

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { DocumentType } from "./DocumentType.js";
import type { Lanes } from "./Lanes.js";
import type { ModelJson } from "./ModelJson.js";
import type { NodeDiagnostic } from "./NodeDiagnostic.js";
import type { NodeState } from "./NodeState.js";
import type { RenderChange } from "./RenderChange.js";
import type { ResourceRequest } from "./ResourceRequest.js";

/**
 * The diff every door hands back. `nodes`/`removed` are only what changed;
 * `render` lists only objects whose cells or placements changed, including
 * `cells: Some([])` when a remaining node drops out of `scene()`; a deleted
 * object appears in `removed`.
 */
export type Changes = { 
/**
 * derived — the node states that changed since the last snapshot.
 */
nodes: Array<NodeState>, 
/**
 * identity — ids of nodes that no longer exist.
 */
removed: Array<number>, 
/**
 * derived — objects whose cells or placements changed.
 */
render: Array<RenderChange>, 
/**
 * derived — findings resolved off the current document.
 */
diagnostics: Array<NodeDiagnostic>, 
/**
 * derived — the resolved lanes, only when they differ from the last
 * snapshot shipped.
 */
lanes?: Lanes, 
/**
 * derived — the document after a structural edit, a key rename, a
 * settings write or a record-lane arg/label write (`ships_document`);
 * absent when only a node-graph arg or label changed.
 */
document?: ModelJson, 
/**
 * derived — `EditHistory.past` is non-empty.
 */
canUndo: boolean, 
/**
 * derived — `EditHistory.future` is non-empty.
 */
canRedo: boolean, 
/**
 * identity — the session's active view key; absent = the free camera.
 */
activeView?: string, 
/**
 * derived — every resource a step is waiting on right now, deduplicated;
 * the host fetches each and hands it back through `engine_add_font` /
 * `engine_add_component`.
 */
pending: Array<ResourceRequest>, 
/**
 * derived — `ModelJson::document_type` of the session's document.
 */
documentType: DocumentType, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { RenderChange } from "./RenderChange.js";
import type { ResourceRequest } from "./ResourceRequest.js";

/**
 * `engine_component_render`'s result: one `RenderChange` per object of the
 * component's isolated evaluation, or none while it waits on `pending`.
 */
export type ComponentRender = { 
/**
 * derived — the component's objects, empty while `pending` is not.
 */
render: Array<RenderChange>, 
/**
 * derived — the resources the evaluation asked for and the session lacks.
 */
pending: Array<ResourceRequest>, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * One `Math`- or `Number`-style numeric constant, mirrored off
 * `expression::builtins::ConstantDefinition` for the wire.
 */
export type ConstantSignature = { 
/**
 * identity — which root this constant hangs on (`Math`, `Number`).
 */
object: string, 
/**
 * identity — the constant's name (`Math.PI`'s `PI`).
 */
name: string, 
/**
 * derived — the constant's numeric value.
 */
value: number, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { Severity } from "./Severity.js";

/**
 * A validate finding. `node` is `None` at this tier — the document has not
 * been built into a node tree yet; a path string is the only address.
 */
export type Diagnostic = { path: string, severity: Severity, message: string, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * Mirrors `validate::Severity` on the wire (`"error" | "warning"`).
 */
export type DiagnosticSeverity = "error" | "warning";

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * What a document is, read off which lanes it fills
 * (`ModelJson::document_type`) — never stored.
 */
export type DocumentType = "component" | "material" | "pattern";

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { EndpointStyle } from "./EndpointStyle.js";

/**
 * One end of a dimension or leader as a DEFINITION, drawn by the renderer
 * at a fixed size on screen (SketchUp's dimension endpoints).
 */
export type Endpoint = { 
/**
 * geometry — cell-space point the endpoint marks (an arrow's tip), mm.
 */
point: [number, number, number], 
/**
 * geometry — cell-space unit direction the endpoint points: an arrow
 * runs along it to `point`, a slash crosses it at 45°.
 */
direction: [number, number, number], 
/**
 * derived — how it is drawn; never `none` (that end draws nothing).
 */
style: EndpointStyle, 
/**
 * derived — length on screen, points: the mark's `endpointSize`, else
 * its font size.
 */
size: number, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * The expression sandbox's DoS-guard budgets, mirrored off each `pub const`
 * at its own definition site — none of these live in this module.
 */
export type ExpressionBudgets = { 
/**
 * derived — `expression::eval::EVAL_STEP_BUDGET`.
 */
evalStepBudget: bigint, 
/**
 * derived — `expression::eval::MAX_ARRAY_LENGTH`.
 */
maxArrayLength: number, 
/**
 * derived — `expression::eval::MAX_CALL_DEPTH`.
 */
maxCallDepth: number, 
/**
 * derived — `expression::parser::EXPR_MAX_AST_DEPTH`.
 */
exprMaxAstDepth: number, 
/**
 * derived — `expression::parser::EXPR_MAX_LENGTH` (SSOT `document::model::EXPR_MAX_LENGTH`).
 */
exprMaxLength: number, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * geometry — the yaw's object-local pivot and the face that must meet the
 * viewer. Presence on `RenderCell` enables the turn; the renderer performs
 * it every paint.
 */
export type FaceCamera = { 
/**
 * geometry — OBJECT-LOCAL mm, the point the yaw turns about (the
 * object's resolved pivot).
 */
pivot: [number, number, number], 
/**
 * geometry — OBJECT-LOCAL unit direction of the face that must meet
 * the viewer. A horizontal normal fails at evaluate — nothing to face.
 */
normal: [number, number, number], };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * How a catalog entry folds: binding, producer, transform, or a bare
 * schema-only step the graph resolves itself.
 */
export type FoldRole = "binding" | "producer" | "transform" | "step";

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { ParameterSignature } from "./ParameterSignature.js";

/**
 * One `expression::namespaces::FunctionDefinition` without its `call` fn
 * pointer — the serializable half `Catalog.namespaces` mirrors.
 */
export type FunctionSignature = { 
/**
 * identity — the member name (`Point.distance`'s `distance`).
 */
name: string, 
/**
 * derived — the function's own parameters, in call order.
 */
parameters: Array<ParameterSignature>, 
/**
 * derived — the value-type word the function returns.
 */
returns: string, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * A placed rectangle: origin corner plus the two unit edge directions and
 * their extents — SketchUp `Sketchup::Image` (origin + width/height + its
 * own plane, https://ruby.sketchup.com/Sketchup/Image.html) and Three.js
 * `PlaneGeometry` under a matrix, rather than a two-corner axis-aligned box
 * (which cannot survive a rotation).
 */
export type Image = { 
/**
 * identity — the image's address (`data:` / `https:`).
 */
url: string, 
/**
 * geometry — the rectangle's origin corner, mm.
 */
origin: [number, number, number], 
/**
 * geometry — the rectangle's width axis, unit.
 */
xAxis: [number, number, number], 
/**
 * geometry — the rectangle's height axis, unit.
 */
yAxis: [number, number, number], 
/**
 * geometry — extent along `x_axis`, mm.
 */
width: number, 
/**
 * geometry — extent along `y_axis`, mm.
 */
height: number, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * One `keyframes` entry — an explicit `(time, value)` pair (USD
 * `timeSamples`, Blender `keyframe_points`; AGENTS.md "No implicit
 * pairing" rules out a parallel times/values-array shape). DERIVED read
 * shape (`engine_animation_set`'s rows), never persisted:
 * `document::model::Argument.keyframes` persists the authored EXPRESSION
 * only. `spec/architecture/concepts.md` §Animation: no `interpolation`
 * field on a key — playback between keys follows the parameter's own
 * method (linear for `length`/`number`/`angle`, step/hold for `integer`).
 */
export type Keyframe = { 
/**
 * derived — absolute seconds on the document's one timeline.
 */
time: number, 
/**
 * derived — the parameter's value at this key.
 */
value: number, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * One `expression::value::KeywordDefinition`, mirrored for the wire.
 */
export type KeywordSignature = { 
/**
 * identity — the keyword's name (`true`, `null`, …).
 */
name: string, 
/**
 * derived — the value-type word this keyword evaluates to.
 */
valueType: string, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { FunctionSignature } from "./FunctionSignature.js";

/**
 * One expression namespace (`Point`, `Arc`, …) — its function table, mirrored
 * off `expression::namespaces::functions_of` without the `call` fn pointer,
 * which does not serialize.
 */
export type NamespaceDefinition = { 
/**
 * identity — the namespace root name (`Point.distance` reads as `Point`
 * + `distance`).
 */
name: string, 
/**
 * derived — every member function this namespace exposes.
 */
functions: Array<FunctionSignature>, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

export type NodeCategory = "parameter" | "object" | "step" | "property" | "behavior" | "material" | "layer" | "pattern" | "view" | "component";

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { ArgDefinition } from "./ArgDefinition.js";
import type { FoldRole } from "./FoldRole.js";
import type { NodeType } from "./NodeType.js";

/**
 * One catalog entry. `context`/`args[].value_type`/`returns` stay raw
 * type strings (`"curveData[] | meshData[]"`), not a second type system.
 */
export type NodeDefinition = { 
/**
 * identity — the method name a node's `method` names.
 */
method: string, 
/**
 * derived — how the fold treats it (producer, transform, …).
 */
role: FoldRole, 
/**
 * derived — the document-shape family it belongs to.
 */
nodeType: NodeType, 
/**
 * derived — the stream types (or node bodies) it is legal in.
 */
context: Array<string>, 
/**
 * derived — its args, in order.
 */
args: Array<ArgDefinition>, 
/**
 * derived — the type it returns.
 */
returns: string, 
/**
 * derived — the key base a new node of this method takes.
 */
defaultKey?: string, 
/**
 * derived — the editor's display name.
 */
label: string, 
/**
 * derived — the editor's one-line help.
 */
tooltip: string, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { DiagnosticSeverity } from "./DiagnosticSeverity.js";

/**
 * A `validate::Diagnostic` plus the `NodeId` that produced it (`None` =
 * document-wide). Wire shape for `Changes.diagnostics`.
 */
export type NodeDiagnostic = { 
/**
 * identity — the node that produced this finding; `None` = document-wide.
 */
node: number | null, 
/**
 * derived — where in the document this finding applies.
 */
path: string, 
/**
 * derived — error or warning.
 */
severity: DiagnosticSeverity, 
/**
 * derived — the finding's text.
 */
message: string, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { NodeCategory } from "./NodeCategory.js";

export type NodeEditCall = { "op": "insert", 
/**
 * identity — the node the entry joins; absent = the document root.
 */
parent?: number, 
/**
 * intent — the category the entry becomes, naming the list it joins.
 */
type: NodeCategory, 
/**
 * intent — the node JSON inserted.
 */
entry: unknown, 
/**
 * intent — position in that list; absent = the end.
 */
index?: number, } | { "op": "remove", 
/**
 * identity — the node removed.
 */
id: number, 
/**
 * intent — remove a record even while something names it.
 */
force?: boolean, } | { "op": "move", 
/**
 * identity — the node moved.
 */
id: number, 
/**
 * intent — its new position among its siblings.
 */
index: number, } | { "op": "replace", 
/**
 * identity — the node replaced.
 */
id: number, 
/**
 * intent — the node JSON it becomes.
 */
entry: unknown, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { ArgState } from "./ArgState.js";
import type { Diagnostic } from "./Diagnostic.js";
import type { NodeCategory } from "./NodeCategory.js";
import type { ValueSummary } from "./ValueSummary.js";

export type NodeState = { 
/**
 * identity — the graph slot.
 */
id: number, 
/**
 * identity — the owning node; absent = a lane root.
 */
parent?: number, 
/**
 * derived — position among the parent's same-slot children (a root:
 * its lane index). A `Move` ships only the moved node; the mirror
 * splices it in at this index.
 */
index: number, 
/**
 * derived — the node's `NodeCategory`.
 */
type: NodeCategory, 
/**
 * identity — the authored key.
 */
key?: string, 
/**
 * derived — `Node.label`, verbatim; `None` when the document carries none.
 */
label?: string, 
/**
 * derived — the catalog method.
 */
method: string, 
/**
 * derived — every arg with its evaluated value.
 */
args: Array<ArgState>, 
/**
 * derived — this node's own diagnostics from the last evaluate.
 */
diagnostics: Array<Diagnostic>, 
/**
 * derived — a summary of the node's evaluated value or stream.
 */
value: ValueSummary, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * The document-shape family a catalog entry belongs to — finer than
 * `role`, so a caller can tell `createObject` from `createBlock` or a
 * lane step's own lane.
 */
export type NodeType = "objectChain" | "objectNest" | "placement" | "material" | "layer" | "pattern" | "view" | "component" | "step" | "value" | "behavior";

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { BinaryOperatorSignature } from "./BinaryOperatorSignature.js";
import type { UnaryOperatorSignature } from "./UnaryOperatorSignature.js";

/**
 * `Catalog.operators`'s wire shape: the binary and unary operator tables.
 */
export type OperatorsCatalog = { 
/**
 * derived — every binary operator, in
 * `expression::parser::BINARY_OPERATORS` order.
 */
binary: Array<BinaryOperatorSignature>, 
/**
 * derived — every unary operator, in
 * `expression::parser::UNARY_OPERATORS` order.
 */
unary: Array<UnaryOperatorSignature>, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { ValueSummary } from "./ValueSummary.js";

/**
 * One evaluated row of an arg's `options` domain — `ArgState.option_rows`.
 */
export type OptionRow = { 
/**
 * derived — the authored `{label, value}` row's own label; `None` for
 * a bare-value row (`graph::argument::option_matches`'s row shape).
 */
label?: string, 
/**
 * derived — the row's evaluated value, same vocabulary as `ArgState.value`.
 */
value: ValueSummary, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * One `expression::namespaces::ParameterDefinition`, mirrored for the wire.
 */
export type ParameterSignature = { 
/**
 * identity — the parameter's name.
 */
name: string, 
/**
 * derived — the value-type word (`document::vocabulary::TYPE_REGISTRY`
 * where one applies, else the closest `Value` variant name).
 */
valueType: string, 
/**
 * derived — whether the closure tolerates this argument being absent.
 */
optional: boolean, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * One `expression::value::PropertyDefinition`, mirrored for the wire —
 * `Value::member`'s hand-kept record, since `value.rs` itself is not a
 * data table.
 */
export type PropertySignature = { 
/**
 * identity — the value-type word of the receiver this property reads
 * from (`array`, `string`).
 */
receiver: string, 
/**
 * identity — the property's name (`length`).
 */
name: string, 
/**
 * derived — the value-type word this property reads back.
 */
returns: string, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { AngularDimensionRecord } from "./AngularDimensionRecord.js";
import type { Endpoint } from "./Endpoint.js";
import type { FaceCamera } from "./FaceCamera.js";
import type { HatchRecord } from "./HatchRecord.js";
import type { ImageRecord } from "./ImageRecord.js";
import type { LeaderRecord } from "./LeaderRecord.js";
import type { LineStyle } from "./LineStyle.js";
import type { LinearDimensionRecord } from "./LinearDimensionRecord.js";
import type { RadialDimensionRecord } from "./RadialDimensionRecord.js";
import type { SectionRecord } from "./SectionRecord.js";
import type { Text } from "./Text.js";

/**
 * One drawable unit in object-local space. `positions`/`normals` are
 * `[x,y,z,…]`; `uvs` is `[u,v,…]` (mesh only). `Face.uvTransform` maps through that
 * 4×4; absent falls back to face-plane coordinates. `indices` triangulates
 * `positions`; `lines` is the hard-edge / wire overlay.
 */
export type RenderCell = { 
/**
 * geometry — `[x,y,z,…]`, object-local. Attached as a typed array in
 * `wasm::fix_render_cell_buffers`, never boxed as a JSON `number[]`.
 */
positions: Float32Array, 
/**
 * geometry — `[x,y,z,…]`, absent for a record cell (no shading).
 */
normals?: Float32Array, 
/**
 * geometry — `[u,v,…]`, mesh only.
 */
uvs: Float32Array, 
/**
 * geometry — triangulates `positions`.
 */
indices: Uint32Array, 
/**
 * geometry — the hard-edge / wire overlay, index pairs into `positions`.
 */
lines: Uint32Array, 
/**
 * geometry — a mesh's smooth edges between two shown faces, index pairs
 * into `positions`: the candidates for a profile line, drawn where one
 * face turns toward the viewer and the other away (SketchUp "Profiles").
 */
profileLines: Uint32Array, 
/**
 * geometry — per `profile_lines` pair, the unit normals of its two
 * faces, `[ax, ay, az, bx, by, bz, …]`, object-local.
 */
profileNormals: Float32Array, 
/**
 * derived — a `CurveEdge`/`MeshEdge`-drawing style; `None` for a mesh
 * triangle cell, which has no line of its own to style.
 */
lineStyle?: LineStyle, 
/**
 * identity — the resolved material's key; a cell paints one material.
 */
material?: string, 
/**
 * identity — the resolved layer's key; a cell belongs to one layer.
 */
layer?: string, 
/**
 * identity — a decimal string on the wire (JS numbers only carry 53
 * safe bits, short of this key's 64); unchanged means "skip re-tessellate".
 */
contentKey: string, 
/**
 * geometry — object-local pivot + face normal the renderer yaws about
 * world Z so the face meets the viewer (SketchUp "always face camera").
 * Absent = this cell does not turn. A `faceCamera` behavior stamps it
 * on every cell it governs (spec/architecture/concepts.md §Behaviors).
 */
faceCamera?: FaceCamera, 
/**
 * identity — nest path from the first child of this `RenderChange`'s
 * object down to the `SceneObject` that produced the cell. Absent = the
 * object's own geometry (no nest). A `createBlock` / `placeComponent`
 * child is named by its `SceneObject.key` at each level.
 */
objectKeys?: Array<string>, 
/**
 * geometry — cell-space points a selection box or marquee measures in
 * place of the drawn linework: a mark's authored points, its furniture
 * (arrows, extension lines, text) left out (`CellType::anchors`). Absent
 * = the drawn geometry is the extent.
 */
anchors?: Array<[number, number, number]>, 
/**
 * derived — a drafting mark's texts, which the renderer draws facing
 * the viewer at a fixed screen size (`annotation::Text`); absent = the
 * cell writes no text.
 */
texts?: Array<Text>, 
/**
 * derived — a drafting mark's endpoints (arrows, slashes, dots), drawn
 * like its texts (`annotation::Endpoint`); absent = none.
 */
endpoints?: Array<Endpoint>, } & ({ "type": "mesh" } | { "type": "curve" } | { "type": "section" } & SectionRecord | { "type": "hatch" } & HatchRecord | { "type": "linearDimension" } & LinearDimensionRecord | { "type": "radialDimension" } & RadialDimensionRecord | { "type": "angularDimension" } & AngularDimensionRecord | { "type": "leader" } & LeaderRecord | { "type": "image" } & ImageRecord);

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { Instance } from "./Instance.js";
import type { RenderCell } from "./RenderCell.js";

/**
 * One object's render diff. `cells` is `None` when tessellation is unchanged,
 * `Some([])` when the object left `scene()` while its node stayed.
 * `placements` is the current instances. A deleted object is in
 * `Changes.removed`, not a missing render entry.
 */
export type RenderChange = { 
/**
 * identity — the object node this diff belongs to.
 */
object: number, 
/**
 * identity — the `createBlock` nest this object's node sits in; absent
 * at the root. A nest is the SAME mechanism as the model root containing
 * objects, recursively: every object node at any depth ships its own
 * `RenderChange`, `parent` naming the nest one level up.
 */
parent?: number, 
/**
 * geometry — `None` when tessellation is unchanged; `Some([])` when the
 * object left `scene()` while its node stayed.
 */
cells: Array<RenderCell> | null, 
/**
 * geometry — this object's current instance matrices (plus per-instance
 * paint/identity), always shipped current.
 */
placements: Array<Instance>, 
/**
 * geometry — this object's own resolved placement pivot
 * (`graph::property::place`/`SceneObject.pivot`), in the SAME frame the
 * `pivot` property is authored in (this object's own local frame,
 * before placement) — always shipped current, same as `placements`, so
 * a host gizmo (rotate/scale about this point) never re-derives it. A
 * record object's pivot follows the SAME resolution (authored, else
 * ORIGIN — a record's content has no bbox, AGENTS.md "RECORDS"). `[0,
 * 0, 0]` on a `clear_absent` ship (the object left the scene; nothing
 * to pivot about).
 */
pivot: [number, number, number], };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * What a step asked for that the session does not hold yet.
 */
export type ResourceRequest = { "type": "font", url: string, } | { "type": "component", url: string, via: Array<string>, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * Overlay payload for `engine_select` — indices always; vertex hits also
 * fill `points`, edge hits fill `segments`. Faces stay indices-only
 * (`Mesh::Face.loops` are edge ids).
 */
export type SelectPreview = { 
/**
 * geometry — the filter hits' indices into the target (vertex/edge/face)
 * list; a curve corner hit carries the curve's own vertex id, a corner
 * having no list of its own.
 */
indices: Array<number>, 
/**
 * geometry — a vertex or corner hit's world position; empty for an edge/face target.
 */
points: Array<[number, number, number]>, 
/**
 * geometry — an edge hit's two endpoint positions; empty for a vertex/face target.
 */
segments: Array<[[number, number, number], [number, number, number]]>, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

export type Severity = "error" | "warning";

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

export type ShadingCapability = { 
/**
 * identity — the shading mode's name, matching `views[].properties.shading`.
 */
name: string, 
/**
 * derived — whether this mode can meter an authored exposure value.
 */
exposure: boolean, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { FoldRole } from "./FoldRole.js";

/**
 * `role` + `context` + `returns`, the three facts a chain-append type check
 * reads together — grouped so a caller does not reassemble them from three
 * separate `definition_of` calls.
 */
export type StreamFact = { role: FoldRole, context: Array<string>, returns: string, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * A mark's text as a DEFINITION — what it says, where it sits, how big —
 * which the renderer draws facing the viewer at a fixed size on screen.
 * Never stored: built from the placed record on every render, so it always
 * sits on the linework it labels and states the mapped measurement.
 */
export type Text = { 
/**
 * derived — the string drawn: the formatted measurement, or the mark's
 * authored `text` override.
 */
text: string, 
/**
 * geometry — cell-space point the text is drawn at, mm.
 */
point: [number, number, number], 
/**
 * derived — size on screen, points: the mark's `fontSize`, else
 * `BUILTIN_FONT_SIZE`.
 */
size: number, 
/**
 * geometry — cell-space unit direction the text runs away along from
 * `point` (a leader's run); absent = the text sits centred just above
 * `point` (a dimension's segment midpoint).
 */
away?: [number, number, number], 
/**
 * geometry — cell-space unit direction the text reads along (its
 * dimension line — SketchUp aligns dimension text to the dimension),
 * turned on screen to read left to right; absent = it reads
 * horizontally on screen.
 */
along?: [number, number, number], };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * One `document::vocabulary::TYPE_REGISTRY` entry — a word an
 * `ArgDefinition.valueType` / `returns` is built from (`point`, `meshData`,
 * `material`, …; `[]` and `|` compose them).
 */
export type TypeSignature = { 
/**
 * identity — the type word.
 */
name: string, 
/**
 * derived — `value` (a plain value), `data` (an evaluated shape or
 * record) or `record` (a lane key).
 */
category: string, 
/**
 * derived — an argument of this type may carry `min` / `max`.
 */
ordered: boolean, 
/**
 * derived — an argument of this type may carry `options`.
 */
options: boolean, 
/**
 * derived — what a value is and how an expression writes it.
 */
description: string, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

/**
 * One `expression::parser::UnaryOperatorDefinition`, mirrored for the wire.
 */
export type UnaryOperatorSignature = { 
/**
 * identity — the operator's token text (`+`, `-`, `!`, `~`).
 */
token: string, };

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

export type ValueSummary = { "type": "none" } | { "type": "number", "value": number } | { "type": "text", "value": string } | { "type": "bool", "value": boolean } | { "type": "vector3", "value": [number, number, number] } | { "type": "vector3List", "value": Array<[number, number, number]> } | { "type": "curve", "value": { chains: number, vertices: number, } } | { "type": "mesh", "value": { faces: number, edges: number, vertices: number, } } | { "type": "block", "value": { objects: number, } } | { "type": "other", "value": string };