@woosh/meep-engine 3.24.0 → 3.25.0

package/src/shade/renderer/buffer/table/GPUReadbackStagingRing.d.ts

@@ -1,96 +0,0 @@
-/**
- * Persistent, mappable buffers for reading GPU data back — a ring, so that a batch may be in flight
- * while the next one is recorded.
- *
- * The pattern is {@link GPUTimerArray}'s: buffers created once and kept, rather than a fresh
- * `MAP_READ` buffer created, copied into, mapped and destroyed per read, which is what
- * {@link inspect_via_copy} does and is the reason it is a debug affordance. Buffer creation is not
- * free, and a per-call one also means the allocator sees a new lifetime on every read.
- *
- * Slots never shrink. A ring sized by the busiest frame of a session stays that size, which is a
- * bounded cost measured in the largest batch, and the alternative is recreating buffers as the
- * request count breathes.
- *
- * @see GPUDatabaseReadback
- */
-export class GPUReadbackStagingRing {
-    /**
-     * @param {GPUDevice} device
-     * @param {Object} [options]
-     * @param {number} [options.frames_in_flight] slot count
-     * @param {string} [options.label]
-     */
-    constructor(device: GPUDevice, { frames_in_flight, label, }?: {
-        frames_in_flight?: number;
-        label?: string;
-    });
-    /**
-     * Number of slots, which is how many batches may be in flight at once.
-     *
-     * @returns {number}
-     */
-    get size(): number;
-    /**
-     * Bytes currently held across every slot. Zero until the first batch, because a database that is
-     * never read back must not pay for the machinery that would read it.
-     *
-     * @returns {number}
-     */
-    get byte_size(): number;
-    /**
-     * Take a slot able to hold `byte_size`, growing its buffer if it is too small.
-     *
-     * @param {number} byte_size
-     * @returns {GPUReadbackStagingSlot|null} `null` when every slot is still in flight. That is not
-     * an error — it means readbacks are being requested faster than they are being read, and the
-     * caller's correct response is to leave the requests queued for the next frame rather than to
-     * overwrite bytes something is still reading
-     */
-    acquire(byte_size: number): GPUReadbackStagingSlot | null;
-    /**
-     * Give a slot back. Its buffer stays.
-     *
-     * @param {GPUReadbackStagingSlot} slot
-     */
-    release(slot: GPUReadbackStagingSlot): void;
-    destroy(): void;
-    #private;
-}
-/**
- * One slot of a {@link GPUReadbackStagingRing}.
- */
-declare class GPUReadbackStagingSlot {
-    /**
-     * `MAP_READ | COPY_DST`, which is the only pair WebGPU allows a mappable read buffer — so this
-     * is a copy destination and nothing else. A shader that wants to write gathered data writes a
-     * storage buffer, which is then copied here.
-     *
-     * @type {GPUBuffer|null}
-     */
-    buffer: GPUBuffer | null;
-    /**
-     * @type {number}
-     */
-    index: number;
-    /**
-     * Where a mapping of this slot is copied to, so that the GPU buffer can be unmapped at once and
-     * the bytes still be there at the apply point.
-     *
-     * Lives on the slot rather than on the batch: a slot holds one batch at a time, so this is one
-     * allocation per slot per high-water mark instead of one per frame. The owner sizes it.
-     *
-     * @type {Uint8Array|null}
-     */
-    cpu_bytes: Uint8Array | null;
-    /**
-     * Whether the slot has been handed out and not yet given back. The ring will not hand out a
-     * busy slot, which is the whole reason it has more than one: a batch is copied into one slot in
-     * the frame that encodes it and mapped a frame or more later, and reusing it in between would
-     * overwrite the bytes being read.
-     *
-     * @type {boolean}
-     */
-    busy: boolean;
-}
-export {};
-//# sourceMappingURL=GPUReadbackStagingRing.d.ts.map

package/src/shade/renderer/buffer/table/GPUReadbackStagingRing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GPUReadbackStagingRing.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUReadbackStagingRing.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;GAcG;AACH;IAyBI;;;;;OAKG;IACH;QAH4B,gBAAgB,GAAjC,MAAM;QACW,KAAK,GAAtB,MAAM;OAqBhB;IAED;;;;OAIG;IACH,mBAEC;IAED;;;;;OAKG;IACH,wBAYC;IAED;;;;;;;;OAQG;IACH,mBANW,MAAM,GACJ,sBAAsB,GAAC,IAAI,CA6BvC;IAED;;;;OAIG;IACH,cAFW,sBAAsB,QAOhC;IA0BD,gBAWC;;CACJ;AA3ND;;GAEG;AACH;IACI;;;;;;OAMG;IACH,QAFU,YAAU,IAAI,CAEV;IAEd;;OAEG;IACH,OAFU,MAAM,CAEL;IAEX;;;;;;;;OAQG;IACH,WAFU,UAAU,GAAC,IAAI,CAER;IAEjB;;;;;;;OAOG;IACH,MAFU,OAAO,CAEJ;CAChB"}

package/src/shade/renderer/scene/InstanceBatch.d.ts

@@ -1,92 +0,0 @@
-/**
- * @typedef {import("../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
- * @typedef {import("./Mesh.js").Mesh} Mesh
- * @typedef {import("./Node3D.js").Node3D} Node3D
- */
-/**
- * The renderable side of a {@link Scene} — every {@link Node3D} that the
- * GPU's `transforms` table needs a row for, plus the cached mesh-only
- * filter rendering iterates.
- *
- * Storage is a flat `Node3D[]`. Anything `Mesh`-shaped feeds the
- * {@link instances} view (the renderable subset); everything else (anchor
- * rigs, attachment points, future skeleton joints) still earns a row in
- * the GPU scene-graph because the propagation pass needs to walk the
- * whole hierarchy regardless of which nodes happen to carry geometry.
- *
- * Lights live in {@link Scene.lights}, separately, and are not added
- * here — they have their own GPU pipeline that doesn't share the
- * `transforms` table.
- */
-export class InstanceBatch {
-    /**
-     * Set of all materials used in this scene.
-     * Primarily useful for rendering.
-     * @type {ShadeMaterial[]}
-     */
-    get materials(): import("../material/ShadeMaterial.js").ShadeMaterial[];
-    /**
-     *
-     * @param {boolean} v
-     */
-    set needsUpdate(v: boolean);
-    /**
-     *
-     * @return {number}
-     */
-    get version(): number;
-    /**
-     * The mesh-only subset of {@link nodes} — what the rasterization
-     * pipeline iterates. Cached so repeated calls within the same
-     * version are O(1).
-     *
-     * @returns {Mesh[]}
-     */
-    get instances(): import("./Mesh.js").Mesh[];
-    /**
-     * Every node in the batch — the input the GPU scene-graph propagation
-     * pass iterates. Order is insertion order; {@link instances} is
-     * a stable subset.
-     *
-     * @returns {Node3D[]}
-     */
-    get nodes(): import("./Node3D.js").Node3D[];
-    /**
-     * Add a node. Accepts any {@link Node3D} — meshes, anchors, future
-     * skeleton joints. Meshes will additionally appear in
-     * {@link instances} (cached).
-     *
-     * @param {Node3D} node
-     */
-    add(node: Node3D): void;
-    /**
-     *
-     * @return {AABB3}
-     */
-    get bounding_box(): AABB3;
-    /**
-     *
-     * @returns {number}
-     */
-    computeTriangleCount(): number;
-    /**
-     * Remove a node (mesh or otherwise). Returns true if the node was
-     * found and dropped.
-     *
-     * @param {Node3D} node
-     * @returns {boolean}
-     */
-    remove(node: Node3D): boolean;
-    hash(): number;
-    /**
-     *
-     * @param {InstanceBatch} other
-     */
-    equals(other: InstanceBatch): boolean;
-    #private;
-}
-export type ShadeMaterial = import("../material/ShadeMaterial.js").ShadeMaterial;
-export type Mesh = import("./Mesh.js").Mesh;
-export type Node3D = import("./Node3D.js").Node3D;
-import { AABB3 } from "../../../core/geom/3d/aabb/AABB3.js";
-//# sourceMappingURL=InstanceBatch.d.ts.map

package/src/shade/renderer/scene/InstanceBatch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"InstanceBatch.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/InstanceBatch.js"],"names":[],"mappings":"AAKA;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IAyCI;;;;OAIG;IACH,wEAcC;IAED;;;OAGG;IACH,4BAMC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;;;OAMG;IACH,4CAeC;IAED;;;;;;OAMG;IACH,4CAEC;IAGD;;;;;;OAMG;IACH,UAFW,MAAM,QAShB;IAED;;;OAGG;IACH,0BAoBC;IAED;;;OAGG;IACH,wBAFa,MAAM,CAclB;IAED;;;;;;OAMG;IACH,aAHW,MAAM,GACJ,OAAO,CAWnB;IAED,eAEC;IAED;;;OAGG;IACH,cAFW,aAAa,WAIvB;;CAEJ;4BApOY,OAAO,8BAA8B,EAAE,aAAa;mBACpD,OAAO,WAAW,EAAE,IAAI;qBACxB,OAAO,aAAa,EAAE,MAAM;sBALnB,qCAAqC"}

package/src/shade/renderer/scene/Mesh.d.ts

@@ -1,55 +0,0 @@
-/**
- * @typedef {import("../geometry/MeshletGeometry.js").MeshletGeometry} MeshletGeometry
- * @typedef {import("../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
- */
-export class Mesh extends Node3D {
-    /**
-     *
-     * @param {MeshletGeometry} geometry
-     * @param {ShadeMaterial} material
-     * @param {number[]|Float32Array|Float64Array} [transform] 4x4 affine matrix, column-major
-     * @return {Mesh}
-     */
-    static from(geometry: MeshletGeometry, material: ShadeMaterial, transform?: number[] | Float32Array | Float64Array): Mesh;
-    /**
-     * @type {MeshletGeometry}
-     */
-    geometry: MeshletGeometry;
-    /**
-     * @type {ShadeMaterial}
-     */
-    material: ShadeMaterial;
-    /**
-     * World-space AABB
-     * @type {Float32Array}
-     */
-    bounding_box: Float32Array;
-    /**
-     *
-     * @type {Float32Array}
-     */
-    bounding_sphere: Float32Array;
-    /**
-     *
-     * @returns {Mesh}
-     */
-    clone(): Mesh;
-    /**
-     *
-     * @param {Mesh} other
-     */
-    copy(other: Mesh): void;
-    /**
-     *
-     * @param {Mesh} other
-     * @returns {boolean}
-     */
-    equals(other: Mesh): boolean;
-    updateBoundsBasic(): void;
-    updateBoundsTight(): void;
-    isMesh: boolean;
-}
-export type MeshletGeometry = import("../geometry/MeshletGeometry.js").MeshletGeometry;
-export type ShadeMaterial = import("../material/ShadeMaterial.js").ShadeMaterial;
-import { Node3D } from "./Node3D.js";
-//# sourceMappingURL=Mesh.d.ts.map

package/src/shade/renderer/scene/Mesh.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/Mesh.js"],"names":[],"mappings":"AAUA;;;GAGG;AAEH;IA2HI;;;;;;OAMG;IACH,sBALW,eAAe,YACf,aAAa,cACb,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GACjC,IAAI,CAoBf;IAnJD;;OAEG;IACH,UAFU,eAAe,CAEhB;IAET;;OAEG;IACH,UAFU,aAAa,CAEd;IAET;;;OAGG;IACH,cAFU,YAAY,CAEa;IAEnC;;;OAGG;IACH,iBAFU,YAAY,CAEgB;IAEtC;;;OAGG;IACH,SAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,YAFW,IAAI,QAiBd;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAQnB;IAQD,0BAOC;IAED,0BAqCC;IA+BL,gBAAqB;CAHpB;8BAzJY,OAAO,gCAAgC,EAAE,eAAe;4BACxD,OAAO,8BAA8B,EAAE,aAAa;uBAJ1C,aAAa"}

package/src/shade/renderer/scene/Node3D.d.ts

@@ -1,159 +0,0 @@
-/**
- * Note that hierarchy only exists on the CPU side
- * The only transform that GPU will see is the {@link transform_global}
- */
-export class Node3D {
-    /**
-     * Stable numeric id, unique across every Node3D instance (meshes,
-     * lights, scenes, anchors) — tied to the JS object's identity, not
-     * its position in any array. A node in a scene is bound to its rows
-     * through the object itself (`GPUSceneContext.node_rows`).
-     *
-     * @type {number}
-     * @readonly
-     */
-    readonly id: number;
-    /**
-     * Human-readable name
-     * @type {string}
-     */
-    name: string;
-    /**
-     * Bumped by {@link updateMatrices}. The renderer compares it against the version it last
-     * uploaded for this node's row, so a node that has not moved since the previous frame costs
-     * nothing beyond the comparison — that is what keeps per-frame scene upkeep proportional to
-     * what changed rather than to scene size.
-     *
-     * A caller that mutates `transform_local` without calling {@link updateMatrices} leaves
-     * `transform_global` stale, and this counter says so: both are derived, and neither is
-     * refreshed until the call is made.
-     *
-     * @returns {number}
-     */
-    get version(): number;
-    /**
-     * @param {boolean} v
-     */
-    set needsUpdate(v: boolean);
-    /**
-     * Where this node reports that it has moved — set by the {@link GPUSceneContext} that gives it
-     * rows, cleared when it takes them back. Null for a node no context holds, which is every node
-     * before it is added to a scene and every node after it leaves one.
-     *
-     * A node reports to one list, not several. Two contexts holding the same node would need two,
-     * and nothing in the engine does that: a `SceneManager` keeps one context per scene, and
-     * {@link GPUSceneContext} asserts when a node arrives already reporting somewhere else rather
-     * than quietly taking the claim and leaving the other context deaf.
-     *
-     * @type {Node3DDirtyList|null}
-     */
-    transform_dirty_list: Node3DDirtyList | null;
-    /**
-     * Handing a row back to the CPU has to be *reported*, not waited for: while the GPU owned the
-     * row nothing bumped this node's version, so nothing else would ever mark it as needing a
-     * write and the CPU would go on not writing a row it now owns.
-     *
-     * @param {TransformAuthority} value
-     */
-    set transform_authority(value: number);
-    /**
-     * Who writes this node's TRS in the GPU `transforms` table. Declared, never inferred — see
-     * {@link TransformAuthority} for what each side owns and why guessing does not work.
-     *
-     * @returns {TransformAuthority}
-     */
-    get transform_authority(): number;
-    /**
-     * World transform, **derived** — {@link updateMatrices} recomputes it from
-     * {@link transform_local} and the parent chain, so writing it directly is undone the moment
-     * anything refreshes. Place a node through its local transform.
-     *
-     * @type {Transform64}
-     */
-    transform_global: Transform64;
-    /**
-     * Local transform, and the node's own truth. Passive: setting a component does not refresh the
-     * matrix, and nothing downstream sees the change until {@link updateMatrices} runs.
-     *
-     * @type {Transform64}
-     */
-    transform_local: Transform64;
-    parent: any;
-    /**
-     *
-     * @type {Node3D[]}
-     */
-    children: Node3D[];
-    /**
-     * Orient this node so its local +Z axis points along `v`. Preserves
-     * position. A zero-length input is a no-op. Recomputes
-     * `transform_global` so the new orientation is visible immediately.
-     *
-     * @param {Vector3|number[]} v
-     */
-    set forward(v: Vector3);
-    /**
-     * Orientation vector — `(0,0,1)` rotated by the node's global transform. Freshly allocated;
-     * hold on to it rather than reading this in a loop.
-     *
-     * @return {Vector3}
-     */
-    get forward(): Vector3;
-    /**
-     * Orientation vector — `(1,0,0)` rotated by the node's global transform. Freshly allocated;
-     * hold on to it rather than reading this in a loop.
-     *
-     * @return {Vector3}
-     */
-    get right(): Vector3;
-    /**
-     * @param {Vector3|number[]} v
-     */
-    set position(v: Float64Array);
-    /**
-     * Live view over the local transform's own storage, freshly allocated on every access. Writing
-     * through it does not refresh anything — {@link updateMatrices} still has to run.
-     *
-     * @returns {Float64Array}
-     */
-    get position(): Float64Array;
-    copy(other: any): void;
-    clone(): Node3D;
-    /**
-     *
-     * @param {function(Node3D)} callback
-     * @param {*} [thisArg]
-     */
-    traverse(callback: (arg0: Node3D) => any, thisArg?: any): void;
-    /**
-     * Recompose this node's world transform and every descendant's.
-     *
-     * The local matrix is refreshed first because nothing else will: a `Transform64` does not track
-     * its own components, and {@link Transform64.multiplyTransforms} composes through matrices. Skip
-     * it and the node would be placed where it was the last time someone asked.
-     */
-    updateMatrices(): void;
-    /**
-     *
-     * @param {Node3D[]} children
-     */
-    addChildren(children: Node3D[]): void;
-    /**
-     *
-     * @param {Node3D} child
-     */
-    addChild(child: Node3D): void;
-    /**
-     * Type tag — lets `instanceof`-free callers (e.g. `InstanceBatch.add`)
-     * accept anything that conforms to the Node3D shape.
-     *
-     * @readonly
-     * @type {boolean}
-     */
-    readonly isNode3D: boolean;
-    #private;
-}
-export type Node3DDirtyList = import("./Node3DDirtyList.js").Node3DDirtyList;
-import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
-import Vector3 from "../../../core/geom/Vector3.js";
-//# sourceMappingURL=Node3D.d.ts.map

package/src/shade/renderer/scene/Node3D.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Node3D.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/Node3D.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH;IAEI;;;;;;;;OAQG;IACH,aAHU,MAAM,CAGE;IAElB;;;OAGG;IACH,MAFU,MAAM,CAEP;IAOT;;;;;;;;;;;OAWG;IACH,sBAEC;IAED;;OAEG;IACH,4BAMC;IAED;;;;;;;;;;;OAWG;IACH,sBAFU,eAAe,GAAC,IAAI,CAEF;IA6C5B;;;;;;OAMG;IACH,uCAQC;IAzBD;;;;;OAKG;IACH,kCAEC;IAmBD;;;;;;OAMG;IACH,kBAFU,WAAW,CAEgB;IAErC;;;;;OAKG;IACH,iBAFU,WAAW,CAEe;IAEpC,YAAc;IAEd;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEL;IAYb;;;;;;OAMG;IACH,wBAMC;IAvBD;;;;;OAKG;IACH,uBAEC;IAiBD;;;;;OAKG;IACH,qBAEC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED,uBAOC;IAED,gBAmBC;IAED;;;;OAIG;IACH,0BAHoB,MAAM,+BASzB;IAED;;;;;;OAMG;IACH,uBA4BC;IAED;;;OAGG;IACH,sBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAchB;IAIL;;;;;;OAMG;IACH,mBAFU,OAAO,CAEQ;;CATxB;8BAhUY,OAAO,sBAAsB,EAAE,eAAe;4BAJ/B,8CAA8C;oBAHtD,+BAA+B"}

package/src/shade/renderer/scene/Node3DDirtyList.d.ts

@@ -1,59 +0,0 @@
-/**
- * @typedef {import("./Node3D.js").Node3D} Node3D
- */
-/**
- * Nodes whose transform has been touched since the last drain — how a {@link GPUSceneContext}
- * finds out what moved, instead of asking every node it holds.
- *
- * A scene-wide scan is proportional to the scene and not to the frame: a version comparison is
- * cheap, several tens of thousands of them are not, and the scan runs once per view. Movement is
- * reported at the one place it happens — {@link Node3D.updateMatrices}, and the two other things
- * that bump a node's version — so the list is what actually changed and the frame costs what it
- * moved.
- *
- * {@link generation} is the drain counter, and a node stamps itself with it when it joins. That is
- * what makes a repeat within one frame free: `updateMatrices` recurses into children, so a
- * character's root moving reaches every joint under it, and reaching a joint twice — through the
- * recursion and again through a call of its own — must not queue it twice.
- *
- * A node on the list is a node that *may* have moved, never a promise that it did. The consumer
- * still compares versions: the membership sweep writes an arriving node's row itself, and that
- * node is on the list as well.
- */
-export class Node3DDirtyList {
-    /**
-     * Bumped by {@link drain}. A node carries the value it last joined under; see the class note.
-     *
-     * @type {number}
-     */
-    generation: number;
-    /**
-     * @param {Node3D} node
-     */
-    add(node: Node3D): void;
-    /**
-     * How many nodes are waiting. For a spec, and for anything that wants to know whether a frame
-     * has anything to do before it starts doing it.
-     *
-     * @returns {number}
-     */
-    get size(): number;
-    /**
-     * Hand over everything queued and start a fresh batch.
-     *
-     * The returned array is valid until the next drain, which is also when it is recycled — so a
-     * caller reads it and lets go of it. Anything queued *while* it is being read lands in the new
-     * batch rather than being appended to the one under the reader's feet.
-     *
-     * @returns {Node3D[]}
-     */
-    drain(): Node3D[];
-    /**
-     * Forget everything queued without handing it anywhere. For a context being torn down, whose
-     * nodes may outlive it.
-     */
-    clear(): void;
-    #private;
-}
-export type Node3D = import("./Node3D.js").Node3D;
-//# sourceMappingURL=Node3DDirtyList.d.ts.map

package/src/shade/renderer/scene/Node3DDirtyList.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Node3DDirtyList.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/Node3DDirtyList.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAEI;;;;OAIG;IACH,YAFU,MAAM,CAED;IAef;;OAEG;IACH,UAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAEC;IAED;;;;;;;;OAQG;IACH,SAFa,MAAM,EAAE,CAapB;IAED;;;OAGG;IACH,cAKC;;CACJ;qBA7FY,OAAO,aAAa,EAAE,MAAM"}

package/src/shade/renderer/scene/SceneNodeBinding.d.ts

@@ -1,52 +0,0 @@
-/**
- * What one {@link Node3D} owns inside a {@link GPUSceneContext}'s scene database: a row in the
- * `transforms` table, and — when the node is a {@link Mesh} — a row in the `meshes` table too.
- *
- * **Rows are stable for the lifetime of the binding.** Removing a node frees its rows and leaves a
- * hole rather than compacting the table, because rows are addresses: GPU animation targets a node
- * by row index, `meshes.node` points at one, and every `transforms.parent` is one. Compaction would
- * silently re-point all of them, so the tables tolerate holes instead and the passes that walk them
- * consult occupancy.
- */
-export class SceneNodeBinding {
-    /**
-     * Row in the scene database's `transforms` table.
-     *
-     * @type {number}
-     */
-    transform_row: number;
-    /**
-     * Row in the scene database's `meshes` table. Meaningful only for a node that is a mesh —
-     * `node.isMesh` is what says whether to read it, not this value.
-     *
-     * @type {number}
-     */
-    mesh_row: number;
-    /**
-     * The {@link Node3D.version} that the rows above were last written from. A node whose version
-     * still matches this has not moved since, and costs nothing but the comparison.
-     *
-     * @type {number}
-     */
-    version: number;
-    /**
-     * The {@link TransformAuthority} in force when the rows were last written.
-     *
-     * Kept because handing a row back to the CPU has to be acted on rather than waited for: while
-     * the GPU owned the row the node's own version stood still, so nothing would ever mark it as
-     * needing a write, and the CPU would take over a row it never wrote to.
-     *
-     * @type {TransformAuthority}
-     */
-    authority: TransformAuthority;
-    /**
-     * Membership-sweep marker. Set to the current sweep's number every time the node is found in
-     * the scene; a binding still carrying an older number after a sweep belongs to a node that has
-     * left, and its rows are freed.
-     *
-     * @type {number}
-     */
-    epoch: number;
-}
-import { TransformAuthority } from "./TransformAuthority.js";
-//# sourceMappingURL=SceneNodeBinding.d.ts.map

package/src/shade/renderer/scene/SceneNodeBinding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SceneNodeBinding.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SceneNodeBinding.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACI;;;;OAIG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;OAKG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;;;;OAQG;IACH,WAFU,kBAAkB,CAEO;IAEnC;;;;;;OAMG;IACH,OAFU,MAAM,CAEL;CACd;mCAvDkC,yBAAyB"}

package/src/shade/renderer/scene/SkinnedMesh.d.ts

@@ -1,27 +0,0 @@
-/**
- * A loader's mark on a primitive that a skin deforms.
- *
- * **A tag, not a renderable.** A skinned model is placed as a prefab — `prefab_compile` reads
- * this class off the loader's tree to know which primitives deform against which skin, and
- * `prefab_instantiate` spawns each as an entity whose mesh row draws a per-instance clone the
- * skinning pass writes (`ShadedGeometryFlags.Skinned`). Adding one of these to a scene as a node
- * is refused by the scene database: a node draws its source geometry rigidly, and there is no
- * node-side skinning any more.
- *
- * What the class still says: the geometry, the material, and that this primitive's vertices are
- * placed by joints rather than by its own transform — which is why glTF declares the node's own
- * transform meaningless for it, and why the prefab moves the node onto the skin's bind frame.
- */
-export class SkinnedMesh extends Mesh {
-    /**
-     * @returns {SkinnedMesh}
-     */
-    clone(): SkinnedMesh;
-    /**
-     * @readonly
-     * @type {boolean}
-     */
-    readonly isSkinnedMesh: boolean;
-}
-import { Mesh } from "./Mesh.js";
-//# sourceMappingURL=SkinnedMesh.d.ts.map

package/src/shade/renderer/scene/SkinnedMesh.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SkinnedMesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SkinnedMesh.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;IAEI;;OAEG;IACH,SAFa,WAAW,CAMvB;IAGL;;;OAGG;IACH,wBAFU,OAAO,CAEkB;CANlC;qBA1BoB,WAAW"}

package/src/shade/renderer/scene/TransformAuthority.d.ts

@@ -1,19 +0,0 @@
-/**
- * Who writes a node's `local_translation` / `local_rotation` / `local_scale` in the scene
- * database's `transforms` table.
- *
- * Both sides can reach those fields — the CPU through {@link GPUSceneContext }, the GPU through the
- * pose accumulator's resolve pass — and neither can tell that the other wrote. Without a stated
- * owner the two race, and the race is not hypothetical: {@link Node3D.updateMatrices } recurses into
- * children, so moving a character's root marks every joint under it as changed, and the CPU would
- * push its own idea of each joint's pose over whatever the animation had just resolved.
- *
- * `global` and `prev_global` are not covered by this — they are GPU-derived for every node, whoever
- * owns the TRS they are composed from.
- */
-export type TransformAuthority = number;
-export namespace TransformAuthority {
-    let CPU: number;
-    let GPU: number;
-}
-//# sourceMappingURL=TransformAuthority.d.ts.map

package/src/shade/renderer/scene/TransformAuthority.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TransformAuthority.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/TransformAuthority.js"],"names":[],"mappings":";;;;;;;;;;;;;iCAaU,MAAM"}