@aethervtt/shard-platform-web 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @aethervtt/shard-platform-web
+
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/audio.d.ts

@@ -0,0 +1,18 @@
+import type { AudioBackend } from '@aethervtt/shard-platform';
+/** Web Audio in a browser or webview: one context, a gain node per bus, a PannerNode per spatial voice. */
+export interface WebAudioBackend extends AudioBackend {
+    readonly context: AudioContext;
+    /** Everything mixed (before the destination), for meters. */
+    readonly output: GainNode;
+    /** A bus's gain node (after its gain), for meters. */
+    busNode(name: string): GainNode;
+    /** Resumes the context (browsers need a user gesture first). */
+    resume(): Promise<void>;
+}
+/**
+ * The Web Audio backend. The context starts suspended in most browsers; it resumes on the first
+ * pointer, key, or touch, and voices asked for before then start in step at that moment.
+ */
+export declare function createWebAudioBackend(options?: {
+    context?: AudioContext;
+}): WebAudioBackend;

package/dist/audio.js

@@ -0,0 +1,273 @@
+import { ShardError } from "@aethervtt/shard-core";
+const GESTURES = ["pointerdown", "keydown", "touchend"];
+const SMOOTH = 0.015;
+const MIN_FADE = 8e-3;
+const MIME = {
+  wav: "audio/wav",
+  vorbis: 'audio/ogg; codecs="vorbis"',
+  opus: 'audio/ogg; codecs="opus"',
+  mp3: "audio/mpeg",
+  flac: "audio/flac"
+};
+function createWebAudioBackend(options = {}) {
+  const ctx = options.context ?? new AudioContext({ latencyHint: "interactive" });
+  const output = ctx.createGain();
+  output.connect(ctx.destination);
+  const buses = /* @__PURE__ */ new Map();
+  const busGains = /* @__PURE__ */ new Map();
+  const voices = /* @__PURE__ */ new Map();
+  const decoded = /* @__PURE__ */ new WeakMap();
+  const urls = /* @__PURE__ */ new WeakMap();
+  let next = 1;
+  const report = (err) => {
+    if (backend.onError) backend.onError(err);
+    else console.error(err);
+  };
+  const resume = async () => {
+    if (ctx.state !== "running" && ctx.state !== "closed") await ctx.resume().catch(() => {
+    });
+  };
+  const onGesture = () => void resume();
+  for (const g of GESTURES) window.addEventListener(g, onGesture, { capture: true });
+  ctx.addEventListener("statechange", () => {
+    if (ctx.state === "running") {
+      for (const g of GESTURES) window.removeEventListener(g, onGesture, { capture: true });
+      for (const voice of voices.values()) if (!voice.started) start(voice);
+    }
+  });
+  function bus(name) {
+    let node = buses.get(name);
+    if (!node) {
+      node = ctx.createGain();
+      node.gain.value = busGains.get(name) ?? 1;
+      node.connect(output);
+      buses.set(name, node);
+    }
+    return node;
+  }
+  function decode(clip) {
+    let p = decoded.get(clip.bytes);
+    if (!p) {
+      const copy = clip.bytes.slice().buffer;
+      p = ctx.decodeAudioData(copy).then(
+        (buffer) => ({ buffer, norm: clip.normalize ? normalization(buffer) : 1 }),
+        (cause) => {
+          throw new ShardError("audio/decode-failed", `Can't decode ${clip.id} (${clip.codec})`, {
+            hint: clip.codec === "opus" ? "This browser can't decode Opus (Safari before 18.4). Use Ogg Vorbis or MP3." : "The file may be damaged, or this browser lacks the codec. Re-export it as Ogg Vorbis or MP3.",
+            cause
+          });
+        }
+      );
+      decoded.set(clip.bytes, p);
+    }
+    return p;
+  }
+  function mediaUrl(clip) {
+    let url = urls.get(clip.bytes);
+    if (!url) {
+      const blob = new Blob([clip.bytes.slice().buffer], { type: MIME[clip.codec] ?? "audio/*" });
+      url = URL.createObjectURL(blob);
+      urls.set(clip.bytes, url);
+    }
+    return url;
+  }
+  function offsetNow(voice, duration) {
+    const d = voice.desc;
+    let t = d.offset + (performance.now() - voice.requestedAt) / 1e3 * voice.params.pitch;
+    if (!d.loop) return t;
+    const end = d.clip.loopEnd > 0 ? Math.min(d.clip.loopEnd, duration) : duration;
+    const begin = d.clip.loopEnd > 0 && d.clip.loopStart < end ? d.clip.loopStart : 0;
+    if (t >= end && end > begin) t = begin + (t - end) % (end - begin);
+    return t;
+  }
+  function start(voice) {
+    if (voice.stopped || voice.started || ctx.state !== "running") return;
+    const d = voice.desc;
+    if (d.clip.stream) {
+      voice.started = true;
+      const el = new Audio(mediaUrl(d.clip));
+      el.loop = d.loop;
+      el.preservesPitch = false;
+      el.playbackRate = voice.params.pitch;
+      el.currentTime = offsetNow(voice, d.clip.duration) % Math.max(d.clip.duration, 1e-3);
+      ctx.createMediaElementSource(el).connect(voice.gain);
+      voice.element = el;
+      el.play().catch(
+        (cause) => report(
+          new ShardError("audio/decode-failed", `Can't stream ${d.clip.id} (${d.clip.codec})`, {
+            cause
+          })
+        )
+      );
+      return;
+    }
+    decode(d.clip).then(
+      ({ buffer, norm }) => {
+        if (voice.stopped || voice.started || ctx.state !== "running") return;
+        const offset = offsetNow(voice, buffer.duration);
+        if (!d.loop && offset >= buffer.duration) return;
+        voice.started = true;
+        voice.norm = norm;
+        voice.gain.gain.value = voice.params.gain * norm;
+        const src = ctx.createBufferSource();
+        src.buffer = buffer;
+        src.loop = d.loop;
+        if (d.loop && d.clip.loopEnd > 0) {
+          src.loopStart = d.clip.loopStart;
+          src.loopEnd = d.clip.loopEnd;
+        }
+        src.playbackRate.value = voice.params.pitch;
+        src.connect(voice.gain);
+        src.start(0, offset);
+        voice.source = src;
+      },
+      (err) => report(err)
+    );
+  }
+  function place(panner, x, y, z, at) {
+    if (panner.positionX) {
+      panner.positionX.setTargetAtTime(x, at, SMOOTH);
+      panner.positionY.setTargetAtTime(y, at, SMOOTH);
+      panner.positionZ.setTargetAtTime(z, at, SMOOTH);
+    } else panner.setPosition(x, y, z);
+  }
+  const backend = {
+    kind: "web",
+    context: ctx,
+    output,
+    get state() {
+      const s = ctx.state;
+      return s === "running" ? "running" : s === "closed" ? "closed" : "suspended";
+    },
+    resume,
+    busNode: bus,
+    play(desc) {
+      const id = next++;
+      const gain = ctx.createGain();
+      gain.gain.value = desc.gain;
+      let panner = null;
+      const s = desc.spatial;
+      if (s) {
+        panner = ctx.createPanner();
+        panner.panningModel = s.panning === "hrtf" ? "HRTF" : "equalpower";
+        panner.distanceModel = s.distanceModel;
+        panner.refDistance = s.refDistance;
+        panner.maxDistance = Math.max(s.maxDistance, s.refDistance + 1e-3);
+        panner.rolloffFactor = s.rolloffFactor;
+        if (panner.positionX) {
+          panner.positionX.value = desc.x;
+          panner.positionY.value = desc.y;
+          panner.positionZ.value = desc.z;
+        } else panner.setPosition(desc.x, desc.y, desc.z);
+        gain.connect(panner).connect(bus(desc.bus));
+      } else gain.connect(bus(desc.bus));
+      const voice = {
+        desc,
+        params: { gain: desc.gain, pitch: desc.pitch, x: desc.x, y: desc.y, z: desc.z },
+        gain,
+        panner,
+        source: null,
+        element: null,
+        norm: 1,
+        requestedAt: performance.now(),
+        started: false,
+        stopped: false
+      };
+      voices.set(id, voice);
+      start(voice);
+      return id;
+    },
+    update(id, params) {
+      const v = voices.get(id);
+      if (!v) return;
+      const now = ctx.currentTime;
+      const p = v.params;
+      if (p.gain !== params.gain) v.gain.gain.setTargetAtTime(params.gain * v.norm, now, SMOOTH);
+      if (p.pitch !== params.pitch) {
+        if (v.source) v.source.playbackRate.setTargetAtTime(params.pitch, now, SMOOTH);
+        if (v.element) v.element.playbackRate = params.pitch;
+      }
+      if (v.panner && (p.x !== params.x || p.y !== params.y || p.z !== params.z)) {
+        place(v.panner, params.x, params.y, params.z, now);
+      }
+      p.gain = params.gain;
+      p.pitch = params.pitch;
+      p.x = params.x;
+      p.y = params.y;
+      p.z = params.z;
+    },
+    stop(id, fade = 0) {
+      const v = voices.get(id);
+      if (!v) return;
+      voices.delete(id);
+      v.stopped = true;
+      const now = ctx.currentTime;
+      const f = Math.max(fade, MIN_FADE);
+      v.gain.gain.cancelScheduledValues(now);
+      v.gain.gain.setValueAtTime(v.gain.gain.value, now);
+      v.gain.gain.linearRampToValueAtTime(0, now + f);
+      const release = () => {
+        v.gain.disconnect();
+        v.panner?.disconnect();
+        if (v.element) {
+          v.element.pause();
+          v.element.removeAttribute("src");
+        }
+      };
+      if (v.source) {
+        v.source.onended = release;
+        v.source.stop(now + f);
+      } else setTimeout(release, f * 1e3 + 50);
+    },
+    setListener(m) {
+      const l = ctx.listener;
+      const fl = Math.sqrt(m[2] * m[2] + m[6] * m[6] + m[10] * m[10]) || 1;
+      const ul = Math.sqrt(m[1] * m[1] + m[5] * m[5] + m[9] * m[9]) || 1;
+      const fx = -m[2] / fl;
+      const fy = -m[6] / fl;
+      const fz = -m[10] / fl;
+      const ux = m[1] / ul;
+      const uy = m[5] / ul;
+      const uz = m[9] / ul;
+      if (l.positionX) {
+        const now = ctx.currentTime;
+        l.positionX.setTargetAtTime(m[3], now, SMOOTH);
+        l.positionY.setTargetAtTime(m[7], now, SMOOTH);
+        l.positionZ.setTargetAtTime(m[11], now, SMOOTH);
+        l.forwardX.setTargetAtTime(fx, now, SMOOTH);
+        l.forwardY.setTargetAtTime(fy, now, SMOOTH);
+        l.forwardZ.setTargetAtTime(fz, now, SMOOTH);
+        l.upX.setTargetAtTime(ux, now, SMOOTH);
+        l.upY.setTargetAtTime(uy, now, SMOOTH);
+        l.upZ.setTargetAtTime(uz, now, SMOOTH);
+      } else {
+        l.setPosition(m[3], m[7], m[11]);
+        l.setOrientation(fx, fy, fz, ux, uy, uz);
+      }
+    },
+    setBus(name, gain) {
+      busGains.set(name, gain);
+      bus(name).gain.setTargetAtTime(gain, ctx.currentTime, SMOOTH);
+    },
+    dispose() {
+      for (const g of GESTURES) window.removeEventListener(g, onGesture, { capture: true });
+      for (const id of [...voices.keys()]) backend.stop(id);
+      void ctx.close();
+    }
+  };
+  return backend;
+}
+function normalization(buffer) {
+  let peak = 0;
+  for (let c = 0; c < buffer.numberOfChannels; c++) {
+    const data = buffer.getChannelData(c);
+    for (let i = 0; i < data.length; i++) {
+      const a = Math.abs(data[i]);
+      if (a > peak) peak = a;
+    }
+  }
+  return peak > 0 ? 1 / peak : 1;
+}
+export {
+  createWebAudioBackend
+};

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import type { Platform } from '@aethervtt/shard-platform';
+export interface WebPlatformOptions {
+    /** Base URL that project paths resolve against. Defaults to the document base. */
+    baseUrl?: string;
+    /** IndexedDB database for `storage` (saves, settings). Default `shard`. */
+    storageName?: string;
+    /** Web workers for `workers` (made on first use). 0 runs jobs inline. Default: cores − 1, 1 to 8. */
+    workers?: number;
+}
+export declare function createWebPlatform(options?: WebPlatformOptions): Platform;
+export { createWebAudioBackend, type WebAudioBackend } from './audio.js';
+export { createDomInputSource } from './input.js';
+export { createIndexedDbStorage } from './storage.js';
+export { createWebWorkers } from './workers.js';

package/dist/index.js

@@ -0,0 +1,61 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { createWebAudioBackend } from "./audio.js";
+import { createIndexedDbStorage } from "./storage.js";
+import { createWebWorkers } from "./workers.js";
+function createWebPlatform(options = {}) {
+  const baseUrl = options.baseUrl ?? document.baseURI;
+  const readOnly = (path) => {
+    throw new ShardError("platform/fs-read-only", `Cannot write "${path}" on the web platform`, {
+      hint: "Writes need a writable host such as Studio or the CLI.",
+      path
+    });
+  };
+  const fetchOk = async (path) => {
+    const res = await fetch(new URL(path, baseUrl));
+    if (!res.ok) {
+      throw new ShardError("platform/fs-not-found", `Failed to fetch "${path}" (${res.status})`, {
+        path
+      });
+    }
+    return res;
+  };
+  const fs = {
+    writable: false,
+    readText: async (path) => (await fetchOk(path)).text(),
+    readBytes: async (path) => new Uint8Array(await (await fetchOk(path)).arrayBuffer()),
+    writeText: async (path) => readOnly(path),
+    writeBytes: async (path) => readOnly(path),
+    exists: async (path) => (await fetch(new URL(path, baseUrl), { method: "HEAD" })).ok
+  };
+  let audio;
+  let workers;
+  return {
+    name: "web",
+    get workers() {
+      workers ??= createWebWorkers(options.workers);
+      return workers;
+    },
+    // Made on first use, so pages that never play sound don't open an AudioContext.
+    get audio() {
+      audio ??= createWebAudioBackend();
+      return audio;
+    },
+    fs,
+    storage: createIndexedDbStorage(options.storageName),
+    clock: { now: () => performance.now() },
+    log: {
+      log: (level, message, data) => console[level](`[shard] ${message}`, data ?? "")
+    }
+  };
+}
+import { createWebAudioBackend as createWebAudioBackend2 } from "./audio.js";
+import { createDomInputSource } from "./input.js";
+import { createIndexedDbStorage as createIndexedDbStorage2 } from "./storage.js";
+import { createWebWorkers as createWebWorkers2 } from "./workers.js";
+export {
+  createDomInputSource,
+  createIndexedDbStorage2 as createIndexedDbStorage,
+  createWebAudioBackend2 as createWebAudioBackend,
+  createWebPlatform,
+  createWebWorkers2 as createWebWorkers
+};

package/dist/input.d.ts

@@ -0,0 +1,6 @@
+import type { InputSource } from '@aethervtt/shard-platform';
+/**
+ * DOM input: pointer and wheel events on `element` (positions in its backing pixels), keys and
+ * focus on the window, gamepads polled on drain. Works in browsers and Tauri webviews alike.
+ */
+export declare function createDomInputSource(element: HTMLElement): InputSource;

package/dist/input.js

@@ -0,0 +1,94 @@
+const BUTTONS = ["left", "middle", "right", "back", "forward"];
+function createDomInputSource(element) {
+  const queue = [];
+  const target = globalThis.window;
+  const toPixels = (e) => {
+    const rect = element.getBoundingClientRect();
+    const sx = element instanceof HTMLCanvasElement ? element.width / Math.max(1, rect.width) : 1;
+    const sy = element instanceof HTMLCanvasElement ? element.height / Math.max(1, rect.height) : 1;
+    return { x: (e.clientX - rect.left) * sx, y: (e.clientY - rect.top) * sy, sx, sy };
+  };
+  const knownPads = /* @__PURE__ */ new Set();
+  const onKeyDown = (e) => {
+    if (!e.ctrlKey && !e.metaKey) {
+      if (e.key.length === 1) queue.push({ type: "text", text: e.key });
+      else if (e.key === "Backspace") queue.push({ type: "text", text: "\b" });
+    }
+    if (e.repeat) return;
+    queue.push({ type: "key", code: e.code, pressed: true });
+  };
+  const onKeyUp = (e) => {
+    queue.push({ type: "key", code: e.code, pressed: false });
+  };
+  const onPointerDown = (e) => {
+    const { x, y } = toPixels(e);
+    if (e.pointerType === "touch")
+      queue.push({ type: "touch", id: e.pointerId, phase: "start", x, y });
+    else queue.push({ type: "mouse-button", button: BUTTONS[e.button] ?? "left", pressed: true });
+  };
+  const onPointerUp = (e) => {
+    const { x, y } = toPixels(e);
+    if (e.pointerType === "touch")
+      queue.push({ type: "touch", id: e.pointerId, phase: "end", x, y });
+    else queue.push({ type: "mouse-button", button: BUTTONS[e.button] ?? "left", pressed: false });
+  };
+  const onPointerMove = (e) => {
+    const { x, y, sx, sy } = toPixels(e);
+    if (e.pointerType === "touch")
+      queue.push({ type: "touch", id: e.pointerId, phase: "move", x, y });
+    else queue.push({ type: "mouse-move", x, y, dx: e.movementX * sx, dy: e.movementY * sy });
+  };
+  const onWheel = (e) => {
+    const scale = e.deltaMode === 1 ? 16 : e.deltaMode === 2 ? 400 : 1;
+    queue.push({ type: "wheel", dx: e.deltaX * scale, dy: e.deltaY * scale });
+  };
+  const onBlur = () => queue.push({ type: "focus", focused: false });
+  const onFocus = () => queue.push({ type: "focus", focused: true });
+  const onContextMenu = (e) => e.preventDefault();
+  target.addEventListener("keydown", onKeyDown);
+  target.addEventListener("keyup", onKeyUp);
+  target.addEventListener("blur", onBlur);
+  target.addEventListener("focus", onFocus);
+  element.addEventListener("pointerdown", onPointerDown);
+  target.addEventListener("pointerup", onPointerUp);
+  element.addEventListener("pointermove", onPointerMove);
+  element.addEventListener("wheel", onWheel, { passive: true });
+  element.addEventListener("contextmenu", onContextMenu);
+  return {
+    drain(out) {
+      for (const e of queue) out.push(e);
+      queue.length = 0;
+      const pads = globalThis.navigator?.getGamepads?.() ?? [];
+      for (let i = 0; i < pads.length; i++) {
+        const pad = pads[i];
+        if (pad?.connected) {
+          knownPads.add(i);
+          out.push({
+            type: "gamepad",
+            index: i,
+            connected: true,
+            buttons: pad.buttons.map((b) => b.value),
+            axes: [...pad.axes]
+          });
+        } else if (knownPads.has(i)) {
+          knownPads.delete(i);
+          out.push({ type: "gamepad", index: i, connected: false, buttons: [], axes: [] });
+        }
+      }
+    },
+    dispose() {
+      target.removeEventListener("keydown", onKeyDown);
+      target.removeEventListener("keyup", onKeyUp);
+      target.removeEventListener("blur", onBlur);
+      target.removeEventListener("focus", onFocus);
+      element.removeEventListener("pointerdown", onPointerDown);
+      target.removeEventListener("pointerup", onPointerUp);
+      element.removeEventListener("pointermove", onPointerMove);
+      element.removeEventListener("wheel", onWheel);
+      element.removeEventListener("contextmenu", onContextMenu);
+    }
+  };
+}
+export {
+  createDomInputSource
+};

package/dist/storage.d.ts

@@ -0,0 +1,6 @@
+import type { KeyValueStorage } from '@aethervtt/shard-platform';
+/**
+ * Storage in an IndexedDB database (one object store of key → bytes): saves and settings survive
+ * reloads and aren't limited to localStorage's few megabytes of strings.
+ */
+export declare function createIndexedDbStorage(name?: string): KeyValueStorage;

package/dist/storage.js

@@ -0,0 +1,49 @@
+import { ShardError } from "@aethervtt/shard-core";
+const STORE = "files";
+function request(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+function createIndexedDbStorage(name = "shard") {
+  let db;
+  const open = () => {
+    db ??= new Promise((resolve, reject) => {
+      if (typeof indexedDB === "undefined") {
+        reject(
+          new ShardError("platform/no-storage", "IndexedDB is not available here", {
+            hint: "Private browsing modes and some embedded webviews disable it."
+          })
+        );
+        return;
+      }
+      const req = indexedDB.open(name, 1);
+      req.onupgradeneeded = () => req.result.createObjectStore(STORE);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+    return db;
+  };
+  const store = async (mode) => (await open()).transaction(STORE, mode).objectStore(STORE);
+  return {
+    read: async (key) => {
+      const value = await request((await store("readonly")).get(key));
+      return value === void 0 ? void 0 : new Uint8Array(value);
+    },
+    write: async (key, data) => {
+      await request((await store("readwrite")).put(data.slice().buffer, key));
+    },
+    list: async (prefix) => {
+      const range = prefix === "" ? void 0 : IDBKeyRange.bound(prefix, `${prefix}\uFFFF`);
+      const keys = await request((await store("readonly")).getAllKeys(range));
+      return keys.filter((k) => k.startsWith(prefix)).sort();
+    },
+    delete: async (key) => {
+      await request((await store("readwrite")).delete(key));
+    }
+  };
+}
+export {
+  createIndexedDbStorage
+};

package/dist/workers.d.ts

@@ -0,0 +1,7 @@
+import { type Workers } from '@aethervtt/shard-platform';
+/**
+ * A pool of module web workers, used by the web and Tauri platforms. Each runs the pool's host
+ * script from a blob URL and imports job modules by absolute URL. `size` 0 runs jobs inline.
+ * Default: one per core but one, 1 to 8.
+ */
+export declare function createWebWorkers(size?: number): Workers;

package/dist/workers.js

@@ -0,0 +1,32 @@
+import {
+  createInlineWorkers,
+  createWorkerPool,
+  defaultWorkerCount,
+  workerHostSource
+} from "@aethervtt/shard-platform";
+let hostUrl;
+function createWebWorkers(size) {
+  const count = size ?? defaultWorkerCount(navigator.hardwareConcurrency || 2);
+  if (count <= 0 || typeof Worker === "undefined") return createInlineWorkers();
+  hostUrl ??= URL.createObjectURL(new Blob([workerHostSource("web")], { type: "text/javascript" }));
+  const url = hostUrl;
+  return createWorkerPool({
+    size: count,
+    spawn: (events) => {
+      const worker = new Worker(url, { type: "module", name: "shard-worker" });
+      worker.onmessage = (e) => events.message(e.data);
+      worker.onerror = (e) => {
+        e.preventDefault();
+        worker.terminate();
+        events.exit(e.message || "worker error");
+      };
+      return {
+        post: (message, transfer) => worker.postMessage(message, transfer),
+        terminate: () => worker.terminate()
+      };
+    }
+  });
+}
+export {
+  createWebWorkers
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@aethervtt/shard-platform-web",
+  "version": "0.0.1",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aethervtt/shard-core": "0.0.1",
+    "@aethervtt/shard-platform": "0.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aethervtt/shard.git",
+    "directory": "packages/platform-web"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "shard": {
+    "buildSha": "d6c5c6aef4675575c878b02cf2c8f738b4190229"
+  }
+}