readData(name: string) → any

parity( ) → any

The parity data: `{ entries, tolerance, cases }`. One entry per current op. Its `cases` are the cases that name only content the library ships; `cases()` adds the ones the suites state beside them.

suiteCases(suite: string) → void

The cases a suite states in the `cases.json` beside it, or nil when the library holds no such file.

cases( ) →

Every case the harness runs: the `cases` of `parity.json`, and the cases each suite of `suites()` states in the `cases.json` of its folder (`{ "cases": { "<op>": case } }`). A suite states there the cases whose inputs are its test fixtures, content its test runs hold and the library ships nowhere, so an engine whose library holds that suite runs them and one whose library leaves it out finds no stated case for those ops. An op has one case: an op both files state, or two suites state, raises.

sheet( ) → any

The composition sheet's expectations: ops, kernels, layers, rows.

listDir(path: string) → void

stripSuffix(name: string, suffix: string) → string

readText(path: string) → string

newSlice( ) → void

walkFiles(path: string, between: () → void

Every file below `path`, as `{ path, name }`.

familyOf(name: string) → string

The kernel family a kernel asset belongs to: an asset `<kernel>_<pass>` belongs to the family `<kernel>` the sheet names (the longest sheet family that is the asset's name or its prefix before an underscore). An asset no sheet family claims is its own family, which the sheet's count then refuses.

libraryBoxes( ) → void

The nodeboxes of the built-in library, as `{ name, path }` sorted by path: a box answers to its registered asset, so a box a package moves stays in the scan.

scan( ) → any

What the library holds of the new parts: the nodes of every built-in nodebox (by id), kernel families (a family is the set of kernel assets `<kernel>` and `<kernel>_<pass>`), shader modules, the ops of `abi.procPack`, every `.wgsl` file inside a nodebox, and every module that sits beside nodes in a nodebox. where `kernels` maps a family to the path of its first asset and `passes` maps a family to the names of its assets.

resolve(scan: any, id: string) →

The nodes of the package a new id names. `box.*` names every node of a box; an id names the node of that nodebox and folder, or the one an underscored folder name finds.

tokenize(src: string) → void

digest(source: string) → string

Two polynomial hashes over a string, joined: a 16 hex digit name for a structure.

familyIn(families: { [string]: any }, name: string) → string

The family a kernel asset name belongs to among `families` (a table keyed by family name): the name itself, or the longest family it extends with `_<pass>`.

analyze(src: string, kernelNames: { [string]: any }, opNames: { string }, graphWords: { string }) → Analysis

A static reading of a node's source: the nodes it calls (`g.<name>(...)`), the ops it names (`op.<name>`), the kernel families it names (a path or an identifier through `kernels`; a pass asset `<kernel>_<pass>` names its family `<kernel>`), and every call as a structural hash that reaches the node's leaves (inputs and literals) with its size in calls.

isOp(t: Token?, text: string) → boolean

parseArgs(close: string) → void

parseTable( ) → void

skipFunction( ) → void

callTail(head: string, size: number) → void

parsePrimary( ) → void

parseUnary( ) → void

parseExpr( ) → void

wgslIn(src: string) →

The WGSL text a source carries in its string literals, as the markers found.

matchesPattern(pattern: string, id: string) → boolean

Dependencies of every node, against the sheet

rowOf(sheet: any, node: Node) → any

The sheet row a node belongs to, or nil.

isL2Id(sheet: any, id: string) → boolean

Whether a node id sits in one of the L2 nodeboxes (`core`, `math`, `io`).

allowedUse(sheet: any, row: any, id: string) → boolean

A call to a node outside the L2 nodeboxes is a node composed of nodes and is free (L3 nodes call each other freely); a call to an L2 node must be one the row lists, or one every row may use (`universalUses`).

dependencies(scan: any, node: Node) → any

A node's recorded dependencies, read from its source. `direct` is whether the node calls `op.device.kernel` itself.

operatorTemplates(src: string) → number

Number of `template = { op = ... }` tables a source builds: a math operator handed to the `map` kernel as its own dispatch.

wgslSpecializations(src: string) →

The WGSL text a source hands to a kernel inside a `specialize` table: a string that is a statement, a block or an include rather than a type, an operator or a mode name.

dispatchViolations(scan: any, node: Node) →

What the sheet's rules about a node's dispatch refuse: a math operator handed to `map` as its own dispatch (math over fields and columns answers a fused template), a `math` node that calls `op.device.kernel` at all, and WGSL text inside a specialization.

directCallers(scan: any) →

The nodes above L2 that call `op.device.kernel` themselves, read from their sources.

rowViolations(scan: any, node: Node) →

What a node's recorded dependencies break of its sheet row: the kernel families, nodes and ops outside the row, an L2 node it calls that the library does not hold, an `op.device.kernel` call above L2 that names no kernel of the row (a row marks the nodes that run an author's kernel with `authorKernel`), and a single-kernel node the sheet does not name.

sharedSubgraphs(scan: any) →

Sub-graphs that two nodes hold identically: a call whose structural hash (its callee and arguments down to inputs and literals) and size are equal in two different nodes, at `MIN_SHARED_CALLS` calls or more.

kernelsUsed(sheet: any, deps: any) →

The kernel families a node uses: the ones its source names, and the family the field compiler runs a Field template through (`fieldMath.kernel` of the sheet) when the node calls a node of a `fieldMath.boxes` nodebox, whose nodes answer Field templates the consumer evaluates in one dispatch of that family.

reported(scan: any) → any

The numbers the sheet states, measured on the package: ops registered by the abi pack, kernel families present, nodes, the share of nodes built from nodes alone (no kernel and no op named), how many nodes use each kernel family (named in the source, or reached through field math, `kernelsUsed`) and each core node, the nodes above L2 that call `op.device.kernel` themselves, and the modules that sit beside nodes.

suitesCalling( ) →

Which existing suites name each current op by id (a quoted `"op.id"`).

opsOfSource(src: string, known: { [string]: boolean }) → void

graphs( ) →

Every graph the library carries (`.procGraph`, `.procNode`) with the current ops it names; a graph is read from its `graph.json` or its source.

assess(scan: any, entry: any) →

Where a parity entry stands: `decided` (a named decision), `unmapped` (the sheet names no counterpart), `pending` (its new node does not exist yet) or `ready` (every new node exists and the comparison can run).

isGeometry(v: any) → boolean

Running both sides

release(v: any) → void

runOp(opId: string, inputs: any, params: any) → any

deepCopy(value: any) → any

findAsset(category: string, identity: string) → any

The reference to the asset of a category that states an identity (`@builtin::meshes.cube`), found in the list of that category: one literal category per call site.

withRefs(value: any) → any

A value of a case in which `{ reference = "<identity>", category = "<asset category>" }` stands for the reference to that asset, where the data states one: an op or node that takes a reference to an asset is given it.

mesh( ) → void

points( ) → void

curve( ) → void

positionField( ) → void

newNodeFor(op: string) → Node

buildInputs(specs: any, side: string?) → void

buildFixture(spec: any, side: string?) → void

A fixture states how one input value is made: a name from `FIXTURES`, a current op run on its own fixtures (`{ op, params, inputs, output }`), a list (`{ list = { ... } }`), a record (`{ record = { key = ... } }`) or a literal (`{ value = ... }`).

fixtureSpecFor(typeName: string) → any

The fixture a socket of a given type takes when its case states none: `types` of `parity.json` by the full lowercase type, its first alternative, or its base name.

caseFor(entry: any) →

The inputs and params one comparison runs under: the entry's own case in `cases()` when one is stated, else the op's defaults with one fixture per required input socket (the `types` table of `parity.json` by the socket's type). A case states `params`, `fixtures` by socket (a fixture spec), `node` (the new node a multi-node entry compares against), `sink` (`asset` or `handles`: the op writes to the world, each side under its own name) and `ignore` (output names left out of the comparison), `suite` and `describe` (the op has no direct call, being a solver over a timeline: the group of an existing suite that holds its comparison stands for it), `world` (`{ entities = { spec, ... } }`: entities spawned for the run and removed after it; `scene` takes the test run's root scene, `settle` waits until the op runs on them) and `rename` (`{ inputs, params, outputs }`, each a table from the op's name to the new node's, for a node whose sockets are named differently).

build( ) → void

build(side: string?) → void

readOutputs(old: any) → void

renamed(rename: any?, kind: string, name: string) → string

A name through a case's `rename` table: `rename[kind][name]` when stated, else the name.

renameKeys(rename: any?, kind: string, values: any) → any

The table of values an op takes, keyed by the new node's names through a case's `rename`; a name the table maps to `false` is left out.

runNode(node: Node, output: string, inputs: any, params: any) → any

Run a new node on inputs: the node's graph is loaded and evaluated for the output named `output`, the op's params wired as inputs beside the sockets.

isShapeRecord(value: any) → boolean

Whether a value a node answered is a shape: a field of space with the box it lies in.

shapeAsValue(record: any) → any

The op's Sdf value answers its distance at a point. A node's shape answers the same, by evaluating its field of space on the device over a Geometry of that one point; a box that reaches no limit is the op's unbounded shape.

distance(x: number, y: number, z: number) → number

nodeAsOp(node: Node, outputs: { string }, rename: any?, base: any?, label: string?) → any

A stand-in for the registry's op definition that runs a new node when the op is called by id: what a current test's `registry.get(op).eval(...)` reaches. outputs: what a graph that names the op reads to wire and evaluate it). A socket the op declares `lazy` reaches the node as a value cooked only when the node reads it. The params of a call are held to its declarations first, as the registry holds a call of the op. answered as the op's Sdf value, whose distance at a point reads that field there, and a shape handed back in as an input goes in as the field it was. A number the node answers for an output the op declares `Bool` is answered as true or false: true for any number but 0.

eval(ctx: any, inputs: any, params: any) → void

redirect(map: { [string]: any }, fn: () →

Call `fn` with `registry.get` answering the new node's stand-in for each id in `map`, so a current test that calls an op by id runs on its new node; the registry is restored afterwards, whatever `fn` does.

get(id: string) → void

readColumn(col: any) → void

liveCountOf(g: any, domain: string) → number

How many elements of a domain are live. A compaction or an append allocates a domain's runs at a capacity (`count`) and keeps its live elements in front, with the live count on the device; a domain without one holds live elements throughout.

liveRun(values: { number }, capacity: number, live: number) → void

The live front of a read column: `live` elements of the `capacity` the domain holds, every lane of each.

maxDiff(a: { number }, b: { number }) → number

boundsOf(g: any) → any

boundsDiff(a: any, b: any) → number

pointSilhouettes(g: any, lo: any, hi: any) → void

triangleArrays(g: any) → any

The triangles of a geometry read off its columns: its point positions, normals and texture coordinates, and the points of every triangle (a primitive of more corners fanned from its first). Nil when it holds none.

numbers(class: string, name: string) → void

silhouettes(g: any, lo: any, hi: any) → void

unionBounds(a: any, b: any) → void

overlap(a: { { boolean } }, b: { { boolean } }) → number

groupMarkers(g: any, legacy: boolean) → void

The groups a geometry holds, as `<class>.<name>`. The old library kept an index record (`detail.__groups`, class -> { name -> true }); the new one marks each group with a detail attribute `__group.<class>.<name>`.

isColumn(v: any) → boolean

isField(v: any) → boolean

fieldValues(field: any, side: string?, n: number) → void

The values a Field takes: over the Geometry its side was given, else at its first `n` elements. The one entry point every Field is read by.

compareGeometry(old: any, new: any, tol: any, out: Findings, mode: string?) → void

`mode` is the case's `compare`: "bounds" holds a Geometry to its bounds alone (an output whose element layout differs by design, such as an indexed mesh against its per-corner expansion).

reason(err: any) → string

What an error says, whether it is a string or a table the evaluator raised.

asNumbers(v: any) → void

The numbers a vector-like value holds: a Luau vector, a record `{ x, y, z, w }` or `{ r, g, b, a }`, or an array of numbers. Nil for anything else (a plain number is not vector-like).

isOldRaster(v: any) → boolean

A raster of the current library (`Raster`: a grid and layers held in tiled buffers) and one of the new library (a record of cell counts and a Geometry of layer columns, x fastest within a tile).

isNewRaster(v: any) → boolean

rasterLayers(r: any) → void

The names of the layers a raster holds.

layerValues(scan: any, r: any, layer: string) → void

One layer of a raster as a flat run of its cells, x fastest then z: the current library samples it at the grid's own cell centres, the new library reads it through `core.raster.read`.

compareRasters(scan: any, old: any, new: any, tol: any, out: Findings, path: string) → void

Two rasters are the same ground when they cover the same cells and each layer the current raster holds reads the same value in every cell on the new raster. A layer the new raster does not hold is a missing attribute.

isTexture(v: any) → boolean

texelsOf(t: any) → void

The texels a texture holds as 0 to 1 channels, and whether they were whole bytes: the current library keeps a generated texture as bytes (`data`), a texture of a raster as floats in a buffer or on the device (`staging`); the new library keeps `texels` as a column of floats.

compareTextures(old: any, new: any, tol: any, out: Findings, path: string) → void

Two textures are the same image when they have the same size and channel count and their texels agree. The carrier each library keeps them in (bytes or floats, a descriptor, a staging buffer) is not what is compared.

instanceCount(v: any) → number

The instances a population stands for: the current library keeps them as a `Population` (one recipe per draw, each with its count), the new library as the instanced points themselves.

isAnimated(v: any) → boolean

compareValue(old: any, new: any, tol: any, out: Findings, path: string, mode: string?) → void

numbersOf(v: any) → void

The numbers a value reads as: a number, a Field or a Column.

compareRamps(scan: any, old: any, new: any, tol: any, out: Findings, path: string) → void

Two ramps are the same ramp when each reads the same value at the same positions: the record a ramp is stored as differs by design, the values it answers do not.

pointsOf(g: any) → void

Invariants of the `meaning` class.

closedVolume(g: any) → void

key(v: number) → string

roundedTo(x: number, places: number) → number

orientedTriangles(g: any) → void

The oriented triangles of a geometry, each as the position, normal and texture coordinate at its three corners, turned to start at its least corner, in a sorted list: two geometries that hold the same triangles give the same list whatever order their points, corners and primitives stand in.

corner(i: number) → string

same_oriented_triangles(old: ?, new: ?, _inv: ?, _params: ?, _tol: ?) → void

The two outputs hold the same oriented triangles: the same number of them, each corner at the same position with the same normal and texture coordinate, wound the same way. The numbering of points, corners and primitives is not part of it.

shape(old: ?, new: ?, _inv: ?, _params: ?, tol: ?) → void

min_distance(old: ?, new: ?, inv: ?, params: ?, _tol: ?) → void

weld_pairs(old: ?, new: ?, inv: ?, params: ?, _tol: ?) → void

counts_within(old: ?, new: ?, inv: ?, _params: ?, _tol: ?) → void

closed_manifold(old: ?, new: ?, inv: ?, _params: ?, _tol: ?) → void

filled_level(old: ?, new: ?, inv: ?, _params: ?, tol: ?) → void

A lake is the basin its seed sits in, filled to a level: the water surface stands at the same height over the cells it wets, and the wet extent (the cells `waterMask` holds above one half) is the same size within a tolerance (the flood of the new library is bounded by its sweeps).

lake(raster: any) → void

invariantKinds( ) →

The invariant kinds this module evaluates.

differences(old: any, new: any) →

What differs between two values by the parity tolerances: counts, attribute values, bounds and picture for a Geometry, deep equality for the rest.

invariant(kind: string, old: any, new: any, invariant: any, params: any) →

Evaluate one invariant of the `meaning` class on a pair of outputs.

median(values: { number }) → number

cost(fn: () → void

releaseDeep(v: any, depth: number) → void

releaseAll(values: any) → void

sidedParams(case: any, side: string, opId: string) → any

The params one side of a sink case runs under: the case's own, with its asset name made distinct and its folder the sandbox.

filesOf(ref: any) → void

companionsOf(ref: any, base: string) → void

The names of the assets that sit beside a written asset and start with its base name, as the remainder after the base: the companions (meshes, populations) a write leaves next to it.

compareSink(path: string, old: any, new: any, bases: { old: string, new: string }, findings: Findings, cleanups: { () → void

Compare what a sink wrote or spawned: an asset by its type, its files and its companions, spawned entities by their count. Whatever the sink made is queued for removal.

covered(row: any) → boolean

ignored(case: any, name: string) → boolean

spawnWorld(case: any, cleanups: { () → void

Spawn the entities a case stands on (`world.entities`, each an `entity.spawn` spec) and queue their removal. A case that states `world.settle` waits, a frame at a time, until the current op runs on what was spawned.

compareBySuite(case: any) → any

An entry whose current op is a solver has no direct call: a suite that holds the comparison of the op beside its node, under one group (`describe`), stands for it. The suite runs once; the entry passes when every case of the group passes.

compareSdfs(scan: any, old: any, new: any, tol: any, out: Findings, path: string) → void

compareMaterialValue(was: any, now: any, tol: any, out: Findings, path: string, depth: number) → void

A Material the current library keeps as `{ albedo, metallic, roughness, emissive }` against the new one's `{ shader, properties = { base_color, metallic, roughness, emissive }, textures }`. A value of a material's record against the other side's: numbers within the attribute tolerance, tables entry by entry (to a depth), anything else by its text.

compareShaderMaterials(old: any, new: any, tol: any, out: Findings, path: string) → void

A material made from a surface shader holds its shader, the properties and textures it sets by name, and the render state it states; each is compared as the two sides hold it.

compareMaterials(old: any, new: any, tol: any, out: Findings, path: string) → void

firstGeometry(inputs: any) → any

The first Geometry among a case's inputs, by input name.

frameMs( ) → number

phase(fn: () → void

Run `fn` and state what it cost: wall time, the part of it spent in `task.wait` (a read-back's frames), the CPU time left over, the frames that passed, the read-backs the substrate counted and the device dispatches `fn` queued.

measureNode(node: Node, output: string, case: any) → any

What a node costs on a case, as separate numbers, from one evaluation of its graph. The evaluator plans the graph and cooks the planned nodes in step (a plan value that is a count or a list is cooked for), and counts the CPU time each node's cook spends in `stats.ms` and the read-backs each cook makes in `stats.placement`. The time in `task.wait` (`waitMs`) is a read-back's frames; it is shared between the cooks and the plan by the read-backs each made, so `cookMs` is the cooks' time with their share of the waiting taken out, and `planMs` is the rest of the evaluation (expanding the call form, lowering refs and constructs, scheduling the cooks) with the plan's share taken out. `frames` is the frames that passed, `readbacks` the read-backs the substrate counted and `dispatches` the device dispatches queued. Times are the median of `COST_RUNS` runs; counts are the last run's.

readbackBudget(op: string, fallback: number) → number

The read-backs a node may make: the number `parity.json` states for it under `budgets`, else what the current op makes.

runComparison(scan: any, entry: any, cleanups: { () → void

compare(scan: any, entry: any) → any

Run one entry's comparison: the current op and the new node on the same inputs. An `exact` entry compares counts, attribute values, bounds and a picture; a `meaning` entry checks its invariant; both compare cost. A sink entry (the case states `sink`) writes each side under its own name and compares what was written or spawned; what the sink made is removed afterwards. The result is also held in `M.results[entry.op]`.

accepting(entry: any, result: any) → any

An entry that states `decided` (the ruling that accepts the difference between the current op and its node) keeps running; the value differences it finds move from the result's findings to `accepted`, where they are reported and held to nothing. A node that raised, an input that could not be made and the cost findings stay findings. entry states one and a value difference stood.

valuesHold(result: any?) → boolean

Whether a comparison answered and found no value difference: the node ran on the case's inputs and answers what the current op answers (or what an entry's `decided` ruling accepts). A cost finding does not count; the cost is the other verdict.

verdict(assessed: string, result: any?) →

What a comparison found, as two verdicts that are never read as one. `value` is `equal` (every value the current op answers is answered by the node), `differ` (a value differs, or a count, a bound or a layout), `missing` (an attribute, a layer or a column the current op answers is not on the new output), `raised` (the new node failed on the inputs the current op took), `harness` (the case's inputs could not be made, or the current op refused them), `skipped` (the new node does not exist yet, the sheet names no counterpart, or a suite holds the comparison) or `decided` (a named decision with nothing to compare, or a comparison whose value differences an entry's `decided` ruling accepts: they stand in `result.accepted`). `cost` is `within`, `over` (the cook or its read-backs exceed what the tolerances allow) or `none` (nothing was measured).

family(entry: any) → string

The family an entry is reported under: the nodebox of its first new node, else (a named decision, or an op the sheet names no node for) the prefix of the current op.

summary(scan: any, entries: { any }?) → any

The state of every entry as this run compared it, counted two ways: `counts` puts each entry under exactly one of `pass` (values equal, cost within), `costOver` (values equal, cost over), `differ`, `missing`, `raised`, `harness`, `skipped` and `decided` (a case whose values differ is counted under `differ` whatever it costs; `raised` and `harness` take precedence over `differ`, which takes precedence over `missing`), and `families` holds the same numbers per family with the median and the worst cost ratio (the new cook's CPU time over the current op's, at least 0.01 ms) of the cases that measured one.

decidedLines(summary: any) →

The accepted differences of a summary: one sentence per entry whose `decided` ruling accepted a difference this run found, with the ruling and the first differences.

summaryOfRows(rows: { any }) → any

The counts and the per-family numbers of `summary`, from rows `{ op, family, value, cost, ratio }` a summary gave, or that `leftRows` read back.

leaveRows(suite: string, summary: any) → void

Leave the rows of a suite's summary where `leftRows` finds them, replacing what the suite left before.

leftRows( ) →

The rows every parity suite left (`leaveRows`).

clearLeftRows( ) → void

Remove what the parity suites left.

summaryLines(summary: any) →

A summary as the lines a report states: the eight counts, then one line per family with its cases, those counts and the median and worst cost ratio.

unsettledLines(summary: any) →

The entries of a summary that are not settled: one sentence each with the family, the two verdicts and the cost ratio. An entry that is skipped or decided, or whose values are equal at a cost within, is settled.

checkCase(entry: any) →

Whether the current op accepts the case an entry states: the case's inputs are made and the op runs on them, and what it answered is released. A sink entry's op writes under its own sandbox name, which is removed afterwards.

suites( ) →

The suites that hold the per-op comparisons, each with the families (`family`) it answers for: the `suites` table of `parity.json`.

entriesOf(suite: string) →

The parity entries one suite answers for: those whose family (`family`) its `suites` row names, in the order `parity.json` states them.

onNodesSuites(suite: string, called: { string }) →

The existing suites one of the on-nodes suites runs: the suites the `onNodes` table of `parity.json` names for it, or, for a suite it names no row for, every existing suite that calls an op and no row names (`onNodesLeft` names the suites no on-nodes suite runs: each compares an op to its own node, so on the nodes both sides are nodes).

refusedCases(entries: { any }) →

Whether the current op accepts the case of every entry given (`checkCase` for each).

standIns(scan: any, ops: { string }?) →

The stand-ins that make a current test reach the new nodes: one op-definition-shaped table per entry whose new node exists, answering the outputs the current op has.

summarize(outcome: any) → any

runSuite(suite: any, redirect: { [string]: any }?) → any

Run one existing suite's test cases through the test framework's own runner (the suite asset's `run`, the same envelope a suite run from another suite gets), with `registry.get` answering the stand-ins in `redirect` for the op ids they name. The runner of the suite around the call is put back afterwards. `group > test` and `byDescribe` holding the counts and failures of each group (`describe`) of the suite.

runSuiteOnNodes(scan: any, name: string, ops: { string }) → any

An existing suite run with every op of `ops` that has a new node answered by that node, and, when that run fails a case, as it stands. The cases the redirected run fails and the plain run passes are the cases the new nodes break.

report(opts: { run: boolean? }?) → any

Every current op with its new composition and where it stands, plus the suites that call it, and every library graph with the worst state among its ops. `byClass` counts them by class (`exact`, `meaning`, `gone`, `unmapped`) and state.