@downdraft/engine 0.0.0 → 0.1.1

package/core/src/plugin/wasm-worker.ts

@@ -0,0 +1,229 @@
+// ============================================================================
+// WASM worker entry — runs inside a dedicated Web Worker per WASM plugin.
+//
+// Receives an init message with the WASM module URL, fetches + instantiates
+// it with the host import module, calls register(), and forwards tick/dispose.
+// ============================================================================
+
+import { getWarningEngine, METRIC_TASK_LATENCY, recordTaskLatency } from "../profiling/worker-prelude";
+import {
+    readStringFromMemory,
+    WASM_PLUGIN_ABI_VERSION,
+    writeBytesToMemory,
+    type WasmPluginExports,
+    type WasmPluginImports
+} from "./wasm-abi";
+
+let exports: WasmPluginExports = { alloc: () => 0, register: () => {} };
+let _subscriptions = new Map<number, (data: unknown) => void>();
+
+self.onmessage = async (ev: MessageEvent) => {
+  const msg = ev.data;
+  if (msg?.__wasmInit) {
+    await initPlugin(msg.entryUrl, msg.pluginId);
+  }
+  if (msg?.__wasmDispose) {
+    try { exports.dispose?.(); } catch { /* */ }
+    (self as any).postMessage({ __wasmDisposed: true });
+  }
+  if (msg?.__wasmTick) {
+    if (typeof exports.tick === "function") {
+      const tickStart = performance.now();
+      exports.tick(msg.dt, msg.elapsedTime);
+      const durationUs = (performance.now() - tickStart) * 1000;
+      recordTaskLatency("wasm", durationUs, "tick");
+      getWarningEngine()?.checkInstant(METRIC_TASK_LATENCY, durationUs);
+    }
+  }
+  if (msg?.__wasmEvent) {
+    if (typeof exports.on_event === "function") {
+      const json = JSON.stringify(msg.data);
+      const [ptr, len] = writeBytesToMemory(exports, new TextEncoder().encode(json)) ?? [0, 0];
+      if (ptr !== 0) {
+        const evtStart = performance.now();
+        exports.on_event(msg.subId, ptr, len);
+        const durationUs = (performance.now() - evtStart) * 1000;
+        recordTaskLatency("wasm", durationUs, "on_event");
+        getWarningEngine()?.checkInstant(METRIC_TASK_LATENCY, durationUs);
+      }
+    }
+  }
+};
+
+async function initPlugin(entryUrl: string, pluginId: string): Promise<void> {
+  try {
+    const resp = await fetch(entryUrl);
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    const bytes = new Uint8Array(await resp.arrayBuffer());
+
+    // Build host imports — the worker forwards calls to the host via postMessage.
+    const imports = buildWorkerImports();
+    const result = await WebAssembly.instantiate(bytes, imports as unknown as WebAssembly.Imports);
+    exports = resolveExports(result.instance);
+    // Hydrate the state mirror before register() so synchronous state_get
+    // sees persisted values.
+    await hydrateState();
+
+    if (typeof exports.register !== "function") {
+      throw new Error("WASM module has no register() export");
+    }
+
+    exports.register();
+    (self as any).postMessage({ __wasmReady: true, pluginId, abiVersion: WASM_PLUGIN_ABI_VERSION });
+  } catch (e) {
+    (self as any).postMessage({ __wasmError: true, pluginId, error: (e as Error).message });
+  }
+}
+
+function resolveExports(instance: WebAssembly.Instance): WasmPluginExports {
+  const exp = instance.exports as Record<string, any>;
+  return {
+    alloc: exp.alloc,
+    register: exp.register,
+    tick: exp.tick,
+    dispose: exp.dispose,
+    on_event: exp.on_event,
+    memory: exp.memory,
+  };
+}
+
+// Local state mirror — WASM state_get is synchronous, so the worker keeps a
+// KV mirror populated at init (via a bridge "state.load") and mutated locally
+// on state_set/delete. Persistence goes through the bridge.
+const localState = new Map<string, unknown>();
+let stateHydrated = false;
+
+async function hydrateState(): Promise<void> {
+  if (stateHydrated) return;
+  try {
+    await bridgeCall("state.load", []);
+    const keys = (await bridgeCall("state.keys", [])) as string[] | undefined;
+    if (Array.isArray(keys)) {
+      for (let _i = 0, _it = keys, _n = _it.length; _i < _n; _i++) { const k = _it[_i];
+        localState.set(k, await bridgeCall("state.get", [k]));
+      }
+    }
+  } catch { /* state unavailable — empty mirror is fine */ }
+  stateHydrated = true;
+}
+
+function bridgeCall(method: string, args: unknown[]): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const callId = Math.random().toString(36).slice(2);
+    const handler = (ev: MessageEvent) => {
+      const msg = ev.data;
+      if (msg?.__wasmBridgeResult && msg.callId === callId) {
+        (self as any).removeEventListener("message", handler);
+        if (msg.error) reject(new Error(msg.error)); else resolve(msg.result);
+      }
+    };
+    (self as any).addEventListener("message", handler);
+    (self as any).postMessage({ __wasmBridge: true, method, args, callId });
+  });
+}
+
+function buildWorkerImports(): WasmPluginImports {
+  const readStr = (ptr: number, len: number) => readStringFromMemory(exports, ptr, len);
+  let nextReqId = 1;
+  // Host-call result delivery mirrors loader-wasm's dispatchHostCall: resolve
+  // the bridge call, then write the JSON result into wasm memory and invoke
+  // the plugin's on_host_call_result export.
+  const dispatchHostCall = (p: Promise<unknown>, requestId: number): void => {
+    p.then((result) => {
+      const exp = exports;
+      if (!exp.on_host_call_result) return;
+      if (result === undefined) {
+        exp.on_host_call_result(requestId, 0, 0, 0, 0);
+      } else {
+        const json = JSON.stringify(result);
+        const [ptr, len] = writeBytesToMemory(exp, new TextEncoder().encode(json)) ?? [0, 0];
+        exp.on_host_call_result(requestId, ptr, len, 0, 0);
+      }
+    }).catch((err: Error) => {
+      const exp = exports;
+      if (!exp.on_host_call_result) return;
+      const [ptr, len] = writeBytesToMemory(exp, new TextEncoder().encode(err.message)) ?? [0, 0];
+      exp.on_host_call_result(requestId, 0, 0, ptr, len);
+    });
+  };
+  const hostCall = (method: string, args: unknown[]): number => {
+    const reqId = nextReqId++;
+    dispatchHostCall(bridgeCall("hostCall", [method, ...args]), reqId);
+    return reqId;
+  };
+
+  return {
+    env: {
+      log_info: (ptr, len) => { void bridgeCall("log", ["info", readStr(ptr, len)]); },
+      log_warn: (ptr, len) => { void bridgeCall("log", ["warn", readStr(ptr, len)]); },
+      log_error: (ptr, len) => { void bridgeCall("log", ["error", readStr(ptr, len)]); },
+      log_debug: (ptr, len) => { void bridgeCall("log", ["debug", readStr(ptr, len)]); },
+      state_get: (keyPtr, keyLen) => {
+        const key = readStr(keyPtr, keyLen);
+        const val = localState.get(key);
+        if (val === undefined) return 0;
+        const json = JSON.stringify(val);
+        const [ptr, len] = writeBytesToMemory(exports, new TextEncoder().encode(json)) ?? [0, 0];
+        if (ptr === 0) return 0;
+        const mem = exports.memory!;
+        const dv = new DataView(mem.buffer, ptr - 4, 4);
+        dv.setUint32(0, len, true);
+        return ptr;
+      },
+      state_set: (keyPtr, keyLen, valPtr, valLen) => {
+        const key = readStr(keyPtr, keyLen);
+        const json = readStr(valPtr, valLen);
+        let val: unknown = json;
+        try { val = JSON.parse(json); } catch { /* raw string */ }
+        localState.set(key, val);
+        void bridgeCall("state.set", [key, val]);
+      },
+      state_delete: (keyPtr, keyLen) => {
+        const key = readStr(keyPtr, keyLen);
+        localState.delete(key);
+        void bridgeCall("state.delete", [key]);
+      },
+      event_publish: (namePtr, nameLen, dataPtr, dataLen) => {
+        const name = readStr(namePtr, nameLen);
+        const data = readStr(dataPtr, dataLen);
+        let parsed: unknown = data;
+        try { parsed = JSON.parse(data); } catch { /* raw string */ }
+        void bridgeCall("events.publish", [name, parsed]);
+      },
+      event_subscribe: (namePtr, nameLen) => {
+        const name = readStr(namePtr, nameLen);
+        const subId = _subscriptions.size + 1;
+        _subscriptions.set(subId, () => {});
+        void bridgeCall("events.subscribe", [name, subId]);
+        return subId;
+      },
+      event_unsubscribe: (subId) => {
+        _subscriptions.delete(subId);
+        void bridgeCall("events.unsubscribe", [subId]);
+      },
+      // ── Host-call bridge (v3) — forwarded to the host's NativePluginContext
+      // bridge; results arrive via on_host_call_result. ──
+      spawn_prop: (contentIdPtr, contentIdLen, x, y, z, qx, qy, qz, qw, scale) =>
+        hostCall("spawnProp", [{
+          contentId: readStr(contentIdPtr, contentIdLen),
+          position: [x, y, z],
+          rotation: [qx, qy, qz, qw],
+          scale,
+        }]),
+      remove_prop: (entityId) => hostCall("removeProp", [entityId]),
+      set_physics: (entityId, mass, restitution, friction, gravityScale) => {
+        const desc: Record<string, number> = {};
+        if (!Number.isNaN(mass)) desc.mass = mass;
+        if (!Number.isNaN(restitution)) desc.restitution = restitution;
+        if (!Number.isNaN(friction)) desc.friction = friction;
+        if (!Number.isNaN(gravityScale)) desc.gravityScale = gravityScale;
+        return hostCall("setPhysics", [entityId, desc]);
+      },
+      get_physics: (entityId) => hostCall("getPhysics", [entityId]),
+      apply_impulse: (entityId, x, y, z) => hostCall("applyImpulse", [entityId, [x, y, z]]),
+      apply_torque: (entityId, x, y, z) => hostCall("applyTorque", [entityId, [x, y, z]]),
+      get_asset_ref: (assetIdPtr, assetIdLen) =>
+        hostCall("getAssetRef", [readStr(assetIdPtr, assetIdLen)]),
+    },
+  };
+}

package/core/src/plugin/workshop.ts

@@ -0,0 +1,169 @@
+// ============================================================================
+// Workshop — remote plugin pack discovery, fetch, and cache.
+//
+// A workshop source is an `AssetManifest` (with a `plugins: PluginPackEntry[]`
+// section) served from a BlobStore. The workshop fetcher:
+//   1. Downloads the manifest from the configured store.
+//   2. For each plugin pack entry, fetches the `plugin.json` + declared asset
+//      files, caches them under `<cacheDir>/<id>@<version>/`.
+//   3. Returns the validated `PluginManifest` + the local cache path so the
+//      PluginHost can `discover()` it with source "workshop".
+//
+// Subscription state (which packs are enabled) is persisted via the provided
+// persistence hook (OPFS in production; in-memory in tests).
+// ============================================================================
+
+import { createLogger } from "../util/logger";
+import {
+  validateManifest,
+  type AssetManifest,
+  type PluginPackEntry,
+} from "../assets/manifest";
+import type { BlobStore } from "../assets/blob-store";
+import { validatePluginManifest, type PluginManifest } from "./manifest";
+
+const log = createLogger("info");
+
+export interface WorkshopSource {
+  /** The blob store to fetch from. */
+  store: BlobStore;
+  /** Key/path of the workshop manifest JSON within the store. */
+  manifestKey: string;
+}
+
+export interface WorkshopFetchResult {
+  /** Discovered plugin manifests (validated + normalized). */
+  manifests: Array<{ manifest: PluginManifest; cachePath: string }>;
+  /** Packs that failed validation/fetch (with errors). */
+  errors: Array<{ id: string; error: string }>;
+}
+
+export interface WorkshopOptions {
+  /** Directory to cache downloaded plugin packs (e.g. userData/plugins). */
+  cacheDir: string;
+  /** Persistence hook for subscription state. Called with the list of
+   *  enabled plugin ids. In production this writes to OPFS; tests inject
+   *  an in-memory impl. */
+  saveSubscriptions?: (ids: string[]) => Promise<void>;
+  loadSubscriptions?: () => Promise<string[]>;
+}
+
+export class WorkshopFetcher {
+  private sources: WorkshopSource[] = [];
+  private opts: WorkshopOptions;
+  /** id → cache path for fetched packs. */
+  private cache = new Map<string, string>();
+
+  constructor(opts: WorkshopOptions) {
+    this.opts = opts;
+  }
+
+  addSource(source: WorkshopSource): void {
+    this.sources.push(source);
+  }
+
+  /**
+   * Fetch all workshop sources, download plugin packs, cache them, and return
+   * validated manifests. Only packs in the subscription list are fetched
+   * (if subscriptions are configured); otherwise all packs in the manifest.
+   */
+  async fetchAll(): Promise<WorkshopFetchResult> {
+    const manifests: Array<{ manifest: PluginManifest; cachePath: string }> = [];
+    const errors: Array<{ id: string; error: string }> = [];
+
+    const subscribed = this.opts.loadSubscriptions ? await this.opts.loadSubscriptions() : null;
+
+    for (let _i = 0, _it = this.sources, _n = _it.length; _i < _n; _i++) { const source = _it[_i];
+      let rawManifest: Uint8Array;
+      try {
+        rawManifest = await source.store.get(source.manifestKey);
+      } catch (e) {
+        log.error("WorkshopFetcher", `Failed to fetch workshop manifest: ${(e as Error).message}`);
+        continue;
+      }
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(new TextDecoder().decode(rawManifest));
+      } catch (e) {
+        log.error("WorkshopFetcher", `Workshop manifest is not valid JSON: ${(e as Error).message}`);
+        continue;
+      }
+      if (!validateManifest(parsed)) {
+        log.error("WorkshopFetcher", `Workshop manifest failed schema validation`);
+        continue;
+      }
+      const assetManifest = parsed as AssetManifest;
+      const pluginEntries = assetManifest.plugins ?? [];
+
+      for (let _i = 0, _it = pluginEntries, _n = _it.length; _i < _n; _i++) { const entry = _it[_i];
+        if (subscribed && !subscribed.includes(entry.id)) continue;
+        try {
+          const result = await this.fetchPack(source, entry);
+          if (result) manifests.push(result);
+        } catch (e) {
+          errors.push({ id: entry.id, error: (e as Error).message });
+        }
+      }
+    }
+    return { manifests, errors };
+  }
+
+  /** Fetch a single plugin pack: download plugin.json + cache the pack. */
+  private async fetchPack(
+    source: WorkshopSource,
+    entry: PluginPackEntry,
+  ): Promise<{ manifest: PluginManifest; cachePath: string } | null> {
+    const cachePath = `${this.opts.cacheDir}/${entry.id}@${entry.version}`;
+    // Fetch plugin.json from the store.
+    const pluginJsonKey = `${entry.path}/plugin.json`;
+    let pluginJsonBytes: Uint8Array;
+    try {
+      pluginJsonBytes = await source.store.get(pluginJsonKey);
+    } catch (e) {
+      throw new Error(`Failed to fetch plugin.json for "${entry.id}": ${(e as Error).message}`);
+    }
+    let pluginRaw: unknown;
+    try {
+      pluginRaw = JSON.parse(new TextDecoder().decode(pluginJsonBytes));
+    } catch (e) {
+      throw new Error(`plugin.json for "${entry.id}" is not valid JSON: ${(e as Error).message}`);
+    }
+    const v = validatePluginManifest(pluginRaw);
+    if (!v.valid) {
+      throw new Error(`plugin.json for "${entry.id}" failed validation: ${v.errors.join("; ")}`);
+    }
+    const manifest = v.normalized!;
+    // Verify the manifest id matches the entry id.
+    if (manifest.id !== entry.id) {
+      throw new Error(
+        `Workshop entry id "${entry.id}" does not match plugin.json id "${manifest.id}"`,
+      );
+    }
+    this.cache.set(entry.id, cachePath);
+    // Note: actual asset files are fetched lazily by the AssetPluginLoader
+    // via the BlobStore (or eagerly if the game wires a prefetch). The cache
+    // path is exposed so the loader's `resolveBase` can point at it.
+    return { manifest, cachePath };
+  }
+
+  /** Get the cache path for a fetched plugin id. */
+  getCachePath(id: string): string | undefined {
+    return this.cache.get(id);
+  }
+
+  /** Enable a plugin subscription (persisted). */
+  async subscribe(id: string): Promise<void> {
+    const current = this.opts.loadSubscriptions ? await this.opts.loadSubscriptions() : [];
+    if (!current.includes(id)) {
+      current.push(id);
+      await this.opts.saveSubscriptions?.(current);
+    }
+  }
+
+  /** Remove a plugin subscription (persisted). */
+  async unsubscribe(id: string): Promise<void> {
+    const current = this.opts.loadSubscriptions ? await this.opts.loadSubscriptions() : [];
+    const next = current.filter((x) => x !== id);
+    await this.opts.saveSubscriptions?.(next);
+  }
+}

package/core/src/profiling/event-loop.ts

@@ -0,0 +1,180 @@
+// ============================================================================
+// EventLoopMonitor — per-realm event-loop health monitoring.
+//
+// Tracks:
+//   - rAF jitter: scheduling delay between expected frame time and actual
+//     rAF callback fire time. Works on the renderer (rAF) and in workers
+//     with a setInterval/setTimeout loop (measures jitter vs the configured
+//     interval).
+//   - longtask: PerformanceObserver for "longtask" entries (renderer + workers
+//     where available — a Blink API, no-ops elsewhere).
+//   - idle headroom: gap between when a frame's work completes and the next
+//     frame deadline.
+//
+// Writes the EventLoop block to the slot each frame.
+// ============================================================================
+
+import { METRIC_LONGTASK, METRIC_RAF_JITTER, type ProfilingSABWriter } from "./profiling-sab";
+import type { WarningEngine } from "./warnings";
+
+interface JitterSample {
+  jitterUs: number;
+  ts: number;
+}
+
+export class EventLoopMonitor {
+  private writer: ProfilingSABWriter | null;
+  private warningEngine: WarningEngine | null;
+  private expectedFrameMs: number;
+  private lastExpectedTime: number = 0;
+  private jitterSamples: JitterSample[] = [];
+  private readonly maxJitterSamples = 120;
+
+  // longtask accumulation (reset each flush)
+  private longtaskCount: number = 0;
+  private longtaskTotalMs: number = 0;
+  private longtaskMaxMs: number = 0;
+  private longtaskObserver: PerformanceObserver | null = null;
+
+  // idle headroom
+  private idleHeadroomMs: number = 0;
+  private frameWorkStartMs: number = 0;
+  // Last frame's work duration (set by recordFrameEnd)
+  private lastWorkMs: number = 0;
+
+  constructor(opts: {
+    writer?: ProfilingSABWriter | null;
+    warningEngine?: WarningEngine | null;
+    expectedFrameMs?: number;
+  }) {
+    this.writer = opts.writer ?? null;
+    this.warningEngine = opts.warningEngine ?? null;
+    this.expectedFrameMs = opts.expectedFrameMs ?? 16.67;
+  }
+
+  /**
+   * Start monitoring. Call once at init.
+   * For the renderer, this sets up the longtask PerformanceObserver.
+   * For workers, call startLoop() instead to begin the jitter tracking interval.
+   */
+  start(): void {
+    this.tryStartLongtaskObserver();
+  }
+
+  /**
+   * Start jitter tracking via a setInterval loop (for workers without rAF).
+   * The renderer uses recordFrameStart/recordFrameEnd around the rAF callback.
+   */
+  startLoop(intervalMs?: number): void {
+    const interval = intervalMs ?? this.expectedFrameMs;
+    this.lastExpectedTime = performance.now();
+    const tick = () => {
+      const now = performance.now();
+      const expected = this.lastExpectedTime + interval;
+      const jitterUs = Math.max(0, (now - expected) * 1000);
+      this.recordJitter(jitterUs);
+      this.lastExpectedTime = now;
+      // Flush event-loop block
+      this.flush();
+    };
+    setInterval(tick, interval);
+    this.tryStartLongtaskObserver();
+  }
+
+  /** Call at the start of each rAF callback (renderer). */
+  recordFrameStart(): void {
+    this.frameWorkStartMs = performance.now();
+    if (this.lastExpectedTime > 0) {
+      const expected = this.lastExpectedTime + this.expectedFrameMs;
+      const jitterUs = Math.max(0, (this.frameWorkStartMs - expected) * 1000);
+      this.recordJitter(jitterUs);
+    }
+    this.lastExpectedTime = this.frameWorkStartMs;
+  }
+
+  /** Call at the end of each rAF callback (renderer). */
+  recordFrameEnd(): void {
+    const now = performance.now();
+    const workMs = now - this.frameWorkStartMs;
+    this.lastWorkMs = workMs;
+    this.idleHeadroomMs = Math.max(0, this.expectedFrameMs - workMs);
+    this.flush();
+  }
+
+  /** Returns the last frame's work duration in ms (time spent in the rAF callback). */
+  getLastWorkMs(): number {
+    return this.lastWorkMs;
+  }
+
+  /** Record a jitter sample + fire warning if needed. */
+  private recordJitter(jitterUs: number): void {
+    this.jitterSamples.push({ jitterUs, ts: performance.now() });
+    if (this.jitterSamples.length > this.maxJitterSamples) this.jitterSamples.shift();
+    if (this.warningEngine && jitterUs > 0) {
+      this.warningEngine.checkInstant(METRIC_RAF_JITTER, jitterUs);
+    }
+  }
+
+  /** Flush the EventLoop block to the SAB. */
+  flush(): void {
+    if (!this.writer) return;
+    const samples = this.jitterSamples;
+    if (samples.length === 0) {
+      this.writer.writeEventLoop({
+        rafJitterP50Us: 0,
+        rafJitterP95Us: 0,
+        rafJitterMaxUs: 0,
+        longtaskCount: this.longtaskCount,
+        longtaskTotalMs: this.longtaskTotalMs,
+        longtaskMaxMs: this.longtaskMaxMs,
+        idleHeadroomMs: this.idleHeadroomMs,
+        expectedFrameMs: this.expectedFrameMs,
+      });
+      return;
+    }
+    const sorted = samples.map(s => s.jitterUs).sort((a, b) => a - b);
+    const p50 = sorted[Math.floor(sorted.length * 0.5)] ?? 0;
+    const p95 = sorted[Math.floor(sorted.length * 0.95)] ?? 0;
+    const max = sorted[sorted.length - 1] ?? 0;
+    this.writer.writeEventLoop({
+      rafJitterP50Us: p50,
+      rafJitterP95Us: p95,
+      rafJitterMaxUs: max,
+      longtaskCount: this.longtaskCount,
+      longtaskTotalMs: this.longtaskTotalMs,
+      longtaskMaxMs: this.longtaskMaxMs,
+      idleHeadroomMs: this.idleHeadroomMs,
+      expectedFrameMs: this.expectedFrameMs,
+    });
+  }
+
+  private tryStartLongtaskObserver(): void {
+    const PO = globalThis.PerformanceObserver;
+    if (!PO) return;
+    try {
+      // Check if longtask is supported
+      const obs = new PO((list) => {
+        for (const entry of list.getEntries()) {
+          const durationMs = entry.duration;
+          this.longtaskCount++;
+          this.longtaskTotalMs += durationMs;
+          if (durationMs > this.longtaskMaxMs) this.longtaskMaxMs = durationMs;
+          if (this.warningEngine) {
+            this.warningEngine.checkInstant(METRIC_LONGTASK, durationMs * 1000); // ms → us
+          }
+        }
+      });
+      obs.observe({ entryTypes: ["longtask"] });
+      this.longtaskObserver = obs;
+    } catch {
+      // longtask not supported (Safari/Firefox) — no-op
+    }
+  }
+
+  dispose(): void {
+    if (this.longtaskObserver) {
+      try { this.longtaskObserver.disconnect(); } catch { /* ignore */ }
+      this.longtaskObserver = null;
+    }
+  }
+}

package/core/src/profiling/index.ts

@@ -0,0 +1,69 @@
+// ============================================================================
+// @downdraft/engine/profiling — public API barrel
+//
+// Re-exports all profiling types + functions for use by workers, the
+// devtools module, the profiler library, and games.
+// ============================================================================
+
+// SAB layout + reader/writer
+export {
+    allocateProfilingSAB,
+    claimSlot, computeProfilingSABLayout, fnv1a32, METRIC_CPU_PERCENT, METRIC_CUSTOM, METRIC_GC_PAUSE, METRIC_GPU_TIME, METRIC_HEAP_PERCENT, METRIC_HEAP_USAGE, METRIC_IOPS_LATENCY, METRIC_LONGTASK, METRIC_RAF_JITTER, METRIC_TASK_LATENCY, METRIC_TICK_LATENCY, PROFILING_IOPS_RING_CAP, PROFILING_MAGIC, PROFILING_MAX_SLOTS, PROFILING_STRING_MAX_LEN, PROFILING_STRING_TABLE_CAP, PROFILING_VERSION, PROFILING_WARNING_RING_CAP, ProfilingSABReader, ProfilingSABWriter, releaseSlot, RUNTIME_JS,
+    RUNTIME_QUICKJS,
+    RUNTIME_WASM, SEVERITY_CRITICAL, SEVERITY_ERROR, SEVERITY_INFO,
+    SEVERITY_WARN, STORE_IDB, STORE_OPFS
+} from "./profiling-sab";
+export type {
+    EventLoopSnapshot,
+    IopsRecordSnapshot, ProfilingSABLayout, ProfilingSnapshot, RuntimeKind,
+    SeverityLevel,
+    SlotSnapshot,
+    ThreadMetricsSnapshot, WarningRecordSnapshot
+} from "./profiling-sab";
+
+// Task latency
+export { TaskLatencyHistogram } from "./task-latency";
+export type { LatencySample } from "./task-latency";
+
+// Thread metrics
+export { ThreadMetricsWriter } from "./thread-metrics";
+export type { ThreadMetricsWriterOptions } from "./thread-metrics";
+
+// Event loop
+export { EventLoopMonitor } from "./event-loop";
+
+// Warnings
+export {
+    DEFAULT_RENDERER_WARNING_RULES, DEFAULT_WORKER_WARNING_RULES, WarningEngine
+} from "./warnings";
+export type {
+    AutoTraceConfig, MetricKind, TracePreset,
+    TraceSource, WarningCallback,
+    WarningContext,
+    WarningRecordData, WarningRule
+} from "./warnings";
+
+// Trace event writer
+export { TraceEventWriter } from "./trace-event-writer";
+export type { TraceEventWriterOptions } from "./trace-event-writer";
+
+// IOPS patches
+export {
+    OPFS_OP_CREATE_SYNC_ACCESS_HANDLE,
+    OPFS_OP_CREATE_WRITABLE, OPFS_OP_GET_DIR_HANDLE, OPFS_OP_GET_FILE, OPFS_OP_GET_FILE_HANDLE, OPFS_OP_STREAM_CLOSE, OPFS_OP_STREAM_WRITE, OPFS_OP_SYNC_CLOSE, OPFS_OP_SYNC_FLUSH, OPFS_OP_SYNC_READ, OPFS_OP_SYNC_WRITE, patchOpfsPrototypes, unpatchOpfsPrototypes
+} from "./iops/opfs-patch";
+export type { IopsPatchOptions } from "./iops/opfs-patch";
+
+export {
+    IDB_OP_ADD, IDB_OP_CLEAR, IDB_OP_CLOSE, IDB_OP_COUNT, IDB_OP_DATABASES, IDB_OP_DELETE, IDB_OP_GET, IDB_OP_GET_ALL,
+    IDB_OP_GET_ALL_KEYS, IDB_OP_OBJECT_STORE, IDB_OP_OPEN, IDB_OP_OPEN_CURSOR,
+    IDB_OP_OPEN_KEY_CURSOR, IDB_OP_PUT, IDB_OP_TRANSACTION, patchIndexedDbPrototypes, unpatchIndexedDbPrototypes
+} from "./iops/idb-patch";
+export type { IdbPatchOptions } from "./iops/idb-patch";
+
+// Worker prelude
+export {
+    addWarningRule, attachProfilingSAB, detachProfilingSAB, flushProfilingTick, getEventLoopMonitor, getProfilingWriter, getSlotIndex, getTaskLatencyHistogram, getWarningEngine, isProfilingAttached, onWarning, recordTaskLatency, setHeapProvider, setWorkerTag
+} from "./worker-prelude";
+export type { ProfilingAttachConfig } from "./worker-prelude";
+