schema

AnalyzeConfig

AnalyzeConfig = SweepConfig | OptimizeConfig | MonteCarloConfig

Design-study vocabulary — sweep / optimize / Monte-Carlo configs and their result tables. Pure records: the runner (@huukhanhnguyen/model) reads them, nothing here holds a live graph object.

AnalyzeMode

AnalyzeMode = "sweep" | "optimize" | "monteCarlo"

AnalyzeProgress

AnalyzeProgress = (done, total) => void

Parameters

done

number

total

number

Returns

void

AnalyzeRunResult

AnalyzeRunResult = AnalyzeTable | OptimizeResult | MonteCarloResult

AnalyzeTable

AnalyzeTable = { columns: string[]; rows: unknown[][]; }

columns

columns: string[]

rows

rows: unknown[][]

AreaUnit

AreaUnit = "mm2" | "cm2" | "m2" | "in2" | "ft2"

Argument

Argument = { input: string; key: string; label?: string; max?: string; min?: string; options?: Option[]; step?: string; }

input

input: string

ALWAYS an expression string — an object-shaped VALUE (e.g. placeComponent's args override) is authored as expression-string SYNTAX like "{ width: 500 }", never a raw JS object. Empty is allowed (file parameter with no file selected); validity is enforced by validateExpressions().

key

key: string

label?

optional label?: string

max?

optional max?: string

min?

optional min?: string

Constraint fields — parameter args (numeric methods) only; ignored elsewhere.

options?

optional options?: Option[]

step?

optional step?: string

BaseObjectJSON

BaseObjectJSON = { attributes: Record<string, unknown>; id: string; }

The two data shapes at the base of the model runtime's object graph. The live pieces (Notifier, BaseCollection, the pull-cell bookkeeping) stay in @huukhanhnguyen/model — they describe behavior, not a record.

attributes

attributes: Record<string, unknown>

id

id: string

BoundingBox

BoundingBox = { max: Point; min: Point; }

Axis-aligned box in 3D (default space). Same stem as geometry BoundingBox ops namespace (type/value dual). Plane twin: BoundingBox2d (core2d.ts).

Structured form used at package boundaries (min/max points). The wasm kernel wire remains flat [minX,minY,minZ,maxX,maxY,maxZ] on op returns — convert at the door when needed.

max

max: Point

min

min: Point

CameraData

CameraData = PerspectiveCamera | OrthographicCamera

A camera. Which PROJECTION it is follows from WHICH FIELD IS PRESENT, the way a block's behaviors are enabled by being present. This is not the object's kind: CameraObject.type is explicit, never sniffed. Both fields at once, or neither, is not a camera; the union says so in TypeScript, and the model package's validation says so for JSON, which can still express it.

Absent by the same rule: zoom (a three.js viewport knob, absent from glTF, USD, BCF and USD's own GfCamera) and any sensor / film back / focal length (fov is an angle and needs no length unit; a film back is an EXPORTER convention — USD's camera carries one — never a scene fact).

Component

Component = { animations?: Chain[]; entities?: unknown[]; flat?: boolean; key: string; label?: string; opening?: (DataStep | Group)[]; operations: (DataStep | Group)[]; parameters?: (Operation | Group)[]; }

A reusable DEFINITION — 2D or 3D. key is unique within the components[] lane (per-lane uniqueness via uniqueKeyArray — not a model-wide key space shared with parameters/operations). Placed via placeComponent in an ordinary 3D chain (root scene / another component's body): a real instanced GROUP placement + the opening cut. NOT on paper — a sheet places a VIEW (a views[] entry with a viewDetail head), never a definition (2026-07-26).

Flatness contract: DECLARED (flat: true on this record — the ONLY flat declaration there is, since a step cannot declare itself flat), NEVER inferred from content. A declared-flat component enforces the flat contract over its whole body (FLAT_LANE_METHODS, point-arg z=0, force-flatten created documents) so a slider cannot silently un-flatten it.

animations?

optional animations?: Chain[]

Animation chains scoped to this component — track nodes fold to AnimationClip + Track exactly like ModelJSON.animations, and materialize per placement. An animation importer would author track NODES here.

entities?

optional entities?: unknown[]

Baked static geometry (import/AI) — plain ObjectData, never an expression. Spliced by placeComponent alongside evaluated operations. A component may have baked content, authored content, or both; only entities (empty operations) is a valid imported asset.

flat?

optional flat?: boolean

Chain-level flat declaration — with ModelJSON.flat and the "flat" LANE, one of the only three ways 2D context is established. When true, the whole operations body runs under the flat contract (vocabulary gate + z=0 point args + force-flatten). Empty operations is valid. opening under flat is meaningless (validate warning).

key

key: string

label?

optional label?: string

Editor-chrome display name (not printed on the artifact — see model's title-vs-label law).

opening?

optional opening?: (DataStep | Group)[]

Optional cut volumes — evaluated in the SAME isolated scope + args, with the SAME placement transform (at/rotate/scale) as the body. THE OPENING LAW (cut-at-placement): in an ordinary 3D chain, each placeComponent step SUBTRACTS these (closed solid) volumes from the stream documents PRESENT BEFORE that step in that SAME chain (a wall placed earlier gets a doorway cut through it; a wall placed AFTER is unaffected — "what is behind does not know"). The opening volumes themselves never render and never flow downstream — they exist only to cut. Ignored entirely in a FLAT placement context (no volume to cut there). Meaningless when flat: true (validate warning).

operations

operations: (DataStep | Group)[]

The component's own body — a data-streaming chain. Lane "component" when undeclared; when flat: true, the whole body is flat-enforced. Undeclared means 3D — flatness is never inferred from content.

parameters?

optional parameters?: (Operation | Group)[]

This component's own input arguments — a function signature. Evaluated in an ISOLATED scope (never sees the host model's parameters[]); a placement's args overrides these by key, so the SAME component placed twice can render differently. Value methods only (length/number/…).

Convention

Convention<D> = { checkFacts?: ConventionFinding[]; default: D; docId: string; lane: ConventionLane; snapshot?: ConventionSnapshot; tier: ConventionTier; }

Type Parameters

D

D = unknown

default

default: D

The out-of-box DEFAULT: pure data + pure functions (dependency-free, engine-safe) that make this lane's output standard-conforming with zero author input. This is where the magic numbers scattered through sheets.ts move to — owned, named, one place.

docId

docId: string

conventions/.md — the progressive-reference doc. gen assembles it into BOTH model-grammar.txt (AI) and the human docs. ONE source, so the AI guidance can never drift from what the DEFAULT actually does.

lane

lane: ConventionLane

snapshot?

optional snapshot?: ConventionSnapshot

The mandatory visual LOOK — required whenever the lane is visual.

tier

tier: ConventionTier

Methods

checkFacts()?

optional checkFacts(report): ConventionFinding[]

Deterministic self-check on an evaluated model's inspect report.

Parameters

report

InspectReport

Returns

ConventionFinding[]

ConventionFinding

ConventionFinding = { message: string; rule: string; severity: "error" | "warning"; }

One deterministic, in-engine finding — a MEASURABLE defect read off an evaluated inspect report ("title block has no Scale field", "content fills < 20% of the usable area"). Facts only; anything needing eyes is a snapshot.

message

message: string

rule

rule: string

Stable id for the rule, so a re-run can point at the same failed check (the reference's "re-run exactly the check that failed").

severity

severity: "error" | "warning"

ConventionLane

ConventionLane = string

A ModelJSON lane key a convention governs ("sheets", "views", "materials", "layers", …). A string, not ModelLane — that type names the fold ROLE (parameters/scene/component/flat), a different axis.

ConventionSnapshot

ConventionSnapshot = { judge: string; surface: "sheet" | "viewport3d" | "texture" | "material"; }

The mandatory LOOK, declared not executed. The engine is dependency-free and never opens a browser; it names the surface to render and the single yes/no question a vision-judge answers. The verify harness renders + judges.

judge

judge: string

ONE yes/no question about the rendered image, phrased so a "no" is a real defect ("Is the sheet a professional drawing — title block with labelled fields, framed content filling the page — not a tiny table in a corner?").

surface

surface: "sheet" | "viewport3d" | "texture" | "material"

ConventionTier

ConventionTier = "T1" | "T2"

Ontology tier (IFC/bSDD/USD applied-schema precedent). T0 core is engine-hard and never appears here. T1 STANDARD ships with the product, versioned. T2 DOMAIN is an opt-in pack (arch Psets, CNC tags). T3 MODEL is the author's own and is never a convention. Everything in this package is T1; a pack registers T2 via mergeConventions.

CurveMetrics

CurveMetrics = { closed: boolean; length: number; selfIntersects: boolean | null; winding: "CW" | "CCW" | null; }

closed

closed: boolean

length

length: number

selfIntersects

selfIntersects: boolean | null

null when the curve isn't planar-XY (test not applicable).

winding

winding: "CW" | "CCW" | null

Loop orientation in the XY plane; null for open or non-planar curves.

DataStep

DataStep = { args?: Argument[]; enabled?: string; key?: string; label?: string; method: string; }

ONE step in a data-streaming chain: it folds a data stream to a data stream, and that is the whole of it.

Which is why it carries neither authoring markers nor a child list. There is no flat (2D context comes from the LANE — ModelLane === "flat" — or from the chain-level owner declaration Component.flat / ModelJSON.flat; a step cannot declare itself into another dimension), no locked (immunity is a property of the PLACEMENT — BaseInstance.locked, stamped by applyLocked — because later steps skip a locked object, not a node), and no children (a chain is a flat pipeline; grouping is a Group, whose own operations is the nested list).

args?

optional args?: Argument[]

enabled?

optional enabled?: string

Optional enable expression — falsy = this step is bypassed / emits nothing.

key?

optional key?: string

label?

optional label?: string

method

method: string

Method VALIDITY is registry-dependent (which node registries are loaded) — the schema only checks the string shape; model's validateModelJSON(json, registry) rejects unknown methods.

EnvironmentHdri

EnvironmentHdri = { intensity?: number; name?: string; }

Image-based lighting. name is a url-method parameter key (an attached HDRI bitmap is an ordinary parameter whose value is its URL) OR a direct https:/data: URI; absent = the host's neutral built-in room, so PBR materials are not pitch black before an HDRI is authored.

intensity?

optional intensity?: number

name?

optional name?: string

GraphAssertResult

GraphAssertResult = { ok: true; } | { message: string; ok: false; }

Graph-snapshot vocabulary — the flat node/edge picture a debugger or graph viewer reads. The SOURCE shapes (live nodes, the registry) stay in @huukhanhnguyen/model.

GraphSnapshot

GraphSnapshot = { edges: GraphSnapshotEdge[]; nodes: GraphSnapshotNode[]; }

edges

edges: GraphSnapshotEdge[]

nodes

nodes: GraphSnapshotNode[]

GraphSnapshotEdge

GraphSnapshotEdge = { from: string; to: string; type: string; }

from

from: string

to

to: string

type

type: string

GraphSnapshotNode

GraphSnapshotNode = { dirty: boolean; id: string; key: string; lane: string; lastEvalMs: number; method: string; type: string; }

dirty

dirty: boolean

id

id: string

key

key: string

lane

lane: string

lastEvalMs

lastEvalMs: number

method

method: string

type

type: string

Group

Group = { enabled?: string; instances?: NodeInstance[]; key?: string; label?: string; operations: (DataStep | Group)[]; properties?: PropertyNode[]; }

Display grouping inside an object or component body, a sheet/template, and parameters[]. Not a scene object — the root is SceneNode[]. key is optional because a nested group needs none. The fold of a group is its own empty-stream scope (applyAttribute sees only the group's steps); the parent concatenates the result.

enabled?

optional enabled?: string

instances?

optional instances?: NodeInstance[]

Authored placements (object-tier). Absent === one identity.

key?

optional key?: string

label?

optional label?: string

operations

operations: (DataStep | Group)[]

properties?

optional properties?: PropertyNode[]

Steps that write instances[] (object-tier). Carried here for the same reason instances is: objectDocuments() hands an ObjectNode to the runtime as this shape, so the field has to survive the trip.

InspectClash

InspectClash = { a: string; b: string; overlap: number; }

a

a: string

b

b: string

overlap

overlap: number

InspectCounts

InspectCounts = { annotations: number; curves: number; faces: number; groups: number; hidden: number; meshes: number; points: number; }

annotations

annotations: number

curves

curves: number

faces

faces: number

groups

groups: number

hidden

hidden: number

meshes

meshes: number

points

points: number

InspectGroup

InspectGroup = { bounds: BoundingBox | null; counts: InspectCounts; hidden: boolean; key: string; layers: string[]; materials: string[]; mesh?: MeshMetrics; steps: InspectStep[]; tessellation?: { curves: { points: Point[]; }[]; meshes: { indices: number[]; positions: number[]; }[]; }; warnings: string[]; }

bounds

bounds: BoundingBox | null

counts

counts: InspectCounts

hidden

hidden: boolean

key

key: string

layers

layers: string[]

materials

materials: string[]

mesh?

optional mesh?: MeshMetrics

Tessellated mesh diagnostics when the group carries faces.

steps

steps: InspectStep[]

tessellation?

optional tessellation?: { curves: { points: Point[]; }[]; meshes: { indices: number[]; positions: number[]; }[]; }

Full tessellation — only with the geometry option (external tools).

curves

curves: { points: Point[]; }[]

meshes

meshes: { indices: number[]; positions: number[]; }[]

warnings

warnings: string[]

InspectReport

InspectReport = { clashes?: InspectClash[]; groups: InspectGroup[]; parameters: { key: string; value: unknown; }[]; title?: string; unit?: string; warnings: string[]; }

clashes?

optional clashes?: InspectClash[]

Coarse bbox-overlap pairs — only with the clashes option.

groups

groups: InspectGroup[]

parameters

parameters: { key: string; value: unknown; }[]

key

key: string

value

value: unknown

title?

optional title?: string

unit?

optional unit?: string

warnings

warnings: string[]

Every group/step warning, prefixed with its path — scan this first.

InspectStep

InspectStep = { bounds: BoundingBox | null; counts: InspectCounts; curve?: CurveMetrics; error?: string; key: string; method: string; steps?: InspectStep[]; warnings: string[]; }

bounds

bounds: BoundingBox | null

counts

counts: InspectCounts

curve?

optional curve?: CurveMetrics

Tessellated curve diagnostics when the step's value is one curve.

error?

optional error?: string

key

key: string

method

method: string

steps?

optional steps?: InspectStep[]

Present when the step is a nested Group: its own pipeline.

warnings

warnings: string[]

LaneEditField

LaneEditField = "operations" | "opening"

The body lanes a chain entry may carry. A components[] entry has two that flow in opposite directions — operations produces into the stream, opening subtracts from it (see schema/model.ts's opening contract) — and both are edited by the same tree editor, so both go through one door.

LengthUnit

LengthUnit = "mm" | "cm" | "m" | "in" | "ft"

MassUnit

MassUnit = "mg" | "g" | "kg" | "lb" | "oz"

MeasureConfig

MeasureConfig = { expression: string; key: string; }

expression

expression: string

key

key: string

MeshMetrics

MeshMetrics = { boundaryEdges: number; degenerate: number; invertedSolids: number; sealed: boolean; solids: number; triangles: number; volume: number; }

boundaryEdges

boundaryEdges: number

degenerate

degenerate: number

invertedSolids

invertedSolids: number

Sealed components with negative volume: inside-out (e.g. an unflipped mirror copy).

sealed

sealed: boolean

True when every edge is shared by exactly two triangles.

solids

solids: number

Connected components (vertex-connectivity) — one per separate solid/sheet.

triangles

triangles: number

volume

volume: number

Signed volume — negative on a sealed mesh means inverted winding.

ModelLane

ModelLane = "parameters" | "scene" | "component" | "flat"

Which section of the model a node was declared in (drives lane validation and serialization). parameters = value bindings; scene = the root fold ROLE (storage field is operations); component = a Component's own operations/opening (full 3D grammar — an ISOLATED scope, not a method restriction); flat = a sheet's ad hoc content — data methods only, restricted to FLAT_LANE_METHODS (no solid/3D).

ModelSettings

ModelSettings = { activeView?: string; cameraTour?: { legs: { duration: number; view: string; }[]; }; environment?: Environment; units?: UnitConfig; }

Model-level settings: ONE document-config block (USD/FBX/DXF industry pattern). Two natures of field:

content semantics: units (display/config units; internal length is ALWAYS mm — never a runtime scale conversion)
presentation state: activeView, cameraTour Permanent CONVENTIONS (never config, never fields here): Z-up world frame and internal mm — glTF-style fixed convention, zero upAxis/scale knob.

Display chord deflection is NOT a document setting — callers pass it as the optional argument to render() / tessellateFaces (engine default when omitted). Nesting owns its own separate legitimate knob.

units: optional display unit config; absent = {length:"mm"}. Read only via Model.unit (the ONE accessor — never N call-site fallbacks).
activeView: which views[] entry the 3D viewport restores on load.
cameraTour: ordered camera legs for viewer present-mode playback (host-owned; engine never plays it).
environment: the light that has no place in space — the site and the moment the sun is DERIVED from, plus the sky fill and any HDRI. A document FACT like units (Revit project location / SketchUp geo-locate), and ONE per document on purpose: a building has one sky, so this cannot be a per-view field. See Environment.

activeView?

optional activeView?: string

cameraTour?

optional cameraTour?: { legs: { duration: number; view: string; }[]; }

legs

legs: { duration: number; view: string; }[]

environment?

optional environment?: Environment

units?

optional units?: UnitConfig

MonteCarloConfig

MonteCarloConfig = { measures: MeasureConfig[]; parameters: MonteCarloParameterConfig[]; samples?: number; seed?: number; }

measures

measures: MeasureConfig[]

parameters

parameters: MonteCarloParameterConfig[]

samples?

optional samples?: number

seed?

optional seed?: number

MonteCarloParameterConfig

MonteCarloParameterConfig = { key: string; max: number; min: number; }

A named numeric range — sampled (Monte Carlo) or searched (optimize). Not the same shape as SweepParameterConfig, which walks from/to in discrete steps rather than sampling a range.

key

key: string

max

max: number

min

min: number

MonteCarloResult

MonteCarloResult = { summary: AnalyzeTable; table: AnalyzeTable; }

summary

summary: AnalyzeTable

table

table: AnalyzeTable

ObjectiveConfig

ObjectiveConfig = { expression: string; goal: "min" | "max"; }

expression

expression: string

goal

goal: "min" | "max"

Operation

Operation = { animation?: AnimationBinding; args?: Argument[]; enabled?: string; key?: string; label?: string; method: string; }

animation?

optional animation?: AnimationBinding

Numeric parameters only — this parameter's USE of a track: which formulaTrack/numberTrack in animations[] drives it (a numeric parameter is one number over time, so only the two 1-number track methods may), and on what terms. Keys are plain, not expressions: the same "just the id, no evaluation" convention a component key / skin's skeleton already use. The terms live here rather than on the track because two parameters may share one curve and disagree about them — see AnimationBinding.

args?

optional args?: Argument[]

enabled?

optional enabled?: string

Optional enable expression — falsy = this node is bypassed / emits nothing.

key?

optional key?: string

label?

optional label?: string

method

method: string

Method VALIDITY is registry-dependent (which node registries are loaded) — the schema only checks the string shape; model's validateModelJSON(json, registry) rejects unknown methods.

OptimizeConfig

OptimizeConfig = { maxEvaluations?: number; objective: ObjectiveConfig; parameters: MonteCarloParameterConfig[]; }

maxEvaluations?

optional maxEvaluations?: number

objective

objective: ObjectiveConfig

parameters

parameters: MonteCarloParameterConfig[]

OptimizeResult

OptimizeResult = { best: { params: Record<string, number>; value: number; }; trace: AnalyzeTable; }

best

best: { params: Record<string, number>; value: number; }

params

params: Record<string, number>

value

value: number

trace

trace: AnalyzeTable

Option

Option = { input: string; label: string; }

input

input: string

An expression string (model's exprSchema).

label

label: string

OrthographicCamera

OrthographicCamera = { far?: number; height: number; near?: number; }

A camera that projects through a BOX.

height is the world height visible, in the model's unit. ONE number, not four edges: left/right/top/bottom is the RENDERER's form (three.js feeds it straight to the projection matrix), while one number is the document form every other system stores — Blender ortho_scale, BCF ViewToWorldScale, glTF xmag/ymag, SketchUp height. The four edges are DERIVED, from this height plus the consumer's aspect.

A view's crop rectangle is a different subject and lives on the placement (viewObject.crop), not here.

far?

optional far?: number

height

height: number

near?

optional near?: number

PerspectiveCamera

PerspectiveCamera = { far?: number; fov: number; near?: number; }

A camera that projects through an ANGLE.

fov is the VERTICAL field of view in DEGREES. Stated here because three live conventions disagree and none of them errors at a boundary: glTF's spec is radians, three.js is degrees, and BCF's FieldOfView is HORIZONTAL degrees. Vertical degrees is the pick, stated on the type so every writer converts at its own door instead of rediscovering the question.

far?

optional far?: number

fov

fov: number

near?

optional near?: number

Sheet

Sheet = { key: string; operations: (Operation | Group)[]; parameters?: (Operation | Group)[]; template?: string; title?: string; }

A drawing sheet — an OBJECT whose space is BOUNDED. Its content is a data chain like any other; what makes it a sheet is that the chain composes into a finite rectangle of paper instead of unbounded world space. Resolving one produces Page.

Record spine is Chain with title instead of label — a deliberate divergence, kept explicit (see Chain, and TableChain which diverges the same way with columns). The reason is the title-vs-label law: a sheet's name is PRINTED, in the ISO 7200 title block's "Title" cell, so it is content, not editor chrome, and it is an expression. A second editor-chrome label beside it would be a second name for the same thing, so there is none.

key

key: string

Sheet identifier / drawing number, e.g. "A-101". Free-form (NOT generatorKeySchema) — drawing numbers contain hyphens and must stay author-facing strings. Unique within the set; also the index entry key.

operations

operations: (Operation | Group)[]

This sheet's content — lane "flat" (see model's FLAT_LANE_METHODS). A top-level viewObject node with no at arg auto-tiles into a scaled row (resolveSheet extracts these before running the rest); every other node (a positioned viewObject, tableEntity, imageEntity, or ordinary curve/point/annotation content) is authored in the SAME y-up bottom-left paper-space convention every other flat context uses, flipped once into sheet space at resolve time.

Required, like every other chain's body. A sheet with no operations is a blank page — frame, zone grid and title block and nothing else — which is a legal (if empty) drawing, and it is spelled []; undefined was a second spelling of the same nothing (the zod schema defaults it, so a document that omits the field still loads).

parameters?

optional parameters?: (Operation | Group)[]

Free params (per-sheet title-block args: date, revision, …). Paper size is on the template — leftover paperWidth/paperHeight fail loud.

template?

optional template?: string

Key of a Template. Absent = the engine's ISO 5457 default.

title?

optional title?: string

Sheet title block name, e.g. "GROUND FLOOR PLAN" — CONTENT printed on the artifact (title-vs-label law). An EXPRESSION (titleValue law): "'PLAN LEVEL ' + level" renders evaluated, a plain name stays literal.

Site

Site = { latitude: number; longitude: number; northAngle?: number; }

Where the model stands on Earth. northAngle rotates project north away from +Y, in degrees counter-clockwise looking down. Revit's project location / SketchUp's geo-locate.

latitude

latitude: number

longitude

longitude: number

northAngle?

optional northAngle?: number

SunMoment

SunMoment = { day: number; hour: number; month: number; }

The moment the sun is computed for — a document FACT (which day and hour this shadow study is about), not a clock reading: nothing here ever consults the wall clock, so the same document always produces the same shadows.

hour is LOCAL SOLAR time (12 = the sun crossing the site's meridian): shadow studies are authored against solar noon, so longitude/time-zone conversion is deliberately out of scope.

day

day: number

hour

hour: number

month

month: number

SweepConfig

SweepConfig = { measures: MeasureConfig[]; parameters: SweepParameterConfig[]; }

measures

measures: MeasureConfig[]

parameters

parameters: SweepParameterConfig[]

SweepParameterConfig

SweepParameterConfig = { from: number; key: string; steps: number; to: number; }

from

from: number

key

key: string

steps

steps: number

to

to: number

TableChain

TableChain = { columns?: Operation[]; key: string; label?: string; operations: Operation[]; }

A reporting stream — header columns (signature) + body operations (row producers + transforms), fold law same as the root body. Referenced via Table.get('key'). Chain-level provenance is banned (the imported CSV stays discoverable as its url-method parameter). Record spine is Chain with columns instead of parameters — a deliberate divergence, kept explicit (see Chain).

columns?

optional columns?: Operation[]

HEADER — one column node per column (key on the node).

key

key: string

label?

optional label?: string

operations

operations: Operation[]

BODY — row producers + verb transforms (tableFilter/Group/Sort/…).

Template

Template = { height: number; key: string; margins: number | [number, number, number, number]; operations?: (Operation | Group)[]; parameters?: (Operation | Group)[]; width: number; }

Shared paper + furniture for a family of sheets. Sheets reference a template by key (AnimationClip.tracks, FreeCAD DrawPage.Template, ArchiCAD Master Layout) — the template does not contain them.

No orientation field: 420×297 versus 297×420 already says it. margins is one number if uniform, or [left, bottom, right, top] mm.

height

height: number

key

key: string

margins

margins: number | [number, number, number, number]

operations?

optional operations?: (Operation | Group)[]

Drawn furniture (frame, zone grid, title-block placeComponent). Nested groups keep a polyline with its applyAttribute stamps.

parameters?

optional parameters?: (Operation | Group)[]

Shared furniture args (project name, client) — value methods.

width

width: number

UnitConfig

UnitConfig = { area?: AreaUnit; length: LengthUnit; mass?: MassUnit; volume?: VolumeUnit; }

Runtime unit config — SSOT shape for settings.units.

area?

optional area?: AreaUnit

length

length: LengthUnit

mass?

optional mass?: MassUnit

volume?

optional volume?: VolumeUnit

UnitType

UnitType = "length" | "area" | "volume" | "mass"

Unit dimension keys (matches RawData in core/UnitSymbols).

ViewFilterOverride

ViewFilterOverride = { color?: string; halftone?: boolean; lineStyle?: LineStyle; lineWidth?: number; }

Per-rule graphic override — rides the same channel per-layer graphics ride: color/lineStyle/lineWidth win over the document's layer/material lookup. halftone renders at a fixed reduced opacity.

color?

optional color?: string

halftone?

optional halftone?: boolean

lineStyle?

optional lineStyle?: LineStyle

lineWidth?

optional lineWidth?: number

ViewFilterRule

ViewFilterRule = { equals?: string | string[]; key: string; notEquals?: string | string[]; override?: ViewFilterOverride; }

One AND-combined test against a field of a data document — key "layer" and "material" read the ENTITY ROW's own lane reference (rowLayerOf / rowMaterialOf; no *Data carries one), any other key reads attributes[key]. equals/notEquals accept a single value OR an array (any-of / none-of). override applies a graphic override to every document the rule matches.