runntime 0.0.1-alpha.0 → 0.0.1-beta.1

package/dist/config-UyxIidZc.d.mts

@@ -0,0 +1,206 @@
+import { StorageFlag, TgpuBuffer, TgpuRoot, d } from "typegpu";
+//#region src/core/kernels/common.d.ts
+type U32Buffer = TgpuBuffer<d.WgslArray<d.U32>> & StorageFlag;
+type F32Buffer = TgpuBuffer<d.WgslArray<d.F32>> & StorageFlag;
+type F16Buffer = TgpuBuffer<d.WgslArray<d.F16>> & StorageFlag;
+//#endregion
+//#region src/core/kernels/activations.d.ts
+declare const ACT_CODE: {
+  readonly none: 0;
+  readonly tanh: 1;
+  readonly gelu: 2;
+  readonly silu: 3;
+  readonly relu: 4;
+};
+type ActName = keyof typeof ACT_CODE;
+type SlotAct = Exclude<ActName, 'none'>;
+//#endregion
+//#region src/core/graph/ops/matmul.d.ts
+/** Options for matmul. `bias` and `addend` are fused epilogue adds, not
+ *  available for quantW. `baseRow` views into a taller weight without copying,
+ *  so MoE experts stay views into one fused tensor. */
+interface MatmulOpts {
+  bias?: Value;
+  addend?: Value;
+  /** Applied to a·b + bias, before any addend, in the same dispatch. */
+  activation?: SlotAct;
+  baseRow?: number;
+  scales?: Value;
+  scaleBase?: number;
+  bits?: 8 | 4;
+  groupSize?: number;
+}
+//#endregion
+//#region src/core/graph/value.d.ts
+type EagerDtype = 'f32' | 'f16' | 'quantW';
+/** Everything known about a Value without computing it. quantW is the
+ *  exception: `dims` stay logical while `elems` is a u32 word count. */
+interface ValueMeta {
+  /** Element count in units of `dtype`. */
+  readonly elems: number;
+  readonly dtype: EagerDtype;
+  /** Logical shape for non-flat ops, e.g. [rows, cols]. */
+  readonly dims?: readonly number[];
+  /** Physical storage order, when it differs from row-major. Under 'hwc4'
+   *  `elems` includes the channel padding while `dims` stay logical, and only
+   *  hwc4-aware ops accept the Value — everything else throws. */
+  readonly layout?: 'hwc4';
+}
+/** The storage buffer behind a materialized Value. */
+type GpuBufferRef = F32Buffer | F16Buffer | U32Buffer;
+/** Every op a pending node can name. */
+type OpName = 'add' | 'mul' | 'sub' | 'swiglu' | 'swigluChunk' | 'rsqrt' | 'addScalar' | 'sigmoid' | 'mulScalar' | 'clampScalar' | 'tanh' | 'gelu' | 'silu' | 'asinh' | 'matmul' | 'matmulQuantW' | 'matmulGatherQuantW' | 'matmulGather' | 'argmaxDot' | 'attn' | 'rope' | 'conv1d' | 'convTranspose2d' | 'conv2dHwc4' | 'maxPool2dHwc4' | 'upsample2dHwc4' | 'avgPool2dHwc4' | 'pad2dHwc4' | 'resizeBilinearHwc4' | 'channelAffineHwc4' | 'concatChannelsHwc4' | 'sliceChannelsHwc4' | 'toHwc4' | 'toChw' | 'ssmScanProject' | 'ssmSelectiveScan' | 'ssmScanMerge' | 'softmax' | 'mean' | 'meanSquare' | 'layerNorm' | 'topk' | 'astype' | 'transpose' | 'sliceCols' | 'concatCols' | 'sliceRows' | 'concatRows' | 'reshape' | 'sliceChannels' | 'concatChannels' | 'writeRows' | 'gatherRowsFrom' | 'gatherRows';
+/** The recipe for a not-yet-computed Value. Inputs may themselves be pending,
+ *  so chained ops form the DAG eval() walks. */
+interface PendingOp {
+  readonly op: OpName;
+  readonly inputs: readonly Value[];
+  /** Scalar operand for ops like addScalar. */
+  readonly scalar?: number;
+  /** Numeric attributes for layout and scalar ops, e.g. [start, end]. */
+  readonly attrs?: readonly number[];
+}
+/** A tensor as the eager API sees it, and one node of a lazy DAG. Calling ops
+ *  only links nodes; reading a result evaluates everything it depends on in one
+ *  submit. */
+declare class Value {
+  readonly shape: ValueMeta;
+  /** Undefined until eval() runs the op, which is what pending means. */
+  private _buffer;
+  /** Set when this Value came from an op. Stays set after eval but is inert:
+   *  `state` depends on `_buffer` alone. */
+  readonly pending: PendingOp | undefined;
+  private constructor();
+  /** Why the buffer is gone. `_buffer` keeps the stale reference on purpose —
+   *  clearing it would flip state back to pending and rerun the recipe. */
+  private _released;
+  get state(): 'materialized' | 'pending' | 'released';
+  /** Why the buffer is gone; undefined while it is still there. */
+  get releasedReason(): string | undefined;
+  /** Throws if not yet materialized, or already gone. */
+  get buffer(): GpuBufferRef;
+  /** @internal */
+  setMaterialized(buffer: GpuBufferRef): void;
+  /** @internal Every later use of the Value throws `reason`. */
+  markReleased(reason?: string): void;
+  static materialized(shape: ValueMeta, buffer: GpuBufferRef): Value;
+  static pending(shape: ValueMeta, op: OpName, inputs: readonly Value[], scalar?: number, attrs?: readonly number[]): Value;
+}
+/** Method forms of the ops, implemented in methods.ts. Declared here so the
+ *  published .d.ts carries them on Value itself rather than as an
+ *  augmentation of a relative path that no longer exists once bundled.
+ *  The import is type-only, so value.ts still never imports ops.ts at
+ *  runtime. */
+interface Value {
+  add(b: Value | number): Value;
+  sub(b: Value | number): Value;
+  mul(b: Value | number): Value;
+  matmul(b: Value, opts?: MatmulOpts): Value;
+  reshape(newDims: number[]): Value;
+  transpose(): Value;
+  clamp(lo: number, hi: number): Value;
+  slice(dim: number, start: number, end: number): Value;
+  chunk(n: number, dim: number): Value[];
+  split(sizes: readonly number[], dim: number): Value[];
+  softmax(): Value;
+  sigmoid(): Value;
+  tanh(): Value;
+  asinh(): Value;
+  mean(): Value;
+  rsqrt(): Value;
+  topk(k: number): Value;
+}
+//#endregion
+//#region src/core/graph/evalCore.d.ts
+interface DispatchExtras {
+  addend?: GpuBufferRef;
+  outBase?: number;
+  outElems?: number;
+}
+interface Executor {
+  acquireOutput(shape: ValueMeta): GpuBufferRef;
+  releaseOutput(buffer: GpuBufferRef, shape: ValueMeta): void;
+  dispatch(node: Value, inputs: readonly GpuBufferRef[], out: GpuBufferRef, extras?: DispatchExtras): void;
+  copyInto?(src: GpuBufferRef, dst: GpuBufferRef, srcShape: ValueMeta, dstShape: ValueMeta, dstBase: number): void;
+  submit(): void;
+}
+interface Releaser {
+  releaseValues(values: readonly Value[]): void;
+  dispose(): void;
+}
+interface Readback {
+  readback(buffer: GpuBufferRef, shape: ValueMeta): Promise<Float32Array>;
+  readbackMany?(items: readonly {
+    buffer: GpuBufferRef;
+    shape: ValueMeta;
+  }[]): Promise<Float32Array[]>;
+}
+//#endregion
+//#region src/core/gpu/timing.d.ts
+interface KernelTiming {
+  name: string;
+  workgroups: number | readonly [number, number];
+  ns: number;
+}
+//#endregion
+//#region src/core/gpu/eval.d.ts
+/** Readback fused into the next submit, so a step costs one submit and one map
+ *  round-trip rather than two submits. */
+interface FusedReadback {
+  /** Resolves after the next submit() or replay(); one request at a time. */
+  readbackOnSubmit(value: Value): Promise<Float32Array>;
+  /** Several values through one staging copy, resolved together. */
+  readbackManyOnSubmit(values: readonly Value[]): Promise<Float32Array[]>;
+  /** toArray with the copy fused into the eval's own submit. */
+  toArrayFused(value: Value): Promise<Float32Array>;
+}
+type RunntimeExecutor = Executor & Readback & Releaser & CaptureExecutor & FusedReadback;
+/** Sets the default device and returns its executor. Call it once at startup;
+ *  tensor(), toArray() and loadStateDict() then need no root. */
+declare function initRunntime(root: TgpuRoot): RunntimeExecutor;
+/** Capture and replay: records one frame's dispatches, then re-submits them
+ *  without walking the graph again. Fixed-shape forwards only. */
+interface CaptureExecutor {
+  /** Runs `fn` once, recording every dispatch. The executor is replay-only
+   *  afterwards. Keep `targets` — their buffers stay valid across replays — and
+   *  overwrite inputs in place before each replay. */
+  captureFrame<T>(fn: () => T): {
+    targets: T;
+    replay: () => void;
+    /** Replays once with a timestamp pair per dispatch. Per-dispatch passes
+     *  remove overlap, so read the sum as relative attribution only. */
+    profileReplay: () => Promise<KernelTiming[] | undefined>;
+  };
+}
+//#endregion
+//#region src/zoo/yolo26/config.d.ts
+declare const YOLO26_SCALES: {
+  readonly n: {
+    readonly depth: 0.5;
+    readonly width: 0.25;
+    readonly maxChannels: 1024;
+  };
+  readonly s: {
+    readonly depth: 0.5;
+    readonly width: 0.5;
+    readonly maxChannels: 1024;
+  };
+  readonly m: {
+    readonly depth: 0.5;
+    readonly width: 1;
+    readonly maxChannels: 512;
+  };
+  readonly l: {
+    readonly depth: 1;
+    readonly width: 1;
+    readonly maxChannels: 512;
+  };
+  readonly x: {
+    readonly depth: 1;
+    readonly width: 1.5;
+    readonly maxChannels: 512;
+  };
+};
+type Yolo26Variant = keyof typeof YOLO26_SCALES;
+//#endregion
+export { initRunntime as n, Yolo26Variant as t };