@biodream-llc/zyth-runtime 0.0.0-stage → 0.1.0-dev.1

package/LICENSE

@@ -0,0 +1,40 @@
+Zyth Binary License
+Copyright (c) 2026 BioDream LLC. All rights reserved.
+
+This license covers the Zyth compiler, checker, interpreter and runtimes: the programs `zyth`,
+`zyth-rt`, `zyth-rt-lite`, `zyth-rt-min`, `zyth-rt-static`, `libzyth_native`, `zyth.wasm`,
+`zyth-lite.wasm`, the npm package `@biodream-llc/zyth-runtime`, and their source code
+("the Software"). The parts of Zyth listed as open source in LICENSING.md are not covered by
+this license; they are licensed under Apache-2.0 or MIT, at your option.
+
+1. Use. BioDream LLC grants you a free, worldwide, non-exclusive license to download, install
+   and run the Software, for any purpose, including commercial use.
+
+2. Your programs are yours. Programs, packages, web pages and other output you make with the
+   Software, including executables and packages that contain a copy of a Zyth runtime, belong
+   to you. You may use, sell and distribute them under any terms you choose. The runtime
+   inside them stays covered by this license, and you may not separate it from your program
+   to distribute it on its own.
+
+3. Sharing the Software. You may copy and distribute the Software's unmodified release files,
+   free of charge, with this license and its notices kept intact.
+
+4. Source code. The Software's source code is confidential and proprietary to BioDream LLC.
+   This license does not grant access to it. You may not modify the Software, or decompile,
+   disassemble or reverse engineer it, except to the extent the law where you live allows
+   this despite this restriction.
+
+5. Names. This license grants no rights to the names and marks "Zyth" and "BioDream", except
+   to say truthfully that a program was made with Zyth.
+
+6. No warranty. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NON-INFRINGEMENT. IN NO EVENT SHALL BIODREAM LLC BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY ARISING FROM THE SOFTWARE OR ITS USE, EXCEPT WHERE THE LAW DOES NOT ALLOW THIS
+   LIMITATION.
+
+7. Third-party code. The Software contains third-party components under their own licenses,
+   listed in the release's notices. Those licenses apply to those components.
+
+8. Changes and ending. Later releases may come with a different license. This license ends if
+   you break its terms; sections 2, 6 and 7 survive.

package/index.d.ts

@@ -0,0 +1,49 @@
+// Generated by `zyth build --target npm-runtime`. Do not edit.
+
+/** Element types a tensor crosses into JavaScript as. */
+export type DType = "f32" | "f64" | "i32" | "i64" | "u8" | "bool";
+
+/** The typed array behind each element type. */
+export interface TensorData {
+  f32: Float32Array;
+  f64: Float64Array;
+  i32: Int32Array;
+  i64: BigInt64Array;
+  u8: Uint8Array;
+  bool: Uint8Array;
+}
+
+export class Tensor<D extends DType = DType> {
+  constructor(data: TensorData[D], shape?: number[], dtype?: D);
+  readonly data: TensorData[D];
+  readonly shape: number[];
+  readonly dtype: D;
+  readonly size: number;
+  /** Nested JavaScript arrays. */
+  toArray(): unknown;
+}
+
+/** What tensor parameters accept: a Tensor, a typed array (1-D), `{ data, shape }`, or nested number arrays. */
+export type TensorInput = Tensor | Float32Array | Float64Array | Int32Array | { data: ArrayBufferView; shape: number[] } | number[] | number[][] | number[][][];
+
+/** `tensor([[1, 2], [3, 4]])` or `tensor(float32Array, [2, 2])`. */
+export function tensor<D extends DType = "f32">(data: unknown, shape?: number[], dtype?: D): Tensor<D>;
+
+export class ZythError extends Error {
+  readonly code: string;
+  /** The full Zyth diagnostic. */
+  readonly details: string;
+}
+
+/** An argument's shape, dtype, or device does not match the Zyth signature. */
+export class ZythShapeError extends ZythError {}
+
+/** Load the runtime and every registered Zyth program ahead of the first call (optional). */
+export function load(): Promise<void>;
+/** Used by the code of Zyth packages: registers a package's program. */
+export function library(source: string, opts?: { name?: string; full?: boolean; code?: string }): unknown;
+/** Options, before the first call: `{ gpu: false }` computes `gpu` tensors on the CPU. */
+export function configure(opts?: { gpu?: boolean }): void;
+/** Where `gpu` tensors are computed: the WebGPU adapter's name (browsers and Deno with WebGPU), or "cpu". */
+export function device(): Promise<string>;
+

package/index.js

@@ -0,0 +1,848 @@
+// @ts-self-types="./index.d.ts"
+// Generated by `zyth build --target npm-runtime`. Do not edit.
+const __zythGpuRoot = {};
+// WebGPU runtime for Zyth's WebAssembly build: provides the `env.zyth_gpu_*`
+// imports that crates/zyth-tensor/src/webgpu.rs calls.
+//
+//   const gpu = await ZythGPU.create();          // null without WebGPU + JSPI
+//   const env = { ...yourImports, ...ZythGPU.imports(gpu, () => memory) };
+//   const { instance } = await WebAssembly.instantiate(bytes, { env });
+//   const ex = ZythGPU.wrap(instance.exports, gpu);   // entry points become async
+//
+// Reading GPU memory is asynchronous in WebGPU; `zyth_gpu_read` suspends the
+// WebAssembly stack with JSPI (WebAssembly.Suspending) until the copy is done,
+// so entry points that may compute on the GPU must be called through `wrap`.
+// Without WebGPU or JSPI, `zyth_gpu_available` returns 0 and `gpu` tensors are
+// computed on the CPU.
+(function (root) {
+  "use strict";
+  const ENTRY_POINTS = ["zyth_run", "zyth_app_start", "zyth_app_event", "zyth_lib_call", "zyth_lib_call_in", "zyth_lib_load", "zyth_lib_load_code"];
+
+  async function create() {
+    if (typeof navigator === "undefined" || !navigator.gpu) return null;
+    if (typeof WebAssembly.Suspending !== "function" || typeof WebAssembly.promising !== "function") return null;
+    const adapter = await navigator.gpu.requestAdapter();
+    if (!adapter) return null;
+    const lim = adapter.limits;
+    const device = await adapter.requestDevice({
+      requiredLimits: {
+        maxStorageBufferBindingSize: lim.maxStorageBufferBindingSize,
+        maxBufferSize: lim.maxBufferSize,
+        maxStorageBuffersPerShaderStage: Math.min(lim.maxStorageBuffersPerShaderStage, 10),
+      },
+    });
+    const info = adapter.info || {};
+    const name = [info.vendor, info.architecture, info.description].filter(Boolean).join(" ");
+    device.lost.then((e) => console.warn("Zyth: WebGPU device lost:", e.message));
+    device.onuncapturederror = (e) => console.error("Zyth WebGPU error:", e.error.message);
+    // dispatches are batched: their parameters share one buffer, and they share one compute pass
+    const align = Math.max(4, (device.limits.minStorageBufferOffsetAlignment || 256) / 4);
+    return { device, name, bufs: [null], pipes: [null], layouts: [null], encoder: null, pending: 0, batch: [], words: new Uint32Array(1 << 14), wlen: 0, align };
+  }
+
+  function imports(g, memory) {
+    const mem = () => memory().buffer;
+    const stub = {
+      zyth_gpu_available: () => 0,
+      zyth_gpu_alloc: () => 0,
+      zyth_gpu_free: () => {},
+      zyth_gpu_write: () => {},
+      zyth_gpu_read: () => {},
+      zyth_gpu_copy: () => {},
+      zyth_gpu_clear: () => {},
+      zyth_gpu_kernel: () => 0,
+      zyth_gpu_dispatch: () => 1,
+      zyth_gpu_name: () => 0,
+    };
+    // zyth.gfx without WebGPU: nothing draws (gfx.available() is false)
+    for (const k of ["zyth_gfx_surface", "zyth_gfx_shader", "zyth_gfx_pipeline", "zyth_gfx_buffer", "zyth_gfx_texture", "zyth_gfx_sampler", "zyth_gfx_events", "zyth_gfx_error"]) stub[k] = () => 0;
+    for (const k of ["zyth_gfx_samples", "zyth_gfx_texture_write"]) stub[k] = () => 1;
+    for (const k of ["zyth_gfx_available"]) stub[k] = () => 0;
+    for (const k of ["zyth_gfx_size", "zyth_gfx_free", "zyth_gfx_present", "zyth_gfx_close"]) stub[k] = () => {};
+    for (const k of ["zyth_gfx_buffer_write", "zyth_gfx_frame", "zyth_gfx_read"]) stub[k] = () => 1;
+    if (!g) return stub;
+    const dev = g.device;
+    const dec = new TextDecoder();
+    const U = GPUBufferUsage;
+    // encode the batched dispatches, in order, before anything encoded after them
+    const encodeBatch = () => {
+      if (!g.batch.length) return;
+      const total = Math.max(4, g.wlen);
+      const params = dev.createBuffer({ size: total * 4, usage: U.STORAGE, mappedAtCreation: true });
+      new Uint32Array(params.getMappedRange()).set(g.words.subarray(0, total));
+      params.unmap();
+      const e = (g.encoder ||= dev.createCommandEncoder());
+      const pass = e.beginComputePass();
+      for (const c of g.batch) {
+        const entries = [{ binding: 0, resource: { buffer: params, offset: c.off * 4, size: c.len * 4 } }];
+        for (let i = 0; i < c.bufs.length; i++) entries.push({ binding: i + 1, resource: { buffer: c.bufs[i] } });
+        pass.setPipeline(c.p);
+        pass.setBindGroup(0, dev.createBindGroup({ layout: c.layout, entries }));
+        pass.dispatchWorkgroups(c.gx, c.gy, c.gz);
+      }
+      pass.end();
+      g.batch = [];
+      g.wlen = 0;
+    };
+    const enc = () => {
+      encodeBatch();
+      return (g.encoder ||= dev.createCommandEncoder());
+    };
+    const flush = () => {
+      encodeBatch();
+      if (g.encoder) {
+        dev.queue.submit([g.encoder.finish()]);
+        g.encoder = null;
+        g.pending = 0;
+      }
+    };
+    return {
+      zyth_gpu_available: () => 1,
+      zyth_gpu_alloc: (bytes) => {
+        // (VERTEX and INDEX too: zyth.gfx draws from tensors' buffers)
+        const b = dev.createBuffer({ size: Math.max(16, (bytes + 3) & ~3), usage: U.STORAGE | U.COPY_SRC | U.COPY_DST | U.VERTEX | U.INDEX });
+        g.bufs.push(b);
+        return g.bufs.length - 1;
+      },
+      zyth_gpu_free: (id) => {
+        const b = g.bufs[id];
+        if (b) b.destroy();
+        g.bufs[id] = null;
+      },
+      zyth_gpu_write: (id, off, ptr, len) => {
+        // earlier dispatches may still use this (pooled) buffer: keep queue order
+        flush();
+        const src = new Uint8Array(mem(), ptr, len);
+        const n = len & ~3;
+        if (n > 0) dev.queue.writeBuffer(g.bufs[id], off, src, 0, n);
+        if (len > n) {
+          const tail = new Uint8Array(4);
+          tail.set(src.subarray(n));
+          dev.queue.writeBuffer(g.bufs[id], off + n, tail);
+        }
+      },
+      zyth_gpu_read: new WebAssembly.Suspending(async (id, off, ptr, len) => {
+        const size = (len + 3) & ~3;
+        const staging = dev.createBuffer({ size, usage: U.MAP_READ | U.COPY_DST });
+        enc().copyBufferToBuffer(g.bufs[id], off, staging, 0, size);
+        flush();
+        try {
+          await staging.mapAsync(GPUMapMode.READ);
+          new Uint8Array(mem(), ptr, len).set(new Uint8Array(staging.getMappedRange(), 0, len));
+          staging.unmap();
+        } catch (e) {
+          console.error("Zyth: WebGPU readback failed:", e.message);
+          new Uint8Array(mem(), ptr, len).fill(0);
+        }
+        staging.destroy();
+      }),
+      zyth_gpu_copy: (dst, src, len) => enc().copyBufferToBuffer(g.bufs[src], 0, g.bufs[dst], 0, (len + 3) & ~3),
+      zyth_gpu_clear: (id, len) => enc().clearBuffer(g.bufs[id], 0, (len + 3) & ~3),
+      zyth_gpu_kernel: (np, nl, sp, sl) => {
+        const name = dec.decode(new Uint8Array(mem(), np, nl));
+        const code = dec.decode(new Uint8Array(mem(), sp, sl));
+        const module = dev.createShaderModule({ code, label: name });
+        module.getCompilationInfo().then((info) => {
+          for (const m of info.messages) if (m.type === "error") console.error(`Zyth WGSL ${name}:${m.lineNum}: ${m.message}`);
+        });
+        const p = dev.createComputePipeline({ layout: "auto", compute: { module, entryPoint: "main" }, label: name });
+        g.pipes.push(p);
+        g.layouts.push(p.getBindGroupLayout(0));
+        return g.pipes.length - 1;
+      },
+      zyth_gpu_dispatch: (pipe, wp, nw, bp, nb, gx, gy, gz) => {
+        const p = g.pipes[pipe];
+        if (!p) return 1;
+        // this dispatch's parameters at an aligned offset of the batch's parameter buffer
+        const off = Math.ceil(g.wlen / g.align) * g.align;
+        const len = Math.max(4, nw);
+        if (off + len > g.words.length) {
+          const w = new Uint32Array(Math.max(g.words.length * 2, off + len));
+          w.set(g.words.subarray(0, g.wlen));
+          g.words = w;
+        }
+        g.words.fill(0, g.wlen, off + len);
+        g.words.set(new Uint32Array(mem(), wp, nw), off);
+        g.wlen = off + len;
+        const ids = new Uint32Array(mem(), bp, nb);
+        const bufs = [];
+        for (let i = 0; i < nb; i++) bufs.push(g.bufs[ids[i]]);
+        g.batch.push({ p, layout: g.layouts[pipe], bufs, off, len, gx, gy, gz });
+        if (++g.pending >= 512) flush();
+        return 0;
+      },
+      zyth_gpu_name: (ptr, cap) => {
+        const b = new TextEncoder().encode(g.name);
+        const n = Math.min(b.length, cap);
+        new Uint8Array(mem(), ptr, n).set(b.subarray(0, n));
+        return n;
+      },
+      ...gfxImports(g, mem, flush),
+    };
+  }
+
+  // zyth.gfx (crates/zyth-tensor/src/gfx_web.rs): drawing with the same device as `gpu` tensors.
+  // Every surface draws into an sRGB texture (so colors match native builds and frames can be
+  // read back); a canvas gets a copy of it at the end of each frame.
+  function gfxImports(g, mem, flush) {
+    const dev = g.device;
+    const dec = new TextDecoder();
+    const U = GPUBufferUsage, T = GPUTextureUsage;
+    const str = (p, l) => dec.decode(new Uint8Array(mem(), p, l));
+    const gx = (g.gfx = { surfaces: [null], shaders: [null], pipes: [null], bufs: [null], texs: [null], texobjs: [], samplers: [null], error: "" });
+    const fail = (m) => { gx.error = String(m); return 0; };
+    const FMT = "rgba8unorm-srgb";
+    const target = (w, h) => dev.createTexture({ size: [w, h], format: FMT, usage: T.RENDER_ATTACHMENT | T.COPY_SRC | T.TEXTURE_BINDING });
+    const depth = (w, h, n = 1) => dev.createTexture({ size: [w, h], format: "depth32float", usage: T.RENDER_ATTACHMENT, sampleCount: n });
+    const msaa = (w, h, n) => (n > 1 ? dev.createTexture({ size: [w, h], format: FMT, usage: T.RENDER_ATTACHMENT, sampleCount: n }) : null);
+    const vfmt = { f32: ["float32", 4], f32x2: ["float32x2", 8], f32x3: ["float32x3", 12], f32x4: ["float32x4", 16], u32: ["uint32", 4], u32x2: ["uint32x2", 8], u32x3: ["uint32x3", 12], u32x4: ["uint32x4", 16], i32: ["sint32", 4], i32x2: ["sint32x2", 8], unorm8x4: ["unorm8x4", 4] };
+    // a canvas with a host element goes into the element now carrying that id (it may have
+    // appeared since, or been replaced by a new one)
+    const place = (s) => {
+      if (!s.host || typeof document === "undefined") return;
+      const h = document.getElementById(s.host);
+      if (h && s.canvas.parentNode !== h) h.appendChild(s.canvas);
+    };
+    const keyOf = (e) => (e.key.length === 1 ? e.key : e.key === "Escape" ? "Escape" : e.key);
+    const scoped = async (f) => {
+      dev.pushErrorScope("validation");
+      let r;
+      try { r = f(); } catch (e) { await dev.popErrorScope(); return fail(e.message); }
+      const e = await dev.popErrorScope();
+      return e ? fail(e.message) : r;
+    };
+    return {
+      zyth_gfx_available: () => 1,
+      zyth_gfx_error: (p, cap) => {
+        const b = new TextEncoder().encode(gx.error);
+        const n = Math.min(b.length, cap);
+        new Uint8Array(mem(), p, n).set(b.subarray(0, n));
+        gx.error = "";
+        return n;
+      },
+      zyth_gfx_surface: (w, h, canvas, tp, tl) => {
+        const s = { w, h, color: target(w, h), depth: depth(w, h), samples: 1, msaa: null, events: [], canvas: null, ctx: null };
+        if (canvas && typeof document !== "undefined") {
+          const c = document.createElement("canvas");
+          c.width = w; c.height = h; c.tabIndex = 0;
+          c.className = "zyth-gfx";
+          // "title\0host": the canvas goes into the element with id `host` (gfx.window(host:))
+          // (with a host, the canvas waits until the element exists, and follows it when the
+          // page replaces it, e.g. a React component mounted again: see `place`)
+          const [title, host] = str(tp, tl).split("\0");
+          c.title = title;
+          s.host = host || null;
+          if (host) { const h = document.getElementById(host); if (h) h.appendChild(c); }
+          else (document.getElementById("zyth-gfx") || document.body).appendChild(c);
+          const ctx = c.getContext("webgpu");
+          ctx.configure({ device: dev, format: "rgba8unorm", viewFormats: [FMT], usage: T.RENDER_ATTACHMENT, alphaMode: "opaque" });
+          const pos = (e) => { const r = c.getBoundingClientRect(); return [(e.clientX - r.left) * (w / r.width), (e.clientY - r.top) * (h / r.height)]; };
+          const btn = (b) => ["left", "middle", "right"][b] || "other";
+          c.addEventListener("pointermove", (e) => { const [x, y] = pos(e); s.events.push(`mouse_move\t${x}\t${y}`); });
+          c.addEventListener("pointerdown", (e) => { c.focus(); const [x, y] = pos(e); s.events.push(`mouse_down\t${btn(e.button)}\t${x}\t${y}`); });
+          c.addEventListener("pointerup", (e) => { const [x, y] = pos(e); s.events.push(`mouse_up\t${btn(e.button)}\t${x}\t${y}`); });
+          c.addEventListener("wheel", (e) => { e.preventDefault(); s.events.push(`wheel\t${-e.deltaX / 100}\t${-e.deltaY / 100}`); }, { passive: false });
+          c.addEventListener("keydown", (e) => s.events.push(`key_down\t${keyOf(e)}`));
+          c.addEventListener("keyup", (e) => s.events.push(`key_up\t${keyOf(e)}`));
+          s.canvas = c; s.ctx = ctx;
+        }
+        gx.surfaces.push(s);
+        return gx.surfaces.length - 1;
+      },
+      zyth_gfx_samples: (id, n) => {
+        const s = gx.surfaces[id];
+        if (!s) { fail("unknown surface"); return 1; }
+        if (s.samples !== n) { s.samples = n; s.depth = depth(s.w, s.h, n); s.msaa = msaa(s.w, s.h, n); }
+        return 0;
+      },
+      zyth_gfx_size: (id, out) => {
+        const s = gx.surfaces[id];
+        new Uint32Array(mem(), out, 2).set(s ? [s.w, s.h] : [0, 0]);
+      },
+      zyth_gfx_shader: new WebAssembly.Suspending(async (p, l) => {
+        const code = str(p, l);
+        const m = dev.createShaderModule({ code, label: "zyth shader" });
+        const info = await m.getCompilationInfo();
+        const errs = info.messages.filter((x) => x.type === "error");
+        if (errs.length) return fail(errs.map((x) => `${x.lineNum}:${x.linePos}: ${x.message}`).join("; "));
+        gx.shaders.push(m);
+        return gx.shaders.length - 1;
+      }),
+      zyth_gfx_pipeline: new WebAssembly.Suspending(async (p, l) => {
+        const d = JSON.parse(str(p, l));
+        const m = gx.shaders[d.shader];
+        if (!m) return fail("unknown shader");
+        let loc = 0;
+        const buffers = [];
+        for (const b of d.buffers) {
+          let off = 0;
+          const attributes = [];
+          for (const a of b.attrs) {
+            const f = vfmt[a];
+            if (!f) return fail(`unknown vertex format \`${a}\``);
+            attributes.push({ format: f[0], offset: off, shaderLocation: loc++ });
+            off += f[1];
+          }
+          buffers.push({ arrayStride: off, stepMode: b.instance ? "instance" : "vertex", attributes });
+        }
+        const topo = { triangles: "triangle-list", triangle_list: "triangle-list", triangle_strip: "triangle-strip", lines: "line-list", line_list: "line-list", line_strip: "line-strip", points: "point-list", point_list: "point-list" }[d.topology];
+        if (!topo) return fail(`unknown topology \`${d.topology}\``);
+        const blend = { none: undefined, "": undefined, alpha: { color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha" }, alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha" } }, add: { color: { srcFactor: "one", dstFactor: "one" }, alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha" } } };
+        if (!(d.blend in blend)) return fail(`unknown blend \`${d.blend}\``);
+        const cull = { none: "none", "": "none", back: "back", front: "front" }[d.cull];
+        if (!cull) return fail(`unknown cull mode \`${d.cull}\``);
+        const pipe = await scoped(() => dev.createRenderPipeline({
+          label: "zyth pipeline",
+          layout: "auto",
+          vertex: { module: m, entryPoint: d.vertex, buffers },
+          primitive: { topology: topo, cullMode: cull },
+          multisample: { count: (gx.surfaces[d.surface] || {}).samples || 1 },
+          depthStencil: { format: "depth32float", depthWriteEnabled: d.depth, depthCompare: d.depth ? "less" : "always" },
+          fragment: { module: m, entryPoint: d.fragment, targets: [{ format: FMT, blend: blend[d.blend] }] },
+        }));
+        if (!pipe) return 0;
+        gx.pipes.push(pipe);
+        return gx.pipes.length - 1;
+      }),
+      zyth_gfx_buffer: (p, l) => {
+        const size = Math.max(16, (l + 15) & ~15);
+        const b = dev.createBuffer({ size, usage: U.VERTEX | U.INDEX | U.UNIFORM | U.STORAGE | U.COPY_DST, label: "zyth gfx buffer" });
+        const src = new Uint8Array(mem(), p, l);
+        const n = l & ~3;
+        if (n) dev.queue.writeBuffer(b, 0, src, 0, n);
+        if (l > n) { const t = new Uint8Array(4); t.set(src.subarray(n)); dev.queue.writeBuffer(b, n, t); }
+        gx.bufs.push(b);
+        return gx.bufs.length - 1;
+      },
+      zyth_gfx_buffer_write: (id, off, p, l) => {
+        const b = gx.bufs[id];
+        if (!b) { fail("unknown buffer"); return 1; }
+        if (off + l > b.size) { fail(`writing ${l} bytes at ${off} goes past the end of a buffer of ${b.size} bytes`); return 1; }
+        const src = new Uint8Array(mem(), p, l);
+        const n = l & ~3;
+        if (n) dev.queue.writeBuffer(b, off, src, 0, n);
+        if (l > n) { const t = new Uint8Array(4); t.set(src.subarray(n)); dev.queue.writeBuffer(b, off + n, t); }
+        return 0;
+      },
+      zyth_gfx_free: (id) => { const b = gx.bufs[id]; if (b) b.destroy(); gx.bufs[id] = null; },
+      zyth_gfx_texture: (w, h, p, l) => {
+        const t = dev.createTexture({ size: [w, h], format: FMT, usage: T.TEXTURE_BINDING | T.COPY_DST });
+        dev.queue.writeTexture({ texture: t }, new Uint8Array(mem(), p, l), { bytesPerRow: 4 * w, rowsPerImage: h }, [w, h]);
+        gx.texs.push(t.createView());
+        gx.texobjs[gx.texs.length - 1] = t;
+        return gx.texs.length - 1;
+      },
+      zyth_gfx_texture_write: (id, x, y, w, h, p, l) => {
+        const t = gx.texobjs[id];
+        if (!t) { fail("unknown texture"); return 1; }
+        dev.queue.writeTexture({ texture: t, origin: [x, y] }, new Uint8Array(mem(), p, l), { bytesPerRow: 4 * w, rowsPerImage: h }, [w, h]);
+        return 0;
+      },
+      zyth_gfx_sampler: (p, l) => {
+        const d = JSON.parse(str(p, l));
+        const a = { clamp: "clamp-to-edge", repeat: "repeat", mirror: "mirror-repeat" }[d.wrap];
+        gx.samplers.push(dev.createSampler({ magFilter: d.filter, minFilter: d.filter, addressModeU: a, addressModeV: a, addressModeW: a }));
+        return gx.samplers.length - 1;
+      },
+      zyth_gfx_frame: (sid, p, l) => {
+        const s = gx.surfaces[sid];
+        if (!s) { fail("unknown surface"); return 1; }
+        const f = JSON.parse(str(p, l));
+        // tensor work first (the frame may draw what it computed)
+        flush();
+        const res = (b) => (b[0] === 1 ? g.bufs[b[1]] : gx.bufs[b[1]]);
+        const e = dev.createCommandEncoder({ label: "zyth frame" });
+        const pass = e.beginRenderPass({
+          // multisampled: drawn into the samples, resolved into the surface's texture
+          colorAttachments: [s.msaa
+            ? { view: s.msaa.createView(), resolveTarget: s.color.createView(), clearValue: { r: f.clear[0], g: f.clear[1], b: f.clear[2], a: f.clear[3] }, loadOp: "clear", storeOp: "discard" }
+            : { view: s.color.createView(), clearValue: { r: f.clear[0], g: f.clear[1], b: f.clear[2], a: f.clear[3] }, loadOp: "clear", storeOp: "store" }],
+          depthStencilAttachment: { view: s.depth.createView(), depthClearValue: 1, depthLoadOp: "clear", depthStoreOp: "discard" },
+        });
+        for (const d of f.draws) {
+          const pipe = gx.pipes[d.p];
+          if (!pipe) { fail("unknown pipeline"); return 1; }
+          pass.setPipeline(pipe);
+          if (d.b.length) {
+            const entries = d.b.map((b, i) => {
+              if (b[0] === 2) return { binding: i, resource: gx.texs[b[1]] };
+              if (b[0] === 4) return { binding: i, resource: gx.surfaces[b[1]].color.createView() };
+              if (b[0] === 3) return { binding: i, resource: gx.samplers[b[1]] };
+              if (b[0] === 1) return { binding: i, resource: { buffer: g.bufs[b[1]], offset: b[2], size: b[3] } };
+              return { binding: i, resource: { buffer: gx.bufs[b[1]] } };
+            });
+            pass.setBindGroup(0, dev.createBindGroup({ layout: pipe.getBindGroupLayout(0), entries }));
+          }
+          d.v.forEach((v, i) => (v[0] === 1 ? pass.setVertexBuffer(i, res(v), v[2], v[3]) : pass.setVertexBuffer(i, res(v))));
+          if (d.i) {
+            const ib = d.i.b;
+            if (ib[0] === 1) pass.setIndexBuffer(res(ib), d.i.wide ? "uint32" : "uint16", ib[2], ib[3]);
+            else pass.setIndexBuffer(res(ib), d.i.wide ? "uint32" : "uint16");
+            pass.drawIndexed(d.n, d.inst);
+          } else pass.draw(d.n, d.inst);
+        }
+        pass.end();
+        if (s.ctx) {
+          place(s);
+          // the frame onto the canvas (a full-screen triangle sampling it; copying between the
+          // two textures loses the device on some implementations)
+          if (!gx.blit) {
+            const m = dev.createShaderModule({ code: "@group(0) @binding(0) var t: texture_2d<f32>;\n@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f { let p = vec2f(f32((i << 1u) & 2u), f32(i & 2u)); return vec4f(p * 2.0 - 1.0, 0.0, 1.0); }\n@fragment fn fs(@builtin(position) q: vec4f) -> @location(0) vec4f { return textureLoad(t, vec2i(q.xy), 0); }" });
+            gx.blit = dev.createRenderPipeline({ layout: "auto", vertex: { module: m, entryPoint: "vs" }, fragment: { module: m, entryPoint: "fs", targets: [{ format: FMT }] } });
+          }
+          const view = s.ctx.getCurrentTexture().createView({ format: FMT });
+          const bp = e.beginRenderPass({ colorAttachments: [{ view, loadOp: "clear", clearValue: { r: 0, g: 0, b: 0, a: 1 }, storeOp: "store" }] });
+          bp.setPipeline(gx.blit);
+          bp.setBindGroup(0, dev.createBindGroup({ layout: gx.blit.getBindGroupLayout(0), entries: [{ binding: 0, resource: s.color.createView() }] }));
+          bp.draw(3);
+          bp.end();
+        }
+        dev.queue.submit([e.finish()]);
+        return 0;
+      },
+      // a canvas's frame is shown when the browser draws the page: wait for that
+      zyth_gfx_present: new WebAssembly.Suspending(() => new Promise((r) => (typeof requestAnimationFrame === "function" ? requestAnimationFrame(() => r()) : setTimeout(r, 16)))),
+      zyth_gfx_read: new WebAssembly.Suspending(async (sid, p, l) => {
+        const s = gx.surfaces[sid];
+        if (!s) { fail("unknown surface"); return 1; }
+        const row = Math.ceil((s.w * 4) / 256) * 256;
+        const st = dev.createBuffer({ size: row * s.h, usage: U.MAP_READ | U.COPY_DST });
+        const e = dev.createCommandEncoder();
+        e.copyTextureToBuffer({ texture: s.color }, { buffer: st, bytesPerRow: row, rowsPerImage: s.h }, [s.w, s.h]);
+        dev.queue.submit([e.finish()]);
+        await st.mapAsync(GPUMapMode.READ);
+        const src = new Uint8Array(st.getMappedRange());
+        const out = new Uint8Array(mem(), p, l);
+        for (let y = 0; y < s.h; y++) out.set(src.subarray(y * row, y * row + s.w * 4), y * s.w * 4);
+        st.unmap(); st.destroy();
+        return 0;
+      }),
+      zyth_gfx_events: (sid, p, cap) => {
+        const s = gx.surfaces[sid];
+        if (!s) return 0;
+        const b = new TextEncoder().encode(s.events.join("\n"));
+        s.events = [];
+        const n = Math.min(b.length, cap);
+        new Uint8Array(mem(), p, n).set(b.subarray(0, n));
+        return n;
+      },
+      zyth_gfx_close: (sid) => {
+        const s = gx.surfaces[sid];
+        if (s && s.canvas) s.canvas.remove();
+        gx.surfaces[sid] = null;
+      },
+    };
+  }
+
+  // Entry points that can reach a GPU readback must be "promising" (they return Promises).
+  function wrap(exports, g) {
+    if (!g) return exports;
+    const out = Object.assign({}, exports);
+    for (const k of ENTRY_POINTS) if (typeof exports[k] === "function") out[k] = WebAssembly.promising(exports[k]);
+    return out;
+  }
+
+  root.ZythGPU = { create, imports, wrap, ENTRY_POINTS };
+})(__zythGpuRoot);
+
+const ZythGPU = __zythGpuRoot.ZythGPU;
+
+// Zyth runtime for npm packages, shared by every Zyth package of an app (the package
+// `@biodream-llc/zyth-runtime`, built by `zyth build --target npm-runtime`). Each package registers its
+// Zyth source with `library(source, { full })`; one zyth.wasm instance runs them all, so an
+// app with several Zyth packages downloads the runtime once. The light zyth.wasm is used
+// unless a package registered before the first call draws or loads images (`full`).
+// Works in Node.js, Deno, Bun, and browsers (ES modules).
+
+const dec = new TextDecoder();
+const enc = new TextEncoder();
+// WebGPU (browsers, Deno): `gpu` tensors run on it when the runtime has WebGPU and JSPI;
+// otherwise, and with `configure({ gpu: false })`, on the CPU
+let useGpu = true;
+let started = false;
+
+/** Options, before the first call: `{ gpu: false }` computes `gpu` tensors on the CPU. */
+export function configure(opts = {}) {
+  if (started) throw new Error("configure() must come before the first call");
+  if (opts.gpu === false) useGpu = false;
+}
+
+/** Where `gpu` tensors are computed: the WebGPU adapter's name, or "cpu". */
+export async function device() {
+  const rt = await runtime(libs.some((l) => l.full));
+  return rt.gpu ? rt.gpu.name || "webgpu" : "cpu";
+}
+
+export class ZythError extends Error {
+  constructor(e) {
+    super(e.message);
+    this.name = "ZythError";
+    this.code = e.code;
+    this.details = e.text;
+  }
+}
+
+/** Raised when an argument's shape, dtype, or device does not match the Zyth signature. */
+export class ZythShapeError extends ZythError {
+  constructor(e) {
+    super(e);
+    this.name = "ZythShapeError";
+  }
+}
+
+/** An n-dimensional array: flat row-major `data` plus `shape`. */
+export class Tensor {
+  constructor(data, shape, dtype) {
+    this.data = data;
+    this.shape = shape ?? [data.length];
+    this.dtype = dtype ?? dtypeOf(data);
+    const n = this.shape.reduce((a, b) => a * b, 1);
+    if (n !== data.length) throw new ZythShapeError({ code: "E0406", message: `data has ${data.length} elements but shape [${this.shape}] needs ${n}`, text: "" });
+  }
+  get size() {
+    return this.data.length;
+  }
+  toArray() {
+    const build = (off, dim) => {
+      if (dim === this.shape.length) return Number(this.data[off]);
+      const stride = this.shape.slice(dim + 1).reduce((a, b) => a * b, 1);
+      return Array.from({ length: this.shape[dim] }, (_, i) => build(off + i * stride, dim + 1));
+    };
+    return build(0, 0);
+  }
+}
+
+function dtypeOf(d) {
+  if (d instanceof Float32Array) return "f32";
+  if (d instanceof Float64Array) return "f64";
+  if (d instanceof Int32Array) return "i32";
+  if (typeof BigInt64Array !== "undefined" && d instanceof BigInt64Array) return "i64";
+  if (d instanceof Uint8Array) return "u8";
+  return "f32";
+}
+
+const TYPED = { f32: Float32Array, f64: Float64Array, i32: Int32Array, i64: BigInt64Array, u8: Uint8Array, bool: Uint8Array };
+
+/** `tensor([[1, 2], [3, 4]])` or `tensor(float32Array, [2, 2])`. */
+export function tensor(data, shape, dtype) {
+  if (ArrayBuffer.isView(data)) return new Tensor(data, shape, dtype);
+  const dims = [];
+  for (let x = data; Array.isArray(x); x = x[0]) dims.push(x.length);
+  const T = TYPED[dtype ?? "f32"];
+  return new Tensor(T.from(data.flat(Infinity), dtype === "i64" ? BigInt : undefined), shape ?? dims, dtype ?? "f32");
+}
+
+function asTensor(x) {
+  if (x instanceof Tensor) return x;
+  if (ArrayBuffer.isView(x)) return new Tensor(x);
+  if (x && typeof x === "object" && ArrayBuffer.isView(x.data)) return new Tensor(x.data, x.shape, x.dtype);
+  if (Array.isArray(x)) return tensor(x);
+  return null;
+}
+
+const finalizer = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry(([lib, h]) => lib.call({ op: "free", handle: h }).catch(() => {})) : null;
+
+// ---- encoding (wire format of zyth_interp::embed: u32 JSON length | JSON | blob)
+
+function encodeArgs(lib, values, tensorParams) {
+  const parts = [];
+  let len = 0;
+  const enc1 = (v, isTensor) => {
+    const t = isTensor || ArrayBuffer.isView(v) || v instanceof Tensor ? asTensor(v) : null;
+    if (t) {
+      const bytes = new Uint8Array(t.data.buffer, t.data.byteOffset, t.data.byteLength);
+      const out = { $tensor: { dtype: t.dtype, shape: t.shape, offset: len, length: bytes.length } };
+      parts.push(bytes);
+      len += bytes.length;
+      return out;
+    }
+    if (v && v.__zythHandle !== undefined) {
+      // a model lives in the package that made it
+      if (v.__zythLib && v.__zythLib !== lib) throw new ZythError({ code: "E0101", message: `a ${v.model ?? "model"} from the package ${v.__zythLib.name} cannot be passed to the package ${lib.name}`, text: "" });
+      return { $handle: v.__zythHandle };
+    }
+    if (Array.isArray(v)) return v.map((x) => enc1(x, false));
+    if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, enc1(x, false)]));
+    if (v === undefined) return null;
+    if (typeof v === "bigint") return Number(v);
+    return v;
+  };
+  const json = values.map((v, i) => enc1(v, tensorParams[i]));
+  const blob = new Uint8Array(len);
+  let o = 0;
+  for (const p of parts) {
+    blob.set(p, o);
+    o += p.length;
+  }
+  return [json, blob];
+}
+
+function decodeValue(lib, v, blob) {
+  if (Array.isArray(v)) return v.map((x) => decodeValue(lib, x, blob));
+  if (v && typeof v === "object") {
+    if (v.$tensor) {
+      const t = v.$tensor;
+      const T = TYPED[t.dtype] ?? Float32Array;
+      const bytes = blob.slice(t.offset, t.offset + t.length);
+      return new Tensor(new T(bytes.buffer, 0, t.length / T.BYTES_PER_ELEMENT), t.shape, t.dtype);
+    }
+    if (v.$handle !== undefined) {
+      const C = lib.models.get(v.model);
+      if (C) return C._wrap(v.$handle);
+      // a model whose class is not exported (React packages hold it as a value): freed in
+      // WebAssembly when JavaScript lets go of it
+      const m = { __zythHandle: v.$handle, __zythLib: lib, model: v.model };
+      finalizer?.register(m, [lib, v.$handle]);
+      return m;
+    }
+    return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, decodeValue(lib, x, blob)]));
+  }
+  return v;
+}
+
+// ---- runtime instances (normally one; a second, full one only when a package that draws
+// registers after the light one started)
+
+let pending = "";
+function write(text) {
+  pending += text;
+  const lines = pending.split("\n");
+  pending = lines.pop();
+  for (const l of lines) console.log(l);
+}
+
+const env = {
+  zyth_now_ms: () => (typeof performance !== "undefined" ? performance.timeOrigin + performance.now() : Date.now()),
+  zyth_dom_get: () => 0,
+  // models.load: no on-demand files and no GPU size here (files come with the program)
+  zyth_gpu_mb: () => -1,
+  zyth_fetch_start: () => -1,
+  zyth_fetch_step: () => -1,
+  zyth_fetch_total: () => 0,
+  zyth_fetch_done: () => 0,
+  zyth_fetch_peek: () => 0,
+  zyth_dom_set: () => 1,
+  zyth_dom_listen: () => 1,
+  // replaced by ZythGPU's imports when WebGPU is used
+  zyth_gpu_available: () => 0,
+  zyth_gpu_alloc: () => 0,
+  zyth_gpu_write: () => {},
+  zyth_gpu_read: () => {},
+  zyth_gpu_copy: () => {},
+  zyth_gpu_clear: () => {},
+  zyth_gpu_kernel: () => 0,
+  zyth_gpu_dispatch: () => 1,
+  zyth_gpu_name: () => 0,
+};
+
+// Both are named here so bundlers ship both; a page downloads only the one it uses.
+const WASM = { full: () => new URL("./zyth.wasm", import.meta.url), lite: () => new URL("./zyth-lite.wasm", import.meta.url) };
+
+async function wasmBytes(url) {
+  const isNode = typeof process !== "undefined" && process.versions && process.versions.node && url.protocol === "file:";
+  if (isNode) {
+    // a name in a variable, so bundlers (Vite, webpack, esbuild) leave this Node-only import alone
+    const fsName = "node:fs/promises";
+    const { readFile } = await import(/* @vite-ignore */ /* webpackIgnore: true */ fsName);
+    return readFile(url);
+  }
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(`cannot load ${url}: ${r.status}`);
+  return r.arrayBuffer();
+}
+
+class Runtime {
+  constructor(full) {
+    this.full = full;
+    this.ex = null;
+    this.gpu = null;
+    this.ready = this.start();
+  }
+  async start() {
+    started = true;
+    if (useGpu) this.gpu = await ZythGPU.create().catch(() => null);
+    let memory = null;
+    // ZythGPU.imports also gives the stand-ins (GPU and zyth.gfx) when there is no WebGPU
+    const imports = { ...env, zyth_write: (p, n) => write(dec.decode(this.bytes(p, n).slice())), ...ZythGPU.imports(this.gpu, () => memory) };
+    let bytes;
+    try {
+      bytes = await wasmBytes((this.full ? WASM.full : WASM.lite)());
+    } catch (e) {
+      // a runtime package built without the light zyth.wasm
+      if (this.full) throw e;
+      this.full = true;
+      bytes = await wasmBytes(WASM.full());
+    }
+    const { instance } = await WebAssembly.instantiate(bytes, { env: imports });
+    memory = instance.exports.memory;
+    this.ex = ZythGPU.wrap(instance.exports, this.gpu);
+  }
+  bytes(p, n) {
+    return new Uint8Array(this.ex.memory.buffer, p, n);
+  }
+  put(b) {
+    const p = this.ex.zyth_alloc(b.length);
+    this.bytes(p, b.length).set(b);
+    return p;
+  }
+  take(p) {
+    const n = new DataView(this.ex.memory.buffer).getUint32(p, true);
+    const out = this.bytes(p + 4, n).slice();
+    this.ex.zyth_free(p, n + 4);
+    return out;
+  }
+  async load(source, code) {
+    await this.ready;
+    const src = enc.encode(source);
+    const p = this.put(src);
+    let rp;
+    if (code && this.ex.zyth_lib_load_code) {
+      // checked bytecode: run without parsing (the light runtime has no parser)
+      const c = fromBase64(code);
+      const cp = this.put(c);
+      rp = await this.ex.zyth_lib_load_code(p, src.length, cp, c.length);
+      this.ex.zyth_free(cp, c.length);
+    } else {
+      rp = await this.ex.zyth_lib_load(p, src.length);
+    }
+    this.ex.zyth_free(p, src.length);
+    const r = JSON.parse(dec.decode(this.take(rp)));
+    if (!r.ok) throw new ZythError({ code: "E0001", message: "the Zyth library failed to load", text: r.text });
+    return r.id;
+  }
+  async call(id, msg) {
+    const p = this.put(msg);
+    // (a Promise when the GPU is used: reading GPU memory suspends the WebAssembly stack)
+    const resp = this.take(await this.ex.zyth_lib_call_in(id, p, msg.length));
+    this.ex.zyth_free(p, msg.length);
+    return resp;
+  }
+}
+
+const libs = [];
+const runtimes = {};
+function runtime(full) {
+  // the light runtime only while no package needs the full one
+  if (!full && runtimes.full) return runtimes.full.ready.then(() => runtimes.full);
+  const key = full ? "full" : "lite";
+  runtimes[key] ??= new Runtime(full);
+  return runtimes[key].ready.then(() => runtimes[key]);
+}
+
+// Calls run one after another: a call that waits (a frame waiting for the screen, GPU memory
+// being read) must not be entered by another call (the library is not re-entrant).
+let queue = Promise.resolve();
+function serial(f) {
+  const r = queue.then(f);
+  queue = r.catch(() => {});
+  return r;
+}
+
+function fromBase64(s) {
+  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(s, "base64"));
+  const b = atob(s);
+  const out = new Uint8Array(b.length);
+  for (let i = 0; i < b.length; i++) out[i] = b.charCodeAt(i);
+  return out;
+}
+
+class Library {
+  constructor(name, source, full, code) {
+    this.name = name;
+    this.source = source;
+    this.code = code;
+    this.full = full;
+    this.models = new Map();
+    this.ready = null;
+  }
+  /** Load the runtime and this package's program (done by the first call). */
+  load() {
+    // the first package to start decides for those registered by then: full if any needs it
+    this.ready ??= (async () => {
+      this.rt = await runtime(this.full || (!started && libs.some((l) => l.full)));
+      this.id = await serial(() => this.rt.load(this.source, this.code));
+    })();
+    return this.ready;
+  }
+  call(req, args = [], tensorParams = [], named = {}) {
+    return this.load().then(() => serial(() => this.callNow(req, args, tensorParams, named)));
+  }
+  async callNow(req, args, tensorParams, named) {
+    const [json, blob] = encodeArgs(this, args, tensorParams);
+    const [njson, nblob] = encodeArgs(this, Object.values(named), []);
+    // named tensors go after positional ones in the blob
+    const shift = blob.length;
+    const fix = (v) => {
+      if (Array.isArray(v)) return v.map(fix);
+      if (v && typeof v === "object") {
+        if (v.$tensor) return { $tensor: { ...v.$tensor, offset: v.$tensor.offset + shift } };
+        return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, fix(x)]));
+      }
+      return v;
+    };
+    const namedObj = Object.fromEntries(Object.keys(named).map((k, i) => [k, fix(njson[i])]));
+    const body = enc.encode(JSON.stringify({ ...req, args: json, named: namedObj }));
+    const msg = new Uint8Array(4 + body.length + blob.length + nblob.length);
+    new DataView(msg.buffer).setUint32(0, body.length, true);
+    msg.set(body, 4);
+    msg.set(blob, 4 + body.length);
+    msg.set(nblob, 4 + body.length + blob.length);
+    const resp = await this.rt.call(this.id, msg);
+    const jn = new DataView(resp.buffer).getUint32(0, true);
+    const r = JSON.parse(dec.decode(resp.subarray(4, 4 + jn)));
+    if (!r.ok) throw r.error.kind === "shape" ? new ZythShapeError(r.error) : new ZythError(r.error);
+    return decodeValue(this, r.value, resp.subarray(4 + jn));
+  }
+  callFn(name, args, tensorParams, named) {
+    return this.call({ op: "call", name }, args, tensorParams, named);
+  }
+  modelClass(name, methods) {
+    const lib = this;
+    class Model {
+      static async create(args = {}) {
+        return lib.call({ op: "new", model: name }, [], [], args);
+      }
+      static _wrap(h) {
+        const m = Object.create(Model.prototype);
+        m.__zythHandle = h;
+        m.__zythLib = lib;
+        finalizer?.register(m, [lib, h], m);
+        return m;
+      }
+      /** Run the model (its `forward`). */
+      forward(...args) {
+        return lib.call({ op: "method", handle: this.__zythHandle, name: "forward" }, args, args.map(() => true));
+      }
+      /** Call any method of the model by its Zyth name, e.g. `m.method("param_count")`. */
+      method(mname, ...args) {
+        return lib.call({ op: "method", handle: this.__zythHandle, name: mname }, args, []);
+      }
+      /** Release the model now instead of waiting for garbage collection. */
+      free() {
+        finalizer?.unregister(this);
+        return lib.call({ op: "free", handle: this.__zythHandle });
+      }
+    }
+    for (const [js, zy, tp] of methods) {
+      Model.prototype[js] = function (...args) {
+        return lib.call({ op: "method", handle: this.__zythHandle, name: zy }, args, tp);
+      };
+    }
+    Object.defineProperty(Model, "name", { value: name });
+    this.models.set(name, Model);
+    return Model;
+  }
+}
+
+/** Register a Zyth package's program (generated code calls this when the package is imported).
+ * `full`: the program draws or loads images (needs the full zyth.wasm). */
+export function library(source, { name = "zyth", full = false, code = null } = {}) {
+  const l = new Library(name, source, full, code);
+  libs.push(l);
+  return l;
+}
+
+/** Load the runtime and every registered program ahead of the first call (optional). */
+export function load() {
+  return Promise.all(libs.map((l) => l.load())).then(() => {});
+}

package/package.json

@@ -1,6 +1,24 @@
 {
   "name": "@biodream-llc/zyth-runtime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-dev.1",
+  "description": "The Zyth runtime (zyth.wasm) shared by the npm packages Zyth builds",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "BioDream LLC",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "zyth.wasm",
+    "LICENSE",
+    "zyth-lite.wasm"
+  ],
+  "sideEffects": false
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.