@simulatte/webgpu 0.2.3 → 0.3.0

package/src/full.d.ts

@@ -0,0 +1,119 @@
+import type {
+  BoundDoeNamespace,
+  DoeKernelDispatchOptions,
+  DoeNamespace,
+  DoeRunComputeOptions,
+} from "./doe.js";
+
+export interface ProviderInfo {
+  module: string;
+  loaded: boolean;
+  loadError: string;
+  defaultCreateArgs: string[];
+  doeNative: boolean;
+  libraryFlavor: string;
+  doeLibraryPath: string;
+  buildMetadataSource: string;
+  buildMetadataPath: string;
+  leanVerifiedBuild: boolean | null;
+  proofArtifactSha256: string | null;
+}
+
+export interface DoeRuntimeRunResult {
+  ok: boolean;
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  signal: string | null;
+  command: string[];
+}
+
+export interface DoeRuntimeBenchResult extends DoeRuntimeRunResult {
+  traceJsonlPath: string | null;
+  traceMetaPath: string | null;
+  traceMeta: Record<string, unknown> | null;
+}
+
+export interface DoeRuntimeBenchOptions {
+  commandsPath: string;
+  quirksPath?: string;
+  vendor?: string;
+  api?: string;
+  family?: string;
+  driver?: string;
+  traceJsonlPath?: string;
+  traceMetaPath?: string;
+  uploadBufferUsage?: string;
+  uploadSubmitEvery?: number;
+  queueWaitMode?: string;
+  queueSyncMode?: string;
+  extraArgs?: string[];
+  cwd?: string;
+}
+
+export interface DoeRuntime {
+  binPath: string;
+  libPath: string | null;
+  runRaw(args: string[], spawnOptions?: Record<string, unknown>): DoeRuntimeRunResult;
+  runBench(options: DoeRuntimeBenchOptions): DoeRuntimeBenchResult;
+}
+
+export interface RequestDeviceOptions {
+  adapterOptions?: GPURequestAdapterOptions;
+  deviceDescriptor?: GPUDeviceDescriptor;
+  createArgs?: string[] | null;
+}
+
+export interface FullDoeRunComputeOptions extends DoeRunComputeOptions<GPUBuffer> {}
+
+export interface FullDoeKernelDispatchOptions extends DoeKernelDispatchOptions<GPUBuffer> {}
+
+export interface FullDoeKernel {
+  readonly device: GPUDevice;
+  readonly entryPoint: string;
+  dispatch(options: FullDoeKernelDispatchOptions): Promise<void>;
+}
+
+export interface FullBoundDoeNamespace
+  extends BoundDoeNamespace<GPUDevice, GPUBuffer, FullDoeKernel, FullDoeRunComputeOptions> {}
+
+export interface FullDoeNamespace
+  extends DoeNamespace<
+    GPUDevice,
+    GPUBuffer,
+    FullDoeKernel,
+    FullBoundDoeNamespace,
+    FullDoeRunComputeOptions,
+    RequestDeviceOptions
+  > {}
+
+export const globals: Record<string, unknown>;
+export function create(createArgs?: string[] | null): GPU;
+export function setupGlobals(target?: object, createArgs?: string[] | null): GPU;
+export function requestAdapter(
+  adapterOptions?: GPURequestAdapterOptions,
+  createArgs?: string[] | null
+): Promise<GPUAdapter | null>;
+export function requestDevice(options?: RequestDeviceOptions): Promise<GPUDevice>;
+export function providerInfo(): ProviderInfo;
+export function createDoeRuntime(options?: {
+  binPath?: string;
+  libPath?: string;
+}): DoeRuntime;
+export function runDawnVsDoeCompare(options: Record<string, unknown>): DoeRuntimeRunResult;
+
+export const doe: FullDoeNamespace;
+
+declare const _default: {
+  create: typeof create;
+  globals: typeof globals;
+  setupGlobals: typeof setupGlobals;
+  requestAdapter: typeof requestAdapter;
+  requestDevice: typeof requestDevice;
+  providerInfo: typeof providerInfo;
+  createDoeRuntime: typeof createDoeRuntime;
+  runDawnVsDoeCompare: typeof runDawnVsDoeCompare;
+  doe: FullDoeNamespace;
+};
+
+export default _default;

package/src/full.js

@@ -0,0 +1,35 @@
+import * as full from './index.js';
+import { createDoeNamespace } from './doe.js';
+
+/**
+ * Shared Doe API / Doe routines namespace for the full package surface.
+ *
+ * This exposes `await doe.requestDevice()` for the one-line Doe API entry,
+ * `doe.bind(device)` when you already have a full device, `doe.buffers.*` and
+ * `doe.compute.run(...)` / `doe.compute.compile(...)` for the `Doe API`
+ * surface, and `doe.compute.once(...)` for `Doe routines`.
+ *
+ * The exported `doe` object here is the JS convenience surface over the Doe
+ * runtime, not a separate runtime.
+ *
+ * This example shows the API in its basic form.
+ *
+ * ```js
+ * import { doe } from "@simulatte/webgpu";
+ *
+ * const gpu = await doe.requestDevice();
+ * ```
+ *
+ * - The Doe API and Doe routines shape is the same as `@simulatte/webgpu/compute`; the difference is that the underlying device here stays full-surface rather than compute-only.
+ * - If you need explicit render, sampler, or surface APIs, keep the raw device from `requestDevice()` or access `gpu.device` after `doe.requestDevice()`.
+ */
+export const doe = createDoeNamespace({
+  requestDevice: full.requestDevice,
+});
+
+export * from './index.js';
+
+export default {
+  ...full,
+  doe,
+};