@forgeax/engine-rhi-null 0.1.2

package/dist/canvas-context.d.ts

@@ -0,0 +1,22 @@
+import type { CanvasConfiguration, Result, RhiCanvasContext, RhiError as RhiErrorType, Texture } from '@forgeax/engine-rhi';
+/**
+ * Headless canvas context. configure succeeds vacuously; getCurrentTexture
+ * mints a legal opaque-handle Texture brand so the swap-chain acquisition path
+ * never blocks frame rendering in headless CI.
+ */
+export declare class RhiNullCanvasContext implements RhiCanvasContext {
+    configure(_desc: CanvasConfiguration): Result<void, RhiErrorType>;
+    unconfigure(): void;
+    getConfiguration(): CanvasConfiguration | undefined;
+    getCurrentTexture(): Result<Texture, RhiErrorType>;
+}
+/**
+ * Acquire a canvas context. The headless backend returns ok(context) so the
+ * createRenderer context-acquisition step succeeds. The context's
+ * getCurrentTexture mints a legal Texture brand once a bookkeeper is attached.
+ *
+ * R-1: this is mounted on the rhi singleton so Channel 1's facade never
+ * crashes on a missing acquireCanvasContext.
+ */
+export declare function acquireCanvasContext(_canvas?: HTMLCanvasElement | OffscreenCanvas | null | undefined): Result<RhiCanvasContext, RhiErrorType>;
+//# sourceMappingURL=canvas-context.d.ts.map

package/dist/canvas-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-context.d.ts","sourceRoot":"","sources":["../src/canvas-context.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EACV,mBAAmB,EACnB,MAAM,EACN,gBAAgB,EAChB,QAAQ,IAAI,YAAY,EACxB,OAAO,EACR,MAAM,qBAAqB,CAAC;AAG7B;;;;GAIG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IAC3D,SAAS,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC;IAIjE,WAAW,IAAI,IAAI;IAEnB,gBAAgB,IAAI,mBAAmB,GAAG,SAAS;IAInD,iBAAiB,IAAI,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC;CAMnD;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,CAAC,EAAE,iBAAiB,GAAG,eAAe,GAAG,IAAI,GAAG,SAAS,GAC/D,MAAM,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAExC"}

package/dist/command-encoder.d.ts

@@ -0,0 +1,27 @@
+import type { Buffer, CommandBuffer, ComputePassDescriptor, QuerySet, Result, RhiCommandEncoder, RhiComputePassEncoder, RhiError as RhiErrorType, RhiRenderPassEncoder } from '@forgeax/engine-rhi';
+import type { Bookkeeper } from './bookkeeping';
+import type { RhiNullDevice } from './device';
+/**
+ * Headless command encoder. begin*Pass returns a no-op pass encoder bound to
+ * the issuing device's ledger; recording methods are no-ops; finish mints a
+ * CommandBuffer brand.
+ */
+export declare class RhiNullCommandEncoder implements RhiCommandEncoder {
+    private readonly bookkeeper;
+    private readonly counter;
+    constructor(bookkeeper: Bookkeeper, device: RhiNullDevice);
+    beginRenderPass(desc: GPURenderPassDescriptor): RhiRenderPassEncoder;
+    beginComputePass(desc?: ComputePassDescriptor | undefined): RhiComputePassEncoder;
+    copyBufferToBuffer(_source: Buffer, _sourceOffsetOrDestination: number | Buffer, _destinationOrSize?: Buffer | number | undefined, _destinationOffset?: number | undefined, _size?: number | undefined): void;
+    copyBufferToTexture(_source: GPUTexelCopyBufferInfo, _destination: GPUTexelCopyTextureInfo, _copySize: GPUExtent3DStrict): void;
+    copyTextureToBuffer(_source: GPUTexelCopyTextureInfo, _destination: GPUTexelCopyBufferInfo, _copySize: GPUExtent3DStrict): void;
+    copyTextureToTexture(_source: GPUTexelCopyTextureInfo, _destination: GPUTexelCopyTextureInfo, _copySize: GPUExtent3DStrict): void;
+    clearBuffer(_buffer: Buffer, _offset?: number | undefined, _size?: number | undefined): void;
+    resolveQuerySet(_querySet: QuerySet, _firstQuery: number, _queryCount: number, _destination: Buffer, _destinationOffset: number): Result<void, RhiErrorType>;
+    writeTimestamp(_querySet: QuerySet, _queryIndex: number): void;
+    pushDebugGroup(_groupLabel: string): void;
+    popDebugGroup(): void;
+    insertDebugMarker(_markerLabel: string): void;
+    finish(): Result<CommandBuffer, RhiErrorType>;
+}
+//# sourceMappingURL=command-encoder.d.ts.map

package/dist/command-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-encoder.d.ts","sourceRoot":"","sources":["../src/command-encoder.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,MAAM,EACN,aAAa,EACb,qBAAqB,EACrB,QAAQ,EACR,MAAM,EACN,iBAAiB,EACjB,qBAAqB,EACrB,QAAQ,IAAI,YAAY,EACxB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AA2C9C;;;;GAIG;AACH,qBAAa,qBAAsB,YAAW,iBAAiB;IAC7D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;gBAE1B,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa;IAKzD,eAAe,CAAC,IAAI,EAAE,uBAAuB,GAAG,oBAAoB;IAKpE,gBAAgB,CAAC,IAAI,CAAC,EAAE,qBAAqB,GAAG,SAAS,GAAG,qBAAqB;IAKjF,kBAAkB,CAChB,OAAO,EAAE,MAAM,EACf,0BAA0B,EAAE,MAAM,GAAG,MAAM,EAC3C,kBAAkB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAChD,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,EACvC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,GACzB,IAAI;IAEP,mBAAmB,CACjB,OAAO,EAAE,sBAAsB,EAC/B,YAAY,EAAE,uBAAuB,EACrC,SAAS,EAAE,iBAAiB,GAC3B,IAAI;IAEP,mBAAmB,CACjB,OAAO,EAAE,uBAAuB,EAChC,YAAY,EAAE,sBAAsB,EACpC,SAAS,EAAE,iBAAiB,GAC3B,IAAI;IAEP,oBAAoB,CAClB,OAAO,EAAE,uBAAuB,EAChC,YAAY,EAAE,uBAAuB,EACrC,SAAS,EAAE,iBAAiB,GAC3B,IAAI;IAEP,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAE5F,eAAe,CACb,SAAS,EAAE,QAAQ,EACnB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,GACzB,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC;IAI7B,cAAc,CAAC,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAE9D,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAEzC,aAAa,IAAI,IAAI;IAErB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAE7C,MAAM,IAAI,MAAM,CAAC,aAAa,EAAE,YAAY,CAAC;CAG9C"}

package/dist/device.d.ts

@@ -0,0 +1,66 @@
+import type { BindGroup, BindGroupDescriptor, BindGroupLayout, BindGroupLayoutDescriptor, Buffer, BufferDescriptor, CommandEncoderDescriptor, ComputePipeline, ComputePipelineDescriptor, PipelineLayout, PipelineLayoutDescriptor, QuerySet, QuerySetDescriptor, RenderPipeline, RenderPipelineDescriptor, Result, RhiCaps, RhiCommandEncoder, RhiDevice, RhiError as RhiErrorType, RhiFeatures, RhiLimits, RhiQueue, Sampler, SamplerDescriptor, Texture, TextureDescriptor, TextureView, TextureViewDescriptor } from '@forgeax/engine-rhi';
+import { Bookkeeper } from './bookkeeping';
+type RhiNullDeviceLost = Awaited<RhiDevice['lost']>;
+/**
+ * Factory that builds a command encoder bound to a device's ledger. Injected at
+ * device construction (rather than imported here) so device.ts carries no
+ * dependency on command-encoder.ts; the singleton assembly (index.ts) supplies
+ * the real factory. The Bookkeeper and RhiNullDevice are passed so the encoder
+ * threads draw / dispatch counts + binding validation through the same per-device
+ * ledger AND writes aggregated frame stats to the device for M3 unit-test readback.
+ */
+export type CommandEncoderFactory = (bookkeeper: Bookkeeper, device: RhiNullDevice) => RhiCommandEncoder;
+/**
+ * Headless no-op RhiDevice. Every create* mints a legal brand and records it;
+ * every destroy* fail-fasts a double-destroy; caps reports the all-true-except-
+ * reserved profile (D-5).
+ */
+export declare class RhiNullDevice implements RhiDevice {
+    private readonly internalBookkeeper;
+    private readonly nullQueue;
+    private readonly encoderFactory;
+    /** Per-frame total draw count across all pass encoders executed this frame
+     *  (aggregated by the command encoder on finish, then reset). M3 unit tests
+     *  (w17) read this to assert draw count >= 1 (AC-06). */
+    totalDrawCount: number;
+    /** Per-frame total direct and indirect compute dispatch count. */
+    totalDispatchCount: number;
+    /** Per-frame total bind group set count (AC-06 / AC-05 readback). */
+    totalBindGroupCount: number;
+    /** Per-frame pass names executed this frame, in schedule order (AC-04). */
+    framePassNames: string[];
+    /** The per-device handle ledger — exposed so M3 tests can assert create/destroy
+     *  pairing and BGL/PSO shape counts (AC-05/06/07). */
+    get bookkeeper(): Bookkeeper;
+    constructor(queue: RhiQueue, encoderFactory: CommandEncoderFactory);
+    get caps(): RhiCaps;
+    get features(): RhiFeatures;
+    get limits(): RhiLimits;
+    get queue(): RhiQueue;
+    get lost(): Promise<RhiNullDeviceLost>;
+    createBuffer(_desc: BufferDescriptor): Result<Buffer, RhiErrorType>;
+    createTexture(_desc: TextureDescriptor): Result<Texture, RhiErrorType>;
+    destroyBuffer(buf: Buffer): Result<void, RhiErrorType>;
+    destroyQuerySet(querySet: QuerySet): Result<void, RhiErrorType>;
+    destroyTexture(tex: Texture): Result<void, RhiErrorType>;
+    createTextureView(_texture: Texture, _desc: TextureViewDescriptor): Result<TextureView, RhiErrorType>;
+    createSampler(_desc?: SamplerDescriptor | undefined): Result<Sampler, RhiErrorType>;
+    createBindGroupLayout(_desc: BindGroupLayoutDescriptor): Result<BindGroupLayout, RhiErrorType>;
+    createBindGroup(_desc: BindGroupDescriptor): Result<BindGroup, RhiErrorType>;
+    createPipelineLayout(_desc: PipelineLayoutDescriptor): Result<PipelineLayout, RhiErrorType>;
+    createRenderPipeline(_desc: RenderPipelineDescriptor): Result<RenderPipeline, RhiErrorType>;
+    createComputePipeline(_desc: ComputePipelineDescriptor): Result<ComputePipeline, RhiErrorType>;
+    createQuerySet(desc: QuerySetDescriptor): Result<QuerySet, RhiErrorType>;
+    createCommandEncoder(_desc?: CommandEncoderDescriptor | undefined): Result<RhiCommandEncoder, RhiErrorType>;
+    /**
+     * Mint a pipeline handle whose object also carries the no-op
+     * `getBindGroupLayout(index)` ops method (D-2). The prod auto-layout path
+     * (debug-draw.ts) and the existing mock unit tests both call
+     * `pipeline.getBindGroupLayout(n)`; returning a legal BindGroupLayout brand
+     * (recorded in the ledger) keeps those consumers from crashing on a missing
+     * method.
+     */
+    private makePipeline;
+}
+export {};
+//# sourceMappingURL=device.d.ts.map

package/dist/device.d.ts.map

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

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import type { RhiInstance } from '@forgeax/engine-rhi';
+import { acquireCanvasContext } from './canvas-context';
+import { createShaderModule } from './shader';
+/**
+ * The `rhi` singleton — RhiBackendPack-shaped entry for Channel 1 injection
+ * (`createRenderer(canvas, { rhi })`). Carries acquireCanvasContext (R-1) so
+ * the facade never crashes on a missing method, and createShaderModule (R-2) so
+ * the ready chain's shader step resolves rather than rejecting.
+ */
+export declare const rhi: RhiInstance & {
+    acquireCanvasContext: typeof acquireCanvasContext;
+    createShaderModule: typeof createShaderModule;
+};
+export { RhiNullAdapter } from './adapter';
+export { acquireCanvasContext, RhiNullCanvasContext } from './canvas-context';
+export { RhiNullCommandEncoder } from './command-encoder';
+export { RhiNullDevice } from './device';
+export { RhiNullComputePassEncoder, RhiNullRenderPassEncoder } from './pass-encoders';
+export { RhiNullQueue } from './queue';
+export { createShaderModule } from './shader';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAKV,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAc9C;;;;;GAKG;AACH,eAAO,MAAM,GAAG,EAAE,WAAW,GAAG;IAC9B,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;IAClD,kBAAkB,EAAE,OAAO,kBAAkB,CAAC;CAK/C,CAAC;AAEF,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AACtF,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.mjs

@@ -0,0 +1,470 @@
+import { ok, err } from '@forgeax/engine-types';
+import { RhiError } from '@forgeax/engine-rhi';
+
+// src/index.ts
+var RhiNullRenderPassEncoder = class {
+  /** Number of draw* calls issued on this pass (AC-06 readback). */
+  drawCount = 0;
+  bindGroupCount = 0;
+  /** Most recent setVertexBuffer / setBindGroup ownership validation; ok unless
+   *  a foreign handle was passed (AC-09 readback). */
+  lastValidation = ok(void 0);
+  bookkeeper;
+  counter;
+  passName;
+  constructor(bookkeeper, counter, passName) {
+    this.bookkeeper = bookkeeper;
+    this.counter = counter;
+    this.passName = passName;
+  }
+  setPipeline(_pipeline) {
+  }
+  setVertexBuffer(_slot, buffer, _offset, _size) {
+    this.lastValidation = this.bookkeeper.validateOwnership(buffer);
+  }
+  setIndexBuffer(_buffer, _format, _offset, _size) {
+  }
+  setBindGroup(_index, bindGroup, _dynamicOffsetsData, _dynamicOffsetsDataStart, _dynamicOffsetsDataLength) {
+    this.bindGroupCount++;
+    this.counter?.recordBindGroup();
+    this.lastValidation = this.bookkeeper.validateOwnership(bindGroup);
+  }
+  draw(_vertexCount, _instanceCount, _firstVertex, _firstInstance) {
+    this.drawCount++;
+    this.counter?.recordDraw();
+  }
+  drawIndexed(_indexCount, _instanceCount, _firstIndex, _baseVertex, _firstInstance) {
+    this.drawCount++;
+    this.counter?.recordDraw();
+  }
+  end() {
+    this.counter?.recordPassName(this.passName);
+  }
+  setViewport(_x, _y, _w, _h, _minDepth, _maxDepth) {
+  }
+  setScissorRect(_x, _y, _w, _h) {
+  }
+  setBlendConstant(_color) {
+  }
+  setStencilReference(_reference) {
+  }
+  drawIndirect(_indirectBuffer, _indirectOffset) {
+    this.drawCount++;
+    this.counter?.recordDraw();
+  }
+  drawIndexedIndirect(_indirectBuffer, _indirectOffset) {
+    this.drawCount++;
+    this.counter?.recordDraw();
+  }
+  pushDebugGroup(_groupLabel) {
+  }
+  popDebugGroup() {
+  }
+  insertDebugMarker(_markerLabel) {
+  }
+  executeBundles(_bundles) {
+    return ok(void 0);
+  }
+  beginOcclusionQuery(_queryIndex) {
+    return ok(void 0);
+  }
+  endOcclusionQuery() {
+    return ok(void 0);
+  }
+};
+var RhiNullComputePassEncoder = class {
+  /** Number of dispatchWorkgroups calls issued on this pass (readback). */
+  dispatchCount = 0;
+  /** Most recent setBindGroup ownership validation (AC-09 readback). */
+  lastValidation = ok(void 0);
+  bookkeeper;
+  counter;
+  passName;
+  constructor(bookkeeper, counter, passName) {
+    this.bookkeeper = bookkeeper;
+    this.counter = counter;
+    this.passName = passName;
+  }
+  setPipeline(_pipeline) {
+  }
+  setBindGroup(_index, bindGroup, _dynamicOffsets) {
+    this.lastValidation = this.bookkeeper.validateOwnership(bindGroup);
+  }
+  dispatchWorkgroups(_x, _y, _z) {
+    this.dispatchCount++;
+    this.counter?.recordDispatch();
+  }
+  dispatchWorkgroupsIndirect(indirectBuffer, _indirectOffset) {
+    this.lastValidation = this.bookkeeper.validateOwnership(indirectBuffer);
+    this.dispatchCount++;
+    this.counter?.recordDispatch();
+  }
+  end() {
+    this.counter?.recordPassName(this.passName);
+  }
+};
+
+// src/command-encoder.ts
+var DeviceCounter = class {
+  constructor(device) {
+    this.device = device;
+  }
+  device;
+  recordDraw() {
+    this.device.totalDrawCount++;
+  }
+  recordDispatch() {
+    this.device.totalDispatchCount++;
+  }
+  recordBindGroup() {
+    this.device.totalBindGroupCount++;
+  }
+  recordPassName(name) {
+    this.device.framePassNames.push(name);
+  }
+};
+function readPassLabel(desc) {
+  if (desc && typeof desc.label === "string" && desc.label.length > 0) {
+    return desc.label;
+  }
+  return "<unnamed>";
+}
+var RhiNullCommandEncoder = class {
+  bookkeeper;
+  counter;
+  constructor(bookkeeper, device) {
+    this.bookkeeper = bookkeeper;
+    this.counter = new DeviceCounter(device);
+  }
+  beginRenderPass(desc) {
+    const label = readPassLabel(desc);
+    return new RhiNullRenderPassEncoder(this.bookkeeper, this.counter, label);
+  }
+  beginComputePass(desc) {
+    const label = readPassLabel(desc);
+    return new RhiNullComputePassEncoder(this.bookkeeper, this.counter, label);
+  }
+  copyBufferToBuffer(_source, _sourceOffsetOrDestination, _destinationOrSize, _destinationOffset, _size) {
+  }
+  copyBufferToTexture(_source, _destination, _copySize) {
+  }
+  copyTextureToBuffer(_source, _destination, _copySize) {
+  }
+  copyTextureToTexture(_source, _destination, _copySize) {
+  }
+  clearBuffer(_buffer, _offset, _size) {
+  }
+  resolveQuerySet(_querySet, _firstQuery, _queryCount, _destination, _destinationOffset) {
+    return ok(void 0);
+  }
+  writeTimestamp(_querySet, _queryIndex) {
+  }
+  pushDebugGroup(_groupLabel) {
+  }
+  popDebugGroup() {
+  }
+  insertDebugMarker(_markerLabel) {
+  }
+  finish() {
+    return ok(this.bookkeeper.register("CommandBuffer"));
+  }
+};
+var BOOKKEEPING_KEY = /* @__PURE__ */ Symbol("forgeax-rhi-null-bookkeeping");
+var Bookkeeper = class {
+  deviceId;
+  nextHandleId = 0;
+  records = /* @__PURE__ */ new Map();
+  constructor(deviceId) {
+    this.deviceId = deviceId;
+  }
+  /**
+   * Register a freshly-minted handle of the given kind, returning a plain
+   * object that carries its ledger row. The caller casts the return value to
+   * the concrete brand (`as unknown as Buffer` etc.).
+   */
+  register(kind) {
+    const id = this.nextHandleId++;
+    const record = {
+      id,
+      kind,
+      destroyed: false,
+      sourceDeviceId: this.deviceId
+    };
+    this.records.set(id, record);
+    return { [BOOKKEEPING_KEY]: record };
+  }
+  /**
+   * Mark a handle destroyed. Fail-fasts on a second destroy
+   * ('destroy-after-destroy') or on a handle issued by a different device
+   * ('rhi-not-available'); otherwise flips the destroyed flag and returns ok.
+   */
+  destroy(handle) {
+    const ownership = this.validateOwnership(handle);
+    if (!ownership.ok) return ownership;
+    const destroyedCheck = isHandleDestroyed(handle);
+    if (!destroyedCheck.ok) return destroyedCheck;
+    ownership.value.destroyed = true;
+    return ok(void 0);
+  }
+  /**
+   * Report whether a handle has already been destroyed (true once destroy()
+   * has flipped its flag). Used by command-stream methods that must not
+   * consume a stale handle.
+   */
+  isDestroyed(handle) {
+    return readRecord(handle)?.destroyed === true;
+  }
+  /**
+   * Validate that a handle was issued by THIS device. Returns the ledger row on
+   * success so callers can mutate it (e.g. flip destroyed); returns
+   * 'rhi-not-available' for a foreign handle (AC-09 — no silent pass).
+   */
+  validateOwnership(handle) {
+    const record = readRecord(handle);
+    if (record === void 0 || record.sourceDeviceId !== this.deviceId) {
+      return err(
+        new RhiError({
+          code: "rhi-not-available",
+          expected: "handle was issued by this RhiNull device",
+          hint: "do not pass a handle created on a different RhiNull device into this device; create resources on the device they are used with"
+        })
+      );
+    }
+    return ok(record);
+  }
+  /**
+   * Return all ledger rows as a readonly array. M3 unit tests (w17) read this
+   * to assert create/destroy pairing, BGL/PSO shape counts, and resource
+   * lifecycle coverage (AC-05/06/07). Returns a snapshot of the current Map
+   * so callers can iterate without a stale reference after further mutations.
+   */
+  allRecords() {
+    return [...this.records.values()];
+  }
+  /** Report the total number of records in the ledger. */
+  recordCount() {
+    return this.records.size;
+  }
+};
+function readRecord(handle) {
+  if (handle === null || typeof handle !== "object") return void 0;
+  const tagged = handle;
+  return tagged[BOOKKEEPING_KEY];
+}
+function isHandleDestroyed(handle) {
+  if (readRecord(handle)?.destroyed === true) {
+    return err(
+      new RhiError({
+        code: "destroy-after-destroy",
+        expected: "GPU buffer/texture handle has not been destroyed yet",
+        hint: "object already destroyed; track lifecycle in caller or check isDestroyed before re-destroy"
+      })
+    );
+  }
+  return ok(void 0);
+}
+
+// src/device.ts
+var nextDeviceId = 0;
+var RhiNullDevice = class {
+  internalBookkeeper;
+  nullQueue;
+  encoderFactory;
+  /** Per-frame total draw count across all pass encoders executed this frame
+   *  (aggregated by the command encoder on finish, then reset). M3 unit tests
+   *  (w17) read this to assert draw count >= 1 (AC-06). */
+  totalDrawCount = 0;
+  /** Per-frame total direct and indirect compute dispatch count. */
+  totalDispatchCount = 0;
+  /** Per-frame total bind group set count (AC-06 / AC-05 readback). */
+  totalBindGroupCount = 0;
+  /** Per-frame pass names executed this frame, in schedule order (AC-04). */
+  framePassNames = [];
+  /** The per-device handle ledger — exposed so M3 tests can assert create/destroy
+   *  pairing and BGL/PSO shape counts (AC-05/06/07). */
+  get bookkeeper() {
+    return this.internalBookkeeper;
+  }
+  constructor(queue, encoderFactory) {
+    this.internalBookkeeper = new Bookkeeper(nextDeviceId++);
+    this.nullQueue = queue;
+    this.encoderFactory = encoderFactory;
+  }
+  get caps() {
+    return {
+      backendKind: "null",
+      compute: true,
+      timestampQuery: false,
+      timestampPeriodNanoseconds: null,
+      indirectDrawing: true,
+      textureCompressionBc: false,
+      textureCompressionEtc2: false,
+      textureCompressionAstc: false,
+      // 3 wgpu-native-only reserved flags stay false on non-native backends
+      // (D-5); the headless backend is not a native runtime.
+      multiDrawIndirect: false,
+      pushConstants: false,
+      textureBindingArray: false,
+      samplerAliasing: true,
+      firstInstanceIndirect: true,
+      storageBuffer: true,
+      storageTexture: true,
+      rgba16floatRenderable: true,
+      rg11b10ufloatRenderable: true,
+      float32Filterable: true,
+      maxColorAttachments: 8
+    };
+  }
+  get features() {
+    return EMPTY_FEATURES;
+  }
+  get limits() {
+    return EMPTY_LIMITS;
+  }
+  get queue() {
+    return this.nullQueue;
+  }
+  // forgeax-async-whitelist: dom-native — spec `GPUDevice.lost` Promise
+  // passthrough. The headless backend never loses a device (no GPU), so the
+  // Promise stays unsettled for the lifetime of the device, mirroring a live
+  // device that never transitions to the lost state.
+  get lost() {
+    return NEVER;
+  }
+  createBuffer(_desc) {
+    return ok(this.internalBookkeeper.register("Buffer"));
+  }
+  createTexture(_desc) {
+    return ok(this.internalBookkeeper.register("Texture"));
+  }
+  destroyBuffer(buf) {
+    return this.internalBookkeeper.destroy(buf);
+  }
+  destroyQuerySet(querySet) {
+    return this.internalBookkeeper.destroy(querySet);
+  }
+  destroyTexture(tex) {
+    return this.internalBookkeeper.destroy(tex);
+  }
+  createTextureView(_texture, _desc) {
+    return ok(this.internalBookkeeper.register("TextureView"));
+  }
+  createSampler(_desc) {
+    return ok(this.internalBookkeeper.register("Sampler"));
+  }
+  createBindGroupLayout(_desc) {
+    return ok(this.internalBookkeeper.register("BindGroupLayout"));
+  }
+  createBindGroup(_desc) {
+    return ok(this.internalBookkeeper.register("BindGroup"));
+  }
+  createPipelineLayout(_desc) {
+    return ok(this.internalBookkeeper.register("PipelineLayout"));
+  }
+  createRenderPipeline(_desc) {
+    return ok(this.makePipeline("RenderPipeline"));
+  }
+  createComputePipeline(_desc) {
+    return ok(this.makePipeline("ComputePipeline"));
+  }
+  createQuerySet(desc) {
+    if (desc.type === "timestamp") {
+      return err(
+        new RhiError({
+          code: "feature-not-enabled",
+          expected: "caps.timestampQuery === true (timestamp-query feature)",
+          hint: "RhiNull is structural-only and cannot produce GPU timestamp ticks"
+        })
+      );
+    }
+    return ok(this.internalBookkeeper.register("QuerySet"));
+  }
+  createCommandEncoder(_desc) {
+    return ok(this.encoderFactory(this.internalBookkeeper, this));
+  }
+  /**
+   * Mint a pipeline handle whose object also carries the no-op
+   * `getBindGroupLayout(index)` ops method (D-2). The prod auto-layout path
+   * (debug-draw.ts) and the existing mock unit tests both call
+   * `pipeline.getBindGroupLayout(n)`; returning a legal BindGroupLayout brand
+   * (recorded in the ledger) keeps those consumers from crashing on a missing
+   * method.
+   */
+  makePipeline(kind) {
+    const handle = this.internalBookkeeper.register(kind);
+    const getBindGroupLayout = (_index) => this.internalBookkeeper.register("BindGroupLayout");
+    return Object.assign(handle, { getBindGroupLayout });
+  }
+};
+var EMPTY_FEATURES = /* @__PURE__ */ new Set();
+var EMPTY_LIMITS = {};
+var NEVER = new Promise(() => {
+});
+var RhiNullQueue = class {
+  writeBuffer(_buffer, _bufferOffset, _data, _dataOffset, _size) {
+    return ok(void 0);
+  }
+  writeTexture(_destination, _data, _dataLayout, _size) {
+    return ok(void 0);
+  }
+  copyExternalImageToTexture(_source, _destination, _copySize) {
+    return ok(void 0);
+  }
+  submit(_commandBuffers) {
+    return ok(void 0);
+  }
+  // forgeax-async-whitelist: dom-native — spec `GPUQueue.onSubmittedWorkDone`
+  // never rejects. The headless backend has no pending GPU work, so it resolves
+  // immediately (AC-12: read-back idioms must not hang).
+  onSubmittedWorkDone() {
+    return Promise.resolve(void 0);
+  }
+};
+
+// src/adapter.ts
+var RhiNullAdapter = class {
+  features = /* @__PURE__ */ new Set();
+  limits = {};
+  // forgeax-async-whitelist is not needed: this returns Promise<Result<...>>
+  // per the spec contract; never rejects.
+  requestDevice(_opts) {
+    const device = new RhiNullDevice(
+      new RhiNullQueue(),
+      (bookkeeper, dev) => new RhiNullCommandEncoder(bookkeeper, dev)
+    );
+    return Promise.resolve(ok(device));
+  }
+};
+var RhiNullCanvasContext = class {
+  configure(_desc) {
+    return ok(void 0);
+  }
+  unconfigure() {
+  }
+  getConfiguration() {
+    return void 0;
+  }
+  getCurrentTexture() {
+    return ok({});
+  }
+};
+function acquireCanvasContext(_canvas) {
+  return ok(new RhiNullCanvasContext());
+}
+function createShaderModule(_device, _desc) {
+  return Promise.resolve(ok({}));
+}
+
+// src/index.ts
+function requestAdapter(_opts, _compatibleSurface) {
+  return Promise.resolve(ok(new RhiNullAdapter()));
+}
+var rhi = {
+  requestAdapter,
+  acquireCanvasContext,
+  createShaderModule
+};
+
+export { RhiNullAdapter, RhiNullCanvasContext, RhiNullCommandEncoder, RhiNullComputePassEncoder, RhiNullDevice, RhiNullQueue, RhiNullRenderPassEncoder, acquireCanvasContext, createShaderModule, rhi };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map