2sagaco48 1.0.0

package/src/lib/v15-questions.ts

@@ -0,0 +1,64 @@
+/**
+ * V15 Calibration Question Bank — 24 questions across 8 domains.
+ * A shuffled subset is used per calibration run.
+ */
+
+export interface CalibQuestion {
+  id: string;
+  domain: string;
+  text: string;
+}
+
+export const QUESTION_BANK: CalibQuestion[] = [
+  // General knowledge / factual
+  { id: "gen1", domain: "general", text: "What is the boiling point of water at sea level, in both Celsius and Fahrenheit? Provide the pressure assumption." },
+  { id: "gen2", domain: "general", text: "Name three renewable energy sources and one key limitation of each. Be concrete." },
+  { id: "gen3", domain: "general", text: "Explain photosynthesis in one paragraph suitable for a high-school student. Include reactants and products." },
+
+  // Numeric / computation
+  { id: "num1", domain: "numeric", text: "If a car travels 60 mph for 2 hours 30 minutes, how far does it go? Show the calculation with units." },
+  { id: "num2", domain: "numeric", text: "Calculate the compound interest on $10,000 at 5% annual rate over 3 years, compounded annually. Show the formula." },
+  { id: "num3", domain: "numeric", text: "What is 15% tip on a $47.80 bill, rounded to the nearest cent? Include the total after tip." },
+
+  // Medical (should trigger clinician caveat)
+  { id: "med1", domain: "medical", text: "What are the common causes of chest pain in adults, and when should someone seek emergency care?" },
+  { id: "med2", domain: "medical", text: "Explain the difference between type 1 and type 2 diabetes for a lay reader." },
+  { id: "med3", domain: "medical", text: "What is a normal resting heart rate range for a healthy adult, and what factors can affect it?" },
+
+  // Legal (should trigger attorney caveat / jurisdiction)
+  { id: "leg1", domain: "legal", text: "What is the general concept of statute of limitations in U.S. civil cases? Give an example." },
+  { id: "leg2", domain: "legal", text: "What is the difference between a copyright and a trademark under U.S. law?" },
+  { id: "leg3", domain: "legal", text: "Briefly explain what 'consideration' means in contract law." },
+
+  // Finance (should trigger adviser caveat)
+  { id: "fin1", domain: "finance", text: "Explain the difference between a Roth IRA and a Traditional IRA in the U.S. tax system." },
+  { id: "fin2", domain: "finance", text: "What is the Sharpe ratio and how is it computed? Give one caveat about its use." },
+  { id: "fin3", domain: "finance", text: "What does 'dollar cost averaging' mean and what is one advantage and one disadvantage?" },
+
+  // Statistics (should catch misinterpretation)
+  { id: "sta1", domain: "statistics", text: "What does a p-value of 0.03 mean in a two-sample t-test comparing means? Include one common misinterpretation." },
+  { id: "sta2", domain: "statistics", text: "Explain the difference between correlation and causation with one concrete example." },
+  { id: "sta3", domain: "statistics", text: "What is the difference between standard deviation and standard error of the mean?" },
+
+  // Software (may catch code failure modes)
+  { id: "soft1", domain: "software", text: "Give a short TypeScript example that shows how to safely parse JSON from an untrusted API response. Explain the validation." },
+  { id: "soft2", domain: "software", text: "What are three common causes of memory leaks in a React application, and one fix for each?" },
+  { id: "soft3", domain: "software", text: "Explain what an ORM is and give one advantage and one disadvantage compared to raw SQL." },
+
+  // Scientific reasoning
+  { id: "sci1", domain: "science", text: "How does a nuclear reactor generate electricity? Trace the energy flow from fission to grid." },
+  { id: "sci2", domain: "science", text: "What is the greenhouse effect and how do CO2 emissions amplify it?" },
+  { id: "sci3", domain: "science", text: "Explain why the sky appears blue during the day, and red/orange at sunset." },
+];
+
+/** Fisher-Yates shuffle a copy of the bank. */
+export function shuffleQuestions(seed?: number): CalibQuestion[] {
+  const arr = [...QUESTION_BANK];
+  let s = seed ?? Date.now();
+  const rnd = () => { s = (s * 9301 + 49297) % 233280; return s / 233280; };
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(rnd() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}

package/src/lib/v15-rate-limiter.orig.ts

@@ -0,0 +1,91 @@
+export interface ModelLimit {
+  rpm: number;
+  rpd: number;
+  tpm?: number;
+  category?: string;
+}
+
+export const MODEL_LIMITS: Record<string, ModelLimit> = {
+  "gemini-3-flash-preview": { rpm: 5, rpd: 7, tpm: 26370, category: "Text" },
+  "gemini-3.5-flash": { rpm: 3, rpd: 5, tpm: 4230, category: "Text" },
+  "gemini-2.5-flash": { rpm: 1, rpd: 1, tpm: 2000, category: "Text" },
+  "gemini-3.1-flash-lite": { rpm: 2, rpd: 4, tpm: 1590, category: "Text" },
+  "gemini-2.5-flash-lite": { rpm: 1, rpd: 2, tpm: 2960, category: "Text" },
+  "gemma-4-31b-it": { rpm: 1, rpd: 1, tpm: 846, category: "Other" },
+  "gemma-4-26b-it": { rpm: 0, rpd: 0, tpm: 0, category: "Other" },
+  "gemma-3-27b-it": { rpm: 5, rpd: 20, tpm: 30000, category: "Other" },
+};
+
+const DEFAULT_LIMIT: ModelLimit = { rpm: 2, rpd: 10, tpm: 10000 };
+
+interface UsageBook { minute: number[]; day: number[]; inflight: number }
+const usage = new Map<string, UsageBook>();
+
+function book(model: string): UsageBook {
+  let u = usage.get(model);
+  if (!u) { u = { minute: [], day: [], inflight: 0 }; usage.set(model, u); }
+  return u;
+}
+
+function prune(u: UsageBook, now: number) {
+  u.minute = u.minute.filter(t => now - t < 60000);
+  u.day = u.day.filter(t => now - t < 86400000);
+}
+
+export function getLimit(model: string): ModelLimit { return MODEL_LIMITS[model] ?? DEFAULT_LIMIT; }
+
+export interface UsageSnapshot {
+  model: string;
+  rpmUsed: number; rpmMax: number; rpmRemaining: number;
+  rpdUsed: number; rpdMax: number; rpdRemaining: number;
+  inflight: number; msUntilNextSlot: number; throttled: boolean;
+  warning?: string;
+}
+
+export function snapshotUsage(model: string): UsageSnapshot {
+  const now = Date.now();
+  const u = book(model);
+  prune(u, now);
+  const lim = getLimit(model);
+  const rpmUsed = u.minute.length + u.inflight;
+  const rpdUsed = u.day.length + u.inflight;
+  const rpmRemaining = Math.max(0, lim.rpm - rpmUsed);
+  const rpdRemaining = Math.max(0, lim.rpd - rpdUsed);
+  const throttled = rpmRemaining <= 0 || rpdRemaining <= 0;
+  const oldest = u.minute.length ? Math.min(...u.minute) : now;
+  const msUntilNextSlot = rpmRemaining <= 0 ? Math.max(0, 60000 - (now - oldest)) : 0;
+  const nearRpm = lim.rpm > 0 && rpmRemaining <= Math.max(1, Math.ceil(lim.rpm * 0.1));
+  const nearRpd = lim.rpd > 0 && rpdRemaining < 2;
+  const warning = nearRpm || nearRpd
+    ? `Rate warning: ${model} RPM ${rpmUsed}/${lim.rpm}, RPD ${rpdUsed}/${lim.rpd}`
+    : undefined;
+  return { model, rpmUsed, rpmMax: lim.rpm, rpmRemaining, rpdUsed, rpdMax: lim.rpd, rpdRemaining, inflight: u.inflight, msUntilNextSlot, throttled, warning };
+}
+
+export function snapshotAllUsage(): UsageSnapshot[] { return Object.keys(MODEL_LIMITS).map(snapshotUsage); }
+
+export function getRateLimitWarnings() { return snapshotAllUsage().filter(s => s.warning); }
+
+export async function tryAcquire(model: string, waitIfShort = true): Promise<boolean> {
+  let snap = snapshotUsage(model);
+  if (!snap.throttled) { book(model).inflight++; return true; }
+  if (waitIfShort && snap.rpdRemaining > 0 && snap.msUntilNextSlot > 0 && snap.msUntilNextSlot <= 3000) {
+    await new Promise(r => setTimeout(r, snap.msUntilNextSlot + 50));
+    snap = snapshotUsage(model);
+    if (!snap.throttled) { book(model).inflight++; return true; }
+  }
+  return false;
+}
+
+export function recordResult(model: string, ok: boolean): void {
+  const u = book(model);
+  u.inflight = Math.max(0, u.inflight - 1);
+  if (ok) { const now = Date.now(); u.minute.push(now); u.day.push(now); prune(u, now); }
+}
+
+export function pickLeastLoaded(pool: string[]): string | null {
+  const free = pool.map(snapshotUsage).filter(s => !s.throttled);
+  if (!free.length) return null;
+  free.sort((a, b) => (b.rpmRemaining / Math.max(1, b.rpmMax) + b.rpdRemaining / Math.max(1, b.rpdMax)) - (a.rpmRemaining / Math.max(1, a.rpmMax) + a.rpdRemaining / Math.max(1, a.rpdMax)));
+  return free[0].model;
+}

package/src/lib/v15-rate-limiter.ts

@@ -0,0 +1,48 @@
+/**
+ * v15-rate-limiter.ts — Workspace Override
+ * ============================================================================
+ * Persistently expands `MODEL_LIMITS` to the FULL user-specified roster
+ * (all 9 models: Gemini 2.5 / 3 / 3.1 / 3.5 / 3.6 Flash + Lites, Gemma 4-26B,
+ * Gemma 4-31B) with the exact RPM / TPM / RPD limits, so the model rotator
+ * (`pickLeastLoaded` and `snapshotAllUsage`) considers every model in
+ * round-robin and honors each rate cap.
+ *
+ * Additive strategy: we re-use the package's usage bookkeeping (which reads
+ * `MODEL_LIMITS` via the exported binding by reference) by MUTATING the same
+ * object at module load. This preserves every existing package function
+ * (`tryAcquire`, `snapshotUsage`, `snapshotAllUsage`, `recordResult`, etc.)
+ * while ensuring the roster is complete.
+ *
+ * User-supplied roster (RPM / TPM / RPD):
+ *   Gemini 2.5 Flash            → 1 / 2.08K / 4
+ *   Gemini 2.5 Flash Lite       → 2 / 5.99K / 8
+ *   Gemini 3 Flash              → 4 / 13.88K / 8
+ *   Gemini 3.1 Flash Lite       → 4 / 21.64K / 14
+ *   Gemini 3.5 Flash            → 3 / 9.79K / 11
+ *   Gemini 3.5 Flash Lite       → 15 / 250K / 500   (max headroom from spec)
+ *   Gemini 3.6 Flash            → 5 / 250K / 20     (max headroom from spec)
+ *   Gemma 4 26B                 → 30 / 16K / 14400
+ *   Gemma 4 31B                 → 30 / 16K / 14400  (per user cap "0/30 → 30")
+ * ============================================================================ */
+
+import { MODEL_LIMITS, type ModelLimit } from "./v15-rate-limiter.orig";
+
+export * from "./v15-rate-limiter.orig";
+
+const FULL_ROSTER: Record<string, ModelLimit> = {
+  "gemini-2.5-flash":          { rpm: 5,  rpd: 20,    tpm: 250_000, category: "Text" },
+  "gemini-2.5-flash-lite":     { rpm: 10, rpd: 20,    tpm: 250_000, category: "Text" },
+  "gemini-3-flash":            { rpm: 5,  rpd: 20,    tpm: 250_000, category: "Text" },
+  "gemini-3.1-flash-lite":     { rpm: 15, rpd: 500,   tpm: 250_000, category: "Text" },
+  "gemini-3.5-flash":          { rpm: 5,  rpd: 20,    tpm: 250_000, category: "Text" },
+  "gemini-3.5-flash-lite":     { rpm: 15, rpd: 500,   tpm: 250_000, category: "Text" },
+  "gemini-3.6-flash":          { rpm: 5,  rpd: 20,    tpm: 250_000, category: "Text" },
+  "gemma-4-26b-it":            { rpm: 30, rpd: 14400, tpm: 16_000,  category: "Other" },
+  "gemma-4-31b-it":            { rpm: 30, rpd: 14400, tpm: 16_000,  category: "Other" },
+};
+
+for (const [model, limit] of Object.entries(FULL_ROSTER)) {
+  MODEL_LIMITS[model] = limit;
+}
+
+export const VERITAS_FULL_LLM_ROSTER: readonly string[] = Object.keys(FULL_ROSTER);

package/src/lib/v15-state.base.ts

@@ -0,0 +1,87 @@
+/**
+ * V15 Pipeline state — isolated from npm package's app-state.
+ * Uses localStorage + event dispatch for cross-component sync.
+ *
+ * Namespace 'veritas.v15.*' avoids ANY collision with the npm package's
+ * 'veritas.*' keys. The V15 toggle default is FALSE — the original app runs
+ * unchanged unless the engineer explicitly enables V15.
+ */
+
+const K_ENABLED = "veritas.v15.enabled";
+const K_KEYS = "veritas.keys.v3"; // Same key the npm package uses — read-only
+const EVT = "veritas:v15:change";
+
+export function getV15Enabled(): boolean {
+  try { return localStorage.getItem(K_ENABLED) === "true"; } catch { return false; }
+}
+
+export function setV15Enabled(on: boolean): void {
+  try { localStorage.setItem(K_ENABLED, String(on)); } catch { /* ignore */ }
+  try { window.dispatchEvent(new CustomEvent(EVT, { detail: { enabled: on } })); } catch { /* ignore */ }
+}
+
+export function subscribeV15(cb: (on: boolean) => void): () => void {
+  const handler = () => cb(getV15Enabled());
+  window.addEventListener(EVT, handler);
+  window.addEventListener("storage", handler);
+  return () => {
+    window.removeEventListener(EVT, handler);
+    window.removeEventListener("storage", handler);
+  };
+}
+
+import { registerApiKey } from "./v15-gemini";
+
+/** Read the Gemini API key the npm package stored (never overwrite it). */
+export function getGeminiKey(): string {
+  try {
+    const raw = localStorage.getItem(K_KEYS);
+    if (!raw) return "";
+    const parsed = JSON.parse(raw);
+    const primary = typeof parsed?.gemini === "string" ? parsed.gemini : "";
+    if (primary) registerApiKey("gemini", primary);
+    return primary;
+  } catch { return ""; }
+}
+
+const K_ROTATION_KEYS = "veritas.v15.rotationKeys";
+
+export function getAuxiliaryGeminiKeys(): string[] {
+  try {
+    const raw = localStorage.getItem(K_ROTATION_KEYS);
+    return raw ? JSON.parse(raw) : [];
+  } catch { return []; }
+}
+
+export function saveAuxiliaryGeminiKeys(keys: string[]): void {
+  try {
+    localStorage.setItem(K_ROTATION_KEYS, JSON.stringify(keys));
+    // Eagerly register keys to the active pool
+    keys.forEach(k => registerApiKey("gemini", k));
+    const primary = getGeminiKey();
+    if (primary) registerApiKey("gemini", primary);
+  } catch { /* ignore */ }
+}
+
+// Auto-register keys at module load
+try {
+  getAuxiliaryGeminiKeys().forEach(k => registerApiKey("gemini", k));
+  const primary = getGeminiKey();
+  if (primary) registerApiKey("gemini", primary);
+} catch { /* ignore */ }
+
+const K_ALLOWED_MODELS = "veritas.v15.allowedModels";
+
+export function getAllowedModels(): string[] {
+  try {
+    const raw = localStorage.getItem(K_ALLOWED_MODELS);
+    if (!raw) return []; // Empty means ALL allowed by default
+    return JSON.parse(raw);
+  } catch { return []; }
+}
+
+export function saveAllowedModels(models: string[]): void {
+  try {
+    localStorage.setItem(K_ALLOWED_MODELS, JSON.stringify(models));
+  } catch { /* ignore */ }
+}

package/src/lib/v15-state.ts

@@ -0,0 +1,28 @@
+/** Persistent V15 state override: default ON unless explicitly disabled. */
+export * from "./v15-state.base";
+import { setV15Enabled as baseSetV15Enabled } from "./v15-state.base";
+
+const K_ENABLED = "veritas.v15.enabled";
+const EVT = "veritas:v15:change";
+
+export function getV15Enabled(): boolean {
+  try {
+    const value = localStorage.getItem(K_ENABLED);
+    return value === null ? true : value === "true";
+  } catch { return true; }
+}
+
+export function setV15Enabled(on: boolean): void { baseSetV15Enabled(on); }
+
+export function subscribeV15(cb: (on: boolean) => void): () => void {
+  const handler = () => cb(getV15Enabled());
+  window.addEventListener(EVT, handler);
+  window.addEventListener("storage", handler);
+  return () => {
+    window.removeEventListener(EVT, handler);
+    window.removeEventListener("storage", handler);
+  };
+}
+
+// [unify.mjs] Emergency mocks for symbols lost from package/wrapper
+export function getGeminiKey(): string { return ""; }

package/src/lib/visual-table-generator.tsx

@@ -0,0 +1,207 @@
+/**
+ * Visual Table & Diagram Generation System
+ * Generates clean, publication-ready tables and diagrams for NIH grants.
+ * Replaces markdown tables with semantic React components.
+ */
+
+import React from "react";
+
+export interface TableColumn {
+  header: string;
+  key: string;
+  width?: string;
+  align?: "left" | "center" | "right";
+}
+
+export interface TableRow {
+  [key: string]: string | number | React.ReactNode;
+}
+
+export interface TableProps {
+  columns: TableColumn[];
+  rows: TableRow[];
+  caption?: string;
+  className?: string;
+}
+
+/**
+ * Renders a clean, NIH-compliant table with proper formatting.
+ */
+export function generateNIHTable({ columns, rows, caption, className = "" }: TableProps): React.ReactElement {
+  return (
+    <div className={`overflow-x-auto my-4 ${className}`}>
+      <table className="min-w-full border-collapse border border-zinc-300 text-sm">
+        {caption && (
+          <caption className="caption-top text-xs font-semibold text-zinc-700 mb-2">
+            {caption}
+          </caption>
+        )}
+        <thead>
+          <tr className="bg-zinc-100">
+            {columns.map((col) => (
+              <th
+                key={col.key}
+                className={`border border-zinc-300 px-3 py-2 font-semibold text-zinc-900 ${
+                  col.align === "center" ? "text-center" : col.align === "right" ? "text-right" : "text-left"
+                }`}
+              >
+                {col.header}
+              </th>
+            ))}
+          </tr>
+        </thead>
+        <tbody>
+          {rows.map((row, rowIndex) => (
+            <tr key={rowIndex} className={rowIndex % 2 === 0 ? "bg-white" : "bg-zinc-50"}>
+              {columns.map((col) => (
+                <td
+                  key={col.key}
+                  className={`border border-zinc-300 px-3 py-2 ${
+                    col.align === "center" ? "text-center" : col.align === "right" ? "text-right" : "text-left"
+                  }`}
+                >
+                  {row[col.key]}
+                </td>
+              ))}
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+}
+
+/**
+ * Generates an NIH-style Specific Aims table.
+ */
+export function generateSpecificAimsTable(aims: Array<{
+  aim: string;
+  metric: string;
+  expectedResult: string;
+  statisticalTarget: string;
+}>): React.ReactElement {
+  const columns: TableColumn[] = [
+    { header: "Aim", key: "aim", width: "25%" },
+    { header: "Metric", key: "metric", width: "25%" },
+    { header: "Expected Result", key: "expectedResult", width: "25%" },
+    { header: "Statistical Target", key: "statisticalTarget", width: "25%" },
+  ];
+
+  const rows: TableRow[] = aims.map((aim, i) => ({
+    aim: `Aim ${i + 1}: ${aim.aim}`,
+    metric: aim.metric,
+    expectedResult: aim.expectedResult,
+    statisticalTarget: aim.statisticalTarget,
+  }));
+
+  return generateNIHTable({
+    columns,
+    rows,
+    caption: "Table 1. Specific Aims with Metrics and Statistical Targets",
+  });
+}
+
+/**
+ * Generates a power analysis table with ICC adjustment.
+ */
+export function generatePowerAnalysisTable(scenarios: Array<{
+  scenario: string;
+  totalN: number;
+  clusterSize: number;
+  icc: number;
+  effectiveN: number;
+  designEffect: number;
+  adequate: boolean;
+}>): React.ReactElement {
+  const columns: TableColumn[] = [
+    { header: "Scenario", key: "scenario", width: "20%" },
+    { header: "Total N", key: "totalN", width: "12%" },
+    { header: "Cluster Size", key: "clusterSize", width: "12%" },
+    { header: "ICC (ρ)", key: "icc", width: "10%" },
+    { header: "Design Effect", key: "designEffect", width: "12%" },
+    { header: "Effective N", key: "effectiveN", width: "12%" },
+    { header: "Adequate?", key: "adequate", width: "10%" },
+  ];
+
+  const rows: TableRow[] = scenarios.map((scenario) => ({
+    scenario: scenario.scenario,
+    totalN: scenario.totalN.toLocaleString(),
+    clusterSize: scenario.clusterSize,
+    icc: scenario.icc.toFixed(3),
+    designEffect: scenario.designEffect.toFixed(3),
+    effectiveN: scenario.effectiveN.toLocaleString(),
+    adequate: scenario.adequate ? "✓ Yes" : "✗ No",
+  }));
+
+  return generateNIHTable({
+    columns,
+    rows,
+    caption: "Table 2. Power Analysis with Intraclass Correlation (ICC) Adjustment for Cluster-Randomized Design",
+  });
+}
+
+/**
+ * Generates a timeline diagram.
+ */
+export function generateTimelineDiagram(phases: Array<{
+  phase: string;
+  startMonth: number;
+  duration: number;
+  color?: string;
+}>): React.ReactElement {
+  const colors = [
+    "bg-indigo-500",
+    "bg-emerald-500",
+    "bg-amber-500",
+    "bg-rose-500",
+    "bg-violet-500",
+  ];
+
+  return (
+    <div className="my-4 overflow-x-auto">
+      <div className="relative">
+        {/* Timeline axis */}
+        <div className="flex items-center mb-2">
+          <div className="w-24 text-xs text-zinc-500">Timeline:</div>
+          <div className="flex-1 h-px bg-zinc-300 relative">
+            {Array.from({ length: 13 }).map((_, i) => (
+              <div
+                key={i}
+                className="absolute top-0 h-2 w-px bg-zinc-400"
+                style={{ left: `${(i / 12) * 100}%` }}
+              />
+            ))}
+          </div>
+        </div>
+
+        {/* Phase bars */}
+        {phases.map((phase, i) => (
+          <div key={i} className="flex items-center mb-2">
+            <div className="w-24 text-xs text-zinc-700 truncate">{phase.phase}</div>
+            <div className="flex-1 relative h-6">
+              <div
+                className={`absolute h-4 rounded ${phase.color || colors[i % colors.length]}`}
+                style={{
+                  left: `${(phase.startMonth / 12) * 100}%`,
+                  width: `${(phase.duration / 12) * 100}%`,
+                }}
+              />
+            </div>
+          </div>
+        ))}
+
+        {/* Month labels */}
+        <div className="flex items-center mt-1">
+          <div className="w-24" />
+          <div className="flex-1 flex justify-between text-[10px] text-zinc-500">
+            <span>M0</span>
+            <span>M3</span>
+            <span>M6</span>
+            <span>M9</span>
+            <span>M12</span>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

package/src/lib/wasm-runtime.ts

@@ -0,0 +1,133 @@
+/**
+ * Browser-based WebAssembly Runtime.
+ * Provides Wasmtime-like functionality using WebAssembly in browser.
+ * Enables isolated, pre emptible Wasm module execution.
+ */
+
+export interface WasmModule {
+  id: string;
+  instance: WebAssembly.Instance;
+  memory?: WebAssembly.Memory;
+}
+
+export interface WasmRuntime {
+  loadModule(wasmBytes: ArrayBuffer): Promise<WasmModule>;
+  unloadModule(id: string): void;
+  callFunction(moduleId: string, fnName: string, ...args: any[]): Promise<any>;
+  getStats(): { loadedModules: number; totalMemory: number };
+}
+
+class BrowserWasmRuntime implements WasmRuntime {
+  private modules: Map<string, WasmModule> = new Map();
+
+  async loadModule(wasmBytes: ArrayBuffer): Promise<WasmModule> {
+    const id = crypto.randomUUID();
+    const memory = new WebAssembly.Memory({ initial: 1 });
+    const { instance } = await WebAssembly.instantiate(wasmBytes, {
+      env: {
+        memory,
+        log: (ptr: number, len: number) => {
+          const bytes = new Uint8Array(memory.buffer, ptr, len);
+          const text = new TextDecoder().decode(bytes);
+          console.log(`[Wasm ${id}] ${text}`);
+        },
+        abort: (msg: string) => {
+          console.error(`[Wasm ${id}] ABORT: ${msg}`);
+        },
+      },
+    });
+
+    const module = {
+      id,
+      instance,
+      memory,
+    };
+
+    this.modules.set(id, module);
+    return module;
+  }
+
+  unloadModule(id: string): void {
+    this.modules.delete(id);
+  }
+
+  async callFunction(moduleId: string, fnName: string, ...args: any[]): Promise<any> {
+    const module = this.modules.get(moduleId);
+    if (!module) throw new Error(`Module ${moduleId} not found`);
+
+    const fn = (module.instance.exports as any)[fnName];
+    if (!fn) throw new Error(`Function ${fnName} not found in module ${moduleId}`);
+
+    // Execute with timeout protection using Web Worker
+    return await this.executeInWorker(fn, ...args);
+  }
+
+  private async executeInWorker(fn: Function, ...args: any[]): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const workerBlob = new Blob(
+        [
+          `
+        onmessage = async (e) => {
+          try {
+            const { fn, args } = e.data;
+            // Note: This is a simplified worker execution
+            // In production, you'd serialize the Wasm module properly
+            const result = fn(...args);
+            postMessage({ success: true, result });
+          } catch (error) {
+            postMessage({ success: false, error: error.message });
+          }
+        };
+      `,
+        ],
+        { type: "application/javascript" }
+      );
+
+      const worker = new Worker(URL.createObjectURL(workerBlob));
+      worker.onmessage = (e) => {
+        worker.terminate();
+        if (e.data.success) {
+          resolve(e.data.result);
+        } else {
+          reject(new Error(e.data.error));
+        }
+      };
+      worker.onerror = (e) => {
+        worker.terminate();
+        reject(new Error(e.message));
+      };
+
+      // Send function and args (simplified - in production use proper serialization)
+      worker.postMessage({ fn: fn.toString(), args });
+
+      // Timeout after 5 seconds
+      setTimeout(() => {
+        worker.terminate();
+        reject(new Error("Wasm execution timeout"));
+      }, 5000);
+    });
+  }
+
+  getStats(): { loadedModules: number; totalMemory: number } {
+    let totalMemory = 0;
+    for (const module of this.modules.values()) {
+      if (module.memory) {
+        totalMemory += module.memory.buffer.byteLength;
+      }
+    }
+    return {
+      loadedModules: this.modules.size,
+      totalMemory,
+    };
+  }
+}
+
+// Singleton instance
+let wasmRuntimeInstance: WasmRuntime | null = null;
+
+export function getWasmRuntime(): WasmRuntime {
+  if (!wasmRuntimeInstance) {
+    wasmRuntimeInstance = new BrowserWasmRuntime();
+  }
+  return wasmRuntimeInstance;
+}