oidn-web 0.3.4 → 0.4.0

package/tests/modelSpec.test.mjs

@@ -0,0 +1,128 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  detectUNetModelSpec,
+  OIDN_UNET_LARGE_SPEC,
+  OIDN_UNET_SMALL_SPEC,
+  validateUNetModel
+} from '../lib/modelSpec.js';
+import { optimizeModelGraph, planModelExecution } from '../lib/graphOptimizer.js';
+import { HostTensor, TensorDesc } from '../lib/tza.js';
+
+function hostTensor(dims, layout = 'x', dataType = 'Float16') {
+  const desc = new TensorDesc();
+  desc.dims = [...dims];
+  desc.paddedDims = [...dims];
+  desc.layout = layout;
+  desc.dataType = dataType;
+  return new HostTensor(desc, new Uint8Array(desc.getByteSize()));
+}
+
+function makeModelTensors(spec, inputChannels = 3) {
+  const tensors = new Map();
+  const channels = new Map([[spec.input, inputChannels]]);
+
+  for (const node of spec.nodes) {
+    if (node.op === 'conv2d') {
+      const inChannels = channels.get(node.input);
+      assert.notEqual(inChannels, undefined);
+      const outChannels = node.id === spec.output ? 3 : 4;
+      tensors.set(
+        node.weight,
+        hostTensor([outChannels, inChannels, 3, 3], 'oihw')
+      );
+      tensors.set(node.bias, hostTensor([outChannels]));
+      channels.set(node.id, outChannels);
+    } else if (node.op === 'concat') {
+      channels.set(
+        node.id,
+        node.inputs.reduce((sum, input) => sum + channels.get(input), 0)
+      );
+    } else {
+      channels.set(node.id, channels.get(node.input));
+    }
+  }
+  return tensors;
+}
+
+test('detects and validates built-in small and large descriptors', () => {
+  for (const spec of [OIDN_UNET_SMALL_SPEC, OIDN_UNET_LARGE_SPEC]) {
+    const tensors = makeModelTensors(spec, 9);
+    assert.equal(detectUNetModelSpec(tensors), spec);
+    const validated = validateUNetModel(tensors);
+    assert.equal(validated.spec, spec);
+    assert.equal(validated.inputChannels, 9);
+    assert.equal(validated.outputChannels, 3);
+    assert.equal(validated.tensorDataType, 'Float16');
+  }
+});
+
+test('rejects an unknown topology instead of silently using a stale graph', () => {
+  const tensors = makeModelTensors(OIDN_UNET_SMALL_SPEC);
+  tensors.set('future_block.weight', hostTensor([4, 4, 3, 3], 'oihw'));
+  assert.throws(
+    () => detectUNetModelSpec(tensors),
+    /Unsupported OIDN model topology/
+  );
+});
+
+test('validates tensor byte length and graph channel flow', () => {
+  const tensors = makeModelTensors(OIDN_UNET_SMALL_SPEC);
+  tensors.get('enc_conv0.weight').data = new Uint8Array(2);
+  assert.throws(
+    () => validateUNetModel(tensors, OIDN_UNET_SMALL_SPEC),
+    /bytes, expected/
+  );
+
+  const wrongChannels = makeModelTensors(OIDN_UNET_SMALL_SPEC);
+  wrongChannels.set('enc_conv1.weight', hostTensor([4, 7, 3, 3], 'oihw'));
+  assert.throws(
+    () => validateUNetModel(wrongChannels, OIDN_UNET_SMALL_SPEC),
+    /expects 7 input channels/
+  );
+});
+
+test('fuses topology patterns without hard-coding a model family', () => {
+  const validated = validateUNetModel(
+    makeModelTensors(OIDN_UNET_SMALL_SPEC),
+    OIDN_UNET_SMALL_SPEC
+  );
+  const graph = optimizeModelGraph(validated);
+
+  assert.deepEqual(graph.fusions, {
+    convPool: 4,
+    upsampleConcatConv: 4
+  });
+  assert.equal(
+    graph.nodes.filter((node) => node.op === 'fusedConvReluMaxPool2d').length,
+    4
+  );
+  assert.equal(
+    graph.nodes.filter((node) => node.op === 'fusedUpsampleConcatConv2d')
+      .length,
+    4
+  );
+  assert.equal(graph.nodes.length, 16);
+});
+
+test('plans fused graph shapes and lifetimes', () => {
+  const validated = validateUNetModel(
+    makeModelTensors(OIDN_UNET_LARGE_SPEC, 9),
+    OIDN_UNET_LARGE_SPEC
+  );
+  const plan = planModelExecution(validated, 384, 256);
+
+  assert.deepEqual(plan.inputShape, { width: 384, height: 256, channels: 9 });
+  assert.deepEqual(plan.valueShapes.get('pool4'), {
+    width: 24,
+    height: 16,
+    channels: 4
+  });
+  assert.deepEqual(plan.valueShapes.get(OIDN_UNET_LARGE_SPEC.output), {
+    width: 384,
+    height: 256,
+    channels: 3
+  });
+  assert.equal(plan.plannedNodes.at(-1).lastUse, plan.nodes.length);
+});

package/tests/resourceLifecycle.test.mjs

@@ -0,0 +1,383 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { validateUNetModel } from '../lib/modelSpec.js';
+import { OIDNResourceTracker } from '../lib/resourceTracker.js';
+import { HostTensor, TensorDesc } from '../lib/tza.js';
+import { NativeUNetExecutor } from '../lib/nativeUNet.js';
+import { WebNNUNetExecutor } from '../lib/webnnUNet.js';
+
+const TEST_SPEC = {
+  schemaVersion: 1,
+  id: 'resource-test-unet',
+  family: 'resource-test',
+  input: 'input',
+  output: 'output',
+  receptiveField: 3,
+  nodes: [
+    {
+      op: 'conv2d',
+      id: 'output',
+      input: 'input',
+      weight: 'output.weight',
+      bias: 'output.bias',
+      activation: 'identity',
+      padding: 'same'
+    }
+  ]
+};
+
+function hostTensor(dims, layout = 'x') {
+  const desc = new TensorDesc();
+  desc.dims = [...dims];
+  desc.paddedDims = [...dims];
+  desc.layout = layout;
+  desc.dataType = 'Float16';
+  return new HostTensor(desc, new Uint8Array(desc.getByteSize()));
+}
+
+function testModel() {
+  return validateUNetModel(
+    new Map([
+      ['output.weight', hostTensor([3, 3, 3, 3], 'oihw')],
+      ['output.bias', hostTensor([3])]
+    ]),
+    TEST_SPEC
+  );
+}
+
+class FakeResource {
+  destroyCalls = 0;
+
+  destroy() {
+    this.destroyCalls++;
+  }
+}
+
+class FakeBuffer extends FakeResource {
+  mapState = 'unmapped';
+
+  constructor(size = 16, mappedAtCreation = false) {
+    super();
+    this.data = new ArrayBuffer(size);
+    this.mapState = mappedAtCreation ? 'mapped' : 'unmapped';
+  }
+
+  getMappedRange() {
+    return this.data;
+  }
+
+  unmap() {
+    this.mapState = 'unmapped';
+  }
+}
+
+function fakeDevice() {
+  const device = {
+    features: new Set(['shader-f16']),
+    limits: {
+      maxComputeInvocationsPerWorkgroup: 256,
+      maxComputeWorkgroupSizeX: 256,
+      maxComputeWorkgroupSizeY: 256,
+      maxComputeWorkgroupStorageSize: 32768
+    },
+    failBindGroup: false,
+    failBufferAt: undefined,
+    createBufferCalls: 0,
+    buffers: [],
+    queue: {
+      submit() {},
+      onSubmittedWorkDone: () => Promise.resolve()
+    },
+    createShaderModule: () => ({}),
+    createComputePipeline: () => ({ getBindGroupLayout: () => ({}) }),
+    createComputePipelineAsync: async () => ({
+      getBindGroupLayout: () => ({})
+    }),
+    createBuffer(descriptor) {
+      this.createBufferCalls++;
+      if (this.createBufferCalls === this.failBufferAt) {
+        throw new Error('injected buffer allocation failure');
+      }
+      const buffer = new FakeBuffer(
+        descriptor.size,
+        descriptor.mappedAtCreation
+      );
+      this.buffers.push(buffer);
+      return buffer;
+    },
+    createBindGroup() {
+      if (this.failBindGroup) throw new Error('injected bind group failure');
+      return {};
+    },
+    createCommandEncoder: () => ({
+      beginComputePass: () => ({
+        setPipeline() {},
+        setBindGroup() {},
+        dispatchWorkgroups() {},
+        end() {}
+      }),
+      finish: () => ({})
+    })
+  };
+  return device;
+}
+
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
+async function withFakeWebNN(run, { build } = {}) {
+  const previous = {
+    navigator: Object.getOwnPropertyDescriptor(globalThis, 'navigator'),
+    builder: Object.getOwnPropertyDescriptor(globalThis, 'MLGraphBuilder'),
+    usage: Object.getOwnPropertyDescriptor(globalThis, 'GPUBufferUsage')
+  };
+  const device = fakeDevice();
+  const context = new FakeResource();
+  Object.assign(context, {
+    async createExportableTensor() {
+      return new FakeResource();
+    },
+    async exportToGPU() {
+      return device.createBuffer({ size: 16 });
+    },
+    dispatch() {},
+    opSupportLimits() {
+      const operand = { dataTypes: ['float16'] };
+      return { conv2d: { input: operand, filter: operand, output: operand } };
+    },
+    async readTensor() {
+      return new ArrayBuffer(0);
+    },
+    writeTensor() {}
+  });
+
+  class FakeBuilder {
+    input() {
+      return {};
+    }
+    constant() {
+      return {};
+    }
+    conv2d() {
+      return {};
+    }
+    relu(value) {
+      return value;
+    }
+    maxPool2d() {
+      return {};
+    }
+    resample2d() {
+      return {};
+    }
+    concat() {
+      return {};
+    }
+    async build(outputs) {
+      return build ? build(outputs) : new FakeResource();
+    }
+  }
+
+  Object.defineProperties(globalThis, {
+    navigator: {
+      configurable: true,
+      value: { ml: { createContext: async () => context } }
+    },
+    MLGraphBuilder: { configurable: true, value: FakeBuilder },
+    GPUBufferUsage: {
+      configurable: true,
+      value: {
+        STORAGE: 1,
+        COPY_SRC: 2,
+        COPY_DST: 4,
+        UNIFORM: 8,
+        QUERY_RESOLVE: 16,
+        MAP_READ: 32
+      }
+    }
+  });
+
+  try {
+    await run({ device, context });
+  } finally {
+    for (const [key, descriptor] of Object.entries(previous)) {
+      const name =
+        key === 'builder'
+          ? 'MLGraphBuilder'
+          : key === 'usage'
+          ? 'GPUBufferUsage'
+          : key;
+      if (descriptor) Object.defineProperty(globalThis, name, descriptor);
+      else delete globalThis[name];
+    }
+  }
+}
+
+test('resource tracker releases each owned handle exactly once', () => {
+  const tracker = new OIDNResourceTracker();
+  const buffer = new FakeResource();
+  tracker.track('gpu-buffer', buffer);
+  tracker.track('gpu-buffer', buffer);
+
+  assert.deepEqual(tracker.snapshot(), {
+    live: 1,
+    created: 1,
+    destroyed: 0,
+    peakLive: 1,
+    pending: 0,
+    byKind: {
+      'gpu-buffer': { created: 1, destroyed: 0, live: 1, peakLive: 1 }
+    }
+  });
+  tracker.release('gpu-buffer', buffer, () => buffer.destroy());
+  tracker.release('gpu-buffer', buffer, () => buffer.destroy());
+  assert.equal(buffer.destroyCalls, 1);
+  assert.equal(tracker.snapshot().live, 0);
+  assert.equal(tracker.snapshot().created, tracker.snapshot().destroyed);
+});
+
+test('native WGSL shape eviction and dispose release every owned GPU buffer', async () => {
+  await withFakeWebNN(async ({ device }) => {
+    const executor = new NativeUNetExecutor(device, testModel(), {
+      precision: 'fp16',
+      shapeCacheSize: 2,
+      kernel: 'direct'
+    });
+    const input = new FakeBuffer();
+    executor.execute([input], 16, 16);
+    executor.execute([input], 32, 16);
+    executor.execute([input], 48, 16);
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const cached = executor.getResourceInfo();
+    assert.equal(cached.pending, 0);
+    assert.equal(cached.byKind['gpu-buffer'].live, 10);
+    assert.equal(cached.byKind['gpu-buffer'].destroyed, 4);
+
+    executor.dispose();
+    executor.dispose();
+    const disposed = executor.getResourceInfo();
+    assert.equal(disposed.pending, 0);
+    assert.equal(disposed.live, 0);
+    assert.equal(disposed.created, disposed.destroyed);
+    assert.ok(device.buffers.every((buffer) => buffer.destroyCalls === 1));
+    assert.equal(input.destroyCalls, 0);
+  });
+});
+
+test('native WGSL rolls back a partially allocated shape on failure', async () => {
+  await withFakeWebNN(async ({ device }) => {
+    const executor = new NativeUNetExecutor(device, testModel(), {
+      precision: 'fp16',
+      kernel: 'direct'
+    });
+    const baseline = executor.getResourceInfo().live;
+    device.failBufferAt = device.createBufferCalls + 3;
+
+    assert.throws(
+      () => executor.execute([new FakeBuffer()], 16, 16),
+      /injected buffer allocation failure/
+    );
+    assert.equal(executor.getResourceInfo().live, baseline);
+    executor.dispose();
+    assert.equal(executor.getResourceInfo().live, 0);
+    assert.ok(device.buffers.every((buffer) => buffer.destroyCalls === 1));
+  });
+});
+
+test('WebNN shape cache stays bounded and dispose returns to zero live resources', async () => {
+  await withFakeWebNN(async ({ device, context }) => {
+    const executor = new WebNNUNetExecutor(device, testModel(), {
+      precision: 'fp16',
+      shapeCacheSize: 2
+    });
+    await executor.prepare();
+    await executor.prewarm([
+      { width: 16, height: 16 },
+      { width: 32, height: 16 },
+      { width: 48, height: 16 }
+    ]);
+    await Promise.resolve();
+
+    const cached = executor.getResourceInfo();
+    assert.equal(cached.pending, 0);
+    assert.equal(cached.byKind['ml-context'].live, 1);
+    assert.equal(cached.byKind['ml-graph'].live, 2);
+    assert.equal(cached.byKind['ml-tensor'].live, 4);
+    assert.equal(cached.byKind['gpu-buffer'].live, 6);
+
+    executor.dispose();
+    executor.dispose();
+    const disposed = executor.getResourceInfo();
+    assert.equal(disposed.pending, 0);
+    assert.equal(disposed.live, 0);
+    assert.equal(disposed.created, disposed.destroyed);
+    assert.equal(context.destroyCalls, 1);
+    assert.ok(device.buffers.every((buffer) => buffer.destroyCalls === 1));
+  });
+});
+
+test('WebNN cleans a graph that finishes after dispose', async () => {
+  const build = deferred();
+  await withFakeWebNN(
+    async ({ device }) => {
+      const executor = new WebNNUNetExecutor(device, testModel(), {
+        precision: 'fp16'
+      });
+      await executor.prepare();
+      const prewarm = executor.prewarm([{ width: 16, height: 16 }]);
+      await Promise.resolve();
+      assert.equal(executor.getResourceInfo().pending, 1);
+
+      executor.dispose();
+      build.resolve(new FakeResource());
+      await assert.rejects(prewarm, /disposed/);
+
+      const resources = executor.getResourceInfo();
+      assert.equal(resources.pending, 0);
+      assert.equal(resources.live, 0);
+      assert.equal(resources.created, resources.destroyed);
+    },
+    { build: () => build.promise }
+  );
+});
+
+test('WebNN releases exported GPU buffers when command setup throws', async () => {
+  await withFakeWebNN(async ({ device }) => {
+    const executor = new WebNNUNetExecutor(device, testModel(), {
+      precision: 'fp16'
+    });
+    await executor.prepare();
+    await executor.prewarm([{ width: 16, height: 16 }]);
+    const baseline = executor.getResourceInfo().live;
+    device.failBindGroup = true;
+
+    await assert.rejects(
+      executor.execute([new FakeBuffer()], 16, 16),
+      /injected bind group failure/
+    );
+    assert.equal(executor.getResourceInfo().live, baseline);
+    executor.dispose();
+    assert.equal(executor.getResourceInfo().live, 0);
+  });
+});
+
+test('WebNN prepare failures destroy the partially initialized context', async () => {
+  await withFakeWebNN(async ({ device, context }) => {
+    context.opSupportLimits = () => ({});
+    const executor = new WebNNUNetExecutor(device, testModel(), {
+      precision: 'fp16'
+    });
+    await assert.rejects(executor.prepare(), /does not support FP16/);
+    assert.equal(context.destroyCalls, 1);
+    assert.equal(executor.getResourceInfo().live, 0);
+  });
+});

package/tests/tileScheduler.test.mjs

@@ -0,0 +1,90 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  DynamicTileController,
+  fitTileDimension,
+  waitForSubmittedGPUWork
+} from '../lib/tileScheduler.js';
+
+test('starts conservatively and respects the hard maximum', () => {
+  assert.equal(new DynamicTileController(512).tileSize, 384);
+  assert.equal(new DynamicTileController(320).tileSize, 320);
+  assert.equal(fitTileDimension(512, 384), 384);
+  assert.equal(fitTileDimension(300, 384), 304);
+});
+
+test('reduces slow tiles and grows fast tiles within configured bounds', () => {
+  const controller = new DynamicTileController(512);
+
+  assert.equal(controller.observe([30, 32, 34]), true);
+  assert.equal(controller.tileSize, 256);
+  assert.equal(controller.observe([40]), false);
+  assert.equal(controller.tileSize, 256);
+
+  assert.equal(controller.observe([4, 6, 8]), true);
+  assert.equal(controller.tileSize, 384);
+  assert.equal(controller.observe([5]), true);
+  assert.equal(controller.tileSize, 512);
+  assert.equal(controller.observe([5]), false);
+});
+
+test('uses the median and ignores invalid timings', () => {
+  const controller = new DynamicTileController(512);
+
+  assert.equal(controller.observe([1, 30, Number.NaN]), false);
+  assert.equal(controller.tileSize, 384);
+  assert.equal(controller.observe([Number.NaN, Number.POSITIVE_INFINITY]), false);
+});
+
+test('can restore fixed-size behavior', () => {
+  const controller = new DynamicTileController(500, false);
+
+  assert.equal(controller.tileSize, 496);
+  assert.equal(controller.observe([100]), false);
+  assert.equal(controller.tileSize, 496);
+});
+
+test('supports custom adaptive limits and timing targets', () => {
+  const controller = new DynamicTileController(768, {
+    minTileSize: 128,
+    initialTileSize: 512,
+    targetTileTimeMs: 24,
+    adjustmentStep: 64
+  });
+
+  assert.equal(controller.tileSize, 512);
+  controller.observe([40]);
+  assert.equal(controller.tileSize, 448);
+  controller.observe([8]);
+  assert.equal(controller.tileSize, 512);
+});
+
+test('waits for submitted GPU work before continuing', async () => {
+  let release;
+  let completed = false;
+  const pendingGPUWork = new Promise((resolve) => {
+    release = resolve;
+  });
+  const queue = {
+    onSubmittedWorkDone: () => pendingGPUWork
+  };
+
+  const wait = waitForSubmittedGPUWork(queue).then(() => {
+    completed = true;
+  });
+  await Promise.resolve();
+  assert.equal(completed, false);
+
+  release();
+  await wait;
+  assert.equal(completed, true);
+});
+
+test('does not strand scheduling when the GPU wait rejects', async () => {
+  await assert.doesNotReject(() =>
+    waitForSubmittedGPUWork({
+      onSubmittedWorkDone: () => Promise.reject(new Error('device lost'))
+    })
+  );
+});

package/lib/helper.d.ts

@@ -1,4 +0,0 @@
-import * as tfjs from '@tensorflow/tfjs-core';
-export declare function profileAndLogKernelCode(execute: () => void, disabled?: boolean): void;
-export declare function memory(): tfjs.MemoryInfo;
-export declare function tidy(f: () => void): void;

package/lib/helper.js

@@ -1,33 +0,0 @@
-import * as tfjs from '@tensorflow/tfjs-core';
-export function profileAndLogKernelCode(execute, disabled = true) {
-    if (disabled) {
-        execute();
-        return;
-    }
-    tfjs
-        .profile(() => {
-        execute();
-    })
-        .then((res) => {
-        const kernelNames = Array.from(new Set(res.kernels.map((k) => k.name).filter((name) => !name.endsWith('_op'))));
-        function nameToConfig(name) {
-            return `${name[0].toLowerCase()}${name.slice(1)}Config`;
-        }
-        const importCode = kernelNames.map((name) => `import { ${nameToConfig(name)} } from '@tensorflow/tfjs-backend-webgpu/dist/kernels/${name}';`);
-        const configCode = kernelNames.map((name) => `${nameToConfig(name)},`);
-        const code = `
-  ${importCode.join('\n')}
-  const kernelConfigs: KernelConfig[] = [
-  ${configCode.join('\n')}
-  ]
-  `;
-        console.log(code);
-    });
-}
-export function memory() {
-    return tfjs.memory();
-}
-export function tidy(f) {
-    return tfjs.tidy(f);
-}
-//# sourceMappingURL=helper.js.map

package/lib/helper.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAC9C,MAAM,UAAU,uBAAuB,CAAC,OAAmB,EAAE,QAAQ,GAAG,IAAI;IAC1E,IAAI,QAAQ,EAAE,CAAC;QACb,OAAO,EAAE,CAAC;QACV,OAAO;IACT,CAAC;IACD,IAAI;SACD,OAAO,CAAC,GAAG,EAAE;QACZ,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;SACD,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;QACZ,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAC5B,IAAI,GAAG,CACL,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CACvE,CACF,CAAC;QACF,SAAS,YAAY,CAAC,IAAY;YAChC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC;QAC1D,CAAC;QACD,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAChC,CAAC,IAAI,EAAE,EAAE,CACP,YAAY,YAAY,CACtB,IAAI,CACL,yDAAyD,IAAI,IAAI,CACrE,CAAC;QACF,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACvE,MAAM,IAAI,GAAG;IACf,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;;IAErB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;;GAEtB,CAAC;QACE,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACpB,CAAC,CAAC,CAAC;AACP,CAAC;AAED,MAAM,UAAU,MAAM;IACpB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;AACvB,CAAC;AAED,MAAM,UAAU,IAAI,CAAC,CAAa;IAChC,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACtB,CAAC"}

package/lib/kernels.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/kernels.js

@@ -1,26 +0,0 @@
-import { registerKernel } from '@tensorflow/tfjs-core/dist/kernel_registry';
-import { mirrorPadConfig } from '@tensorflow/tfjs-backend-webgpu/dist/kernels/MirrorPad';
-import { padV2Config } from '@tensorflow/tfjs-backend-webgpu/dist/kernels/PadV2';
-import { sliceConfig } from '@tensorflow/tfjs-backend-webgpu/dist/kernels/Slice';
-import { fusedConv2DConfig } from '@tensorflow/tfjs-backend-webgpu/dist/kernels/FusedConv2D';
-import { maxPoolConfig } from '@tensorflow/tfjs-backend-webgpu/dist/kernels/MaxPool';
-import { resizeNearestNeighborConfig } from '@tensorflow/tfjs-backend-webgpu/dist/kernels/ResizeNearestNeighbor';
-import { concatConfig } from '@tensorflow/tfjs-backend-webgpu/dist/kernels/Concat';
-import { identityConfig } from '@tensorflow/tfjs-backend-webgpu/dist/kernels/Identity';
-const kernelConfigs = [
-    mirrorPadConfig,
-    padV2Config,
-    sliceConfig,
-    fusedConv2DConfig,
-    maxPoolConfig,
-    resizeNearestNeighborConfig,
-    concatConfig,
-    identityConfig
-];
-for (const kernelConfig of kernelConfigs) {
-    registerKernel({
-        ...kernelConfig,
-        backendName: 'webgpu-oidn'
-    });
-}
-//# sourceMappingURL=kernels.js.map

package/lib/kernels.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"kernels.js","sourceRoot":"","sources":["../src/kernels.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,cAAc,EACf,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EAAE,eAAe,EAAE,MAAM,wDAAwD,CAAC;AACzF,OAAO,EAAE,WAAW,EAAE,MAAM,oDAAoD,CAAC;AACjF,OAAO,EAAE,WAAW,EAAE,MAAM,oDAAoD,CAAC;AACjF,OAAO,EAAE,iBAAiB,EAAE,MAAM,0DAA0D,CAAC;AAC7F,OAAO,EAAE,aAAa,EAAE,MAAM,sDAAsD,CAAC;AACrF,OAAO,EAAE,2BAA2B,EAAE,MAAM,oEAAoE,CAAC;AACjH,OAAO,EAAE,YAAY,EAAE,MAAM,qDAAqD,CAAC;AACnF,OAAO,EAAE,cAAc,EAAE,MAAM,uDAAuD,CAAC;AAEvF,MAAM,aAAa,GAAmB;IACpC,eAAe;IACf,WAAW;IACX,WAAW;IACX,iBAAiB;IACjB,aAAa;IACb,2BAA2B;IAC3B,YAAY;IACZ,cAAc;CACf,CAAC;AAEF,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;IACzC,cAAc,CAAC;QACb,GAAG,YAAY;QACf,WAAW,EAAE,aAAa;KAC3B,CAAC,CAAC;AACL,CAAC"}