@graphty/webgpu-graph-algorithms 0.0.0 → 0.2.1

package/dist/src/layouts/force-simulation.d.ts

@@ -0,0 +1,498 @@
+/**
+ * The shared layout state machine (spec 7.19): the buffers every model shares (positions, scenePositions, fixed,
+ * partials, state + trace), the in-flight batches and their readbacks, the settle window, the fixed mask and the
+ * setPosition override list (spec 7.12), the trace and the batch driver; consumes a ForceModel by composition (the
+ * per-model kernel sequence, buffers, overrides, per-iteration params, controller hooks and stats decoding).
+ * Positions are layout units on the device and scene units in the owner's array (spec 7.18): load() repacks
+ * (scene - center) / scale into vec4f with the mass in .w (D23); the model's toScene stage, recorded once per batch
+ * on the last iteration (PLAN DECISION 2), writes p * scale + center back into scenePositions.
+ */
+import { type F32, type GraphSnapshot, type NodeMask } from "@graphty/graph-format";
+import { type GpuContext } from "../context.js";
+import { CommandBatch } from "../kernel/batch.js";
+import { type PipelineCache } from "../kernel/pipeline-cache.js";
+import { type UniformBlock, type UniformValues } from "../kernel/struct-block.js";
+import { UniformRing } from "../kernel/uniform-ring.js";
+import { type WgslModuleSpec } from "../kernel/wgsl.js";
+import { type CoreBinding } from "../memory/residency.js";
+import { type PlanCaps } from "../types/context.js";
+import { type GpuLayoutSimulation, type LayoutStatsBase, type ResolvedLayoutTuning, type RunOptions } from "../types/layout.js";
+import { type Binding } from "../types/memory.js";
+import { type CommonLayoutOptions, type SimulationOptions } from "../types/options.js";
+import { type ResolvedWeights } from "./inputs.js";
+/** A model-owned buffer beyond the shared set (spec 7.19: oldForce, velocity, the grid tier's). */
+export interface BufferSpec {
+    readonly name: string;
+    readonly byteLength: number;
+    readonly usage: number;
+    readonly zero: boolean;
+}
+/** Host writes into the state header collected between submits (spec 7.19 onLoad / onReheat / onSetParams). */
+export interface StateWriter {
+    /** Queues a field write (flushed by one writeBuffer before the next submit; also applied to the host shadow immediately). */
+    set(field: string, value: number | readonly number[]): void;
+    /** The host shadow of a field (last known value). */
+    get(field: string): number | readonly number[];
+}
+/** What a model gets at bind time (after load() / a resize): the graph, the shared and model buffers, the ring, the cache. */
+export interface ModelResources {
+    readonly device: GPUDevice;
+    readonly caps: PlanCaps;
+    readonly pipelines: PipelineCache;
+    readonly core: CoreBinding;
+    readonly perm: Binding | null;
+    /**
+     * The RESOLVED weights binding (model.inputs(): source "arcs" -> core.weights (null on an unweighted snapshot),
+     * "column" -> the registered ArrayBinding's binding, "none" -> null); group 0 is built as
+     * graphBindings(core, perm, weights) (3.10).
+     */
+    readonly weights: Binding | null;
+    readonly n: number;
+    readonly dim: 2 | 3;
+    readonly tier: "exact" | "grid";
+    readonly ring: UniformRing;
+    /** A shared or model-owned buffer by name: "positions", "scenePositions", "fixed", "partials", "state", "trace", plus every BufferSpec name. */
+    buffer(name: string): Binding;
+}
+/** The per-load inputs a model resolves from the snapshot and its options (mass into the `.w` lane; weights into the group-0 slot). */
+export interface ModelInputs {
+    readonly mass: F32;
+    readonly weights: ResolvedWeights;
+}
+/**
+ * Spec 7.19 ForceModel (kind, buffers, overrides, paramsFor, recordIteration, onLoad, onReheat, onSetParams,
+ * readStats) with SEVEN additions (CONTRACT DECISION, each with its reason): `stages` (the kernel stage names for
+ * debugRunStages / inspect, spec 11.9 item 2); `params` (the model's uniform block, which must declare the shared
+ * field names n, dim, flags, iterationIndex, seed, scale, center, settleThreshold, so the simulation can write
+ * them); `state` and `trace` (the model's generated Fa2State / Fa2Trace blocks, so the simulation allocates,
+ * initialises and decodes the state buffer through the model's own layouts, D20); `specs` (the module specs of an
+ * override set, for warm() and the compile matrix); `bind` (the model compiles and binds after load(), when the
+ * buffers exist); `inputs` (mass and weight resolution need the model's option names -- nodeMass / weight are
+ * ForceAtlas2Options, not CommonLayoutOptions -- so the simulation calls it at load() and derives USE_PERM /
+ * HAS_WEIGHTS from ModelResources, 3.10); and the optional `upTo` argument of `recordIteration` (truncates the
+ * sequence after a stage, for debugRunStages / inspect). PLAN DECISION 4: the state block must declare centroid,
+ * min, max (vec4f), rmsRadius, radius, meanDisplacement (f32), iteration, settledCount (u32) and fit in
+ * STATE_HEADER_BYTES; the params block must declare the eight shared names with center a vec4f and fit in
+ * UNIFORM_SLOT_BYTES. PLAN DECISION 6: paramsFor receives the GLOBAL iteration index; the shared fields win.
+ * PLAN DECISION 2: recordIteration with `upTo` undefined records EVERY stage (toScene included); `upTo = <stage>`
+ * stops after that stage.
+ */
+export interface ForceModel<Options, Stats extends LayoutStatsBase> {
+    readonly kind: "forceatlas2" | "fruchtermanReingold" | "springElectrical";
+    readonly stages: readonly string[];
+    readonly params: UniformBlock;
+    readonly state: UniformBlock;
+    readonly trace: UniformBlock;
+    buffers(n: number, dim: 2 | 3): readonly BufferSpec[];
+    /** Called at load() before the upload: FA2 = { mass: resolveNodeMass(s, nodeMass), weights: resolveWeights(s, weight) }. */
+    inputs(s: GraphSnapshot, options: Options): ModelInputs;
+    /** The model's OWN override set; the simulation merges USE_PERM / HAS_WEIGHTS from graphOverrides(core, perm, resources.weights) before specs() / bind(). */
+    overrides(options: Options): Readonly<Record<string, number | boolean>>;
+    specs(overrides: Readonly<Record<string, number | boolean>>, subgroups: boolean): readonly WgslModuleSpec[];
+    bind(resources: ModelResources, overrides: Readonly<Record<string, number | boolean>>): Promise<void>;
+    paramsFor(iteration: number, options: Options): UniformValues;
+    recordIteration(batch: CommandBatch, slot: number, tier: "exact" | "grid", upTo?: string): void;
+    onLoad(state: StateWriter): void;
+    onReheat(state: StateWriter): void;
+    onSetParams(patch: Partial<Options>, state: StateWriter): void;
+    readStats(state: DataView, trace: DataView): Stats;
+}
+/**
+ * The shared layout state machine (spec 7.19): buffers, in-flight batches, readback, settle window, fixed mask,
+ * setPosition overrides, trace, batch driver; consumes a ForceModel by composition.
+ */
+export declare class ForceSimulation<Options extends CommonLayoutOptions & SimulationOptions, Stats extends LayoutStatsBase> implements GpuLayoutSimulation<Options, Stats> {
+    readonly ctx: GpuContext;
+    readonly model: ForceModel<Options, Stats>;
+    readonly tuning: ResolvedLayoutTuning;
+    /**
+     * Present when ctx.debug.inspect is true: reads back any named buffer (a shared name, a BufferSpec name,
+     * "force", "state", "trace") after the last submitted kernel; resolves a Float32Array except for "fixed",
+     * "trace" (raw words) which resolve Uint32Array.
+     */
+    inspect?: (name: string) => Promise<Float32Array | Uint32Array>;
+    private readonly resolveOptions;
+    private readonly maxInFlight;
+    private readonly label;
+    private readonly traceBytes;
+    private readonly writer;
+    private readonly overrideList;
+    private readonly pending;
+    private readonly unregisterLost;
+    private optionsValue;
+    private stateValue;
+    private generationValue;
+    private tierValue;
+    private dimValue;
+    private snapshot;
+    private serial;
+    private owner;
+    private n;
+    private scale;
+    private center;
+    private buffers;
+    private core;
+    private resources;
+    private weightsUpload;
+    private ready;
+    private submitChain;
+    private fixedWords;
+    private fixedDirty;
+    private iterationsSubmitted;
+    private iterationsDoneValue;
+    private settledCountValue;
+    private settledValue;
+    private firstPending;
+    private statsValue;
+    private lastSubmittedBatchIdValue;
+    /** The id of the last batch submitted BEFORE the most recent reheat() (PLAN DECISION 21); 0 = none. */
+    private reheatedAfterBatchId;
+    private coalescedValue;
+    private torndown;
+    /**
+     * Creates a simulation over a context and a model (state "created"; load() makes it "loaded").
+     * @param ctx - the context (ready)
+     * @param model - the force model
+     * @param options - the option record (defaults applied by the caller's factory)
+     * @param tuning - the resolved GPU tuning
+     * @param resolve - how setParams merges a patch into the current record
+     */
+    constructor(ctx: GpuContext, model: ForceModel<Options, Stats>, options: Options, tuning: ResolvedLayoutTuning, resolve: (patch: Partial<Options>, current: Options) => Options);
+    /**
+     * "created" | "loaded" | "disposed".
+     * @returns the state
+     */
+    get state(): "created" | "loaded" | "disposed";
+    /**
+     * The current options record (defaults applied).
+     * @returns the record
+     */
+    get options(): Options;
+    /**
+     * The repulsion tier of the current load ("exact" until P4 lifts the grid tier).
+     * @returns the tier
+     */
+    get tier(): "exact" | "grid";
+    /**
+     * Nodes of the current load (0 before load()).
+     * @returns the node count
+     */
+    get nodeCount(): number;
+    /**
+     * 2 or 3, fixed at construction (setParams({ dim }) is rejected, spec 7.13).
+     * @returns the dimension
+     */
+    get dim(): 2 | 3;
+    /**
+     * iterationsDone >= the budget OR settledCount >= settleWindow of the last completed batch (spec 7.17); true for an empty graph.
+     * @returns whether the layout is settled
+     */
+    get settled(): boolean;
+    /**
+     * Batches created by step() and not yet landed (PLAN DECISION 7: counted from the step() call).
+     * @returns the count
+     */
+    get inFlight(): number;
+    /**
+     * Iterations landed since load() or the last reheat().
+     * @returns the count
+     */
+    get iterationsDone(): number;
+    /**
+     * The stats of the last completed batch; before one lands, the host-written header decoded through the model
+     * with an empty trace and msPerIteration null.
+     * @returns the stats
+     */
+    get stats(): Stats;
+    /**
+     * Uploads the snapshot's core, seeds the NaN rows of `positions`, repacks it into layout-unit vec4f with the
+     * mass in .w, writes the initial state, starts the model's compile + bind and enters "loaded" (spec 7.19; a
+     * load() during flight bumps the generation and discards the in-flight batches). Order of the checks (PLAN
+     * DECISION 16): E_DISPOSED, the context's assertReady, E_SNAPSHOT (directed), E_TOO_LARGE (nodeCount), the
+     * positions array, the tuning, then the core upload and model.inputs() BEFORE any state is touched.
+     * PLAN DECISION 10: nodeCount 0 loads with no GPU work at all. PLAN DECISION 11: the tier is resolved here
+     * and "grid" is E_UNSUPPORTED until P4. PLAN DECISION 17: a same-size load() keeps the buffers and re-zeroes
+     * partials, the trace region and every `zero: true` model buffer.
+     * @param snapshot - an undirected snapshot
+     * @param positions - the owner's stride-3 scene-unit array (NaN rows are seeded in place)
+     */
+    load(snapshot: GraphSnapshot, positions: F32): void;
+    /**
+     * Submits k iterations (spec 7.19 items 1-6): "created" -> E_NOT_LOADED; "disposed" -> E_DISPOSED; a released
+     * snapshot -> E_RELEASED; k outside [1, MAX_ITERATIONS_PER_STEP] -> E_INVALID_ARGUMENT; settled -> resolves at
+     * once; inFlight >= maxInFlight -> the OLDEST pending batch's promise (coalesced); else the batch is queued on
+     * the submit chain (after the bind promise and allocator.check()) and its promise resolves when its readback
+     * landed in the owner's array. The same promise object is returned for every coalesced call. PLAN DECISION 7:
+     * the batch counts in `inFlight` from this call, not from its submission.
+     * @param iterations - k (default options.iterationsPerStep, default 1)
+     * @returns resolves when the batch landed (or was discarded); rejects E_VALIDATION / E_DEVICE_LOST / E_OUT_OF_MEMORY / E_SHADER_COMPILE
+     */
+    step(iterations?: number): Promise<void>;
+    /**
+     * Resolves when nothing is in flight (every pending batch landed or was discarded).
+     * @returns the promise
+     */
+    flush(): Promise<void>;
+    /**
+     * Node batch driver: loops step(batch) until settled, the budget (`maxIter ?? options.maxIter`, PLAN DECISION
+     * 1) is reached or the signal aborts (E_ABORTED; the batch in flight at the abort is discarded, spec 5.7 / Q-15).
+     * @param options - maxIter, batch (default 8), signal
+     * @returns the stats of the last completed batch
+     */
+    run(options?: RunOptions): Promise<Stats>;
+    /**
+     * Copies the mask words (spec 7.12): E_INVALID_ARGUMENT when shorter than ceil(n / 32); the buffer is marked
+     * dirty and re-uploaded before the next submit; reheat() iff some bit went 1 -> 0 (an unpin). PLAN DECISION
+     * 18: the comparison is bit by bit below n (bits at or above n never count as an unpin).
+     * @param mask - the NodeMask (LSB-first words)
+     */
+    setFixed(mask: NodeMask): void;
+    /**
+     * Writes a scene-unit position (spec 7.12): into the owner's array at once, into the device (layout units, z 0
+     * in 2D, 12 bytes at 16 i, queue-ordered before the next submit), into the override list keyed by the last
+     * submitted batch id, then reheat(). PLAN DECISION 18: non-finite coordinates are E_INVALID_ARGUMENT.
+     * @param index - the node index (< n)
+     * @param x - scene x
+     * @param y - scene y
+     * @param z - scene z (ignored on the device in 2D)
+     */
+    setPosition(index: number, x: number, y: number, z: number): void;
+    /**
+     * iterationsDone = 0, settledCount = 0 (a queued state write), model.onReheat(writer); nothing else (D8: the
+     * speed controller keeps its state). `settled` is recomputed at once (PLAN DECISION 8). Allowed before load().
+     * PLAN DECISION 21: the id of the last batch submitted so far is remembered; a batch with that id or an older
+     * one was computed from the pre-reheat counter, so its landed settledCount is taken as 0 (see onLanded) and a
+     * drag or unpin can never leave the simulation settled through a batch that was already in flight.
+     */
+    reheat(): void;
+    /**
+     * Live tuning (spec 3.3, 7.17): `dim` differing from the current -> E_INVALID_ARGUMENT; `maxInFlight` differing
+     * -> E_INVALID_ARGUMENT (the ring is sized by it); a non-null `nodeSize` -> E_UNSUPPORTED; the record is
+     * replaced through `resolve(patch, current)`; a change of the model's override set (a force LAW) recompiles
+     * and re-binds; scale / center changes reach the next batch through the shared params of every slot (the
+     * model's toScene reads them); then model.onSetParams(patch, writer) and reheat().
+     * @param patch - the fields to change
+     */
+    setParams(patch: Partial<Options>): void;
+    /**
+     * Discards in-flight batches (their promises resolve), destroys every simulation buffer and the ring, trims
+     * the pool, unregisters the loss listener; state "disposed"; idempotent.
+     */
+    dispose(): void;
+    /**
+     * The serialised submission of one pending batch: awaits the bind / warm promise and allocator.check(), then
+     * records and submits unless the record went stale meanwhile; wires the readback handlers. A record that went
+     * stale while waiting (a load() or dispose() superseded it) RESOLVES even when the wait rejected (PLAN
+     * DECISION 8: the rejection belongs to the superseded generation -- a bind that failed E_SHADER_COMPILE, or
+     * the ring's E_DISPOSED after dispose() tore it down under a running bind).
+     * @param record - the pending batch
+     */
+    private submitBatch;
+    /**
+     * Flushes the host writes, fills k ring slots, records k iterations (only the last one runs the model's toScene
+     * epilogue, PLAN DECISION 2) + the two readbacks into one CommandBatch and submits it (spec 7.19 items 4-5).
+     * @param record - the pending batch
+     * @returns the submitted batch
+     */
+    private recordAndSubmit;
+    /**
+     * A landed readback (spec 7.19 item 6): stale -> discard; else the scene bytes go into the owner's array row by
+     * row (skipping overridden rows, clearing overrides older than this batch), the header refreshes the shadow,
+     * the stats are decoded through the model (msPerIteration from the profiler or the wall time, PLAN DECISION 3),
+     * iterationsDone += k and settled is recomputed -- with the landed settledCount taken as 0 when the batch was
+     * submitted before the last reheat() (PLAN DECISION 21; the header is still absorbed and the stats decoded).
+     * @param record - the pending batch
+     * @param bytes - the batch's readback bytes
+     */
+    private onLanded;
+    /**
+     * A failed readback: a discarded batch's E_ABORTED resolves (PLAN DECISION 8); a lost device rejects
+     * E_DEVICE_LOST; everything else (E_VALIDATION, E_DISPOSED) rejects as is.
+     * @param record - the pending batch
+     * @param err - the rejection
+     */
+    private onFailed;
+    /**
+     * Copies the scene bytes of a landed batch into the owner's array, honouring the override list (spec 7.12).
+     * @param owner - the owner's array
+     * @param bytes - the readback
+     * @param record - the batch
+     */
+    private copyScene;
+    /**
+     * The batch's duration in milliseconds: the profiler's pass timings summed when present, else wall time.
+     * @param record - the batch
+     * @param bytes - its readback (the profiler's resolve lands in it)
+     * @returns milliseconds
+     */
+    private batchMilliseconds;
+    /**
+     * Whether a record belongs to an earlier generation, was discarded, or the simulation left "loaded".
+     * @param record - the batch
+     * @returns true when its readback must be ignored
+     */
+    private isStale;
+    /**
+     * Removes a record from the pending list (idempotent).
+     * @param record - the batch
+     */
+    private finish;
+    /** Marks every pending batch stale and discards the submitted ones (their readbacks resolve empty or E_ABORTED). */
+    private discardPending;
+    /** An OOM surfaced by allocator.check(): every simulation buffer is destroyed and the state returns to "created". */
+    private outOfMemory;
+    /**
+     * The E_ABORTED of run().
+     * @returns the error
+     */
+    private abortedError;
+    /**
+     * The uniform values of one iteration slot: the model's values with the shared fields on top (PLAN DECISION 6).
+     * @param global - the global iteration index (iterationsSubmitted + i)
+     * @param index - the slot index within the batch (the trace slot)
+     * @param flags - FA2_FLAG_FIRST for the first iteration after load(), else 0
+     * @returns the values
+     */
+    private paramsForSlot;
+    /**
+     * The option seed as a u32 (0 when unseeded), the near-field hash seed of P4.
+     * @returns the seed
+     */
+    private seedU32;
+    /**
+     * Writes the queued state fields, each as one writeBuffer of its own byte range (PLAN DECISION 5).
+     * @param state - the state buffer
+     */
+    private flushStateWrites;
+    /**
+     * The stage that precedes the toScene epilogue in model.stages (the `upTo` of every iteration but the last), or
+     * undefined when the model has no epilogue or lists it first (every iteration then records every stage).
+     * @returns the stage name or undefined
+     */
+    private lastIterationStage;
+    /**
+     * The settle threshold of the current options (FA2_DEFAULTS when absent).
+     * @returns the threshold
+     */
+    private settleThreshold;
+    /**
+     * The settle window of the current options (FA2_DEFAULTS when absent).
+     * @returns the window
+     */
+    private settleWindow;
+    /**
+     * The iteration budget (PLAN DECISION 1): options.maxIter, else options.iterations, else no budget.
+     * @returns the budget
+     */
+    private iterationBudget;
+    /**
+     * The settle rule of spec 7.17 over the counters of the last completed batch.
+     * @returns whether the layout is settled
+     */
+    private computeSettled;
+    /**
+     * Allocates the shared buffers (spec 7.3 sizes) and the model's BufferSpecs through the allocator (every buffer
+     * labelled); a `zero: true` spec must carry COPY_DST so it can be re-zeroed when kept across loads (PLAN
+     * DECISION 17). The state buffer is STATE_HEADER_BYTES + MAX_ITERATIONS_PER_STEP x model.trace.byteLength:
+     * contract 3.13 writes TRACE_RECORD_BYTES (32, the FA2 record) for the last factor; the model's block is the
+     * same number for FA2 and is what the simulation decodes the trace with, so it is the general rule (PLAN
+     * DECISION 4) and the constant is not imported here.
+     * @param n - the node count (> 0)
+     * @returns the buffers and the name -> Binding map
+     */
+    private allocate;
+    /**
+     * Re-zeroes the buffers a same-size load() keeps: partials, the trace region and every `zero: true` model buffer.
+     * @param buffers - the kept buffers
+     */
+    private clearKept;
+    /**
+     * Destroys every simulation buffer through the allocator (the ring lives on until dispose()). While batches are
+     * still in flight the destruction is DEFERRED until their readbacks have settled: the GPU may still be copying
+     * out of `scene` / `state` and Dawn's Metal backend (dawn-node 0.4.0 on macOS) has taken the worker process
+     * down when a buffer with pending work was destroyed (the Vulkan backends defer internally). The simulation
+     * drops its references at once either way, so nothing here is reachable afterwards.
+     */
+    private destroyBuffers;
+    /**
+     * Runs `action` now when no submitted batch is in flight, otherwise once every in-flight readback has settled
+     * (resolved, discarded or rejected -- the staging slot is returned and the GPU work is done either way).
+     * @param action - the destruction to run
+     */
+    private afterInFlight;
+    /**
+     * The buffers of the current load.
+     * @returns the buffers; E_NOT_LOADED when there are none
+     */
+    private requireBuffers;
+    /**
+     * Repacks the seeded scene array into layout-unit vec4f (mass in .w, z = 0 in 2D), uploads it, and writes the
+     * initial centroid / bbox / rmsRadius / radius (f64 over the f32 values uploaded) with iteration 0,
+     * settledCount 0, meanDisplacement 0 into the state header, then model.onLoad(writer) and one whole-header
+     * writeBuffer (spec 7.4, 7.17, 7.18).
+     * @param buffers - the buffers
+     * @param positions - the seeded owner array
+     * @param mass - the resolved masses
+     */
+    private uploadPositions;
+    /**
+     * The weights binding of a load (3.10): "arcs" -> core.weights, "none" -> null, "column" -> the expanded array
+     * registered with residency.array(expanded, "weights", snapshot), the previous array object reused when the
+     * column and its version are unchanged (so the upload cache finds it).
+     * @param snapshot - the snapshot
+     * @param core - its core
+     * @param resolved - model.inputs().weights
+     * @returns the binding for the group-0 weights slot, or null
+     */
+    private resolveWeightsBinding;
+    /**
+     * The ModelResources of a load.
+     * @param core - the core
+     * @param weights - the resolved weights binding
+     * @param buffers - the buffers
+     * @returns the resources
+     */
+    private makeResources;
+    /**
+     * Chains the compile + bind promise the next step() awaits on the PREVIOUS one (PLAN DECISION 20: binds are
+     * serialised on `ready` for load() and setParams() alike, so a superseded load()'s bind either fails its
+     * generation check before model.bind() or completes before its successor's bind starts -- it can never bind
+     * the model to destroyed buffers AFTER the new bind finished). The previous promise's rejection is swallowed by
+     * the chain (it belonged to the superseded generation); this promise's rejection is kept for the next step()
+     * (the derived catch only silences the unhandled-rejection warning).
+     * @param resources - the resources
+     * @param overrides - the merged override set
+     */
+    private startBind;
+    /**
+     * warm(model.specs()) then model.bind(); the await re-checks that the load is current before binding.
+     * @param resources - the resources
+     * @param overrides - the merged override set
+     * @param generation - the generation the bind belongs to
+     */
+    private compileAndBind;
+    /**
+     * inspect(name): flush, read the named buffer back, Uint32Array for "fixed" and "trace", Float32Array otherwise.
+     * @param name - a shared or BufferSpec name
+     * @returns the words
+     */
+    private inspectBuffer;
+    /**
+     * debugRunStages(upTo): one iteration truncated after a stage, submitted alone after flush(), awaited through
+     * a header readback; never advances the counters or the FA2_FLAG_FIRST flag (PLAN DECISION 9).
+     * @param upTo - a model stage name
+     */
+    private runStages;
+    /**
+     * Device loss (spec 5.7): every pending promise rejects E_DEVICE_LOST, the simulation is disposed.
+     * @param info - the loss info
+     */
+    private onDeviceLost;
+    /** Releases everything once: pending batches discarded, buffers and ring destroyed, pool trimmed, listener unregistered. */
+    private teardown;
+    /** E_DISPOSED after dispose() or device loss. */
+    private assertNotDisposed;
+    /** E_NOT_LOADED before load(), E_DISPOSED after dispose(). */
+    private assertLoaded;
+}
+//# sourceMappingURL=force-simulation.d.ts.map

package/dist/src/layouts/force-simulation.d.ts.map

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