@graphty/webgpu-graph-algorithms 0.0.0 → 0.2.1

package/dist/chunks/context-E6iKaeuJ.js

@@ -0,0 +1,3136 @@
+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 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 FA2_FLAG_FIRST = 1;
+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 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) {
+      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);
+    return bound;
+  }
+  /**
+   * setPipeline + setBindGroup for every group (dynamic offsets in dynamicGroups order) + dispatchWorkgroups(plan.x, plan.y, 1); 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) {
+    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
+        }
+      );
+    }
+    if (plan.x === 0) {
+      return;
+    }
+    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);
+      }
+    });
+    pass.dispatchWorkgroups(plan.x, plan.y, 1);
+  }
+  /** 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 MAX_WORKGROUPS_PER_DIM: u32 = ${MAX_WORKGROUPS_PER_DIM}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 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; }
+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 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_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_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"];
+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.pending = [];
+    this.cursor = 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.
+   * @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 || this.cursor + 2 > this.slots) {
+      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)
+    );
+    this.pending = [];
+    this.cursor = 0;
+    return 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;
+    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 = /* @__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.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 RESIDENT_USAGE = BufferUsage.STORAGE | BufferUsage.COPY_DST | BufferUsage.COPY_SRC;
+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 throws E_TOO_LARGE { path: "windowed" }
+   * until P4 (PLAN DECISION 2); 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);
+    if (plan.kind === "windowed") {
+      throw new WebGpuGraphError(
+        "E_TOO_LARGE",
+        `snapshot ${s.serial}: an arc array of ${4 * s.arcCount} bytes needs arc windows (${plan.windows.length}), which P1-P3 plan but do not execute`,
+        {
+          needed: 4 * s.arcCount,
+          limit: this.caps.limits.maxStorageBufferBindingSize,
+          path: "windowed",
+          algorithm: null
+        }
+      );
+    }
+    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 };
+      }
+    }
+    for (const name of names) {
+      if (!record.bindings.has(name)) {
+        record.bindings.set(name, 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: null,
+      hasWeights: weights !== null
+    });
+  }
+  /**
+   * Uploads (or finds) a view; P1-P3 support outDegree / inDegree / degreeOrder / reverseDegreeOrder; the others
+   * -> E_UNSUPPORTED until P7. packViews is accepted and ignored until P7 (a `true` request is E_UNSUPPORTED
+   * { option: "packViews" }, PLAN DECISION 9).
+   * @param s - the snapshot
+   * @param name - the view
+   * @param options - view options
+   * @param options.packViews - P7's packed reverse upload; `true` is E_UNSUPPORTED until then
+   * @returns the view binding
+   */
+  view(s, name, options) {
+    this.assertLive();
+    assertAttached(s);
+    if (options?.packViews === true) {
+      throw new WebGpuGraphError("E_UNSUPPORTED", "packViews is not supported before the P7 view uploads", {
+        option: "packViews",
+        hint: "omit packViews; the four reverse arrays are uploaded separately"
+      });
+    }
+    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 "reverse":
+      case "coo":
+      case "edgeList":
+      case "mate":
+        throw new WebGpuGraphError("E_UNSUPPORTED", `the ${name} view is not uploaded before P7`, {
+          feature: `view:${name}`,
+          hint: "P1-P3 upload outDegree, inDegree, degreeOrder and reverseDegreeOrder"
+        });
+      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)
+    });
+  }
+  /**
+   * 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 `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.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(),
+        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 {
+  ARC_WINDOW_ALIGN as A,
+  BufferUsage as B,
+  EXACT_MAX_NODES as E,
+  FA2_DEFAULTS as F,
+  GpuContext as G,
+  LAYOUT_TUNING_DEFAULTS as L,
+  MAX_WORKGROUPS_PER_DIM as M,
+  PARTIAL_BYTES as P,
+  STATE_HEADER_BYTES as S,
+  TRACE_RECORD_BYTES as T,
+  UNIFORM_SLOT_BYTES as U,
+  WebGpuGraphError as W,
+  WGSL_RESERVED_WORDS as a,
+  MAX_ITERATIONS_PER_STEP as b,
+  MAX_1D_ITEMS as c,
+  deviceLostError as d,
+  FA2_FLAG_FIRST as e,
+  PASSTHROUGH_FORMAT_CODES as f,
+  STORAGE_ALIGN as g,
+  hasErrorCode as h,
+  isWebGpuGraphError as i,
+  WORKGROUP_SIZE as j,
+  isSoftwareAdapter as k
+};
+//# sourceMappingURL=context-E6iKaeuJ.js.map