@graphty/webgpu-graph-algorithms 0.6.26 → 0.6.28

package/dist/chunks/context-BZY6SMsM.js

@@ -1,3615 +0,0 @@
-import { INVALID_INDEX } from "@graphty/graph-format";
-const WORKGROUP_SIZE = 256;
-const MAX_WORKGROUPS_PER_DIM = 65535;
-const MAX_1D_ITEMS = MAX_WORKGROUPS_PER_DIM * WORKGROUP_SIZE;
-const U32_MAX = 4294967295;
-const RADIX_BINS = 256;
-const ARC_WINDOW_ALIGN = 64;
-const STORAGE_ALIGN = 256;
-const UNIFORM_SLOT_BYTES = 256;
-const EXACT_MAX_NODES = 32768;
-const DEFAULT_STAGING_SLOTS = 3;
-const PROFILER_QUERY_SLOTS = 256;
-const OOM_SCOPE_THRESHOLD_BYTES = 16 * 1024 * 1024;
-const POOL_MAX_IDLE_PER_CLASS = 4;
-const POOL_MIN_CLASS_BYTES = 4 * 1024;
-const POOL_MAX_POW2_CLASS_BYTES = 64 * 1024 * 1024;
-const POOL_LINEAR_STEP_BYTES = 16 * 1024 * 1024;
-const DEFAULT_WARN_UNRELEASED_SNAPSHOTS = 2;
-const MAX_ITERATIONS_PER_STEP = 256;
-const TRACE_RECORD_BYTES = 32;
-const STATE_HEADER_BYTES = 256;
-const PARTIAL_BYTES = 64;
-const FA2_DEFAULTS = Object.freeze({
-  maxIter: 100,
-  jitterTolerance: 1,
-  scalingRatio: 2,
-  gravity: 1,
-  strongGravity: false,
-  distributedAction: false,
-  linlog: false,
-  dissuadeHubs: false,
-  dim: 2,
-  scale: 1,
-  settleThreshold: 1e-3,
-  settleWindow: 10,
-  iterationsPerStep: 1,
-  maxInFlight: 2
-});
-const LAYOUT_TUNING_DEFAULTS = Object.freeze({
-  repulsion: "auto",
-  exactMaxNodes: EXACT_MAX_NODES,
-  nearMax: 64,
-  deterministic: true,
-  gridMax2D: 512,
-  gridMax3D: 128,
-  extentFactor: 6,
-  compat: "paper"
-});
-const FA2_DISTANCE_FLOOR = 0.01;
-const FA2_DISTANCE_FLOOR_SQ = 1e-4;
-const FA2_COINCIDENT_SQ = 1e-8;
-const EXACT_TILES_PER_PASS = 128;
-const FA2_FLAG_FIRST = 1;
-const FA2_FLAG_ADAPTIVE = 2;
-const FR_START_TEMPERATURE = 0.1;
-const FR_REHEAT_FRACTION = 0.7;
-const FR_COOLING_STEP = 0.9;
-const FR_COOLING_PATIENCE = 5;
-const FR_ADAPTIVE_MAX_ITERATIONS = 1e4;
-const FR_DEFAULTS = Object.freeze({
-  k: null,
-  iterations: 50,
-  fixed: null,
-  dim: 2,
-  scale: 1,
-  settleThreshold: 1e-3,
-  settleWindow: 10,
-  iterationsPerStep: 1,
-  maxInFlight: 2,
-  cooling: "linear"
-});
-const SE_SCALE_REFERENCE_NODES = 300;
-const SE_DEFAULTS = Object.freeze({
-  springLength: 10,
-  springCoefficient: 0.8,
-  gravity: -12,
-  dragCoefficient: 0.9,
-  timeStep: 0.5,
-  dim: 2,
-  scale: 1,
-  settleThreshold: 1e-3,
-  settleWindow: 10,
-  iterationsPerStep: 1,
-  maxInFlight: 2
-});
-const SETTLE_FLOOR_FRACTION = Object.freeze(
-  {
-    springElectrical: 3e-3,
-    fruchtermanReingold: 2e-3
-  }
-);
-const SETTLE_FLOOR_REFERENCE_NODES = 2e3;
-const SETTLE_FLOOR_UNBOUNDED = 2 ** 128 - 2 ** 104;
-const GRID_MIN_SIDE = 8;
-const GRID_COARSEST_SIDE = 4;
-const GRID_HUB_CELL = 1024;
-const GRID_EXTENT_FLOOR = 1e-6;
-const GRID_BBOX_MARGIN = 1.01;
-const GRID_SORT_BITS = 24;
-const MAX_LEVELS_PER_SUBMIT = 32;
-const FUSED_FRONTIER_MAX = 4096;
-const BEAMER_BETA = 24;
-const SSSP_DELTA_FACTOR = 32;
-const F32_INF_BITS = 2139095040;
-const BC_BATCH_BUDGET_FRACTION = 0.25;
-const BC_MAX_BATCH = 64;
-const BC_EDGE_PARALLEL_GAMMA = 2;
-const BC_SIGMA_EXPONENT_CAP = 100;
-const BC_COUNT_MAX_GROUPS = 256;
-const BC_BACKWARD_LEVELS_PER_SUBMIT = 64;
-const APSP_TILE = 32;
-const APSP_MAX_DISPATCHES_PER_SUBMIT = 4096;
-const LABEL_PROP_PASSES_PER_SUBMIT = 8;
-const BORUVKA_ROUNDS_PER_SUBMIT = 4;
-const F32_SIGN_BIT = 2147483648;
-const GROUP_ROW_THREAD_MAX = 32;
-const GROUP_ROW_THREAD_LIMIT = 128;
-const PARALLEL_MERGE_LIMIT = 65e3;
-const GROUP_HASH_LOAD_FACTOR = 2;
-const TRIANGLE_BINARY_SEARCH_RATIO = 32;
-const PASSTHROUGH_FORMAT_CODES = Object.freeze(["E_GPU_INELIGIBLE", "E_UNKNOWN_NODE", "E_UNKNOWN_COLUMN", "E_COLUMN_LENGTH"]);
-const EMPTY_DETAILS = Object.freeze({});
-class WebGpuGraphError extends Error {
-  /**
-   * Create a WebGpuGraphError.
-   * @param code - the stable code the caller can branch on
-   * @param message - a plain-ASCII human-readable message naming the offending label, limit or value
-   * @param details - optional machine-readable context; copied shallowly and frozen
-   */
-  constructor(code, message, details) {
-    super(message);
-    this.name = "WebGpuGraphError";
-    this.code = code;
-    this.details = details === void 0 ? EMPTY_DETAILS : Object.freeze({ ...details });
-  }
-}
-function isWebGpuGraphError(x) {
-  if (typeof x !== "object" || x === null) {
-    return false;
-  }
-  const candidate = x;
-  return candidate.name === "WebGpuGraphError" && typeof candidate.code === "string";
-}
-function hasErrorCode(x, code) {
-  return isWebGpuGraphError(x) && x.code === code;
-}
-const RAISABLE_LIMITS = Object.freeze([
-  "maxBufferSize",
-  "maxStorageBufferBindingSize",
-  "maxStorageBuffersPerShaderStage",
-  "maxComputeWorkgroupStorageSize",
-  "maxComputeInvocationsPerWorkgroup",
-  "maxComputeWorkgroupSizeX"
-]);
-const LIMIT_NAMES = [
-  "maxTextureDimension1D",
-  "maxTextureDimension2D",
-  "maxTextureDimension3D",
-  "maxTextureArrayLayers",
-  "maxBindGroups",
-  "maxBindGroupsPlusVertexBuffers",
-  "maxBindingsPerBindGroup",
-  "maxDynamicUniformBuffersPerPipelineLayout",
-  "maxDynamicStorageBuffersPerPipelineLayout",
-  "maxSampledTexturesPerShaderStage",
-  "maxSamplersPerShaderStage",
-  "maxStorageBuffersPerShaderStage",
-  "maxStorageBuffersInVertexStage",
-  "maxStorageBuffersInFragmentStage",
-  "maxStorageTexturesPerShaderStage",
-  "maxStorageTexturesInVertexStage",
-  "maxStorageTexturesInFragmentStage",
-  "maxUniformBuffersPerShaderStage",
-  "maxUniformBufferBindingSize",
-  "maxStorageBufferBindingSize",
-  "minUniformBufferOffsetAlignment",
-  "minStorageBufferOffsetAlignment",
-  "maxVertexBuffers",
-  "maxBufferSize",
-  "maxVertexAttributes",
-  "maxVertexBufferArrayStride",
-  "maxInterStageShaderVariables",
-  "maxColorAttachments",
-  "maxColorAttachmentBytesPerSample",
-  "maxComputeWorkgroupStorageSize",
-  "maxComputeInvocationsPerWorkgroup",
-  "maxComputeWorkgroupSizeX",
-  "maxComputeWorkgroupSizeY",
-  "maxComputeWorkgroupSizeZ",
-  "maxComputeWorkgroupsPerDimension",
-  "maxImmediateSize"
-];
-const consumedAdapters = /* @__PURE__ */ new WeakSet();
-function messageOf$1(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-function isSoftwareAdapter(info) {
-  return info.architecture === "software" || info.architecture === "swiftshader" || info.architecture === "warp" || info.isFallbackAdapter === true;
-}
-function summarizeAdapter(adapter) {
-  const { info } = adapter;
-  const source = adapter.limits;
-  const limits = {};
-  for (const name of LIMIT_NAMES) {
-    const value = source[name];
-    if (typeof value === "number") {
-      limits[name] = value;
-    }
-  }
-  return Object.freeze({
-    vendor: info.vendor,
-    architecture: info.architecture,
-    device: info.device,
-    description: info.description,
-    software: isSoftwareAdapter(info),
-    subgroupMinSize: info.subgroupMinSize ?? 0,
-    subgroupMaxSize: info.subgroupMaxSize ?? 0,
-    features: Object.freeze(Array.from(adapter.features).sort()),
-    limits: Object.freeze(limits)
-  });
-}
-async function requestAdapter(gpu, powerPreference) {
-  let adapter;
-  try {
-    adapter = await gpu.requestAdapter({ powerPreference });
-  } catch (err) {
-    const reason = `requestAdapter() threw: ${messageOf$1(err)}`;
-    throw new WebGpuGraphError("E_NO_ADAPTER", reason, { reason });
-  }
-  if (adapter === null) {
-    const reason = "requestAdapter() returned null: no usable WebGPU adapter";
-    throw new WebGpuGraphError("E_NO_ADAPTER", reason, { reason });
-  }
-  return adapter;
-}
-function buildRequiredLimits(adapter, policy) {
-  const limits = {};
-  if (policy === "default") {
-    return limits;
-  }
-  if (policy === "raise") {
-    for (const name of RAISABLE_LIMITS) {
-      limits[name] = adapter.limits[name];
-    }
-    return limits;
-  }
-  for (const name of RAISABLE_LIMITS) {
-    const requested = policy[name];
-    if (requested === void 0) {
-      continue;
-    }
-    const available = adapter.limits[name];
-    if (requested > available) {
-      throw new WebGpuGraphError(
-        "E_NO_DEVICE",
-        `requested ${name} = ${requested} exceeds the adapter's ${available}`,
-        { reason: "limit", adapter: summarizeAdapter(adapter), limit: name, requested, available }
-      );
-    }
-    limits[name] = requested;
-  }
-  return limits;
-}
-function buildRequiredFeatures(adapter, required, optional) {
-  const features = [];
-  for (const feature of required) {
-    if (!adapter.features.has(feature)) {
-      throw new WebGpuGraphError("E_NO_DEVICE", `required feature "${feature}" is not supported by the adapter`, {
-        reason: "feature",
-        adapter: summarizeAdapter(adapter),
-        requested: feature
-      });
-    }
-    if (!features.includes(feature)) {
-      features.push(feature);
-    }
-  }
-  for (const feature of optional) {
-    if (adapter.features.has(feature) && !features.includes(feature)) {
-      features.push(feature);
-    }
-  }
-  return features;
-}
-function consumedError(adapter, message) {
-  return new WebGpuGraphError(
-    "E_NO_DEVICE",
-    `the adapter already created a device (an adapter is consumed by one requestDevice, spec 2.2 step 1): ${message}`,
-    { reason: "consumed", adapter: summarizeAdapter(adapter) }
-  );
-}
-async function requestDevice(adapter, descriptor) {
-  if (consumedAdapters.has(adapter)) {
-    throw consumedError(adapter, "recorded by this package");
-  }
-  let device;
-  try {
-    device = await adapter.requestDevice(descriptor);
-  } catch (err) {
-    const message = messageOf$1(err);
-    if (/consumed|already been used/i.test(message)) {
-      throw consumedError(adapter, message);
-    }
-    throw new WebGpuGraphError("E_NO_DEVICE", `requestDevice() rejected: ${message}`, {
-      reason: "requestDevice",
-      adapter: summarizeAdapter(adapter)
-    });
-  }
-  consumedAdapters.add(adapter);
-  return device;
-}
-function captureCaps(device, info, runtime, wgslFeatures) {
-  const features = new Set(device.features);
-  const subgroups = features.has("subgroups");
-  return {
-    limits: device.limits,
-    features,
-    wgslFeatures: new Set(wgslFeatures),
-    subgroupMinSize: subgroups ? info.subgroupMinSize ?? 0 : 0,
-    subgroupMaxSize: subgroups ? info.subgroupMaxSize ?? 0 : 0,
-    software: isSoftwareAdapter(info),
-    runtime,
-    vendor: info.vendor,
-    architecture: info.architecture,
-    device: info.device,
-    description: info.description
-  };
-}
-function capsFromDevice(device, info) {
-  const features = new Set(device.features);
-  const subgroups = features.has("subgroups");
-  return {
-    limits: device.limits,
-    features,
-    wgslFeatures: info?.wgslFeatures ?? /* @__PURE__ */ new Set(),
-    subgroupMinSize: subgroups ? info?.subgroupMinSize ?? 0 : 0,
-    subgroupMaxSize: subgroups ? info?.subgroupMaxSize ?? 0 : 0,
-    software: info?.software ?? false,
-    runtime: info?.runtime ?? "unknown",
-    vendor: info?.vendor ?? "",
-    architecture: info?.architecture ?? "",
-    device: info?.device ?? "",
-    description: info?.description ?? ""
-  };
-}
-function workgroupSizeFor(caps) {
-  const cap = Math.min(WORKGROUP_SIZE, caps.limits.maxComputeInvocationsPerWorkgroup);
-  let size = 1;
-  while (size * 2 <= cap) {
-    size *= 2;
-  }
-  return size;
-}
-function assertPlanLimits(caps) {
-  const perDim = caps.limits.maxComputeWorkgroupsPerDimension;
-  if (perDim !== MAX_WORKGROUPS_PER_DIM) {
-    throw new WebGpuGraphError(
-      "E_NO_DEVICE",
-      `maxComputeWorkgroupsPerDimension is ${perDim}; the dispatch planner and the WGSL prelude bake ${MAX_WORKGROUPS_PER_DIM}`,
-      {
-        reason: "maxComputeWorkgroupsPerDimension",
-        adapter: null,
-        requested: MAX_WORKGROUPS_PER_DIM,
-        available: perDim
-      }
-    );
-  }
-  const wg = workgroupSizeFor(caps);
-  if (wg < 64) {
-    throw new WebGpuGraphError(
-      "E_NO_DEVICE",
-      `the device allows a workgroup of ${wg} invocations; the kernels need a power of two >= 64`,
-      {
-        reason: "limit",
-        adapter: null,
-        limit: "maxComputeInvocationsPerWorkgroup",
-        requested: 64,
-        available: wg
-      }
-    );
-  }
-}
-function formatCompilationInfo(info, preludeLines) {
-  return info.messages.map((m) => {
-    if (m.lineNum === 0) {
-      return `${m.type} ${m.message}`;
-    }
-    const line = m.lineNum - preludeLines;
-    if (line >= 1) {
-      return `${m.type} ${line}:${m.linePos} ${m.message}`;
-    }
-    return `${m.type} prelude:${m.lineNum}:${m.linePos} ${m.message}`;
-  });
-}
-class AllocationTracker {
-  /**
-   * Creates a tracker over one device.
-   * @param device - the device buffers are created on
-   * @param thresholdBytes - the byte size from which createBuffer runs inside an out-of-memory scope (default OOM_SCOPE_THRESHOLD_BYTES)
-   */
-  constructor(device, thresholdBytes) {
-    this.live = /* @__PURE__ */ new Map();
-    this.residentBytes = 0;
-    this.pending = [];
-    this.failure = null;
-    this.serial = 0;
-    this.device = device;
-    this.threshold = thresholdBytes ?? OOM_SCOPE_THRESHOLD_BYTES;
-  }
-  /**
-   * createBuffer with the scope rule; every buffer is labelled (an unlabelled descriptor becomes `buffer-<n>`).
-   * @param descriptor - the buffer descriptor
-   * @returns the buffer
-   */
-  createBuffer(descriptor) {
-    this.serial += 1;
-    const label = descriptor.label === void 0 || descriptor.label === "" ? `buffer-${this.serial}` : descriptor.label;
-    const { size } = descriptor;
-    const scoped = size >= this.threshold;
-    if (scoped) {
-      this.device.pushErrorScope("out-of-memory");
-    }
-    const buffer = this.device.createBuffer({ ...descriptor, label });
-    this.live.set(buffer, size);
-    this.residentBytes += size;
-    if (scoped) {
-      const pop = this.device.popErrorScope().then(
-        (error) => {
-          if (error === null) {
-            return;
-          }
-          if (this.live.has(buffer)) {
-            this.live.delete(buffer);
-            this.residentBytes -= size;
-          }
-          if (this.failure === null) {
-            this.failure = new WebGpuGraphError(
-              "E_OUT_OF_MEMORY",
-              `out of memory creating "${label}" (${size} bytes, ${this.residentBytes} resident): ${error.message}`,
-              { requested: size, resident: this.residentBytes, label }
-            );
-          }
-        },
-        () => void 0
-      );
-      this.pending.push(pop);
-    }
-    return buffer;
-  }
-  /**
-   * Destroys a buffer created here and decrements `resident`; a buffer the tracker does not know is destroyed
-   * without touching the bookkeeping, so destroying twice is harmless.
-   * @param buffer - the buffer to destroy
-   */
-  destroy(buffer) {
-    const size = this.live.get(buffer);
-    if (size !== void 0) {
-      this.live.delete(buffer);
-      this.residentBytes -= size;
-    }
-    buffer.destroy();
-  }
-  /**
-   * Awaits every outstanding scope pop; the first OOM -> E_OUT_OF_MEMORY { requested, resident, label }; later
-   * calls after a failure throw the same error again until `reset()`.
-   */
-  async check() {
-    while (this.pending.length > 0) {
-      const batch = this.pending.splice(0);
-      await Promise.all(batch);
-    }
-    if (this.failure !== null) {
-      throw this.failure;
-    }
-  }
-  /** Forgets a recorded OOM after the caller released what it allocated. */
-  reset() {
-    this.failure = null;
-  }
-  /**
-   * Bytes of live buffers created through this tracker.
-   * @returns the resident byte count
-   */
-  get resident() {
-    return this.residentBytes;
-  }
-  /**
-   * Number of live buffers created through this tracker.
-   * @returns the live buffer count
-   */
-  get liveBuffers() {
-    return this.live.size;
-  }
-}
-class PendingErrorSlot {
-  constructor() {
-    this.queue = [];
-  }
-  /**
-   * Stores an error; a second error before `take()` is kept as `details.next` of the first.
-   * @param error - the error to hold until the next public call
-   */
-  set(error) {
-    this.queue.push(error);
-  }
-  /**
-   * Returns and clears the pending error, or null. With several errors queued the FIRST is returned and
-   * each later one is chained as `details.next` of its predecessor (a copy: `details` is frozen).
-   * @returns the first pending error with the chain attached, or null
-   */
-  take() {
-    if (this.queue.length === 0) {
-      return null;
-    }
-    const errors = this.queue.splice(0);
-    let chained = null;
-    for (let i = errors.length - 1; i >= 0; i -= 1) {
-      const error = errors[i];
-      chained = chained === null ? error : new WebGpuGraphError(error.code, error.message, { ...error.details, next: chained });
-    }
-    return chained;
-  }
-  /**
-   * True when an error is pending.
-   * @returns whether `take()` would return an error
-   */
-  get pending() {
-    return this.queue.length > 0;
-  }
-}
-function uncapturedError(error, label) {
-  const { message } = error;
-  if (error.constructor.name === "GPUOutOfMemoryError") {
-    return new WebGpuGraphError("E_OUT_OF_MEMORY", `uncaptured out-of-memory error on "${label}": ${message}`, {
-      requested: 0,
-      resident: 0,
-      label
-    });
-  }
-  return new WebGpuGraphError("E_VALIDATION", `uncaptured validation error on "${label}": ${message}`, {
-    label,
-    message
-  });
-}
-function installUncapturedErrorSink(device, slot, onError) {
-  let installed = true;
-  const label = device.label ?? "";
-  const listener = (event) => {
-    if (!installed) {
-      return;
-    }
-    const wrapped = uncapturedError(event.error, label);
-    if (onError !== null) {
-      onError(wrapped);
-    } else {
-      slot.set(wrapped);
-    }
-  };
-  device.addEventListener("uncapturederror", listener);
-  return () => {
-    installed = false;
-    if (typeof device.removeEventListener === "function") {
-      device.removeEventListener("uncapturederror", listener);
-    }
-  };
-}
-function watchDeviceLost(device, onLost) {
-  let delivered = false;
-  return device.lost.then((info) => {
-    if (!delivered) {
-      delivered = true;
-      onLost(info);
-    }
-    return info;
-  });
-}
-function deviceLostError(info) {
-  return new WebGpuGraphError("E_DEVICE_LOST", `device lost (${info.reason}): ${info.message}`, {
-    reason: info.reason,
-    message: info.message
-  });
-}
-const INDIRECT_ARGS_STRIDE = 16;
-const BIND_GROUP_CACHE_LIMIT = 32;
-const bufferIds = /* @__PURE__ */ new WeakMap();
-let nextBufferId = 1;
-function bufferId(buffer) {
-  let id = bufferIds.get(buffer);
-  if (id === void 0) {
-    id = nextBufferId;
-    nextBufferId += 1;
-    bufferIds.set(buffer, id);
-  }
-  return id;
-}
-function rangesIntersect(a, b) {
-  return a.offset < b.offset + b.size && b.offset < a.offset + a.size;
-}
-class Kernel {
-  /**
-   * Wraps a compiled pipeline.
-   * @param device - the device the bind groups are created on
-   * @param spec - the module
-   * @param composed - the composed text (workgroup size and entry point)
-   * @param pipeline - the compiled pipeline
-   * @param layouts - the explicit bind-group layouts, one per group 0..maxGroup
-   */
-  constructor(device, spec, composed, pipeline, layouts) {
-    this.cache = /* @__PURE__ */ new Map();
-    this.device = device;
-    this.spec = spec;
-    this.pipeline = pipeline;
-    this.layouts = layouts;
-    this.workgroupSize = composed.overrides.WG;
-    this.entryPoint = composed.entryPoint;
-    const groups = layouts.map(() => []);
-    for (const decl of spec.bindings) {
-      groups[decl.group].push(decl);
-    }
-    for (const group of groups) {
-      group.sort((a, b) => a.binding - b.binding);
-    }
-    this.groups = groups;
-    this.dynamicCounts = groups.map((group) => group.filter((decl) => decl.kind === "uniform").length);
-  }
-  /**
-   * Creates (or reuses, keyed by every buffer identity + offset + size) the bind groups, each labelled
-   * `<spec.id>/<group>`; a missing or extra name is E_INVALID_ARGUMENT; two bindings of one call whose ranges
-   * intersect on one buffer while either slot is `storage` (read_write) is E_INVALID_ARGUMENT
-   * { argument: "aliasing" } (the host-side mirror of WebGPU's writable buffer-binding-aliasing rule, 3.10.1, so
-   * the failure is synchronous and labelled). CONTRACT DECISION: bind() is synchronous, so a createBindGroup
-   * validation error (a wrong-size uniform binding, a usage mismatch) is NOT thrown here -- it reaches the
-   * pending-error slot as E_VALIDATION { label: "<spec.id>/<group>" } and is thrown by the batch's readback
-   * (Dawn-node) or the next assertReady() (browser), spec 5.7. An empty bind group is created for every empty
-   * layout index so setBindGroup is called for 0..maxGroup.
-   * PLAN DECISION (verified on Dawn 0.4.0 / lavapipe): one buffer bound with two DIFFERENT access modes when one is
-   * `storage` is also E_INVALID_ARGUMENT { argument: "aliasing", reason: "usage" } even with disjoint ranges, because
-   * WebGPU's usage-scope rule rejects "writable usage and another usage in the same synchronization scope" per
-   * BUFFER; two `storage` slots with disjoint ranges (the state header / trace pattern) are accepted; a zero-size
-   * binding (never bind a zero-length buffer, spec 3.6) and an offset that is not a multiple of STORAGE_ALIGN = 256
-   * (spec 2.6; Dawn: "does not satisfy the minimum ... alignment (256)") are E_INVALID_ARGUMENT.
-   * @param resources - one Binding per declared name
-   * @returns the bound kernel (the same object for the same buffers, offsets and sizes until invalidate())
-   */
-  bind(resources) {
-    const { id } = this.spec;
-    const declared = new Map(this.spec.bindings.map((decl) => [decl.name, decl]));
-    for (const name of Object.keys(resources)) {
-      if (!declared.has(name)) {
-        throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${id}: no binding named "${name}"`, {
-          argument: "bindings",
-          value: name,
-          expected: [...declared.keys()].join(", ")
-        });
-      }
-    }
-    const resolved = [];
-    for (const decl of this.spec.bindings) {
-      const binding = resources[decl.name];
-      if (binding === void 0) {
-        throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${id}: binding "${decl.name}" is missing`, {
-          argument: "bindings",
-          value: decl.name,
-          expected: "a Binding for every declared name"
-        });
-      }
-      if (!(Number.isInteger(binding.size) && binding.size > 0)) {
-        throw new WebGpuGraphError(
-          "E_INVALID_ARGUMENT",
-          `${id}: binding "${decl.name}" has size ${binding.size}`,
-          {
-            argument: decl.name,
-            value: binding.size,
-            expected: "size > 0 (a zero-length buffer is never bound)"
-          }
-        );
-      }
-      if (!(Number.isInteger(binding.offset) && binding.offset >= 0 && binding.offset % STORAGE_ALIGN === 0)) {
-        throw new WebGpuGraphError(
-          "E_INVALID_ARGUMENT",
-          `${id}: binding "${decl.name}" has offset ${binding.offset}`,
-          {
-            argument: decl.name,
-            value: binding.offset,
-            expected: `a multiple of ${STORAGE_ALIGN} (spec 2.6: the offset alignment the package always honours)`
-          }
-        );
-      }
-      resolved.push({ decl, binding });
-    }
-    for (let i = 0; i < resolved.length; i++) {
-      for (let j = i + 1; j < resolved.length; j++) {
-        const a = resolved[i];
-        const b = resolved[j];
-        if (a.binding.buffer !== b.binding.buffer) {
-          continue;
-        }
-        const writable = a.decl.kind === "storage" || b.decl.kind === "storage";
-        if (!writable) {
-          continue;
-        }
-        if (a.decl.kind !== b.decl.kind) {
-          throw new WebGpuGraphError(
-            "E_INVALID_ARGUMENT",
-            `${id}: "${a.decl.name}" and "${b.decl.name}" bind one buffer with different access modes (writable usage next to another usage)`,
-            {
-              argument: "aliasing",
-              value: [a.decl.name, b.decl.name],
-              expected: "one access mode per buffer when a slot is read_write",
-              reason: "usage"
-            }
-          );
-        }
-        if (rangesIntersect(a.binding, b.binding)) {
-          throw new WebGpuGraphError(
-            "E_INVALID_ARGUMENT",
-            `${id}: "${a.decl.name}" and "${b.decl.name}" bind intersecting ranges of one read_write buffer`,
-            {
-              argument: "aliasing",
-              value: [a.decl.name, b.decl.name],
-              expected: "disjoint ranges",
-              reason: "range"
-            }
-          );
-        }
-      }
-    }
-    const key = resolved.map(({ binding }) => `${bufferId(binding.buffer)}:${binding.offset}:${binding.size}`).join("|");
-    const cached = this.cache.get(key);
-    if (cached !== void 0) {
-      this.cache.delete(key);
-      this.cache.set(key, cached);
-      return cached;
-    }
-    const byName = new Map(resolved.map(({ decl, binding }) => [decl.name, binding]));
-    const bindGroups = this.layouts.map(
-      (layout, group) => this.device.createBindGroup({
-        label: `${id}/${group}`,
-        layout,
-        entries: this.groups[group].map((decl) => {
-          const binding = byName.get(decl.name);
-          return {
-            binding: decl.binding,
-            resource: { buffer: binding.buffer, offset: binding.offset, size: binding.size }
-          };
-        })
-      })
-    );
-    const dynamicGroups = [];
-    this.dynamicCounts.forEach((count, group) => {
-      if (count > 0) {
-        dynamicGroups.push(group);
-      }
-    });
-    const bound = Object.freeze({
-      kernel: this,
-      bindGroups: Object.freeze(bindGroups),
-      dynamicGroups: Object.freeze(dynamicGroups)
-    });
-    this.cache.set(key, bound);
-    if (this.cache.size > BIND_GROUP_CACHE_LIMIT) {
-      this.cache.delete(this.cache.keys().next().value);
-    }
-    return bound;
-  }
-  /**
-   * setPipeline + setBindGroup for every group (dynamic offsets in dynamicGroups order) + dispatchWorkgroups(plan.x, plan.y, plan.z); a plan with x === 0 records nothing (spec 5.6).
-   * PLAN DECISION: one dynamic offset per dynamic GROUP, replicated over every uniform binding of that group (every
-   * P1-P3 kernel has exactly one params uniform per group); absent offsets mean 0; a BoundKernel of another kernel
-   * or an offset list of the wrong length is E_INVALID_ARGUMENT.
-   * PLAN DECISION: `dynamicOffsets?` is spelled `?: readonly number[]` rather than the contract's
-   * `?: readonly number[] | undefined` because the root ESLint rule no-duplicate-type-constituents rejects the
-   * explicit undefined on an optional parameter (the call signature is identical).
-   * @param pass - the open compute pass
-   * @param bound - a BoundKernel of THIS kernel
-   * @param plan - the dispatch shape
-   * @param dynamicOffsets - one byte offset per entry of bound.dynamicGroups
-   */
-  dispatch(pass, bound, plan, dynamicOffsets) {
-    this.check(bound, dynamicOffsets);
-    if (plan.x === 0) {
-      return;
-    }
-    this.setUp(pass, bound, dynamicOffsets);
-    pass.dispatchWorkgroups(plan.x, plan.y, plan.z);
-  }
-  /**
-   * setPipeline + the bind groups exactly as dispatch(), then dispatchWorkgroupsIndirect(args.buffer, args.offset +
-   * INDIRECT_ARGS_STRIDE * slot) (spec 5.4): the (x, y, 1) of the slot were written by the indirect-finalize kernel
-   * earlier in the same pass. A slot beyond the binding is E_INVALID_ARGUMENT.
-   * @param pass - the open compute pass
-   * @param bound - a BoundKernel of THIS kernel
-   * @param args - the args buffer range (usage INDIRECT | STORAGE)
-   * @param slot - the 16-byte slot index inside the range
-   * @param dynamicOffsets - one byte offset per entry of bound.dynamicGroups
-   */
-  dispatchIndirect(pass, bound, args, slot, dynamicOffsets) {
-    this.check(bound, dynamicOffsets);
-    if (!Number.isInteger(slot) || slot < 0 || (slot + 1) * INDIRECT_ARGS_STRIDE > args.size) {
-      throw new WebGpuGraphError(
-        "E_INVALID_ARGUMENT",
-        `${this.spec.id}: args slot ${slot} is outside the binding`,
-        {
-          argument: "slot",
-          value: slot,
-          expected: `0 <= slot < ${Math.floor(args.size / INDIRECT_ARGS_STRIDE)}`
-        }
-      );
-    }
-    this.setUp(pass, bound, dynamicOffsets);
-    pass.dispatchWorkgroupsIndirect(args.buffer, args.offset + INDIRECT_ARGS_STRIDE * slot);
-  }
-  /**
-   * The argument checks dispatch() and dispatchIndirect() share: a BoundKernel of another kernel or an offset list
-   * of the wrong length is E_INVALID_ARGUMENT.
-   * @param bound - the bound kernel
-   * @param dynamicOffsets - the offsets, if any
-   */
-  check(bound, dynamicOffsets) {
-    const { id } = this.spec;
-    if (bound.kernel !== this) {
-      throw new WebGpuGraphError(
-        "E_INVALID_ARGUMENT",
-        `${id}: the bound kernel belongs to "${bound.kernel.spec.id}"`,
-        {
-          argument: "bound",
-          value: bound.kernel.spec.id,
-          expected: id
-        }
-      );
-    }
-    if (dynamicOffsets !== void 0 && dynamicOffsets.length !== bound.dynamicGroups.length) {
-      throw new WebGpuGraphError(
-        "E_INVALID_ARGUMENT",
-        `${id}: ${dynamicOffsets.length} dynamic offsets for ${bound.dynamicGroups.length} dynamic groups`,
-        {
-          argument: "dynamicOffsets",
-          value: dynamicOffsets.length,
-          expected: bound.dynamicGroups.length
-        }
-      );
-    }
-  }
-  /**
-   * setPipeline + setBindGroup for every group (the dynamic offsets replicated over the uniform bindings of each
-   * dynamic group), the prefix dispatch() and dispatchIndirect() share.
-   * @param pass - the open compute pass
-   * @param bound - a BoundKernel of this kernel
-   * @param dynamicOffsets - one byte offset per entry of bound.dynamicGroups (absent = 0)
-   */
-  setUp(pass, bound, dynamicOffsets) {
-    pass.setPipeline(this.pipeline);
-    let next = 0;
-    bound.bindGroups.forEach((bindGroup, group) => {
-      const count = this.dynamicCounts[group];
-      if (count > 0) {
-        const offset = dynamicOffsets?.[next] ?? 0;
-        next += 1;
-        const offsets = [];
-        for (let k = 0; k < count; k++) {
-          offsets.push(offset);
-        }
-        pass.setBindGroup(group, bindGroup, offsets);
-      } else {
-        pass.setBindGroup(group, bindGroup);
-      }
-    });
-  }
-  /** Drops cached bind groups (a layout's buffers changed). */
-  invalidate() {
-    this.cache.clear();
-  }
-}
-const BufferUsage = Object.freeze({
-  MAP_READ: 1,
-  // GPUBufferUsage.MAP_READ
-  MAP_WRITE: 2,
-  // GPUBufferUsage.MAP_WRITE
-  COPY_SRC: 4,
-  // GPUBufferUsage.COPY_SRC
-  COPY_DST: 8,
-  // GPUBufferUsage.COPY_DST
-  INDEX: 16,
-  // GPUBufferUsage.INDEX
-  VERTEX: 32,
-  // GPUBufferUsage.VERTEX
-  UNIFORM: 64,
-  // GPUBufferUsage.UNIFORM
-  STORAGE: 128,
-  // GPUBufferUsage.STORAGE
-  INDIRECT: 256,
-  // GPUBufferUsage.INDIRECT
-  QUERY_RESOLVE: 512
-  // GPUBufferUsage.QUERY_RESOLVE
-});
-const MapMode = Object.freeze({
-  READ: 1,
-  // GPUMapMode.READ
-  WRITE: 2
-  // GPUMapMode.WRITE
-});
-const ShaderStage = Object.freeze({
-  VERTEX: 1,
-  // GPUShaderStage.VERTEX
-  FRAGMENT: 2,
-  // GPUShaderStage.FRAGMENT
-  COMPUTE: 4
-  // GPUShaderStage.COMPUTE
-});
-function wgslF32Literal(value) {
-  if (!Number.isFinite(value)) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `wgslF32Literal: ${value} is not a finite number`, {
-      argument: "value",
-      value,
-      expected: "a finite number"
-    });
-  }
-  const text = String(value);
-  return /[.e]/.test(text) ? text : `${text}.0`;
-}
-const PRELUDE_WGSL = (
-  /* wgsl */
-  `// ---- prelude: constants, standard overrides, helpers (every module receives this text first)
-const INVALID_INDEX: u32 = ${INVALID_INDEX}u;
-const U32_MAX: u32 = ${U32_MAX}u;
-const F32_INF_BITS: u32 = ${F32_INF_BITS}u;
-const F32_SIGN_BIT: u32 = ${F32_SIGN_BIT}u;
-const MAX_WORKGROUPS_PER_DIM: u32 = ${MAX_WORKGROUPS_PER_DIM}u;
-const EXACT_TILES_PER_PASS: u32 = ${EXACT_TILES_PER_PASS}u;
-const FA2_DIST_FLOOR: f32 = ${wgslF32Literal(FA2_DISTANCE_FLOOR)};
-const FA2_DIST_FLOOR_SQ: f32 = ${wgslF32Literal(FA2_DISTANCE_FLOOR_SQ)};
-const FA2_COINCIDENT_SQ: f32 = ${wgslF32Literal(FA2_COINCIDENT_SQ)};
-const FA2_FLAG_FIRST: u32 = ${FA2_FLAG_FIRST}u;
-const FA2_FLAG_ADAPTIVE: u32 = ${FA2_FLAG_ADAPTIVE}u;
-const FR_COOLING_STEP: f32 = ${wgslF32Literal(FR_COOLING_STEP)};
-const FR_COOLING_PATIENCE: u32 = ${FR_COOLING_PATIENCE}u;
-const GRID_HUB_CELL: u32 = ${GRID_HUB_CELL}u;
-const GRID_EXTENT_FLOOR: f32 = ${wgslF32Literal(GRID_EXTENT_FLOOR)};
-const GRID_BBOX_MARGIN: f32 = ${wgslF32Literal(GRID_BBOX_MARGIN)};
-const RADIX_BINS: u32 = ${RADIX_BINS}u;
-const RADIX_DIGIT_MASK: u32 = ${RADIX_BINS - 1}u;
-const APSP_TILE: u32 = ${APSP_TILE}u;
-const GROUP_HASH_LOAD_FACTOR: u32 = ${GROUP_HASH_LOAD_FACTOR}u;
-const TRIANGLE_BINARY_SEARCH_RATIO: u32 = ${TRIANGLE_BINARY_SEARCH_RATIO}u;
-const BC_SIGMA_EXPONENT_CAP: i32 = ${BC_SIGMA_EXPONENT_CAP}i;
-const F32_MAX: f32 = 0x1.fffffep+127;
-override WG: u32 = ${WORKGROUP_SIZE}u;
-override USE_PERM: bool = false;
-override HAS_WEIGHTS: bool = false;
-override SUBGROUP_MIN: u32 = 4u;
-override SUBGROUP_MAX: u32 = 0u;
-
-fn linear_id(wid: vec3<u32>, lid: u32) -> u32 { return (wid.x + wid.y * MAX_WORKGROUPS_PER_DIM) * WG + lid; }
-fn group_id(wid: vec3<u32>) -> u32 { return wid.x + wid.y * MAX_WORKGROUPS_PER_DIM; }
-// betweenness: the power of two the counts of depth L + 1 are divided by, from the f32 bits of depth L's largest count
-fn sigma_shift(maxBits: u32) -> i32 { return max(0i, i32((maxBits >> 23u) & 0xffu) - 127i - BC_SIGMA_EXPONENT_CAP); }
-fn lowbias32(x0: u32) -> u32 {
-    var x = x0;
-    x = x ^ (x >> 16u);
-    x = x * 0x7feb352du;
-    x = x ^ (x >> 15u);
-    x = x * 0x846ca68bu;
-    x = x ^ (x >> 16u);
-    return x;
-}
-fn mask_bit(w: u32, i: u32) -> bool { return ((w >> (i & 31u)) & 1u) == 1u; }
-fn unpack_u8(w: u32, i: u32) -> u32 { return (w >> (8u * (i & 3u))) & 0xFFu; }
-fn pair_hash(i: u32, j: u32) -> u32 { return lowbias32((min(i, j) * 0x9E3779B9u) ^ max(i, j)); }
-fn order_key(w: f32) -> u32 {
-    let raw = bitcast<u32>(w);
-    let bits = select(raw, 0u, raw == F32_SIGN_BIT);
-    return select(bits | F32_SIGN_BIT, ~bits, (bits & F32_SIGN_BIT) != 0u);
-}
-fn hash_unit(h: u32) -> f32 { return f32(h >> 8u) * (1.0 / 16777216.0); }
-fn hash_dir(h: u32, dim: u32) -> vec3f {
-    let phi = 6.283185307179586 * hash_unit(h);
-    if (dim == 2u) { return vec3f(cos(phi), sin(phi), 0.0); }
-    let z = 2.0 * hash_unit(lowbias32(h ^ 0x5bd1e995u)) - 1.0;
-    let r = sqrt(max(0.0, 1.0 - z * z));
-    return vec3f(r * cos(phi), r * sin(phi), z);
-}
-fn kick_dir(i: u32, j: u32, dim: u32) -> vec3f {
-    let d = hash_dir(pair_hash(i, j), dim);
-    return select(d, -d, i > j);
-}`
-);
-PRELUDE_WGSL.split("\n").length;
-const REDUCE_HELPERS_WORKGROUP_WGSL = (
-  /* wgsl */
-  `var<workgroup> wg_scratch_v: array<vec4f, WG>;
-var<workgroup> wg_scratch_u: array<u32, WG>;
-fn combine_v(a: vec4f, b: vec4f, op: u32) -> vec4f {
-    if (op == 1u) { return min(a, b); }
-    if (op == 2u) { return max(a, b); }
-    return a + b;
-}
-fn combine_u(a: u32, b: u32, op: u32) -> u32 {
-    if (op == 1u) { return min(a, b); }
-    if (op == 2u) { return max(a, b); }
-    return a + b;
-}
-fn wg_reduce_vec4(v: vec4f, lid: u32, op: u32) -> vec4f {
-    workgroupBarrier();
-    wg_scratch_v[lid] = v;
-    workgroupBarrier();
-    for (var s = WG / 2u; s > 0u; s = s >> 1u) {
-        if (lid < s) { wg_scratch_v[lid] = combine_v(wg_scratch_v[lid], wg_scratch_v[lid + s], op); }
-        workgroupBarrier();
-    }
-    let total = wg_scratch_v[0];
-    workgroupBarrier();
-    return total;
-}
-fn wg_reduce_u32(v: u32, lid: u32, op: u32) -> u32 {
-    workgroupBarrier();
-    wg_scratch_u[lid] = v;
-    workgroupBarrier();
-    for (var s = WG / 2u; s > 0u; s = s >> 1u) {
-        if (lid < s) { wg_scratch_u[lid] = combine_u(wg_scratch_u[lid], wg_scratch_u[lid + s], op); }
-        workgroupBarrier();
-    }
-    let total = wg_scratch_u[0];
-    workgroupBarrier();
-    return total;
-}
-fn wg_scan_u32(v: u32, lid: u32) -> u32 {
-    workgroupBarrier();
-    wg_scratch_u[lid] = v;
-    workgroupBarrier();
-    for (var s = 1u; s < WG; s = s * 2u) {                       // Hillis-Steele inclusive scan (scan-block's body); uniform: every lane runs every round
-        var t = 0u;
-        if (lid >= s) { t = wg_scratch_u[lid - s]; }
-        workgroupBarrier();
-        wg_scratch_u[lid] = wg_scratch_u[lid] + t;
-        workgroupBarrier();
-    }
-    let inclusive = wg_scratch_u[lid];
-    workgroupBarrier();                                          // the scratch is free for the next call
-    return inclusive;
-}
-fn wg_reduce_f32(v: f32, lid: u32, op: u32) -> f32 { return wg_reduce_vec4(vec4f(v, 0.0, 0.0, 0.0), lid, op).x; }`
-);
-const REDUCE_HELPERS_SUBGROUP_WGSL = (
-  /* wgsl */
-  `override SG_SLOTS: u32 = (WG + SUBGROUP_MIN - 1u) / SUBGROUP_MIN;   // one slot per subgroup; the count is largest when the compiler picks the SMALLEST size
-var<workgroup> sg_counter: atomic<u32>;
-var<workgroup> sg_val_v: array<vec4f, SG_SLOTS>;
-var<workgroup> sg_val_u: array<u32, SG_SLOTS>;
-var<workgroup> sg_key: array<u32, SG_SLOTS>;
-var<workgroup> sg_sorted_v: array<vec4f, SG_SLOTS>;
-var<workgroup> sg_sorted_u: array<u32, SG_SLOTS>;
-fn combine_v(a: vec4f, b: vec4f, op: u32) -> vec4f {
-    if (op == 1u) { return min(a, b); }
-    if (op == 2u) { return max(a, b); }
-    return a + b;
-}
-fn combine_u(a: u32, b: u32, op: u32) -> u32 {
-    if (op == 1u) { return min(a, b); }
-    if (op == 2u) { return max(a, b); }
-    return a + b;
-}
-fn wg_reduce_vec4(v: vec4f, lid: u32, op: u32) -> vec4f {
-    workgroupBarrier();
-    if (lid == 0u) { atomicStore(&sg_counter, 0u); }
-    workgroupBarrier();
-    let s_add = subgroupAdd(v);
-    let s_min = subgroupMin(v);
-    let s_max = subgroupMax(v);
-    var partial = s_add;
-    if (op == 1u) { partial = s_min; }
-    if (op == 2u) { partial = s_max; }
-    let key = subgroupMin(lid);                       // the smallest local id of this subgroup: a stable identity without @builtin(subgroup_id)
-    var slot = 0u;
-    if (subgroupElect()) { slot = atomicAdd(&sg_counter, 1u); }   // D16: the elected lane takes a slot from the counter
-    slot = subgroupBroadcast(slot, 0u);                            // and broadcasts it (lane 0 is the elected lane in uniform control flow)
-    if (subgroupElect()) { sg_val_v[slot] = partial; sg_key[slot] = key; }
-    workgroupBarrier();
-    let count = atomicLoad(&sg_counter);
-    if (lid < count) {                                             // rank the slots by key so the final sum has a fixed order (11.9 item 4)
-        let mine = sg_key[lid];
-        var rank = 0u;
-        for (var k = 0u; k < count; k = k + 1u) { if (sg_key[k] < mine) { rank = rank + 1u; } }
-        sg_sorted_v[rank] = sg_val_v[lid];
-    }
-    workgroupBarrier();
-    var total = sg_sorted_v[0];
-    for (var k = 1u; k < count; k = k + 1u) { total = combine_v(total, sg_sorted_v[k], op); }
-    workgroupBarrier();
-    return total;
-}
-fn wg_reduce_u32(v: u32, lid: u32, op: u32) -> u32 {
-    workgroupBarrier();
-    if (lid == 0u) { atomicStore(&sg_counter, 0u); }
-    workgroupBarrier();
-    let s_add = subgroupAdd(v);
-    let s_min = subgroupMin(v);
-    let s_max = subgroupMax(v);
-    var partial = s_add;
-    if (op == 1u) { partial = s_min; }
-    if (op == 2u) { partial = s_max; }
-    let key = subgroupMin(lid);
-    var slot = 0u;
-    if (subgroupElect()) { slot = atomicAdd(&sg_counter, 1u); }
-    slot = subgroupBroadcast(slot, 0u);
-    if (subgroupElect()) { sg_val_u[slot] = partial; sg_key[slot] = key; }
-    workgroupBarrier();
-    let count = atomicLoad(&sg_counter);
-    if (lid < count) {
-        let mine = sg_key[lid];
-        var rank = 0u;
-        for (var k = 0u; k < count; k = k + 1u) { if (sg_key[k] < mine) { rank = rank + 1u; } }
-        sg_sorted_u[rank] = sg_val_u[lid];
-    }
-    workgroupBarrier();
-    var total = sg_sorted_u[0];
-    for (var k = 1u; k < count; k = k + 1u) { total = combine_u(total, sg_sorted_u[k], op); }
-    workgroupBarrier();
-    return total;
-}
-fn wg_scan_u32(v: u32, lid: u32) -> u32 {
-    workgroupBarrier();
-    if (lid == 0u) { atomicStore(&sg_counter, 0u); }
-    workgroupBarrier();
-    let inSub = subgroupExclusiveAdd(v) + v;                     // the lane's inclusive sum within its subgroup
-    let total = subgroupAdd(v);
-    let key = subgroupMin(lid);                                   // the subgroup's identity: its smallest local id (D16)
-    var slot = 0u;
-    if (subgroupElect()) { slot = atomicAdd(&sg_counter, 1u); }
-    slot = subgroupBroadcast(slot, 0u);
-    if (subgroupElect()) { sg_val_u[slot] = total; sg_key[slot] = key; }
-    workgroupBarrier();
-    let count = atomicLoad(&sg_counter);
-    var carry = 0u;                                               // the totals of every subgroup whose key is below this lane's: LANE order, whatever order the slots were taken in
-    for (var k = 0u; k < count; k = k + 1u) { if (sg_key[k] < key) { carry = carry + sg_val_u[k]; } }
-    workgroupBarrier();                                          // the slots are free for the next call
-    return inSub + carry;
-}
-fn wg_reduce_f32(v: f32, lid: u32, op: u32) -> f32 { return wg_reduce_vec4(vec4f(v, 0.0, 0.0, 0.0), lid, op).x; }`
-);
-const REDUCE_HELPER_NAMES = ["wg_reduce_f32", "wg_reduce_u32", "wg_reduce_vec4", "wg_scan_u32"];
-const WGSL_RESERVED_WORDS = Object.freeze(
-  `NULL Self abstract active alignas alignof as asm asm_fragment async attribute auto await become cast catch class
-    co_await co_return co_yield coherent column_major common compile compile_fragment concept const_cast consteval
-    constexpr constinit crate debugger decltype delete demote demote_to_helper do dynamic_cast enum explicit export
-    extends extern external fallthrough filter final finally friend from fxgroup get goto groupshared highp impl
-    implements import inline instanceof interface layout lowp macro macro_rules match mediump meta mod module move
-    mut mutable namespace new nil noexcept noinline nointerpolation non_coherent noncoherent noperspective null
-    nullptr of operator package packoffset partition pass patch pixelfragment precise precision premerge priv
-    protected pub public readonly ref regardless register reinterpret_cast require resource restrict self set shared
-    sizeof smooth snorm static static_assert static_cast std subroutine super target template this thread_local
-    throw trait try type typedef typeid typename typeof union unless unorm unsafe unsized use using varying virtual
-    volatile wgsl where with writeonly yield`.trim().split(/\s+/)
-);
-const STANDARD_OVERRIDES = ["WG", "USE_PERM", "HAS_WEIGHTS", "SUBGROUP_MIN", "SUBGROUP_MAX"];
-const STANDARD_OVERRIDE_TYPES = Object.freeze({
-  WG: "u32",
-  USE_PERM: "bool",
-  HAS_WEIGHTS: "bool",
-  SUBGROUP_MIN: "u32",
-  SUBGROUP_MAX: "u32"
-});
-const KNOWN_NEEDS = Object.freeze(["subgroups"]);
-const SUBGROUP_FLOOR = 4;
-const BUILTIN_TYPES = /* @__PURE__ */ new Set([
-  "u32",
-  "i32",
-  "f32",
-  "f16",
-  "bool",
-  "vec2f",
-  "vec3f",
-  "vec4f",
-  "vec2u",
-  "vec3u",
-  "vec4u",
-  "vec2i",
-  "vec3i",
-  "vec4i",
-  "vec2h",
-  "vec3h",
-  "vec4h"
-]);
-const TEMPLATED_BUILTIN = /^(vec[234]|mat[234]x[234]|atomic|array)</;
-const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const ADDRESS_SPACE = Object.freeze({
-  storage: "var<storage, read_write>",
-  "storage-ro": "var<storage, read>",
-  uniform: "var<uniform>"
-});
-const RESERVED = new Set(WGSL_RESERVED_WORDS);
-const MARKER = /\/\/@@([A-Za-z0-9_]+)@@/;
-const IDENTIFIER_TOKENS = new RegExp("(?<![A-Za-z0-9_])[A-Za-z_][A-Za-z0-9_]*", "g");
-const COMPUTE_ATTRIBUTE = /@compute\b/g;
-const ENTRY_FN = /\bfn\s+([A-Za-z_][A-Za-z0-9_]*)/;
-function composeError(id, slot, message) {
-  return new WebGpuGraphError("E_SHADER_COMPILE", `${id}: ${message}`, { id, stage: "compose", slot });
-}
-function stripComments(text) {
-  return text.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, "");
-}
-function structNameOf(wgslType) {
-  const trimmed = wgslType.trim();
-  const inner = trimmed.startsWith("array<") ? trimmed.slice("array<".length).replace(/\s*(,[^>]*)?>\s*$/, "") : trimmed;
-  if (BUILTIN_TYPES.has(inner) || TEMPLATED_BUILTIN.test(inner)) {
-    return null;
-  }
-  return inner;
-}
-function assertOverrideValue(id, name, type, value) {
-  const ok = type === "bool" ? typeof value === "boolean" : typeof value === "number" && Number.isFinite(value) && (type === "f32" || Number.isInteger(value) && value >= 0);
-  if (!ok) {
-    throw composeError(id, `override:${name}`, `override ${name} (${type}) cannot take the value ${String(value)}`);
-  }
-}
-function overrideLiteral(decl) {
-  if (decl.type === "bool") {
-    return decl.default ? "true" : "false";
-  }
-  const value = decl.default;
-  return decl.type === "u32" ? `${value}u` : wgslF32Literal(value);
-}
-function bindingLine(decl) {
-  const space = ADDRESS_SPACE[decl.kind];
-  return `@group(${decl.group}) @binding(${decl.binding}) ${space} ${decl.name}: ${decl.wgslType};`;
-}
-function findEntryPoint(body) {
-  const stripped = stripComments(body);
-  const matches = [...stripped.matchAll(COMPUTE_ATTRIBUTE)];
-  if (matches.length !== 1 || matches[0].index === void 0) {
-    return null;
-  }
-  const fn = ENTRY_FN.exec(stripped.slice(matches[0].index));
-  return fn === null ? null : fn[1];
-}
-function bindGroupLayoutDescriptors(spec) {
-  const maxGroup = spec.bindings.reduce((acc, b) => Math.max(acc, b.group), -1);
-  const blocks = new Map(spec.uniforms.map((block) => [block.name, block]));
-  const descriptors = [];
-  for (let group = 0; group <= maxGroup; group++) {
-    const entries = spec.bindings.filter((b) => b.group === group).sort((a, b) => a.binding - b.binding).map((b) => {
-      if (b.kind === "uniform") {
-        const block = blocks.get(b.wgslType);
-        const buffer = { type: "uniform", hasDynamicOffset: true };
-        if (block !== void 0) {
-          buffer.minBindingSize = block.byteLength;
-        }
-        return { binding: b.binding, visibility: ShaderStage.COMPUTE, buffer };
-      }
-      return {
-        binding: b.binding,
-        visibility: ShaderStage.COMPUTE,
-        buffer: { type: b.kind === "storage" ? "storage" : "read-only-storage" }
-      };
-    });
-    descriptors.push({ entries });
-  }
-  return descriptors;
-}
-function validateDeclarations(spec) {
-  const { id } = spec;
-  for (const need of spec.needs) {
-    if (!KNOWN_NEEDS.includes(need)) {
-      throw composeError(id, `needs:${need}`, `unknown feature "${need}" in needs`);
-    }
-  }
-  const declared = /* @__PURE__ */ new Map();
-  for (const decl of spec.overrideDecls) {
-    if (!IDENTIFIER.test(decl.name) || RESERVED.has(decl.name)) {
-      throw composeError(id, `override:${decl.name}`, `override name "${decl.name}" is not a usable identifier`);
-    }
-    if (STANDARD_OVERRIDES.includes(decl.name) || declared.has(decl.name)) {
-      throw composeError(
-        id,
-        `override:${decl.name}`,
-        `override "${decl.name}" is declared twice (the prelude declares the standard ones)`
-      );
-    }
-    assertOverrideValue(id, decl.name, decl.type, decl.default);
-    declared.set(decl.name, decl.type);
-  }
-  for (const [key, value] of Object.entries(spec.overrides)) {
-    const standard = STANDARD_OVERRIDE_TYPES[key];
-    const type = standard ?? declared.get(key);
-    if (type === void 0) {
-      throw composeError(
-        id,
-        `override:${key}`,
-        `override "${key}" is neither a standard override nor declared in overrideDecls`
-      );
-    }
-    assertOverrideValue(id, key, type, value);
-  }
-  const slots = /* @__PURE__ */ new Set();
-  const names = /* @__PURE__ */ new Set();
-  const blocks = new Set(spec.uniforms.map((block) => block.name));
-  for (const b of spec.bindings) {
-    if (!IDENTIFIER.test(b.name) || RESERVED.has(b.name)) {
-      throw composeError(id, `binding:${b.name}`, `binding name "${b.name}" is not a usable identifier`);
-    }
-    const slot = `${b.group}.${b.binding}`;
-    if (slots.has(slot)) {
-      throw composeError(id, `binding:${b.name}`, `two bindings share group ${b.group} binding ${b.binding}`);
-    }
-    if (names.has(b.name)) {
-      throw composeError(id, `binding:${b.name}`, `two bindings share the name "${b.name}"`);
-    }
-    slots.add(slot);
-    names.add(b.name);
-    const struct = structNameOf(b.wgslType);
-    if (struct !== null && !blocks.has(struct)) {
-      throw composeError(
-        id,
-        `type:${struct}`,
-        `binding "${b.name}" names struct "${struct}" but no block in spec.uniforms declares it`
-      );
-    }
-  }
-}
-function substituteSnippets(spec) {
-  const { id } = spec;
-  let { body } = spec;
-  for (const [key, snippet] of Object.entries(spec.snippets ?? {})) {
-    const marker = `//@@${key}@@`;
-    if (!body.includes(marker)) {
-      throw composeError(id, `snippet:${key}`, `snippet "${key}" has no ${marker} marker in the body`);
-    }
-    body = body.split(marker).join(snippet);
-  }
-  const left = MARKER.exec(body);
-  if (left !== null) {
-    throw composeError(id, `marker:${left[1]}`, `marker //@@${left[1]}@@ is not filled by any snippet`);
-  }
-  return body;
-}
-function validateBody(spec, body) {
-  const { id } = spec;
-  for (const forbidden of ["@group(", "override "]) {
-    if (body.includes(forbidden)) {
-      throw composeError(
-        id,
-        `body:${forbidden}`,
-        `a body must not contain "${forbidden}" (the composer emits those lines)`
-      );
-    }
-  }
-  const stripped = stripComments(body);
-  const helpers = REDUCE_HELPER_NAMES;
-  for (const match of stripped.matchAll(IDENTIFIER_TOKENS)) {
-    const word = match[0];
-    if (RESERVED.has(word)) {
-      throw composeError(
-        id,
-        `reserved:${word}`,
-        `"${word}" is a WGSL reserved word (spec 16.2) and cannot be an identifier`
-      );
-    }
-    if (helpers.includes(word) && !spec.needs.includes("subgroups")) {
-      throw composeError(id, `helper:${word}`, `the body calls ${word} but spec.needs does not list "subgroups"`);
-    }
-  }
-}
-function composeWgsl(spec, caps) {
-  validateDeclarations(spec);
-  const entryPoint = findEntryPoint(spec.body);
-  if (entryPoint === null) {
-    throw composeError(
-      spec.id,
-      "entry",
-      "a body must carry exactly one @compute attribute followed by `fn <name>`"
-    );
-  }
-  const body = substituteSnippets(spec);
-  validateBody(spec, body);
-  const wantsHelpers = spec.needs.includes("subgroups");
-  const subgroups = wantsHelpers && caps.features.has("subgroups");
-  const overrides = { ...spec.overrides };
-  if (overrides.WG === void 0) {
-    overrides.WG = workgroupSizeFor(caps);
-  }
-  if (subgroups) {
-    overrides.SUBGROUP_MAX = caps.subgroupMaxSize;
-    overrides.SUBGROUP_MIN = Math.max(SUBGROUP_FLOOR, caps.subgroupMinSize);
-  }
-  const parts = [];
-  if (subgroups) {
-    parts.push("enable subgroups;");
-  }
-  parts.push(PRELUDE_WGSL);
-  for (const decl of spec.overrideDecls) {
-    parts.push(`override ${decl.name}: ${decl.type} = ${overrideLiteral(decl)};`);
-  }
-  for (const block of spec.uniforms) {
-    parts.push(block.wgsl);
-  }
-  if (wantsHelpers) {
-    parts.push(subgroups ? REDUCE_HELPERS_SUBGROUP_WGSL : REDUCE_HELPERS_WORKGROUP_WGSL);
-  }
-  for (const decl of spec.bindings) {
-    parts.push(bindingLine(decl));
-  }
-  const head = parts.join("\n");
-  const code = `${head}
-${body}`;
-  return Object.freeze({
-    id: spec.id,
-    code,
-    bodyLine: head.split("\n").length + 1,
-    overrides: Object.freeze(overrides),
-    constants: Object.freeze(referencedOverrides(code, overrides)),
-    entryPoint,
-    subgroups
-  });
-}
-function referencedOverrides(code, overrides) {
-  const stripped = code.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ").replace(/^\s*override\s+\w+\s*:[^\n]*$/gm, " ");
-  const referenced = {};
-  for (const [name, value] of Object.entries(overrides)) {
-    if (new RegExp(`\\b${name}\\b`).test(stripped)) {
-      referenced[name] = value;
-    }
-  }
-  return referenced;
-}
-function stableJson(value) {
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableJson(item)).join(",")}]`;
-  }
-  if (typeof value === "object" && value !== null) {
-    const record = value;
-    const keys = Object.keys(record).sort();
-    return `{${keys.map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-function hashSnippets(snippets) {
-  if (snippets === void 0 || Object.keys(snippets).length === 0) {
-    return "0";
-  }
-  const text = stableJson(snippets);
-  let hash = 2166136261;
-  for (let i = 0; i < text.length; i++) {
-    hash ^= text.charCodeAt(i);
-    hash = Math.imul(hash, 16777619) >>> 0;
-  }
-  return hash.toString(16).padStart(8, "0");
-}
-function pipelineKey(spec, caps) {
-  const present = spec.needs.filter((need) => caps.features.has(need)).join(",");
-  return `${spec.id}|${stableJson(spec.overrides)}|${present}|${hashSnippets(spec.snippets)}`;
-}
-function messageOf(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-class PipelineCache {
-  /**
-   * Builds a cache over a device.
-   * @param device - the device pipelines are created on
-   * @param caps - its capabilities (WG, subgroup sizes, features)
-   */
-  constructor(device, caps) {
-    this.pending = /* @__PURE__ */ new Map();
-    this.entries = /* @__PURE__ */ new Map();
-    this.order = [];
-    this.disposed = false;
-    this.device = device;
-    this.caps = caps;
-  }
-  /**
-   * The cache key of a spec on this device: `id + "|" + stableJson(overrides) + "|" + needs.filter(present).join(",") + "|" + hash(snippets)`.
-   * @param spec - the module
-   * @returns the key
-   */
-  key(spec) {
-    return pipelineKey(spec, this.caps);
-  }
-  /**
-   * createComputePipelineAsync inside a validation scope with the layouts derived from spec.bindings; compilation messages become E_SHADER_COMPILE { id, stage: "compile", messages } with body-relative lines.
-   * @param spec - the module
-   * @returns the pipeline (the same object for the same key)
-   */
-  async get(spec) {
-    return (await this.entry(spec)).pipeline;
-  }
-  /**
-   * The Kernel (pipeline + layouts + binding names) for a spec; cached with the pipeline.
-   * @param spec - the module
-   * @returns the kernel (the same object for the same key)
-   */
-  async kernel(spec) {
-    return (await this.entry(spec)).kernel;
-  }
-  /**
-   * Compiles every spec not yet cached (load() calls it so the first step() does not compile).
-   * @param specs - the modules
-   */
-  async warm(specs) {
-    await Promise.all(specs.map((spec) => this.entry(spec)));
-  }
-  /**
-   * Number of cached pipelines.
-   * @returns the count of finished compiles
-   */
-  get size() {
-    return this.entries.size;
-  }
-  /**
-   * Every key created so far, in creation order (the override-matrix coverage test reads it).
-   * PLAN DECISION: keys are listed in compile-START order and only those whose compile finished (warm() compiles
-   * concurrently, so completion order is not deterministic; a failed compile is removed).
-   * @returns the keys
-   * @internal
-   */
-  keys() {
-    return this.order.filter((key) => this.entries.has(key));
-  }
-  /**
-   * The bind-group layouts of a cached kernel by key.
-   * @param key - a key from keys()
-   * @returns the layouts, or null when the key is not cached
-   * @internal
-   */
-  layoutsOf(key) {
-    return this.entries.get(key)?.layouts ?? null;
-  }
-  /**
-   * PLAN DECISION: forgets every pipeline and refuses further compiles with E_DISPOSED (the context's dispose()
-   * may call it; a GPUComputePipeline has no destroy(), so the objects are simply released).
-   */
-  dispose() {
-    this.disposed = true;
-    this.pending.clear();
-    this.entries.clear();
-    this.order.length = 0;
-  }
-  /**
-   * The cached entry of a spec, compiling it once per key.
-   * @param spec - the module
-   * @returns the entry
-   */
-  entry(spec) {
-    if (this.disposed) {
-      return Promise.reject(
-        new WebGpuGraphError("E_DISPOSED", "PipelineCache: disposed", { label: "PipelineCache" })
-      );
-    }
-    const key = this.key(spec);
-    const inFlight = this.pending.get(key);
-    if (inFlight !== void 0) {
-      return inFlight;
-    }
-    this.order.push(key);
-    const compile = this.compile(spec, key).then(
-      (entry) => {
-        if (!this.disposed) {
-          this.entries.set(key, entry);
-        }
-        return entry;
-      },
-      (err) => {
-        this.pending.delete(key);
-        const at = this.order.indexOf(key);
-        if (at >= 0) {
-          this.order.splice(at, 1);
-        }
-        throw err;
-      }
-    );
-    this.pending.set(key, compile);
-    return compile;
-  }
-  /**
-   * One compile: compose, create the shader module inside a synchronous push / pop validation pair (so concurrent
-   * compiles never interleave scopes), check the compilation info, create the layouts and the pipeline.
-   * PLAN DECISION: `E_SHADER_COMPILE` at stage "compile" also carries `lines` (the body-relative 1-based line of every
-   * error message, from `composed.bodyLine`) next to the contract's `messages`; a `createComputePipelineAsync`
-   * rejection (a GPUPipelineError, which pushes nothing into a validation scope on Dawn 0.4.0) is
-   * `E_VALIDATION { label: "<id>|pipeline", message }`; bool overrides travel as the pipeline constants 1 / 0
-   * because dawn.node's WebIDL layer rejects a boolean constant.
-   * @param spec - the module
-   * @param key - its key (the pipeline label)
-   * @returns the entry
-   */
-  async compile(spec, key) {
-    const composed = composeWgsl(spec, this.caps);
-    const { device } = this;
-    const label = `${spec.id}|pipeline`;
-    device.pushErrorScope("validation");
-    const module = device.createShaderModule({ code: composed.code, label: spec.id });
-    const layouts = bindGroupLayoutDescriptors(spec).map(
-      (descriptor, group) => device.createBindGroupLayout({ ...descriptor, label: `${spec.id}/layout${group}` })
-    );
-    const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: layouts, label: `${spec.id}|layout` });
-    const popped = device.popErrorScope();
-    const info = await module.getCompilationInfo();
-    const scopeError = await popped;
-    const errors = info.messages.filter((message) => message.type === "error");
-    if (errors.length > 0) {
-      const preludeLines = composed.bodyLine - 1;
-      throw new WebGpuGraphError(
-        "E_SHADER_COMPILE",
-        `${spec.id}: WGSL compilation failed (${errors.length} error(s))`,
-        {
-          id: spec.id,
-          stage: "compile",
-          messages: formatCompilationInfo(info, preludeLines),
-          lines: errors.map((message) => message.lineNum - preludeLines)
-        }
-      );
-    }
-    if (scopeError !== null) {
-      throw new WebGpuGraphError("E_VALIDATION", `${spec.id}: ${scopeError.message}`, {
-        label,
-        message: scopeError.message
-      });
-    }
-    const constants = {};
-    for (const [name, value] of Object.entries(composed.constants)) {
-      if (typeof value === "boolean") {
-        constants[name] = value ? 1 : 0;
-      } else {
-        constants[name] = value;
-      }
-    }
-    let pipeline;
-    try {
-      pipeline = await device.createComputePipelineAsync({
-        label: key,
-        layout: pipelineLayout,
-        compute: { module, entryPoint: composed.entryPoint, constants }
-      });
-    } catch (err) {
-      const message = messageOf(err);
-      throw new WebGpuGraphError("E_VALIDATION", `${spec.id}: pipeline creation failed: ${message}`, {
-        label,
-        message
-      });
-    }
-    const kernel = new Kernel(device, spec, composed, pipeline, layouts);
-    return { key, composed, pipeline, layouts, kernel };
-  }
-}
-class Profiler {
-  /**
-   * Creates the query set and the resolve buffer when usable; `slots` defaults to PROFILER_QUERY_SLOTS = 256
-   * (spec 5.5); 2 query slots per pass. `enabled` is also false when the device lacks "timestamp-query" or
-   * `slots < 2`, so no caller can make the profiler raise a validation error.
-   * @param device - the device the query set is created on
-   * @param enabled - whether the caller wants profiling (the context passes `features.has("timestamp-query")`)
-   * @param quantised - true in browsers
-   * @param slots - query slots, two per pass (default PROFILER_QUERY_SLOTS)
-   */
-  constructor(device, enabled, quantised, slots) {
-    this.labels = /* @__PURE__ */ new WeakMap();
-    this.partialRequests = /* @__PURE__ */ new WeakSet();
-    this.pending = [];
-    this.cursor = 0;
-    this.refused = 0;
-    this.destroyed = false;
-    const count = slots ?? PROFILER_QUERY_SLOTS;
-    this.quantised = quantised;
-    this.slots = count;
-    const usable = enabled && count >= 2 && device.features.has("timestamp-query");
-    this.enabled = usable;
-    if (usable) {
-      this.querySet = device.createQuerySet({ label: "profiler/timestamps", type: "timestamp", count });
-      this.resolveBuffer = device.createBuffer({
-        label: "profiler/resolve",
-        size: count * 8,
-        usage: BufferUsage.QUERY_RESOLVE | BufferUsage.COPY_SRC
-      });
-    } else {
-      this.querySet = null;
-      this.resolveBuffer = null;
-    }
-  }
-  /**
-   * The timestampWrites descriptor for a new pass, or undefined when disabled / out of slots. A pass refused for
-   * want of slots is counted, and the next `resolveInto()` marks its request partial.
-   * @param label - the pass name reported by `timings()`
-   * @returns the descriptor a CommandBatch puts on beginComputePass, or undefined
-   */
-  beginPass(label) {
-    if (this.querySet === null || this.destroyed) {
-      return void 0;
-    }
-    if (this.cursor + 2 > this.slots) {
-      this.refused++;
-      return void 0;
-    }
-    const begin = this.cursor;
-    this.cursor += 2;
-    this.pending.push({ label, begin });
-    return { querySet: this.querySet, beginningOfPassWriteIndex: begin, endOfPassWriteIndex: begin + 1 };
-  }
-  /**
-   * Records the resolve + copy into the batch's staging slot; returns the request's byte range, or null when
-   * nothing was written (disabled, destroyed, or no pass begun since the last resolve).
-   * @param batch - the batch whose passes were timed (it must still be open)
-   * @returns the readback request `timings()` decodes, or null
-   */
-  resolveInto(batch) {
-    if (this.querySet === null || this.resolveBuffer === null || this.destroyed || this.pending.length === 0) {
-      return null;
-    }
-    const count = this.cursor;
-    batch.resolveQuerySet(this.querySet, 0, count, this.resolveBuffer);
-    const request = batch.readback(this.resolveBuffer, 0, count * 8);
-    this.labels.set(
-      request,
-      this.pending.map((pass) => pass.label)
-    );
-    if (this.refused > 0) {
-      this.partialRequests.add(request);
-    }
-    this.pending = [];
-    this.cursor = 0;
-    this.refused = 0;
-    return request;
-  }
-  /**
-   * Whether a pass of the batch was refused a slot pair, so `timings()` covers only its first slots / 2 passes
-   * and their sum is not the batch's duration.
-   * @param request - the request `resolveInto()` returned
-   * @returns true when at least one pass of that batch went untimed
-   */
-  partial(request) {
-    return this.partialRequests.has(request);
-  }
-  /**
-   * Decodes the timings of a batch from its readback bytes.
-   * @param bytes - the resolved readback of the batch
-   * @param request - the request `resolveInto()` returned for it
-   * @returns one timing per pass in pass order (empty for a request this profiler did not create)
-   */
-  timings(bytes, request) {
-    const labels = this.labels.get(request);
-    if (labels === void 0) {
-      return [];
-    }
-    const view = new DataView(bytes);
-    const out = [];
-    for (let i = 0; i < labels.length; i++) {
-      const at = request.offset + i * 16;
-      if (at + 16 > bytes.byteLength) {
-        break;
-      }
-      const begin = view.getBigUint64(at, true);
-      const end = view.getBigUint64(at + 8, true);
-      out.push({ label: labels[i], ns: Number(end - begin) });
-    }
-    return out;
-  }
-  /** Destroys the query set and the resolve buffer; idempotent. */
-  destroy() {
-    if (this.destroyed) {
-      return;
-    }
-    this.destroyed = true;
-    this.pending = [];
-    this.cursor = 0;
-    this.refused = 0;
-    if (this.querySet !== null) {
-      this.querySet.destroy();
-    }
-    if (this.resolveBuffer !== null) {
-      this.resolveBuffer.destroy();
-    }
-  }
-}
-class Lease {
-  /**
-   * Creates a lease over a pool; `pool.lease()` is the usual way to get one.
-   * @param pool - the pool every acquisition of this lease goes through
-   */
-  constructor(pool) {
-    this.buffers = /* @__PURE__ */ new Set();
-    this.released = false;
-    this.pool = pool;
-  }
-  /**
-   * pool.acquire(byteLength, STORAGE | COPY_SRC | COPY_DST, label).
-   * @param byteLength - bytes needed; the pool rounds up to its size class
-   * @param label - the buffer label
-   * @returns the buffer, returned to the pool by `release()`
-   */
-  storage(byteLength, label) {
-    return this.acquire(byteLength, BufferUsage.STORAGE | BufferUsage.COPY_SRC | BufferUsage.COPY_DST, label);
-  }
-  /**
-   * pool.acquire(byteLength, UNIFORM | COPY_DST, label).
-   * @param byteLength - bytes needed; the pool rounds up to its size class
-   * @param label - the buffer label
-   * @returns the buffer, returned to the pool by `release()`
-   */
-  uniform(byteLength, label) {
-    return this.acquire(byteLength, BufferUsage.UNIFORM | BufferUsage.COPY_DST, label);
-  }
-  /**
-   * pool.acquire with explicit usage.
-   * @param byteLength - bytes needed; the pool rounds up to its size class
-   * @param usage - the GPUBufferUsage bits
-   * @param label - the buffer label
-   * @returns the buffer, returned to the pool by `release()`
-   */
-  acquire(byteLength, usage, label) {
-    if (this.released) {
-      throw new WebGpuGraphError("E_DISPOSED", `lease already released: cannot acquire "${label}"`, { label });
-    }
-    const buffer = this.pool.acquire(byteLength, usage, label);
-    this.buffers.add(buffer);
-    return buffer;
-  }
-  /**
-   * Releases every buffer acquired through this lease; idempotent. A pool that `ctx.dispose()` already
-   * destroyed has nothing left to take back, so its E_DISPOSED is swallowed here: the lease sits in a
-   * `finally` block and must never mask the error that unwound the algorithm.
-   */
-  release() {
-    if (this.released) {
-      return;
-    }
-    this.released = true;
-    const owned = [...this.buffers];
-    this.buffers.clear();
-    for (const buffer of owned) {
-      try {
-        this.pool.release(buffer);
-      } catch (error) {
-        if (!hasErrorCode(error, "E_DISPOSED")) {
-          throw error;
-        }
-      }
-    }
-  }
-  /**
-   * Live buffers of this lease.
-   * @returns the number of buffers acquired through the lease and not yet released
-   */
-  get count() {
-    return this.buffers.size;
-  }
-}
-function classKey(sizeClass, usage) {
-  return `${sizeClass}:${usage}`;
-}
-class BufferPool {
-  /**
-   * Creates an empty pool.
-   * @param _device - the device (buffers are created through the allocator, which owns it; the parameter keeps
-   *   the contract's constructor shape)
-   * @param allocator - the context's OOM-scoped allocator
-   * @param maxBufferSize - the device's maxBufferSize (classes above it are never created)
-   * @param options - pool options
-   * @param options.maxIdlePerClass - idle buffers kept per (class, usage); default POOL_MAX_IDLE_PER_CLASS
-   */
-  constructor(_device, allocator, maxBufferSize, options) {
-    this.idle = /* @__PURE__ */ new Map();
-    this.live = /* @__PURE__ */ new Map();
-    this.liveBytesValue = 0;
-    this.idleBytesValue = 0;
-    this.disposed = false;
-    this.allocator = allocator;
-    this.maxBufferSize = maxBufferSize - maxBufferSize % 4;
-    this.maxIdlePerClass = options?.maxIdlePerClass ?? POOL_MAX_IDLE_PER_CLASS;
-  }
-  /**
-   * The size class a byte length rounds up to: powers of two from 4 KiB to 64 MiB, then 16 MiB steps (pure).
-   * @param byteLength - a positive integer
-   * @returns the class in bytes
-   */
-  static sizeClass(byteLength) {
-    if (!Number.isInteger(byteLength) || byteLength <= 0) {
-      throw new WebGpuGraphError("E_INVALID_ARGUMENT", "byteLength: expected a positive integer", {
-        argument: "byteLength",
-        value: byteLength,
-        expected: "a positive integer"
-      });
-    }
-    if (byteLength > POOL_MAX_POW2_CLASS_BYTES) {
-      return Math.ceil(byteLength / POOL_LINEAR_STEP_BYTES) * POOL_LINEAR_STEP_BYTES;
-    }
-    let sizeClass = POOL_MIN_CLASS_BYTES;
-    while (sizeClass < byteLength) {
-      sizeClass *= 2;
-    }
-    return sizeClass;
-  }
-  /**
-   * Acquires a buffer of at least byteLength (an idle one of the class and usage, else a new one through the
-   * allocator); E_TOO_LARGE above maxBufferSize.
-   * @param byteLength - the bytes needed
-   * @param usage - the GPUBufferUsage flags
-   * @param label - the buffer label (a reused buffer is relabelled)
-   * @returns a buffer of the class size
-   */
-  acquire(byteLength, usage, label) {
-    if (this.disposed) {
-      throw new WebGpuGraphError("E_DISPOSED", "the buffer pool was disposed", { label: "pool" });
-    }
-    const rounded = BufferPool.sizeClass(byteLength);
-    if (byteLength > this.maxBufferSize) {
-      throw new WebGpuGraphError(
-        "E_TOO_LARGE",
-        `pool: ${byteLength} bytes exceed the device maxBufferSize of ${this.maxBufferSize} bytes`,
-        { needed: byteLength, limit: this.maxBufferSize, path: "pool", algorithm: null }
-      );
-    }
-    const sizeClass = Math.min(rounded, this.maxBufferSize);
-    const key = classKey(sizeClass, usage);
-    const idle = this.idle.get(key);
-    let buffer = idle?.pop();
-    if (buffer === void 0) {
-      buffer = this.allocator.createBuffer({ label, size: sizeClass, usage });
-    } else {
-      this.idleBytesValue -= sizeClass;
-      buffer.label = label;
-    }
-    this.live.set(buffer, { sizeClass, usage });
-    this.liveBytesValue += sizeClass;
-    return buffer;
-  }
-  /**
-   * Returns a buffer to its class; destroys it when the class already holds maxIdlePerClass idle buffers. A no-op
-   * after destroyAll() (so a `finally` never masks the original error).
-   * @param buffer - a buffer acquired from this pool and not yet released
-   */
-  release(buffer) {
-    if (this.disposed) {
-      return;
-    }
-    const entry = this.live.get(buffer);
-    if (entry === void 0) {
-      throw new WebGpuGraphError("E_INVALID_ARGUMENT", "buffer: not a live buffer of this pool", {
-        argument: "buffer",
-        value: buffer.label,
-        expected: "a buffer acquired from this pool and not yet released"
-      });
-    }
-    this.live.delete(buffer);
-    this.liveBytesValue -= entry.sizeClass;
-    const key = classKey(entry.sizeClass, entry.usage);
-    let idle = this.idle.get(key);
-    if (idle === void 0) {
-      idle = [];
-      this.idle.set(key, idle);
-    }
-    if (idle.length >= this.maxIdlePerClass) {
-      this.allocator.destroy(buffer);
-      return;
-    }
-    idle.push(buffer);
-    this.idleBytesValue += entry.sizeClass;
-  }
-  /** Destroys every idle buffer. */
-  trim() {
-    for (const buffers of this.idle.values()) {
-      for (const buffer of buffers) {
-        this.allocator.destroy(buffer);
-      }
-    }
-    this.idle.clear();
-    this.idleBytesValue = 0;
-  }
-  /** Destroys everything, idle and live (ctx.dispose()); idempotent. @internal */
-  destroyAll() {
-    this.trim();
-    for (const buffer of this.live.keys()) {
-      this.allocator.destroy(buffer);
-    }
-    this.live.clear();
-    this.liveBytesValue = 0;
-    this.disposed = true;
-  }
-  /**
-   * A scope object that releases everything acquired through it (spec 4.4, P2).
-   * @returns a fresh lease over this pool
-   */
-  lease() {
-    return new Lease(this);
-  }
-  /**
-   * Bytes of buffers acquired and not yet released (class sizes).
-   * @returns the live byte count
-   */
-  get liveBytes() {
-    return this.liveBytesValue;
-  }
-  /**
-   * Bytes of idle buffers (class sizes).
-   * @returns the idle byte count
-   */
-  get idleBytes() {
-    return this.idleBytesValue;
-  }
-}
-const DEFAULT_SLOT_BYTES = 4 * 1024 * 1024;
-const STAGING_USAGE = BufferUsage.MAP_READ | BufferUsage.COPY_DST;
-const SLOT_GRANULE = 256;
-function isSharedBuffer$1(buffer) {
-  return Object.prototype.toString.call(buffer) === "[object SharedArrayBuffer]";
-}
-function invalid$2(argument, value, expected) {
-  return new WebGpuGraphError("E_INVALID_ARGUMENT", `${argument}: expected ${expected}`, {
-    argument,
-    value,
-    expected
-  });
-}
-class Readback {
-  /**
-   * Creates the ring with `slots` slots of `slotBytes` each.
-   * @param device - the device the copies run on
-   * @param allocator - the context's OOM-scoped allocator (used for slots at or above OOM_SCOPE_THRESHOLD_BYTES)
-   * @param options - ring options
-   * @param options.slots - slots created up front; default DEFAULT_STAGING_SLOTS
-   * @param options.slotBytes - capacity of each slot and the chunk size of read(); default 4 MiB; a positive multiple of 4
-   */
-  constructor(device, allocator, options) {
-    this.ring = [];
-    this.disposed = false;
-    const slotBytes = options?.slotBytes ?? DEFAULT_SLOT_BYTES;
-    if (!Number.isInteger(slotBytes) || slotBytes <= 0 || slotBytes % 4 !== 0) {
-      throw invalid$2("slotBytes", slotBytes, "a positive multiple of 4");
-    }
-    const slots = options?.slots ?? DEFAULT_STAGING_SLOTS;
-    if (!Number.isInteger(slots) || slots < 0) {
-      throw invalid$2("slots", slots, "a non-negative integer");
-    }
-    this.device = device;
-    this.allocator = allocator;
-    this.slotBytes = slotBytes;
-    for (let i = 0; i < slots; i++) {
-      this.addSlot(slotBytes);
-    }
-  }
-  /**
-   * Copies `byteLength` bytes from `src` at `srcOffset` (own encoder, own submit), maps, copies out BEFORE unmap;
-   * resolves the bytes (a fresh ArrayBuffer, or `dest.buffer` after `dest.set` when given). Requests above the slot
-   * size are chunked.
-   * @param src - a COPY_SRC buffer
-   * @param byteLength - bytes to read (a positive multiple of 4, within src)
-   * @param dest - an optional destination view of at least byteLength bytes over a plain ArrayBuffer
-   * @param srcOffset - the byte offset in src (default 0; a multiple of 4)
-   * @returns the bytes read
-   */
-  async read(src, byteLength, dest, srcOffset) {
-    this.assertLive();
-    const offset = srcOffset ?? 0;
-    if (!Number.isInteger(byteLength) || byteLength <= 0 || byteLength % 4 !== 0) {
-      throw invalid$2("byteLength", byteLength, "a positive multiple of 4");
-    }
-    if (!Number.isInteger(offset) || offset < 0 || offset % 4 !== 0) {
-      throw invalid$2("srcOffset", offset, "a non-negative multiple of 4");
-    }
-    if (offset + byteLength > src.size) {
-      throw invalid$2("byteLength", byteLength, `srcOffset + byteLength <= src.size (${src.size})`);
-    }
-    if ((src.usage & BufferUsage.COPY_SRC) === 0) {
-      throw invalid$2("src", src.label, "a buffer with COPY_SRC usage");
-    }
-    let out;
-    let outBytes;
-    if (dest === void 0) {
-      out = new ArrayBuffer(byteLength);
-      outBytes = new Uint8Array(out);
-    } else {
-      if (isSharedBuffer$1(dest.buffer)) {
-        throw invalid$2("dest", "SharedArrayBuffer", "a view over a plain ArrayBuffer");
-      }
-      if (dest.byteLength < byteLength) {
-        throw invalid$2("dest", dest.byteLength, `at least ${byteLength} bytes`);
-      }
-      out = dest.buffer;
-      outBytes = new Uint8Array(out, dest.byteOffset, byteLength);
-    }
-    let done = 0;
-    while (done < byteLength) {
-      const chunk = Math.min(this.slotBytes, byteLength - done);
-      const slot = this.borrowSlot(chunk);
-      const entry = this.ring[slot.index];
-      try {
-        const encoder = this.device.createCommandEncoder({ label: "readback" });
-        encoder.copyBufferToBuffer(src, offset + done, slot.buffer, 0, chunk);
-        this.device.queue.submit([encoder.finish()]);
-        await this.map(entry, chunk);
-        outBytes.set(new Uint8Array(slot.buffer.getMappedRange(0, chunk)), done);
-      } finally {
-        this.returnSlot(slot);
-      }
-      done += chunk;
-    }
-    return out;
-  }
-  /**
-   * Reads one u32 counter through the same ring.
-   * @param src - a COPY_SRC buffer
-   * @param byteOffset - the counter's byte offset (a multiple of 4)
-   * @returns the counter value
-   */
-  async readU32(src, byteOffset) {
-    const bytes = await this.read(src, 4, void 0, byteOffset);
-    return new Uint32Array(bytes)[0];
-  }
-  /**
-   * Borrows an unmapped slot of at least byteLength (grows the ring when none is free); the borrower ALWAYS
-   * returns it (spec 4.4).
-   * @param byteLength - the bytes the borrower will copy into the slot
-   * @returns the slot
-   */
-  borrowSlot(byteLength) {
-    this.assertLive();
-    if (!Number.isInteger(byteLength) || byteLength <= 0) {
-      throw invalid$2("byteLength", byteLength, "a positive integer");
-    }
-    for (const entry2 of this.ring) {
-      if (!entry2.borrowed && entry2.slot.capacity >= byteLength) {
-        entry2.borrowed = true;
-        return entry2.slot;
-      }
-    }
-    const capacity = Math.max(this.slotBytes, Math.ceil(byteLength / SLOT_GRANULE) * SLOT_GRANULE);
-    const entry = this.addSlot(capacity);
-    entry.borrowed = true;
-    return entry.slot;
-  }
-  /**
-   * mapAsync(READ) on a borrowed slot, tracked by the ring: the slot counts as borrowed, and is neither unmapped
-   * nor destroyed, until the map settles (see the file comment). Returns the runtime's own promise, untranslated:
-   * the borrower classifies a rejection (a CommandBatch races it against device loss, spec 5.7).
-   * @param slot - a slot borrowed from this ring and not yet returned
-   * @param byteLength - the bytes to map from offset 0
-   * @returns the mapAsync promise
-   */
-  mapSlot(slot, byteLength) {
-    this.assertLive();
-    const entry = this.borrowedEntry(slot);
-    if (entry.mapPending || entry.mapped) {
-      throw invalid$2("slot", slot.index, "a borrowed slot that is not mapped and has no map pending");
-    }
-    return this.track(entry, slot.buffer.mapAsync(MapMode.READ, 0, byteLength));
-  }
-  /**
-   * Returns a borrowed slot (unmapping it if mapped). A slot whose map through the ring is still pending stays
-   * borrowed until the map settles, when the ring unmaps and returns it; a borrower that maps a slot itself must
-   * unmap it before returning it (spec 4.4; `mapState` decides when the runtime exposes it, otherwise the ring's
-   * own record does). A no-op after destroyAll() (the ring is gone; a borrower's finally must never mask the
-   * E_DISPOSED / E_DEVICE_LOST of the read it was serving).
-   * @param slot - a slot borrowed from this ring and not yet returned
-   */
-  returnSlot(slot) {
-    if (this.disposed) {
-      return;
-    }
-    const entry = this.borrowedEntry(slot);
-    if (entry.mapPending) {
-      entry.returnRequested = true;
-      return;
-    }
-    this.finishReturn(entry);
-  }
-  /**
-   * The entry of a slot borrowed from this ring and not yet returned.
-   * @param slot - the slot
-   * @returns its entry
-   */
-  borrowedEntry(slot) {
-    const entry = this.ring[slot.index];
-    if (entry === void 0 || entry.slot !== slot || !entry.borrowed) {
-      throw invalid$2("slot", slot.index, "a slot borrowed from this ring and not yet returned");
-    }
-    return entry;
-  }
-  /**
-   * Unmaps a returned slot when it is mapped and frees it.
-   * @param entry - the slot's entry (no map pending)
-   */
-  finishReturn(entry) {
-    const state = entry.slot.buffer.mapState;
-    const mapped = state === void 0 ? entry.mapped : state !== "unmapped";
-    if (mapped) {
-      entry.slot.buffer.unmap();
-    }
-    entry.mapped = false;
-    entry.borrowed = false;
-    entry.returnRequested = false;
-  }
-  /**
-   * Tracks one mapAsync on a slot: mapPending until it settles, then the deferred work -- the destruction
-   * destroyAll() left to the settle, or the return returnSlot() left to it. The handler is attached before the
-   * promise is handed out, so it runs before any borrower's continuation.
-   * @param entry - the slot's entry
-   * @param pending - the runtime's mapAsync promise
-   * @returns the same promise
-   */
-  track(entry, pending) {
-    entry.mapPending = true;
-    const settle = (mapped) => {
-      entry.mapPending = false;
-      entry.mapped = mapped;
-      if (this.disposed) {
-        if (mapped) {
-          entry.slot.buffer.unmap();
-        }
-        this.destroySlot(entry);
-        entry.mapped = false;
-        return;
-      }
-      if (entry.returnRequested) {
-        this.finishReturn(entry);
-      }
-    };
-    void pending.then(
-      () => {
-        settle(true);
-      },
-      () => {
-        settle(false);
-      }
-    );
-    return pending;
-  }
-  /**
-   * Number of slots (grows).
-   * @returns the slot count
-   */
-  get slots() {
-    return this.ring.length;
-  }
-  /**
-   * Slots currently borrowed.
-   * @returns the borrowed count
-   */
-  get borrowed() {
-    let count = 0;
-    for (const entry of this.ring) {
-      if (entry.borrowed) {
-        count++;
-      }
-    }
-    return count;
-  }
-  /**
-   * Destroys every staging buffer (ctx.dispose()); idempotent. A slot whose mapAsync is still pending is NOT
-   * destroyed here (the file comment: dawn-node 0.4.0 settles the promise twice); its destruction is deferred to
-   * the moment the map settles (track()), where a pending read() still rejects with E_DISPOSED as the contract
-   * promises.
-   * @internal
-   */
-  destroyAll() {
-    for (const entry of this.ring) {
-      if (entry.mapPending) {
-        continue;
-      }
-      this.destroySlot(entry);
-    }
-    this.ring.length = 0;
-    this.disposed = true;
-  }
-  /**
-   * Destroys one slot's buffer through the allocator when it was created there.
-   * @param entry - the slot
-   */
-  destroySlot(entry) {
-    if (entry.tracked) {
-      this.allocator.destroy(entry.slot.buffer);
-    } else {
-      entry.slot.buffer.destroy();
-    }
-  }
-  /**
-   * Creates one slot at the end of the ring.
-   * @param capacity - the slot's byte capacity
-   * @returns the new entry
-   */
-  addSlot(capacity) {
-    const index = this.ring.length;
-    const descriptor = {
-      label: `readback:slot:${index}`,
-      size: capacity,
-      usage: STAGING_USAGE
-    };
-    const tracked = capacity >= OOM_SCOPE_THRESHOLD_BYTES;
-    const buffer = tracked ? this.allocator.createBuffer(descriptor) : this.device.createBuffer(descriptor);
-    const entry = {
-      slot: Object.freeze({ index, buffer, capacity }),
-      borrowed: false,
-      mapped: false,
-      mapPending: false,
-      returnRequested: false,
-      tracked
-    };
-    this.ring.push(entry);
-    return entry;
-  }
-  /**
-   * mapAsync(READ) on a slot for read(); a rejection becomes E_DISPOSED (after destroyAll) or E_DEVICE_LOST.
-   * @param entry - the ring entry of the borrowed slot
-   * @param byteLength - the bytes to map
-   */
-  async map(entry, byteLength) {
-    let mapped = false;
-    let failure = null;
-    try {
-      await this.track(entry, entry.slot.buffer.mapAsync(MapMode.READ, 0, byteLength));
-      mapped = true;
-    } catch (err) {
-      failure = err;
-    }
-    if (this.disposed) {
-      throw new WebGpuGraphError("E_DISPOSED", "the readback ring was disposed while a read was pending", {
-        label: "readback"
-      });
-    }
-    if (!mapped) {
-      const message = failure instanceof Error ? failure.message : String(failure);
-      throw new WebGpuGraphError("E_DEVICE_LOST", `mapAsync rejected: ${message}`, {
-        reason: "mapAsync",
-        message
-      });
-    }
-  }
-  /** Throws E_DISPOSED after destroyAll(). */
-  assertLive() {
-    if (this.disposed) {
-      throw new WebGpuGraphError("E_DISPOSED", "the readback ring was disposed", { label: "readback" });
-    }
-  }
-}
-const CORE_ORDER$1 = Object.freeze(["rowPtr", "colIdx", "weights", "arcToEdge", "edgeToArc"]);
-const ARC_INDEXED$1 = /* @__PURE__ */ new Set(["colIdx", "weights", "arcToEdge"]);
-function coreByteLengths(s) {
-  const arcs = s.arcCount;
-  const identity = s.flags.arcToEdgeIsIdentity;
-  return {
-    rowPtr: 4 * (s.nodeCount + 1),
-    colIdx: 4 * arcs,
-    weights: s.flags.weighted && arcs > 0 ? 4 * arcs : 0,
-    arcToEdge: !identity && arcs > 0 ? 4 * arcs : 0,
-    edgeToArc: !identity && s.edgeCount > 0 ? 4 * s.edgeCount : 0
-  };
-}
-function neededNames(need, lengths) {
-  const wanted = new Set(need);
-  wanted.add("rowPtr");
-  return CORE_ORDER$1.filter((name) => wanted.has(name) && lengths[name] > 0);
-}
-function alignDown(value) {
-  return value - value % ARC_WINDOW_ALIGN;
-}
-function tooLarge(needed, limit, path) {
-  return new WebGpuGraphError("E_TOO_LARGE", `${path}: ${needed} bytes exceed the device limit of ${limit} bytes`, {
-    needed,
-    limit,
-    path,
-    algorithm: null
-  });
-}
-function invalid$1(argument, value, expected) {
-  return new WebGpuGraphError("E_INVALID_ARGUMENT", `${argument}: expected ${expected}`, {
-    argument,
-    value,
-    expected
-  });
-}
-function arcsPerWindowFor(limits) {
-  return alignDown(Math.floor(limits.maxStorageBufferBindingSize / 4));
-}
-function planArcWindows(rowPtr, arcCount, arcsPerWindow) {
-  if (rowPtr.length === 0) {
-    throw invalid$1("rowPtr", rowPtr.length, "nodeCount + 1 entries");
-  }
-  if (!Number.isInteger(arcsPerWindow) || arcsPerWindow < ARC_WINDOW_ALIGN || arcsPerWindow % ARC_WINDOW_ALIGN !== 0) {
-    throw invalid$1("arcsPerWindow", arcsPerWindow, `a positive multiple of ${ARC_WINDOW_ALIGN}`);
-  }
-  const n = rowPtr.length - 1;
-  if (rowPtr[n] !== arcCount) {
-    throw invalid$1("arcCount", arcCount, `rowPtr[${n}] === ${rowPtr[n]}`);
-  }
-  const windows = [];
-  if (arcCount === 0) {
-    return windows;
-  }
-  let pos = 0;
-  let v = 0;
-  let rowFirst = 0;
-  while (pos < arcCount) {
-    while (rowPtr[v + 1] <= pos) {
-      v++;
-    }
-    const start = alignDown(pos);
-    const limit = start + arcsPerWindow;
-    if (rowPtr[v + 1] > limit) {
-      windows.push({ start, end: limit, rowFirst, rowLast: v, bufferIndex: 0, offset: 4 * start });
-      pos = limit;
-      rowFirst = v;
-    } else {
-      let u = v;
-      while (u + 1 < n && rowPtr[u + 2] <= limit) {
-        u++;
-      }
-      const end = rowPtr[u + 1];
-      windows.push({ start, end, rowFirst, rowLast: u, bufferIndex: 0, offset: 4 * start });
-      pos = end;
-      rowFirst = u + 1;
-    }
-  }
-  return windows;
-}
-function placeWindows(windows, arcBytes, bufferLimit) {
-  if (arcBytes <= bufferLimit) {
-    return { buffers: [{ byteOffset: 0, byteLength: arcBytes }], placed: [...windows] };
-  }
-  const buffers = [];
-  const placed = [];
-  let first = 0;
-  while (first < windows.length) {
-    let last = first;
-    while (last + 1 < windows.length && 4 * (windows[last + 1].end - windows[first].start) <= bufferLimit) {
-      last++;
-    }
-    const base = windows[first].start;
-    const bufferIndex = buffers.length;
-    buffers.push({ byteOffset: 4 * base, byteLength: 4 * (windows[last].end - base) });
-    for (let i = first; i <= last; i++) {
-      const w = windows[i];
-      placed.push({
-        start: w.start,
-        end: w.end,
-        rowFirst: w.rowFirst,
-        rowLast: w.rowLast,
-        bufferIndex,
-        offset: 4 * (w.start - base)
-      });
-    }
-    first = last + 1;
-  }
-  return { buffers, placed };
-}
-function planUpload(s, caps, need) {
-  const { limits } = caps;
-  const binding = limits.maxStorageBufferBindingSize;
-  const bufferLimit = limits.maxBufferSize;
-  const fits = (bytes) => bytes <= binding && bytes <= bufferLimit;
-  const violated = (bytes) => bytes > binding ? binding : bufferLimit;
-  const lengths = coreByteLengths(s);
-  const names = neededNames(need, lengths);
-  if (!fits(lengths.rowPtr)) {
-    throw tooLarge(lengths.rowPtr, violated(lengths.rowPtr), "rowPtr");
-  }
-  const { arena } = s;
-  if (arena !== null) {
-    const coldNeeded = names.some(
-      (name) => (name === "arcToEdge" || name === "edgeToArc") && arena.segments[name] !== null
-    );
-    const includesCold = coldNeeded && arena.byteLength <= bufferLimit;
-    const bytes = includesCold ? arena.byteLength : arena.hotByteLength;
-    const bindable = names.every((name) => {
-      const segment = arena.segments[name];
-      return segment === null || fits(segment.byteLength);
-    });
-    if (bytes <= bufferLimit && bindable) {
-      const segmentOf = (name) => {
-        const segment = arena.segments[name];
-        if (segment === null) {
-          return null;
-        }
-        const offset = segment.byteOffset - arena.byteOffset;
-        return offset + segment.byteLength <= bytes ? { offset, size: segment.byteLength } : null;
-      };
-      return {
-        kind: "arena",
-        bytes,
-        includesCold,
-        segments: {
-          rowPtr: segmentOf("rowPtr"),
-          colIdx: segmentOf("colIdx"),
-          weights: segmentOf("weights"),
-          arcToEdge: segmentOf("arcToEdge"),
-          edgeToArc: segmentOf("edgeToArc")
-        }
-      };
-    }
-  }
-  if (names.every((name) => fits(lengths[name]))) {
-    return {
-      kind: "perArray",
-      arrays: names.map((name) => ({
-        name,
-        byteLength: lengths[name],
-        buffers: [{ byteOffset: 0, byteLength: lengths[name] }]
-      }))
-    };
-  }
-  if (names.includes("edgeToArc") && !fits(lengths.edgeToArc)) {
-    throw tooLarge(lengths.edgeToArc, violated(lengths.edgeToArc), "binding");
-  }
-  const arcsPerWindow = Math.min(arcsPerWindowFor(limits), alignDown(Math.floor(bufferLimit / 4)));
-  if (arcsPerWindow < ARC_WINDOW_ALIGN) {
-    throw tooLarge(4 * ARC_WINDOW_ALIGN, binding, "binding");
-  }
-  const windows = planArcWindows(s.rowPtr, s.arcCount, arcsPerWindow);
-  const { buffers, placed } = placeWindows(windows, 4 * s.arcCount, bufferLimit);
-  const arrays = names.map(
-    (name) => ARC_INDEXED$1.has(name) ? { name, byteLength: lengths[name], buffers } : { name, byteLength: lengths[name], buffers: [{ byteOffset: 0, byteLength: lengths[name] }] }
-  );
-  return { kind: "windowed", arrays, windows: placed, arcsPerWindow };
-}
-const DEFAULT_NEED = Object.freeze(["rowPtr", "colIdx", "weights"]);
-const CORE_ORDER = Object.freeze(["rowPtr", "colIdx", "weights", "arcToEdge", "edgeToArc"]);
-const ARC_INDEXED = Object.freeze(["colIdx", "weights", "arcToEdge"]);
-const RESIDENT_USAGE = BufferUsage.STORAGE | BufferUsage.COPY_DST | BufferUsage.COPY_SRC;
-function isArcIndexed(name) {
-  return ARC_INDEXED.includes(name);
-}
-function isSharedBuffer(buffer) {
-  return Object.prototype.toString.call(buffer) === "[object SharedArrayBuffer]";
-}
-function invalid(argument, value, expected) {
-  return new WebGpuGraphError("E_INVALID_ARGUMENT", `${argument}: expected ${expected}`, {
-    argument,
-    value,
-    expected
-  });
-}
-function assertAttached(s) {
-  if (s.detached) {
-    throw new WebGpuGraphError("E_SNAPSHOT", `snapshot ${s.serial} is detached (its core was transferred away)`, {
-      reason: "detached",
-      serial: s.serial
-    });
-  }
-}
-function isPresent(s, name) {
-  switch (name) {
-    case "rowPtr":
-      return true;
-    case "colIdx":
-      return s.arcCount > 0;
-    case "weights":
-      return s.flags.weighted && s.arcCount > 0;
-    case "arcToEdge":
-      return !s.flags.arcToEdgeIsIdentity && s.arcCount > 0;
-    case "edgeToArc":
-      return !s.flags.arcToEdgeIsIdentity && s.edgeCount > 0;
-    default:
-      return false;
-  }
-}
-function coreArray(s, name) {
-  switch (name) {
-    case "rowPtr":
-      return s.rowPtr;
-    case "colIdx":
-      return s.colIdx;
-    case "weights": {
-      const { weights } = s;
-      if (weights === null) {
-        throw invalid("weights", null, "a weighted snapshot");
-      }
-      return weights;
-    }
-    case "arcToEdge":
-      return s.arcToEdge;
-    case "edgeToArc":
-      return s.edgeToArc;
-    default:
-      throw invalid("name", name, "a core array name");
-  }
-}
-class GraphResidency {
-  /**
-   * Creates an empty residency over a device.
-   * @param device - the device (queue.writeBuffer)
-   * @param caps - the device capabilities the planner reads
-   * @param allocator - the context's OOM-scoped allocator (every buffer is created and destroyed through it)
-   * @param options - the once-only warning
-   * @param options.warnUnreleasedSnapshots - the resident-snapshot count above which the warning fires once
-   * @param options.warn - the warning sink; default console.warn
-   */
-  constructor(device, caps, allocator, options) {
-    this.residents = /* @__PURE__ */ new WeakMap();
-    this.records = /* @__PURE__ */ new WeakMap();
-    this.bySerial = /* @__PURE__ */ new Map();
-    this.orphans = /* @__PURE__ */ new Set();
-    this.tombstones = /* @__PURE__ */ new Set();
-    this.liveCount = 0;
-    this.liveBytesValue = 0;
-    this.warned = false;
-    this.disposed = false;
-    this.device = device;
-    this.caps = caps;
-    this.allocator = allocator;
-    this.warnUnreleasedSnapshots = options.warnUnreleasedSnapshots;
-    this.warn = options.warn ?? ((message) => {
-      console.warn(message);
-    });
-  }
-  /**
-   * Uploads (or finds) the core; `need` defaults to ["rowPtr", "colIdx", "weights"]; cold segments on demand
-   * (spec 4.2). Never materialises an identity permutation. A windowed plan (spec 4.2, PD-8) uploads every
-   * arc-indexed array as the plan's buffer ranges and binds window 0 as its default binding; rowPtr and edgeToArc
-   * stay whole. A tombstoned serial is lifted and re-uploaded (PLAN DECISION 7).
-   * @param s - the snapshot
-   * @param need - the core arrays to bind (rowPtr is always included; absent arrays are ignored)
-   * @returns the core binding (a frozen object; grows as cold segments are added)
-   */
-  core(s, need) {
-    this.assertLive();
-    assertAttached(s);
-    const wanted = need ?? DEFAULT_NEED;
-    const names = CORE_ORDER.filter((name) => (name === "rowPtr" || wanted.includes(name)) && isPresent(s, name));
-    const plan = planUpload(s, this.caps, names);
-    const record = this.ensureRecord(s);
-    if (record.plan === null) {
-      record.plan = plan.kind;
-      if (plan.kind === "arena" && s.arena !== null) {
-        const { arena } = s;
-        const resident = this.upload(
-          record,
-          s.rowPtr,
-          new Uint8Array(arena.buffer, arena.byteOffset, plan.bytes),
-          `residency:core:${record.serial}:arena`
-        );
-        record.arena = { buffer: resident.buffer, segments: plan.segments };
-      }
-      if (plan.kind === "windowed") {
-        record.windows = plan.windows;
-      }
-    }
-    for (const name of names) {
-      if (!record.bindings.has(name)) {
-        const planned = plan.kind === "windowed" ? plan.arrays.find((a) => a.name === name) : void 0;
-        record.bindings.set(
-          name,
-          planned !== void 0 && planned.buffers.length > 0 && record.windows !== null && isArcIndexed(name) ? this.bindWindowed(record, s, name, planned.buffers, record.windows[0]) : this.bindCore(record, s, name)
-        );
-      }
-    }
-    const rowPtr = record.bindings.get("rowPtr");
-    if (rowPtr === void 0) {
-      throw invalid("rowPtr", null, "a bound rowPtr (internal invariant)");
-    }
-    const weights = record.bindings.get("weights") ?? null;
-    return Object.freeze({
-      serial: record.serial,
-      plan: plan.kind,
-      rowPtr,
-      colIdx: record.bindings.get("colIdx") ?? null,
-      weights,
-      arcToEdge: record.bindings.get("arcToEdge") ?? null,
-      edgeToArc: record.bindings.get("edgeToArc") ?? null,
-      windows: record.windows,
-      arcBuffers: record.windows === null ? null : Object.freeze({
-        colIdx: Object.freeze([...record.arcBuffers.get("colIdx") ?? []]),
-        weights: Object.freeze([...record.arcBuffers.get("weights") ?? []]),
-        arcToEdge: Object.freeze([...record.arcBuffers.get("arcToEdge") ?? []])
-      }),
-      hasWeights: weights !== null
-    });
-  }
-  /**
-   * Uploads (or finds) a view: outDegree / inDegree / degreeOrder / reverseDegreeOrder upload one array each;
-   * reverse and edgeList (P7) upload their arrays perArray, never into the arena, and are memoised per record so
-   * a second call uploads nothing (spec 4.3). coo uploads its per-arc `src` (P11; the rest aliases the core); mate ->
-   * E_UNSUPPORTED. packViews concatenates a
-   * reverse or edgeList view into ONE buffer at STORAGE_ALIGN offsets; on any other view `true` is E_UNSUPPORTED
-   * { option: "packViews" }.
-   * @param s - the snapshot
-   * @param name - the view
-   * @param options - view options
-   * @param options.packViews - pack the reverse / edgeList arrays into one buffer (a no-op on an undirected reverse)
-   * @returns the view binding
-   */
-  view(s, name, options) {
-    this.assertLive();
-    assertAttached(s);
-    const packed = options?.packViews === true;
-    if (name === "reverse" || name === "edgeList") {
-      this.assertNotReleased(s);
-      this.assertNonEmpty(s);
-      const memoKey = packed ? `${name}:packed` : name;
-      const record2 = this.ensureRecord(s);
-      const memo = record2.views.get(memoKey);
-      if (memo !== void 0) {
-        return memo;
-      }
-      const built = name === "reverse" ? this.buildReverse(s, record2, packed) : this.buildEdgeList(s, record2, packed);
-      record2.views.set(memoKey, built);
-      return built;
-    }
-    if (packed) {
-      throw new WebGpuGraphError("E_UNSUPPORTED", "packViews applies to the reverse and edgeList views only", {
-        option: "packViews",
-        hint: `the ${name} view uploads one array`
-      });
-    }
-    let array;
-    let bindingName;
-    let scalars = {};
-    switch (name) {
-      case "outDegree":
-        this.assertNotReleased(s);
-        this.assertNonEmpty(s);
-        array = s.outDegree();
-        bindingName = "outDegree";
-        break;
-      case "inDegree":
-        this.assertNotReleased(s);
-        this.assertNonEmpty(s);
-        array = s.inDegree();
-        bindingName = "inDegree";
-        break;
-      case "degreeOrder": {
-        this.assertNotReleased(s);
-        this.assertNonEmpty(s);
-        const order = s.degreeOrder();
-        array = order.perm;
-        bindingName = "perm";
-        scalars = { segmentOffsets: Array.from(order.segmentOffsets) };
-        break;
-      }
-      case "reverseDegreeOrder": {
-        this.assertNotReleased(s);
-        this.assertNonEmpty(s);
-        const order = s.degreeOrder({ of: "reverse" });
-        array = order.perm;
-        bindingName = "perm";
-        scalars = { segmentOffsets: Array.from(order.segmentOffsets) };
-        break;
-      }
-      case "coo":
-        this.assertNotReleased(s);
-        this.assertNonEmpty(s);
-        if (s.arcCount === 0) {
-          return Object.freeze({ view: name, bindings: Object.freeze({}), scalars: Object.freeze({}) });
-        }
-        array = s.coo().src;
-        bindingName = "src";
-        break;
-      case "mate":
-        throw new WebGpuGraphError("E_UNSUPPORTED", "the mate view is not uploaded: no kernel reads it", {
-          feature: "view:mate",
-          hint: "outDegree, inDegree, degreeOrder, reverseDegreeOrder, coo, reverse and edgeList are uploaded"
-        });
-      default:
-        throw invalid("name", name, "a view name");
-    }
-    const record = this.ensureRecord(s);
-    const resident = this.upload(record, array, array, `residency:view:${record.serial}:${name}`);
-    const binding = { buffer: resident.buffer, offset: 0, size: resident.byteLength, window: null };
-    return Object.freeze({
-      view: name,
-      bindings: Object.freeze({ [bindingName]: binding }),
-      scalars: Object.freeze(scalars)
-    });
-  }
-  /**
-   * The reverse adjacency's bindings. On an UNDIRECTED snapshot graph-format invariant I7 makes reverse() return
-   * the FORWARD arrays, so the core bindings ARE the reverse bindings and nothing is uploaded -- delegating to
-   * core() rather than re-uploading the arrays is what makes that true on the arena plan as well, where the
-   * per-array WeakMap key resolves to the whole-arena resident (spec 4.3 lines 1182-1186). `fwdArc` is never
-   * uploaded (spec 13 row P7). `packed` is ignored when undirected: there is nothing to pack.
-   * @param s - the snapshot
-   * @param record - its residency record
-   * @param packed - concatenate the arrays into one buffer (directed only)
-   * @returns the view binding
-   */
-  buildReverse(s, record, packed) {
-    const rev = s.reverse();
-    if (!s.directed) {
-      const core = this.core(s, ["rowPtr", "colIdx", "weights"]);
-      if (core.plan === "windowed") {
-        throw new WebGpuGraphError(
-          "E_TOO_LARGE",
-          `snapshot ${s.serial}: the undirected reverse view is the core, which needs arc windows (${core.windows?.length ?? 0}) that no view executes`,
-          {
-            needed: 4 * s.arcCount,
-            limit: this.caps.limits.maxStorageBufferBindingSize,
-            path: "windowed",
-            algorithm: null
-          }
-        );
-      }
-      const bindings2 = { rowPtr: core.rowPtr };
-      if (core.colIdx !== null) {
-        bindings2.colIdx = core.colIdx;
-      }
-      if (core.weights !== null) {
-        bindings2.weights = core.weights;
-      }
-      return Object.freeze({
-        view: "reverse",
-        bindings: Object.freeze(bindings2),
-        scalars: Object.freeze({ arcCount: [rev.arcCount], directed: [0] })
-      });
-    }
-    const arrays = [
-      ["rowPtr", rev.rowPtr],
-      ["colIdx", rev.colIdx]
-    ];
-    if (rev.weights !== null) {
-      arrays.push(["weights", rev.weights]);
-    }
-    const bindings = packed ? this.packArrays(
-      record,
-      arrays,
-      this.packKey(record, "reverse:packed"),
-      `residency:view:${record.serial}:reverse:packed`
-    ) : this.separateArrays(record, arrays, `residency:view:${record.serial}:reverse`);
-    return Object.freeze({
-      view: "reverse",
-      bindings,
-      scalars: Object.freeze({ arcCount: [rev.arcCount], directed: [1] })
-    });
-  }
-  /**
-   * The each-edge-once binding an edge-parallel kernel uses on directed and undirected snapshots alike (spec 8.1
-   * row 2); `arc` is not uploaded (no kernel of P7 reads it).
-   * @param s - the snapshot
-   * @param record - its residency record
-   * @param packed - concatenate into one buffer
-   * @returns the view binding
-   */
-  buildEdgeList(s, record, packed) {
-    const list = s.edgeList();
-    const arrays = [
-      ["src", list.src],
-      ["dst", list.dst]
-    ];
-    if (list.weights !== null) {
-      arrays.push(["weights", list.weights]);
-    }
-    const bindings = packed ? this.packArrays(
-      record,
-      arrays,
-      this.packKey(record, "edgeList:packed"),
-      `residency:view:${record.serial}:edgeList:packed`
-    ) : this.separateArrays(record, arrays, `residency:view:${record.serial}:edgeList`);
-    return Object.freeze({
-      view: "edgeList",
-      bindings,
-      scalars: Object.freeze({ edgeCount: [s.edgeCount] })
-    });
-  }
-  /**
-   * One resident per array (spec 4.3: views upload in perArray mode, never into the arena). An empty array (the
-   * colIdx of an edgeless directed reverse view, the src / dst of an edgeless edgeList) is skipped: spec 5.6 never
-   * uploads a zero-length array, and Kernel.bind rejects a zero-size binding, so it is absent as in core().
-   * @param record - the owning record
-   * @param arrays - the named arrays
-   * @param label - the buffer label prefix
-   * @returns the bindings by name
-   */
-  separateArrays(record, arrays, label) {
-    const bindings = {};
-    for (const [name, array] of arrays) {
-      if (array.byteLength === 0) {
-        continue;
-      }
-      const resident = this.upload(record, array, array, `${label}:${name}`);
-      bindings[name] = { buffer: resident.buffer, offset: 0, size: resident.byteLength, window: null };
-    }
-    return Object.freeze(bindings);
-  }
-  /**
-   * The arrays concatenated into ONE buffer at STORAGE_ALIGN-aligned offsets (spec 4.3 packViews): one
-   * createBuffer and one writeBuffer instead of three of each, which is what the option buys. The resident is
-   * keyed on `key`, a marker object owned by the record (packKey), NOT on one of the snapshot's arrays: upload()
-   * returns an existing resident whenever the key matches and the serial matches, without comparing byte
-   * lengths, so keying the packed buffer on `rev.rowPtr` would make the packed and the unpacked view of one
-   * snapshot collide -- whichever was built second would get the other's buffer. The record still owns the
-   * resident, so release(s) destroys it with the rest. Offsets are STORAGE_ALIGN-aligned because Kernel.bind
-   * rejects any other offset synchronously (E_INVALID_ARGUMENT { argument: "offset" }). Empty arrays are left
-   * out as in separateArrays; when nothing is left, nothing is uploaded.
-   * @param record - the owning record
-   * @param all - the named arrays, in buffer order
-   * @param key - the marker object the resident is keyed on
-   * @param label - the buffer label
-   * @returns the bindings by name, all into the one buffer
-   */
-  packArrays(record, all, key, label) {
-    const arrays = all.filter(([, array]) => array.byteLength > 0);
-    if (arrays.length === 0) {
-      return Object.freeze({});
-    }
-    const offsets = [];
-    let total = 0;
-    for (const [, array] of arrays) {
-      offsets.push(total);
-      total += Math.ceil(array.byteLength / STORAGE_ALIGN) * STORAGE_ALIGN;
-    }
-    const staging = new Uint8Array(total);
-    arrays.forEach(([, array], i) => {
-      staging.set(new Uint8Array(array.buffer, array.byteOffset, array.byteLength), offsets[i]);
-    });
-    const resident = this.upload(record, key, staging, label);
-    const bindings = {};
-    arrays.forEach(([name, array], i) => {
-      bindings[name] = { buffer: resident.buffer, offset: offsets[i], size: array.byteLength, window: null };
-    });
-    return Object.freeze(bindings);
-  }
-  /**
-   * The upload key of a packed view: a marker object allocated once per record and memo name, never one of the
-   * snapshot's arrays.
-   * @param record - the owning record
-   * @param memoKey - the `views` memo key of this packed view
-   * @returns the stable marker object
-   */
-  packKey(record, memoKey) {
-    const existing = record.packKeys.get(memoKey);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const created = {};
-    record.packKeys.set(memoKey, created);
-    return created;
-  }
-  /**
-   * gpuView(name) + column.version; re-uploads in place when the version changed and the byte length did not
-   * (spec 4.3). CONTRACT DECISION: `owner` is required so release(owner) can find the buffer (a table has no
-   * back-reference to its snapshot). The key is the Column object (PLAN DECISION 8). E_GPU_INELIGIBLE and
-   * E_UNKNOWN_COLUMN from the format pass through unchanged.
-   * @param table - the table holding the column
-   * @param name - the column name
-   * @param owner - the snapshot the buffer is recorded against
-   * @returns the column binding
-   */
-  column(table, name, owner) {
-    this.assertLive();
-    assertAttached(owner);
-    this.assertNotReleased(owner);
-    const column = table.require(name);
-    const data = table.gpuView(name);
-    if (data.byteLength === 0) {
-      throw invalid("column", name, "a column with at least one row (zero-length arrays are never uploaded)");
-    }
-    const record = this.ensureRecord(owner);
-    const label = `residency:column:${record.serial}:${column.meta.domain}.${name}`;
-    const existing = this.residents.get(column);
-    let resident;
-    if (existing !== void 0 && !existing.destroyed && existing.serial === record.serial && existing.byteLength === data.byteLength) {
-      resident = existing;
-      if (resident.version !== column.version) {
-        this.device.queue.writeBuffer(resident.buffer, 0, data);
-        resident.version = column.version;
-      }
-    } else {
-      if (existing !== void 0) {
-        this.residents.delete(column);
-      }
-      resident = this.upload(record, column, data, label);
-      resident.version = column.version;
-    }
-    return Object.freeze({
-      binding: { buffer: resident.buffer, offset: 0, size: resident.byteLength, window: null },
-      column,
-      version: resident.version,
-      eligibility: column.gpu,
-      components: column.meta.components
-    });
-  }
-  /**
-   * Any format array keyed on the object; registered against `owner` when given (spec 4.1).
-   * @param key - the array (a non-empty, 4-byte-multiple array over a plain ArrayBuffer)
-   * @param label - the buffer label suffix
-   * @param owner - the snapshot to record the buffer against, or undefined for a caller-owned buffer
-   * @returns the array binding; `destroy()` is idempotent (PLAN DECISION 12)
-   */
-  array(key, label, owner) {
-    this.assertLive();
-    if (key.byteLength === 0 || key.byteLength % 4 !== 0) {
-      throw invalid("key", key.byteLength, "a non-empty array whose byteLength is a multiple of 4");
-    }
-    if (isSharedBuffer(key.buffer)) {
-      throw invalid("key", "SharedArrayBuffer", "an array over a plain ArrayBuffer");
-    }
-    let record = null;
-    if (owner !== void 0) {
-      assertAttached(owner);
-      this.assertNotReleased(owner);
-      record = this.ensureRecord(owner);
-    }
-    const resident = this.upload(record, key, key, `residency:array:${label}`);
-    const binding = { buffer: resident.buffer, offset: 0, size: resident.byteLength, window: null };
-    return {
-      binding,
-      byteLength: resident.byteLength,
-      owner: owner ?? null,
-      destroy: () => {
-        this.destroyResident(resident, record);
-      }
-    };
-  }
-  /**
-   * Destroys every buffer recorded for s.serial (siblings included, Q-27) and tombstones the serial; idempotent
-   * (spec 4.5); safe on a snapshot never uploaded (nothing to tombstone, PLAN DECISION 7).
-   * @param s - the snapshot (or any withColumns() sibling)
-   */
-  release(s) {
-    const record = this.bySerial.get(s.serial);
-    if (record === void 0) {
-      return;
-    }
-    for (const resident of [...record.entries]) {
-      this.destroyResident(resident, record);
-    }
-    this.forget(record);
-    this.tombstones.add(s.serial);
-  }
-  /** Drops every record WITHOUT destroying (device lost: the buffers are gone). @internal */
-  clearOnLoss() {
-    for (const record of [...this.bySerial.values()]) {
-      for (const resident of record.entries) {
-        resident.destroyed = true;
-        if (this.residents.get(resident.key) === resident) {
-          this.residents.delete(resident.key);
-        }
-      }
-      record.entries.length = 0;
-      this.forget(record);
-    }
-    for (const resident of this.orphans) {
-      resident.destroyed = true;
-      if (this.residents.get(resident.key) === resident) {
-        this.residents.delete(resident.key);
-      }
-    }
-    this.orphans.clear();
-    this.liveCount = 0;
-    this.liveBytesValue = 0;
-  }
-  /** Destroys everything (ctx.dispose()); idempotent. @internal */
-  destroyAll() {
-    for (const record of [...this.bySerial.values()]) {
-      for (const resident of [...record.entries]) {
-        this.destroyResident(resident, record);
-      }
-      this.forget(record);
-    }
-    for (const resident of [...this.orphans]) {
-      this.destroyResident(resident, null);
-    }
-    this.disposed = true;
-  }
-  /**
-   * The resident buffers, bytes and snapshots (spec 4.1).
-   * @returns the statistics
-   */
-  stats() {
-    const perSnapshot = [...this.bySerial.values()].map((record) => ({
-      serial: record.serial,
-      label: record.label,
-      bytes: record.entries.reduce((sum, resident) => sum + resident.byteLength, 0),
-      buffers: record.entries.length
-    }));
-    return { buffers: this.liveCount, bytes: this.liveBytesValue, snapshots: this.bySerial.size, perSnapshot };
-  }
-  /**
-   * Bytes of every resident buffer (graft: C R-18).
-   * @returns the resident byte count
-   */
-  get residentBytes() {
-    return this.liveBytesValue;
-  }
-  /**
-   * True when the serial was released and not re-uploaded. @internal
-   * @param serial - a snapshot serial
-   * @returns whether a live user holding bindings of that serial must stop
-   */
-  isReleased(serial) {
-    return this.tombstones.has(serial);
-  }
-  /**
-   * Binds one core array: a segment of the arena buffer when the buffer holds it, else its own buffer keyed on
-   * the array object (the cold-segment-on-demand path of spec 4.2, and the whole perArray path).
-   * @param record - the snapshot's record
-   * @param s - the snapshot
-   * @param name - a PRESENT core array
-   * @returns the binding
-   */
-  bindCore(record, s, name) {
-    if (record.arena !== null) {
-      const segment = record.arena.segments[name];
-      if (segment !== null) {
-        return { buffer: record.arena.buffer, offset: segment.offset, size: segment.size, window: null };
-      }
-    }
-    const array = coreArray(s, name);
-    const resident = this.upload(record, array, array, `residency:core:${record.serial}:${name}`);
-    return { buffer: resident.buffer, offset: 0, size: resident.byteLength, window: null };
-  }
-  /**
-   * Uploads one arc-indexed array as the windowed plan's buffer ranges (spec 4.2: an array above maxBufferSize is
-   * split across buffers at window boundaries), each keyed on a marker object of the record (windowKey), and
-   * returns window 0's binding so a caller that ignores windows still binds something valid (PD-8).
-   * @param record - the snapshot's record
-   * @param s - the snapshot
-   * @param name - a PRESENT arc-indexed core array
-   * @param ranges - the plan's buffer ranges of the array
-   * @param first - window 0
-   * @returns the binding of window 0
-   */
-  bindWindowed(record, s, name, ranges, first) {
-    const array = coreArray(s, name);
-    const buffers = ranges.map(
-      (range, index) => this.upload(
-        record,
-        this.windowKey(record, `${name}:${index}`),
-        new Uint8Array(array.buffer, array.byteOffset + range.byteOffset, range.byteLength),
-        `residency:core:${record.serial}:${name}:w${index}`
-      ).buffer
-    );
-    record.arcBuffers.set(name, buffers);
-    return {
-      buffer: buffers[first.bufferIndex],
-      offset: first.offset,
-      size: 4 * (first.end - first.start),
-      window: first
-    };
-  }
-  /**
-   * The upload key of one window buffer: a marker object allocated once per record and `<name>:<bufferIndex>`.
-   * @param record - the owning record
-   * @param memoKey - `<name>:<bufferIndex>`
-   * @returns the stable marker object
-   */
-  windowKey(record, memoKey) {
-    const existing = record.windowKeys.get(memoKey);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const created = {};
-    record.windowKeys.set(memoKey, created);
-    return created;
-  }
-  /**
-   * Uploads `data` into a new buffer keyed on `key`, or returns the resident already uploaded for that key by
-   * the same owner (PLAN DECISION 11: a resident belongs to one record).
-   * @param record - the owning record, or null for an owner-less array
-   * @param key - the object the buffer is keyed on
-   * @param data - the bytes (byteLength a multiple of 4, graph-format invariant I10; a view over a plain
-   *   ArrayBuffer, which is what writeBuffer's GPUAllowSharedBufferSource accepts under @webgpu/types 0.1.72)
-   * @param label - the buffer label
-   * @returns the resident
-   */
-  upload(record, key, data, label) {
-    const serial = record === null ? null : record.serial;
-    const existing = this.residents.get(key);
-    if (existing !== void 0 && !existing.destroyed && existing.serial === serial) {
-      return existing;
-    }
-    const buffer = this.allocator.createBuffer({ label, size: data.byteLength, usage: RESIDENT_USAGE });
-    this.device.queue.writeBuffer(buffer, 0, data);
-    const resident = { key, buffer, byteLength: data.byteLength, serial, version: 0, destroyed: false };
-    this.residents.set(key, resident);
-    if (record === null) {
-      this.orphans.add(resident);
-    } else {
-      record.entries.push(resident);
-    }
-    this.liveCount++;
-    this.liveBytesValue += data.byteLength;
-    return resident;
-  }
-  /**
-   * Destroys one resident buffer and unregisters it; idempotent.
-   * @param resident - the resident
-   * @param record - its owning record, or null for an orphan
-   */
-  destroyResident(resident, record) {
-    if (resident.destroyed) {
-      return;
-    }
-    resident.destroyed = true;
-    this.allocator.destroy(resident.buffer);
-    if (this.residents.get(resident.key) === resident) {
-      this.residents.delete(resident.key);
-    }
-    if (record === null) {
-      this.orphans.delete(resident);
-    } else {
-      const index = record.entries.indexOf(resident);
-      if (index >= 0) {
-        record.entries.splice(index, 1);
-      }
-    }
-    this.liveCount--;
-    this.liveBytesValue -= resident.byteLength;
-  }
-  /**
-   * Marks a record released and drops it from the serial map (the snapshot WeakMap entries recognise it by the flag).
-   * @param record - the record
-   */
-  forget(record) {
-    record.released = true;
-    record.bindings.clear();
-    record.views.clear();
-    record.packKeys.clear();
-    record.windowKeys.clear();
-    record.arcBuffers.clear();
-    record.windows = null;
-    record.arena = null;
-    record.plan = null;
-    this.bySerial.delete(record.serial);
-  }
-  /**
-   * The record of a snapshot's serial, created when absent (which lifts a tombstone and may fire the warning).
-   * @param s - the snapshot
-   * @returns the record
-   */
-  ensureRecord(s) {
-    let record = this.records.get(s);
-    if (record !== void 0 && record.released) {
-      record = void 0;
-    }
-    if (record === void 0) {
-      record = this.bySerial.get(s.serial);
-    }
-    if (record === void 0) {
-      record = {
-        serial: s.serial,
-        label: s.label,
-        entries: [],
-        plan: null,
-        arena: null,
-        bindings: /* @__PURE__ */ new Map(),
-        views: /* @__PURE__ */ new Map(),
-        packKeys: /* @__PURE__ */ new Map(),
-        windowKeys: /* @__PURE__ */ new Map(),
-        windows: null,
-        arcBuffers: /* @__PURE__ */ new Map(),
-        released: false
-      };
-      this.bySerial.set(s.serial, record);
-      this.tombstones.delete(s.serial);
-      if (!this.warned && this.bySerial.size > this.warnUnreleasedSnapshots) {
-        this.warned = true;
-        this.warn(
-          `[webgpu-graph-algorithms] ${this.bySerial.size} snapshots are resident on the device (warnUnreleasedSnapshots = ${this.warnUnreleasedSnapshots}); call ctx.release(snapshot) for superseded snapshots -- GPU memory is never freed by garbage collection (spec 4.1)`
-        );
-      }
-    }
-    this.records.set(s, record);
-    return record;
-  }
-  /**
-   * Throws E_RELEASED for a tombstoned serial (a bind without a fresh core()).
-   * @param s - the snapshot
-   */
-  assertNotReleased(s) {
-    if (this.tombstones.has(s.serial)) {
-      throw new WebGpuGraphError(
-        "E_RELEASED",
-        `snapshot ${s.serial} was released; upload it again through core() before binding views, columns or arrays`,
-        { serial: s.serial }
-      );
-    }
-  }
-  /**
-   * Throws E_INVALID_ARGUMENT for an empty snapshot (a view of it would be a zero-length array, spec 5.6).
-   * @param s - the snapshot
-   */
-  assertNonEmpty(s) {
-    if (s.nodeCount === 0) {
-      throw invalid("snapshot", 0, "nodeCount > 0 (an empty snapshot has no per-node view to upload)");
-    }
-  }
-  /** Throws E_DISPOSED after destroyAll() (PLAN DECISION 13). */
-  assertLive() {
-    if (this.disposed) {
-      throw new WebGpuGraphError("E_DISPOSED", "the residency was disposed", { label: "residency" });
-    }
-  }
-}
-const DEFAULT_LABEL = "webgpu-graph-algorithms";
-const DEFAULT_OPTIONAL_FEATURES = Object.freeze(["subgroups", "timestamp-query"]);
-const DEFAULT_POWER_PREFERENCE = "high-performance";
-async function adapterOf(options) {
-  if (options.adapter !== void 0) {
-    return options.adapter;
-  }
-  if (options.gpu !== void 0) {
-    return requestAdapter(options.gpu, options.powerPreference ?? DEFAULT_POWER_PREFERENCE);
-  }
-  throw new WebGpuGraphError("E_NO_WEBGPU", "GpuContext.create needs one of gpu, adapter or device", {
-    reason: "no gpu, adapter or device given",
-    hint: "pass navigator.gpu (browser) or the gpu of createNodeGpu() (Node), or use the ./browser and ./node entries"
-  });
-}
-class GpuContext {
-  /**
-   * Steps 5 and 6 of create() (spec 2.2): the sink, the loss watcher and the singletons.
-   * @param init - the device, its caps and the create-time choices
-   */
-  constructor(init) {
-    this.currentState = "ready";
-    this.lostError = null;
-    this.slot = new PendingErrorSlot();
-    this.lostListeners = /* @__PURE__ */ new Set();
-    this.disposers = [];
-    this.batchCounter = 0;
-    this.device = init.device;
-    this.caps = init.caps;
-    this.ownsDevice = init.ownsDevice;
-    this.label = init.label;
-    this.debug = { inspect: false };
-    this.workgroupSize = workgroupSizeFor(init.caps);
-    this.allocator = new AllocationTracker(init.device);
-    this.residency = new GraphResidency(init.device, init.caps, this.allocator, {
-      warnUnreleasedSnapshots: init.warnUnreleasedSnapshots
-    });
-    this.pool = new BufferPool(init.device, this.allocator, init.caps.limits.maxBufferSize);
-    this.readback = new Readback(init.device, this.allocator);
-    this.pipelines = new PipelineCache(init.device, init.caps);
-    this.profiler = init.device.features.has("timestamp-query") ? new Profiler(init.device, true, init.caps.runtime !== "node") : null;
-    this.uninstallSink = installUncapturedErrorSink(init.device, this.slot, init.onError);
-    this.lost = watchDeviceLost(init.device, (info) => {
-      this.handleLost(info);
-    });
-  }
-  /**
-   * Probe without creating a device (spec 2.2); never throws. `gpu === undefined` -> E_NO_WEBGPU;
-   * requestAdapter() null or a throw -> E_NO_ADAPTER; `rejectSoftware && software` -> E_SOFTWARE_ONLY (the
-   * adapter and its summary are still reported); else OK with the UNUSED adapter and its summary.
-   * @param options - the GPU object, the power preference and the software policy
-   * @returns the probe result
-   */
-  static async probe(options) {
-    const { gpu } = options;
-    if (gpu === void 0) {
-      return {
-        ok: false,
-        code: "E_NO_WEBGPU",
-        reason: "no GPU object: navigator.gpu is undefined (no WebGPU in this runtime)",
-        adapter: null,
-        summary: null
-      };
-    }
-    let adapter;
-    try {
-      adapter = await requestAdapter(gpu, options.powerPreference ?? DEFAULT_POWER_PREFERENCE);
-    } catch (err) {
-      const reason = isWebGpuGraphError(err) ? err.message : String(err);
-      return { ok: false, code: "E_NO_ADAPTER", reason, adapter: null, summary: null };
-    }
-    const summary = summarizeAdapter(adapter);
-    if (options.rejectSoftware === true && summary.software) {
-      return {
-        ok: false,
-        code: "E_SOFTWARE_ONLY",
-        reason: `software adapter rejected: ${summary.vendor}/${summary.architecture}`,
-        adapter,
-        summary
-      };
-    }
-    return { ok: true, code: "OK", reason: null, adapter, summary };
-  }
-  /**
-   * The six-step acquisition of spec 2.2: adopt `device`, else take `adapter`, else request one from `gpu`
-   * (step 1); the software test (step 2); the limits / features and requestDevice (step 3); the caps from
-   * device.limits plus assertPlanLimits (step 4); the sink, the loss watcher and the singletons (steps 5-6,
-   * in the constructor).
-   * @param options - see GpuContextOptions
-   * @returns the context
-   */
-  static async create(options) {
-    const runtime = options.runtime ?? "unknown";
-    const label = options.label ?? DEFAULT_LABEL;
-    const onError = options.onError ?? null;
-    const warnUnreleasedSnapshots = options.warnUnreleasedSnapshots ?? DEFAULT_WARN_UNRELEASED_SNAPSHOTS;
-    if (options.device !== void 0) {
-      const adopted = capsFromDevice(options.device, { runtime });
-      assertPlanLimits(adopted);
-      return new GpuContext({
-        device: options.device,
-        caps: adopted,
-        ownsDevice: false,
-        label,
-        onError,
-        warnUnreleasedSnapshots
-      });
-    }
-    const adapter = await adapterOf(options);
-    const summary = summarizeAdapter(adapter);
-    if (options.rejectSoftware === true && summary.software) {
-      throw new WebGpuGraphError(
-        "E_SOFTWARE_ONLY",
-        `software adapter rejected by rejectSoftware: ${summary.vendor}/${summary.architecture}`,
-        { adapter: summary }
-      );
-    }
-    const requiredLimits = buildRequiredLimits(adapter, options.limits ?? "raise");
-    const requiredFeatures = buildRequiredFeatures(
-      adapter,
-      options.requiredFeatures ?? [],
-      options.optionalFeatures ?? DEFAULT_OPTIONAL_FEATURES
-    );
-    const device = await requestDevice(adapter, { label, requiredLimits, requiredFeatures });
-    const caps = captureCaps(device, adapter.info, runtime, options.gpu?.wgslLanguageFeatures ?? []);
-    try {
-      assertPlanLimits(caps);
-    } catch (err) {
-      device.destroy();
-      throw err;
-    }
-    return new GpuContext({ device, caps, ownsDevice: true, label, onError, warnUnreleasedSnapshots });
-  }
-  /**
-   * Zero-cost adoption of a device the caller owns (ownsDevice false, runtime "unknown" unless info says
-   * otherwise). The context is labelled with the device's label, or "GpuContext.from" when it has none.
-   * @param device - the device to adopt
-   * @param info - what the caller knows about the adapter, if anything
-   * @returns the context
-   */
-  static from(device, info) {
-    const caps = capsFromDevice(device, info);
-    assertPlanLimits(caps);
-    const deviceLabel = device.label ?? "";
-    return new GpuContext({
-      device,
-      caps,
-      ownsDevice: false,
-      label: deviceLabel === "" ? "GpuContext.from" : deviceLabel,
-      onError: null,
-      warnUnreleasedSnapshots: DEFAULT_WARN_UNRELEASED_SNAPSHOTS
-    });
-  }
-  /**
-   * "ready" | "lost" | "disposed".
-   * @returns the lifecycle state
-   */
-  get state() {
-    return this.currentState;
-  }
-  /**
-   * Throws E_DEVICE_LOST / E_DISPOSED by state and rethrows a pending uncaptured error (spec 5.7: "thrown
-   * from the next public call").
-   * @internal
-   */
-  assertReady() {
-    if (this.currentState === "disposed") {
-      throw new WebGpuGraphError("E_DISPOSED", `GpuContext "${this.label}" is disposed`, { label: this.label });
-    }
-    if (this.lostError !== null) {
-      throw this.lostError;
-    }
-    const pending = this.slot.take();
-    if (pending !== null) {
-      throw pending;
-    }
-  }
-  /**
-   * Takes the pending uncaptured error (used by CommandBatch right after submit).
-   * @internal
-   * @returns the error, or null
-   */
-  takePendingError() {
-    return this.slot.take();
-  }
-  /**
-   * Monotonically increasing batch ids, starting at 1.
-   * @internal
-   * @returns the next id
-   */
-  nextBatchId() {
-    this.batchCounter += 1;
-    return this.batchCounter;
-  }
-  /**
-   * Registers a device-loss listener (simulations enter "disposed"); returns the unregister function.
-   * @internal
-   * @param listener - called once with the lost info
-   * @returns removes the listener
-   */
-  onLost(listener) {
-    this.lostListeners.add(listener);
-    return () => {
-      this.lostListeners.delete(listener);
-    };
-  }
-  /**
-   * A disposer run by dispose() (the Node entry attaches the GPU handle's dispose); attached after
-   * dispose() it runs immediately.
-   * @internal
-   * @param dispose - the disposer
-   */
-  attachDisposer(dispose) {
-    if (this.currentState === "disposed") {
-      dispose();
-      return;
-    }
-    this.disposers.push(dispose);
-  }
-  /**
-   * Destroys every buffer recorded for the snapshot (spec 4.5), then `pool.trim()` (spec 4.4: idle scratch
-   * goes with the graph); idempotent; safe on a snapshot never uploaded; a no-op after dispose().
-   * @param snapshot - the snapshot whose buffers are released
-   */
-  release(snapshot) {
-    if (this.currentState === "disposed") {
-      return;
-    }
-    this.residency.release(snapshot);
-    this.pool.trim();
-  }
-  /**
-   * Rejects pending work with E_DISPOSED (every later public call), destroys residency, pool and staging
-   * ring, destroys the device when owned, runs attached disposers; idempotent (spec 2.8).
-   */
-  dispose() {
-    if (this.currentState === "disposed") {
-      return;
-    }
-    this.currentState = "disposed";
-    this.uninstallSink();
-    this.residency.destroyAll();
-    this.pool.destroyAll();
-    this.readback.destroyAll();
-    if (this.profiler !== null) {
-      this.profiler.destroy();
-    }
-    if (this.ownsDevice) {
-      this.device.destroy();
-    }
-    const disposers = this.disposers.splice(0);
-    for (const dispose of disposers) {
-      dispose();
-    }
-  }
-  /**
-   * Step 5 of spec 2.2 on loss: state "lost", the residency cleared without destroying (the buffers are
-   * gone with the device), every registered listener run once; a loss reported after dispose() (the owned
-   * device was destroyed by dispose) changes nothing.
-   * @param info - the device.lost result
-   */
-  handleLost(info) {
-    if (this.currentState === "disposed") {
-      return;
-    }
-    this.currentState = "lost";
-    this.lostError = deviceLostError(info);
-    this.residency.clearOnLoss();
-    for (const listener of Array.from(this.lostListeners)) {
-      try {
-        listener(info);
-      } catch {
-      }
-    }
-  }
-}
-export {
-  SE_DEFAULTS as $,
-  APSP_MAX_DISPATCHES_PER_SUBMIT as A,
-  BufferUsage as B,
-  PARTIAL_BYTES as C,
-  GRID_HUB_CELL as D,
-  EXACT_TILES_PER_PASS as E,
-  FUSED_FRONTIER_MAX as F,
-  GpuContext as G,
-  LAYOUT_TUNING_DEFAULTS as H,
-  INDIRECT_ARGS_STRIDE as I,
-  EXACT_MAX_NODES as J,
-  SETTLE_FLOOR_UNBOUNDED as K,
-  LABEL_PROP_PASSES_PER_SUBMIT as L,
-  MAX_WORKGROUPS_PER_DIM as M,
-  GRID_BBOX_MARGIN as N,
-  GRID_EXTENT_FLOOR as O,
-  PARALLEL_MERGE_LIMIT as P,
-  FR_ADAPTIVE_MAX_ITERATIONS as Q,
-  RADIX_BINS as R,
-  STATE_HEADER_BYTES as S,
-  TRACE_RECORD_BYTES as T,
-  UNIFORM_SLOT_BYTES as U,
-  FR_START_TEMPERATURE as V,
-  WebGpuGraphError as W,
-  FA2_FLAG_ADAPTIVE as X,
-  SETTLE_FLOOR_FRACTION as Y,
-  FR_REHEAT_FRACTION as Z,
-  FR_DEFAULTS as _,
-  WGSL_RESERVED_WORDS as a,
-  SETTLE_FLOOR_REFERENCE_NODES as a0,
-  SE_SCALE_REFERENCE_NODES as a1,
-  ARC_WINDOW_ALIGN as a2,
-  PASSTHROUGH_FORMAT_CODES as a3,
-  STORAGE_ALIGN as a4,
-  WORKGROUP_SIZE as a5,
-  isSoftwareAdapter as a6,
-  U32_MAX as b,
-  MAX_LEVELS_PER_SUBMIT as c,
-  deviceLostError as d,
-  BEAMER_BETA as e,
-  SSSP_DELTA_FACTOR as f,
-  F32_INF_BITS as g,
-  BC_EDGE_PARALLEL_GAMMA as h,
-  isWebGpuGraphError as i,
-  BC_BATCH_BUDGET_FRACTION as j,
-  BC_MAX_BATCH as k,
-  BC_BACKWARD_LEVELS_PER_SUBMIT as l,
-  BC_COUNT_MAX_GROUPS as m,
-  APSP_TILE as n,
-  GROUP_ROW_THREAD_MAX as o,
-  GROUP_ROW_THREAD_LIMIT as p,
-  GROUP_HASH_LOAD_FACTOR as q,
-  BORUVKA_ROUNDS_PER_SUBMIT as r,
-  GRID_COARSEST_SIDE as s,
-  GRID_MIN_SIDE as t,
-  GRID_SORT_BITS as u,
-  FA2_DEFAULTS as v,
-  MAX_ITERATIONS_PER_STEP as w,
-  MAX_1D_ITEMS as x,
-  hasErrorCode as y,
-  FA2_FLAG_FIRST as z
-};
-//# sourceMappingURL=context-BZY6SMsM.js.map