tensorgrad 0.0.14 → 0.0.16

package/dist/worker.debug.js

@@ -0,0 +1,553 @@
+// src/runtime.ts
+var Captures = class {
+  constructor(shapes, data) {
+    this.shapes = shapes;
+    this.data = data;
+  }
+  shapes;
+  data;
+  get(name) {
+    const d = this.data.get(name);
+    if (!d) {
+      const known = [...this.data.keys()].sort().join(", ");
+      const detail = known ? `Known this call: ${known}` : `(call run/step with { withCaptures: true } to populate)`;
+      throw new Error(`Captures.get: '${name}' not present. ${detail}`);
+    }
+    return d;
+  }
+  shapeOf(name) {
+    const s = this.shapes[name];
+    if (!s) {
+      const known = Object.keys(this.shapes).sort().join(", ") || "(none registered)";
+      throw new Error(`Captures.shapeOf: '${name}' not registered. Known: ${known}`);
+    }
+    return s;
+  }
+  has(name) {
+    return this.data.has(name);
+  }
+  names() {
+    return [...this.data.keys()].sort();
+  }
+};
+var STORAGE_RW = 128 | 8 | 4;
+var READBACK = 1 | 8;
+async function createRuntime(plan, kernels, lossBufferId, opts = {}) {
+  const device2 = opts.device ?? await acquireDevice();
+  const queue = device2.queue;
+  const buffers = /* @__PURE__ */ new Map();
+  const ownedBufferIds = /* @__PURE__ */ new Set();
+  const sharedParams = opts.sharedParams;
+  for (const spec of plan.buffers) {
+    const shared = spec.kind === "param" ? sharedParams?.get(spec.name) : void 0;
+    if (shared) {
+      if (shared.size !== spec.byteSize) {
+        throw new Error(
+          `sharedParams: size mismatch for '${spec.name}' \u2014 supplied ${shared.size} bytes, compiled graph expects ${spec.byteSize}.`
+        );
+      }
+      buffers.set(spec.id, shared);
+      continue;
+    }
+    const buf = device2.createBuffer({
+      size: spec.byteSize,
+      usage: STORAGE_RW,
+      label: spec.name ?? `t${spec.id}-${spec.kind}`
+    });
+    buffers.set(spec.id, buf);
+    ownedBufferIds.add(spec.id);
+    if (spec.kind === "state") fillStateBuffer(spec, buf);
+  }
+  const moduleCache = /* @__PURE__ */ new Map();
+  const pipelines = [];
+  const probes = [];
+  for (const k of kernels) {
+    if (!k.wgsl) {
+      pipelines.push(null);
+      continue;
+    }
+    let module = moduleCache.get(k.wgsl);
+    if (!module) {
+      module = device2.createShaderModule({ code: k.wgsl, label: k.opKind });
+      moduleCache.set(k.wgsl, module);
+    }
+    device2.pushErrorScope("validation");
+    const pipeline = device2.createComputePipeline({
+      layout: "auto",
+      compute: { module, entryPoint: "main" },
+      label: k.opKind
+    });
+    pipelines.push(pipeline);
+    probes.push(device2.popErrorScope().then((err) => err ? { k, module, err } : null));
+  }
+  const probeResults = await Promise.all(probes);
+  const failures = probeResults.filter((p) => p != null);
+  if (failures.length > 0) {
+    const reports = [];
+    for (const { k, module, err } of failures) {
+      const info = await module.getCompilationInfo();
+      const messages = info.messages.map((m) => `  L${m.lineNum}:${m.linePos} [${m.type}] ${m.message}`).join("\n");
+      reports.push(
+        `[shader compile error] ${k.opKind} (op #${k.opIndex}): ${err.message}
+` + (messages || "  (no compilation messages)") + `
+--- WGSL ---
+${k.wgsl}
+-----------`
+      );
+    }
+    console.error(reports.join("\n\n"));
+    throw new Error(`tensorgrad: ${failures.length} shader(s) failed to compile (see console).`);
+  }
+  const bindGroups = kernels.map((k, i) => {
+    const pipeline = pipelines[i];
+    if (!pipeline) return null;
+    return device2.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: k.bindings.map((bufId, idx) => ({
+        binding: idx,
+        resource: { buffer: buffers.get(bufId) }
+      }))
+    });
+  });
+  const outputSpec = plan.buffers[lossBufferId];
+  const outputReadback = device2.createBuffer({ size: outputSpec.byteSize, usage: READBACK });
+  let captureStaging = null;
+  function ensureCaptureStaging() {
+    if (captureStaging) return captureStaging;
+    let totalBytes = 0;
+    const slices = [];
+    for (const [name, bufId] of plan.capturesByName) {
+      const spec = plan.buffers[bufId];
+      slices.push({ name, bufId, offset: totalBytes, byteSize: spec.byteSize });
+      totalBytes += spec.byteSize;
+    }
+    const buffer = device2.createBuffer({ size: totalBytes, usage: READBACK, label: "captures-staging" });
+    captureStaging = { buffer, slices };
+    return captureStaging;
+  }
+  let pending = Promise.resolve();
+  async function dispatch(inputs, opts2) {
+    const turn = pending.catch(() => {
+    }).then(() => dispatchUnsynchronized(inputs, opts2));
+    pending = turn;
+    return turn;
+  }
+  async function dispatchUnsynchronized(inputs, opts2) {
+    const wantCaptures = opts2.wantCaptures;
+    if (wantCaptures && plan.capturesByName.size === 0) {
+      throw new Error(
+        `withCaptures=true but no capture(...) calls were registered during the trace. Add capture('name', tensor) inside your forward pass for the intermediates you want read back.`
+      );
+    }
+    for (const [name, bufId] of plan.inputsByName) {
+      const data = inputs[name];
+      if (!data) throw new Error(`tensorgrad: missing input '${name}'`);
+      const expectedBytes = plan.buffers[bufId].byteSize;
+      if (data.byteLength !== expectedBytes) {
+        throw new Error(`tensorgrad: input '${name}' has ${data.byteLength} bytes, expected ${expectedBytes}`);
+      }
+      queue.writeBuffer(buffers.get(bufId), 0, data);
+    }
+    const encoder = device2.createCommandEncoder({ label: "tensorgrad-step" });
+    for (let i = 0; i < kernels.length; i++) {
+      const k = kernels[i];
+      if (!k.wgsl || k.threads === 0) continue;
+      const pipeline = pipelines[i];
+      const bindGroup = bindGroups[i];
+      const pass = encoder.beginComputePass({ label: k.opKind });
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, bindGroup);
+      const wgCount = Math.max(1, Math.ceil(k.threads / k.workgroupSize));
+      const MAX_X = 65535;
+      const wgX = Math.min(wgCount, MAX_X);
+      const wgY = Math.ceil(wgCount / MAX_X);
+      pass.dispatchWorkgroups(wgX, wgY, 1);
+      pass.end();
+    }
+    for (const wb of plan.writebacks) {
+      encoder.copyBufferToBuffer(buffers.get(wb.source), 0, buffers.get(wb.dest), 0, wb.bytes);
+    }
+    encoder.copyBufferToBuffer(buffers.get(lossBufferId), 0, outputReadback, 0, outputSpec.byteSize);
+    let layout = null;
+    if (wantCaptures) {
+      layout = ensureCaptureStaging();
+      for (const s of layout.slices) {
+        encoder.copyBufferToBuffer(buffers.get(s.bufId), 0, layout.buffer, s.offset, s.byteSize);
+      }
+    }
+    queue.submit([encoder.finish()]);
+    if (!opts2.readback) return null;
+    await outputReadback.mapAsync(GPUMapMode.READ);
+    const output = new Float32Array(outputReadback.getMappedRange().slice(0));
+    outputReadback.unmap();
+    const captures = /* @__PURE__ */ new Map();
+    if (layout) {
+      await layout.buffer.mapAsync(GPUMapMode.READ);
+      const range = layout.buffer.getMappedRange();
+      for (const s of layout.slices) {
+        captures.set(s.name, new Float32Array(range, s.offset, s.byteSize / 4).slice());
+      }
+      layout.buffer.unmap();
+    }
+    return { output, captures };
+  }
+  async function step(inputs, opts2) {
+    if (opts2?.readLoss === false) {
+      await dispatch(inputs, { wantCaptures: false, readback: false });
+      return;
+    }
+    const r = await dispatch(inputs, { wantCaptures: opts2?.withCaptures === true, readback: true });
+    if (opts2?.withCaptures) return { loss: r.output[0], captures: new Captures(captureShapes, r.captures) };
+    return r.output[0];
+  }
+  async function readLoss() {
+    const turn = pending.catch(() => {
+    }).then(async () => {
+      await outputReadback.mapAsync(GPUMapMode.READ);
+      const v = new Float32Array(outputReadback.getMappedRange())[0];
+      outputReadback.unmap();
+      return v;
+    });
+    pending = turn;
+    return turn;
+  }
+  async function run(inputs, opts2) {
+    const r = await dispatch(inputs, { wantCaptures: opts2?.withCaptures === true, readback: true });
+    if (opts2?.withCaptures) return { output: r.output, captures: new Captures(captureShapes, r.captures) };
+    return r.output;
+  }
+  function uploadParams(params2, opts2) {
+    const partial = opts2?.partial ?? false;
+    for (const name of Object.keys(params2)) {
+      if (!plan.paramsByName.has(name)) {
+        throw new Error(
+          `uploadParams: unknown param '${name}'. Known: ${[...plan.paramsByName.keys()].sort().join(", ")}`
+        );
+      }
+    }
+    if (!partial) {
+      for (const name of plan.paramsByName.keys()) {
+        if (!(name in params2)) {
+          throw new Error(
+            `uploadParams: missing param '${name}'. Pass { partial: true } if you mean to update only some params.`
+          );
+        }
+      }
+    }
+    for (const [name, bufId] of plan.paramsByName) {
+      const data = params2[name];
+      if (!data) continue;
+      const expected = plan.buffers[bufId].byteSize / 4;
+      if (data.length !== expected) {
+        throw new Error(`uploadParams: '${name}' has ${data.length} elements, expected ${expected}`);
+      }
+      queue.writeBuffer(buffers.get(bufId), 0, data);
+    }
+  }
+  async function downloadFromMap(map) {
+    const stagings = [];
+    const encoder = device2.createCommandEncoder({ label: "tensorgrad-download" });
+    for (const [name, bufId] of map) {
+      const spec = plan.buffers[bufId];
+      const staging = device2.createBuffer({ size: spec.byteSize, usage: READBACK });
+      encoder.copyBufferToBuffer(buffers.get(bufId), 0, staging, 0, spec.byteSize);
+      stagings.push({ name, buf: staging, bytes: spec.byteSize });
+    }
+    queue.submit([encoder.finish()]);
+    const out = {};
+    for (const s of stagings) {
+      await s.buf.mapAsync(GPUMapMode.READ);
+      out[s.name] = new Float32Array(s.buf.getMappedRange().slice(0));
+      s.buf.unmap();
+      s.buf.destroy();
+    }
+    return out;
+  }
+  function fillStateBuffer(spec, target) {
+    const elements = spec.byteSize / 4;
+    const init = spec.dtype === "f32" ? new Float32Array(elements).fill(spec.initValue ?? 0) : new Int32Array(elements).fill(Math.trunc(spec.initValue ?? 0));
+    queue.writeBuffer(target, 0, init);
+  }
+  function resetOptimizerState() {
+    for (const spec of plan.buffers) {
+      if (spec.kind === "state") fillStateBuffer(spec, buffers.get(spec.id));
+    }
+  }
+  const params = /* @__PURE__ */ new Map();
+  for (const [name, bufId] of plan.paramsByName) {
+    params.set(name, buffers.get(bufId));
+  }
+  const captureShapes = {};
+  for (const [name, bufId] of plan.capturesByName) {
+    captureShapes[name] = [...plan.buffers[bufId].shape];
+  }
+  const outputShape = [...plan.buffers[lossBufferId].shape];
+  const destroy = () => {
+    for (const [id, b] of buffers) {
+      if (ownedBufferIds.has(id)) b.destroy();
+    }
+    outputReadback.destroy();
+    if (captureStaging) captureStaging.buffer.destroy();
+  };
+  return {
+    device: device2,
+    params,
+    outputShape,
+    uploadParams,
+    downloadParams: () => downloadFromMap(plan.paramsByName),
+    downloadParamGrads: () => downloadFromMap(plan.paramGradsByName),
+    step,
+    run,
+    readLoss,
+    resetOptimizerState,
+    destroy
+  };
+}
+async function acquireDevice() {
+  if (typeof navigator === "undefined" || !navigator.gpu) {
+    throw new Error("tensorgrad: WebGPU not available in this environment");
+  }
+  const adapter = await navigator.gpu.requestAdapter();
+  if (!adapter) throw new Error("tensorgrad: no WebGPU adapter");
+  return await adapter.requestDevice();
+}
+
+// src/adam.ts
+function resolveLR(schedule, step) {
+  if (typeof schedule === "number") return schedule;
+  switch (schedule.kind) {
+    case "constant":
+      return schedule.value;
+    case "linearDecay": {
+      const f = Math.min(step / schedule.steps, 1);
+      return schedule.peak + (schedule.final - schedule.peak) * f;
+    }
+    case "cosineDecay": {
+      const f = Math.min(step / schedule.steps, 1);
+      return schedule.final + 0.5 * (schedule.peak - schedule.final) * (1 + Math.cos(Math.PI * f));
+    }
+    case "warmup": {
+      if (step <= schedule.warmupSteps) return schedule.peakLr * (step / schedule.warmupSteps);
+      return resolveLR(schedule.after, step - schedule.warmupSteps);
+    }
+  }
+}
+
+// src/worker-protocol.ts
+function wireError(e) {
+  if (e instanceof Error) {
+    return { name: e.name, message: e.message, stack: e.stack ?? "" };
+  }
+  return { name: "Error", message: String(e), stack: "" };
+}
+
+// src/worker.ts
+var graphs = /* @__PURE__ */ new Map();
+var device = null;
+async function ensureDevice() {
+  if (device) return device;
+  if (typeof navigator === "undefined" || !navigator.gpu) {
+    throw new Error("tensorgrad worker: WebGPU not available in this environment");
+  }
+  const adapter = await navigator.gpu.requestAdapter();
+  if (!adapter) throw new Error("tensorgrad worker: no WebGPU adapter");
+  device = await adapter.requestDevice();
+  return device;
+}
+async function handleCreateRuntime(payload) {
+  const dev = await ensureDevice();
+  const { graph, plan, kernels } = payload.ir;
+  const outputTensorId = graph.outputs[0];
+  const outputBufferId = plan.tensorToBuffer.get(outputTensorId);
+  const opts = { device: dev };
+  const runtime = await createRuntime(plan, kernels, outputBufferId, opts);
+  if (Object.keys(payload.initialParams).length > 0) {
+    runtime.uploadParams(payload.initialParams);
+  }
+  const captureShapes = {};
+  for (const [name, bufId] of plan.capturesByName) {
+    captureShapes[name] = [...plan.buffers[bufId].shape];
+  }
+  const slot = {
+    runtime,
+    paramNames: [...plan.paramsByName.keys()],
+    outputShape: [...runtime.outputShape],
+    kernelCount: kernels.filter((k) => k.wgsl).length,
+    captureShapes,
+    adam: payload.adam ? createAdamState(payload.adam) : null
+  };
+  graphs.set(payload.graphId, slot);
+  return {
+    paramNames: [...slot.paramNames],
+    outputShape: slot.outputShape,
+    kernelCount: slot.kernelCount,
+    captureShapes: slot.captureShapes
+  };
+}
+async function handleCompileForward(payload) {
+  const dev = await ensureDevice();
+  const parent = graphs.get(payload.parentGraphId);
+  if (!parent) throw new Error(`compileForward: parent graph ${payload.parentGraphId} not found`);
+  const { graph, plan, kernels } = payload.ir;
+  const outputTensorId = graph.outputs[0];
+  const outputBufferId = plan.tensorToBuffer.get(outputTensorId);
+  const opts = { device: dev, sharedParams: parent.runtime.params };
+  const runtime = await createRuntime(plan, kernels, outputBufferId, opts);
+  const captureShapes = {};
+  for (const [name, bufId] of plan.capturesByName) {
+    captureShapes[name] = [...plan.buffers[bufId].shape];
+  }
+  const slot = {
+    runtime,
+    paramNames: [...plan.paramsByName.keys()],
+    outputShape: [...runtime.outputShape],
+    kernelCount: kernels.filter((k) => k.wgsl).length,
+    captureShapes,
+    adam: null
+  };
+  graphs.set(payload.graphId, slot);
+  return {
+    paramNames: [...slot.paramNames],
+    outputShape: slot.outputShape,
+    kernelCount: slot.kernelCount,
+    captureShapes: slot.captureShapes
+  };
+}
+function createAdamState(cfg) {
+  return {
+    config: cfg,
+    t: 0,
+    lrtBuf: new Float32Array(1),
+    decayShrinkBuf: cfg.decayShrinkInputName ? new Float32Array(1) : null
+  };
+}
+function injectAdamScalars(slot, inputs) {
+  const a = slot.adam;
+  if (!a) return inputs;
+  a.t++;
+  const lrNow = resolveLR(a.config.lr, a.t);
+  a.lrtBuf[0] = lrNow * Math.sqrt(1 - Math.pow(a.config.b2, a.t)) / (1 - Math.pow(a.config.b1, a.t));
+  const merged = { ...inputs, [a.config.lrtInputName]: a.lrtBuf };
+  if (a.decayShrinkBuf && a.config.decayShrinkInputName) {
+    a.decayShrinkBuf[0] = 1 - lrNow * a.config.weightDecay;
+    merged[a.config.decayShrinkInputName] = a.decayShrinkBuf;
+  }
+  return merged;
+}
+async function handleStep(payload) {
+  const slot = mustGet(payload.graphId);
+  const merged = injectAdamScalars(slot, payload.inputs);
+  if (payload.withCaptures) {
+    const r = await slot.runtime.step(merged, { withCaptures: true });
+    return { loss: r.loss, captures: capturesToRecord(r.captures, slot.captureShapes) };
+  }
+  const loss = await slot.runtime.step(merged);
+  return { loss, captures: null };
+}
+async function handleRun(payload) {
+  const slot = mustGet(payload.graphId);
+  if (payload.withCaptures) {
+    const r = await slot.runtime.run(payload.inputs, { withCaptures: true });
+    return { output: r.output, captures: capturesToRecord(r.captures, slot.captureShapes) };
+  }
+  const output = await slot.runtime.run(payload.inputs);
+  return { output, captures: null };
+}
+function capturesToRecord(captures, shapes) {
+  const out = {};
+  for (const name of Object.keys(shapes)) {
+    if (captures.has(name)) out[name] = captures.get(name);
+  }
+  return out;
+}
+function handleUploadParams(payload) {
+  const slot = mustGet(payload.graphId);
+  slot.runtime.uploadParams(payload.params, { partial: payload.partial });
+}
+async function handleDownloadParams(payload) {
+  const slot = mustGet(payload.graphId);
+  return { params: await slot.runtime.downloadParams() };
+}
+async function handleDownloadParamGrads(payload) {
+  const slot = mustGet(payload.graphId);
+  return { params: await slot.runtime.downloadParamGrads() };
+}
+function handleResetOptimizer(payload) {
+  const slot = mustGet(payload.graphId);
+  slot.runtime.resetOptimizerState();
+  if (slot.adam) slot.adam.t = 0;
+}
+function handleDestroy(payload) {
+  const slot = graphs.get(payload.graphId);
+  if (!slot) return;
+  slot.runtime.destroy();
+  graphs.delete(payload.graphId);
+}
+function mustGet(graphId) {
+  const slot = graphs.get(graphId);
+  if (!slot) throw new Error(`tensorgrad worker: graph ${graphId} not found`);
+  return slot;
+}
+self.onmessage = async (ev) => {
+  const req = ev.data;
+  try {
+    let result;
+    let transferList = [];
+    switch (req.kind) {
+      case "createRuntime":
+        result = await handleCreateRuntime(req.payload);
+        break;
+      case "compileForward":
+        result = await handleCompileForward(req.payload);
+        break;
+      case "step":
+        result = await handleStep(req.payload);
+        transferList = collectTransfers(result.captures);
+        break;
+      case "run": {
+        const r = await handleRun(req.payload);
+        result = r;
+        transferList = [r.output.buffer, ...collectTransfers(r.captures)];
+        break;
+      }
+      case "uploadParams":
+        handleUploadParams(req.payload);
+        result = null;
+        break;
+      case "downloadParams": {
+        const r = await handleDownloadParams(req.payload);
+        result = r;
+        transferList = collectTransfers(r.params);
+        break;
+      }
+      case "downloadParamGrads": {
+        const r = await handleDownloadParamGrads(req.payload);
+        result = r;
+        transferList = collectTransfers(r.params);
+        break;
+      }
+      case "resetOptimizer":
+        handleResetOptimizer(req.payload);
+        result = null;
+        break;
+      case "destroy":
+        handleDestroy(req.payload);
+        result = null;
+        break;
+      default:
+        throw new Error(`unknown request kind: ${req.kind}`);
+    }
+    const reply = { id: req.id, ok: true, result };
+    self.postMessage(reply, { transfer: transferList });
+  } catch (e) {
+    const error = wireError(e);
+    const reply = { id: req.id, ok: false, error };
+    self.postMessage(reply);
+  }
+};
+function collectTransfers(rec) {
+  if (!rec) return [];
+  const out = [];
+  for (const v of Object.values(rec)) out.push(v.buffer);
+  return out;
+}

package/package.json

@@ -1,58 +1,60 @@
-{
-  "name": "tensorgrad",
-  "version": "0.0.14",
-  "description": "Tiny TypeScript-native tensor library with autograd, compiling to WebGPU. Train small models in the browser without hand-writing kernels.",
-  "license": "MIT",
-  "author": "Ben Albahari",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/typebulb/tensorgrad.git"
-  },
-  "homepage": "https://github.com/typebulb/tensorgrad#readme",
-  "bugs": {
-    "url": "https://github.com/typebulb/tensorgrad/issues"
-  },
-  "keywords": [
-    "webgpu",
-    "machine-learning",
-    "autograd",
-    "tensor",
-    "neural-network",
-    "transformer",
-    "browser",
-    "typescript"
-  ],
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "sideEffects": false,
-  "files": [
-    "dist",
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build:js": "tsc -p tsconfig.json",
-    "build:types": "tsc -p tsconfig.types.json && rollup -c rollup.dts.config.mjs && rimraf dist/types-temp",
-    "build": "npm run build:js && npm run build:types",
-    "clean": "rimraf dist",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "tsx test/smoke.ts",
-    "prepublishOnly": "npm run clean && npm run build"
-  },
-  "devDependencies": {
-    "rimraf": "^6.0.1",
-    "rollup": "^4.0.0",
-    "rollup-plugin-dts": "^6.2.0",
-    "tsx": "*",
-    "typescript": "*"
-  }
-}
+{
+  "name": "tensorgrad",
+  "version": "0.0.16",
+  "description": "Tiny TypeScript-native tensor library with autograd, compiling to WebGPU. Train small models in the browser without hand-writing kernels.",
+  "license": "MIT",
+  "author": "Ben Albahari",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/typebulb/tensorgrad.git"
+  },
+  "homepage": "https://github.com/typebulb/tensorgrad#readme",
+  "bugs": {
+    "url": "https://github.com/typebulb/tensorgrad/issues"
+  },
+  "keywords": [
+    "webgpu",
+    "machine-learning",
+    "autograd",
+    "tensor",
+    "neural-network",
+    "transformer",
+    "browser",
+    "typescript"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build:js": "node scripts/build.mjs",
+    "build:js:watch": "node scripts/build.mjs --watch",
+    "build:types": "tsc -p tsconfig.types.json && rollup -c rollup.dts.config.mjs && rimraf dist/types-temp",
+    "build": "npm run build:js && npm run build:types",
+    "clean": "rimraf dist",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsx test/smoke.ts",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.0",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.0.0",
+    "rollup-plugin-dts": "^6.2.0",
+    "tsx": "*",
+    "typescript": "*"
+  }
+}