brass-runtime 1.13.7 → 1.14.0

package/dist/chunk-L6KKKM66.js

@@ -1,2557 +0,0 @@
-// src/core/types/asyncEffect.ts
-var Async = {
-  succeed: (value) => ({ _tag: "Succeed", value }),
-  fail: (error) => ({ _tag: "Fail", error }),
-  sync: (thunk) => ({ _tag: "Sync", thunk }),
-  async: (register) => ({ _tag: "Async", register })
-};
-function asyncFold(fa, onFailure, onSuccess) {
-  return { _tag: "Fold", first: fa, onFailure, onSuccess };
-}
-function asyncCatchAll(fa, handler) {
-  return asyncFold(
-    fa,
-    (e) => handler(e),
-    (a) => asyncSucceed(a)
-  );
-}
-function asyncMapError(fa, f) {
-  return asyncFold(
-    fa,
-    (e) => asyncFail(f(e)),
-    (a) => asyncSucceed(a)
-  );
-}
-var SUCCEED_UNDEFINED = { _tag: "Succeed", value: void 0 };
-var SUCCEED_TRUE = { _tag: "Succeed", value: true };
-var SUCCEED_FALSE = { _tag: "Succeed", value: false };
-var SUCCEED_NULL = { _tag: "Succeed", value: null };
-var unit = () => SUCCEED_UNDEFINED;
-var asyncSucceed = (value) => {
-  if (value === void 0) return SUCCEED_UNDEFINED;
-  if (value === true) return SUCCEED_TRUE;
-  if (value === false) return SUCCEED_FALSE;
-  if (value === null) return SUCCEED_NULL;
-  return { _tag: "Succeed", value };
-};
-var asyncFail = (error) => ({
-  _tag: "Fail",
-  error
-});
-var asyncSync = (thunk) => ({
-  _tag: "Sync",
-  thunk
-});
-var asyncTotal = (thunk) => asyncSync(() => thunk());
-var async = (register) => ({
-  _tag: "Async",
-  register
-});
-function asyncMap(fa, f) {
-  return asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
-}
-function asyncFlatMap(fa, f) {
-  return {
-    _tag: "FlatMap",
-    first: fa,
-    andThen: f
-  };
-}
-function acquireRelease(acquire, release, scope) {
-  return asyncFlatMap(acquire, (resource) => {
-    scope.addFinalizer((exit) => release(resource, exit));
-    return asyncSucceed(resource);
-  });
-}
-function asyncInterruptible(register) {
-  return async(register);
-}
-var withAsyncPromise = (run) => (eff) => {
-  const anyEff = eff;
-  if (!anyEff.toPromise) {
-    anyEff.toPromise = (env) => run(eff, env);
-    anyEff.unsafeRunPromise = () => run(eff, {});
-  }
-  return anyEff;
-};
-var mapAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
-var mapTryAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSync(() => f(a)));
-
-// src/core/types/option.ts
-var none = { _tag: "None" };
-var some = (value) => ({ _tag: "Some", value });
-
-// src/core/types/effect.ts
-var Cause = {
-  fail: (error) => ({ _tag: "Fail", error }),
-  interrupt: () => ({ _tag: "Interrupt" }),
-  die: (defect) => ({ _tag: "Die", defect })
-};
-var Exit = {
-  succeed: (value) => ({
-    _tag: "Success",
-    value
-  }),
-  failCause: (cause) => ({
-    _tag: "Failure",
-    cause
-  })
-};
-var succeed = (value) => asyncSucceed(value);
-var fail = (error) => asyncFail(error);
-var sync = (thunk) => asyncSync((env) => thunk(env));
-var map = (fa, f) => asyncMap(fa, f);
-var flatMap = (fa, f) => asyncFlatMap(fa, (a) => f(a));
-var mapError = (fa, f) => asyncMapError(fa, f);
-var catchAll = (fa, handler) => asyncFold(
-  fa,
-  (e) => handler(e),
-  (a) => asyncSucceed(a)
-);
-function orElseOptional(fa, that) {
-  return asyncFold(
-    fa,
-    (opt) => opt._tag === "Some" ? asyncFail(opt) : that(),
-    (a) => asyncSucceed(a)
-  );
-}
-var end = () => fail(none);
-
-// src/core/runtime/ringBuffer.ts
-var PushStatus = /* @__PURE__ */ ((PushStatus3) => {
-  PushStatus3[PushStatus3["Ok"] = 0] = "Ok";
-  PushStatus3[PushStatus3["Grew"] = 1] = "Grew";
-  PushStatus3[PushStatus3["Dropped"] = 2] = "Dropped";
-  return PushStatus3;
-})(PushStatus || {});
-var RingBuffer = class {
-  buf;
-  head = 0;
-  tail = 0;
-  size_ = 0;
-  // nuevo
-  maxCap;
-  constructor(initialCapacity = 1024, maxCapacity = initialCapacity) {
-    let initPow = Math.max(2, initialCapacity);
-    initPow--;
-    initPow |= initPow >>> 1;
-    initPow |= initPow >>> 2;
-    initPow |= initPow >>> 4;
-    initPow |= initPow >>> 8;
-    initPow |= initPow >>> 16;
-    initPow++;
-    let maxPow = Math.max(initPow, maxCapacity);
-    maxPow--;
-    maxPow |= maxPow >>> 1;
-    maxPow |= maxPow >>> 2;
-    maxPow |= maxPow >>> 4;
-    maxPow |= maxPow >>> 8;
-    maxPow |= maxPow >>> 16;
-    maxPow++;
-    this.buf = new Array(initPow);
-    this.maxCap = maxPow;
-  }
-  get length() {
-    return this.size_;
-  }
-  get capacity() {
-    return this.buf.length;
-  }
-  isEmpty() {
-    return this.size_ === 0;
-  }
-  push(value) {
-    if (this.size_ === this.buf.length) {
-      if (this.buf.length >= this.maxCap) {
-        return 2 /* Dropped */;
-      }
-      this.grow();
-      this.buf[this.tail] = value;
-      this.tail = this.tail + 1 & this.buf.length - 1;
-      this.size_++;
-      return 0 /* Ok */ | 1 /* Grew */;
-    }
-    this.buf[this.tail] = value;
-    this.tail = this.tail + 1 & this.buf.length - 1;
-    this.size_++;
-    return 0 /* Ok */;
-  }
-  shift() {
-    if (this.size_ === 0) return void 0;
-    const value = this.buf[this.head];
-    this.buf[this.head] = void 0;
-    this.head = this.head + 1 & this.buf.length - 1;
-    this.size_--;
-    return value;
-  }
-  clear() {
-    this.head = 0;
-    this.tail = 0;
-    this.size_ = 0;
-  }
-  grow() {
-    const old = this.buf;
-    const nextLen = Math.min(old.length * 2, this.maxCap);
-    const newBuf = new Array(nextLen);
-    for (let i = 0; i < this.size_; i++) {
-      newBuf[i] = old[this.head + i & old.length - 1];
-    }
-    this.buf = newBuf;
-    this.head = 0;
-    this.tail = this.size_;
-  }
-};
-
-// src/core/runtime/wasmModule.ts
-import { createRequire } from "module";
-var cachedWasmModule;
-var cachedWasmModuleErrors = [];
-function resolveWasmModule(options = {}) {
-  if (!options.fresh && options.modulePath == null && cachedWasmModule !== void 0) {
-    return cachedWasmModule;
-  }
-  const req = getBestRequire();
-  const candidates = wasmModuleCandidates(options.modulePath);
-  const errors = [];
-  if (!req) {
-    errors.push("no CommonJS-compatible require/createRequire was available");
-    return remember(options, null, errors);
-  }
-  for (const candidate of candidates) {
-    try {
-      return remember(options, req(candidate), errors);
-    } catch (error) {
-      errors.push(`${candidate}: ${formatError(error)}`);
-    }
-  }
-  return remember(options, null, errors);
-}
-function wasmModuleResolutionErrors() {
-  return cachedWasmModuleErrors.slice();
-}
-function wasmModuleCandidates(modulePath) {
-  if (modulePath) return [modulePath];
-  return [
-    "brass-runtime/wasm/pkg/brass_runtime_wasm_engine.js",
-    "../wasm/pkg/brass_runtime_wasm_engine.js",
-    "../../../wasm/pkg/brass_runtime_wasm_engine.js",
-    "../../../../../wasm/pkg/brass_runtime_wasm_engine.js",
-    `${getCwd()}/wasm/pkg/brass_runtime_wasm_engine.js`
-  ];
-}
-function remember(options, value, errors) {
-  if (!options.fresh && options.modulePath == null) {
-    cachedWasmModule = value;
-    cachedWasmModuleErrors = errors;
-  }
-  return value;
-}
-function getBestRequire() {
-  return getNonWebpackRequire() ?? getRuntimeRequire() ?? getCreateRequire();
-}
-function getNonWebpackRequire() {
-  try {
-    return (0, eval)(
-      "typeof __non_webpack_require__ === 'function' ? __non_webpack_require__ : undefined"
-    );
-  } catch {
-    return void 0;
-  }
-}
-function getRuntimeRequire() {
-  try {
-    return (0, eval)(
-      "typeof require === 'function' ? require : undefined"
-    );
-  } catch {
-    return void 0;
-  }
-}
-function getCreateRequire() {
-  try {
-    return createRequire(`${getCwd()}/package.json`);
-  } catch {
-    return void 0;
-  }
-}
-function getCwd() {
-  try {
-    return (0, eval)(
-      "typeof process !== 'undefined' ? process.cwd() : ''"
-    );
-  } catch {
-    return "";
-  }
-}
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/core/runtime/boundedRingBuffer.ts
-var cachedWasmCtor;
-function resolveWasmRingBuffer() {
-  if (cachedWasmCtor !== void 0) return cachedWasmCtor;
-  const mod = resolveWasmModule();
-  cachedWasmCtor = mod?.BrassWasmRingBuffer ?? null;
-  return cachedWasmCtor;
-}
-var WasmRingBuffer = class {
-  engine = "wasm";
-  fallbackUsed = false;
-  inner;
-  pushes = 0;
-  shifts = 0;
-  clears = 0;
-  dropped = 0;
-  constructor(initialCapacity, maxCapacity) {
-    const Ctor = resolveWasmRingBuffer();
-    if (!Ctor) {
-      throw new Error("brass-runtime wasm ring buffer is not available. Run npm run build:wasm first.");
-    }
-    this.inner = new Ctor(initialCapacity, maxCapacity);
-  }
-  get length() {
-    return this.inner.len();
-  }
-  get capacity() {
-    return this.inner.capacity();
-  }
-  isEmpty() {
-    return this.inner.is_empty();
-  }
-  push(value) {
-    this.pushes++;
-    const status = this.inner.push(value);
-    if ((status & 2) !== 0) this.dropped++;
-    return status;
-  }
-  shift() {
-    const value = this.inner.shift();
-    if (value !== void 0) this.shifts++;
-    return value === void 0 ? void 0 : value;
-  }
-  clear() {
-    this.clears++;
-    this.inner.clear();
-  }
-  stats() {
-    return {
-      engine: "wasm",
-      fallbackUsed: false,
-      data: {
-        len: this.length,
-        capacity: this.capacity,
-        pushes: this.pushes,
-        shifts: this.shifts,
-        clears: this.clears,
-        dropped: this.dropped
-      }
-    };
-  }
-};
-var JsBoundedRingBuffer = class {
-  constructor(inner, fallbackUsed) {
-    this.inner = inner;
-    this.fallbackUsed = fallbackUsed;
-  }
-  inner;
-  fallbackUsed;
-  engine = "js";
-  pushes = 0;
-  shifts = 0;
-  clears = 0;
-  dropped = 0;
-  get length() {
-    return this.inner.length;
-  }
-  get capacity() {
-    return this.inner.capacity;
-  }
-  isEmpty() {
-    return this.inner.isEmpty();
-  }
-  push(value) {
-    this.pushes++;
-    const status = this.inner.push(value);
-    if ((status & 2) !== 0) this.dropped++;
-    return status;
-  }
-  shift() {
-    const value = this.inner.shift();
-    if (value !== void 0) this.shifts++;
-    return value;
-  }
-  clear() {
-    this.clears++;
-    this.inner.clear();
-  }
-  stats() {
-    return {
-      engine: "js",
-      fallbackUsed: this.fallbackUsed,
-      data: {
-        len: this.length,
-        capacity: this.capacity,
-        pushes: this.pushes,
-        shifts: this.shifts,
-        clears: this.clears,
-        dropped: this.dropped
-      }
-    };
-  }
-};
-function makeBoundedRingBuffer(initialCapacity, maxCapacity = initialCapacity, options = {}) {
-  const engine = options.engine ?? "auto";
-  if (engine === "js") {
-    return new JsBoundedRingBuffer(new RingBuffer(initialCapacity, maxCapacity), false);
-  }
-  if (engine === "wasm") {
-    return new WasmRingBuffer(initialCapacity, maxCapacity);
-  }
-  const Ctor = resolveWasmRingBuffer();
-  if (Ctor) {
-    return new WasmRingBuffer(initialCapacity, maxCapacity);
-  }
-  return new JsBoundedRingBuffer(new RingBuffer(initialCapacity, maxCapacity), true);
-}
-
-// src/core/runtime/scheduler.ts
-var FLUSH_BUDGET = 2048;
-var MICRO_THRESHOLD = 4096;
-var SCHEDULER_QUEUE_CAPACITY = 8192;
-var scheduleMacro = (() => {
-  if (typeof globalThis.setImmediate === "function") {
-    return (f) => globalThis.setImmediate(f);
-  }
-  if (typeof globalThis.MessageChannel === "function") {
-    const ch = new globalThis.MessageChannel();
-    let cb = null;
-    ch.port1.onmessage = () => {
-      const f = cb;
-      cb = null;
-      f?.();
-    };
-    return (f) => {
-      cb = f;
-      ch.port2.postMessage(0);
-    };
-  }
-  return (f) => setTimeout(f, 0);
-})();
-function resolveWasmScheduler() {
-  const mod = resolveWasmModule();
-  return mod?.BrassWasmSchedulerStateMachine ?? null;
-}
-var JsSchedulerState = class {
-  tasks;
-  tags;
-  flushing = false;
-  scheduled = false;
-  scheduledFlushes = 0;
-  completedFlushes = 0;
-  enqueuedTasks = 0;
-  executedTasks = 0;
-  droppedTasks = 0;
-  yieldedByBudget = 0;
-  constructor(options) {
-    const initial = options.initialCapacity ?? 1024;
-    const max = options.maxCapacity ?? initial;
-    this.tasks = makeBoundedRingBuffer(initial, max, { engine: options.engine });
-    this.tags = makeBoundedRingBuffer(initial, max, { engine: options.engine });
-  }
-};
-var WasmSchedulerState = class {
-  machine;
-  nextRef = 1;
-  tasks = /* @__PURE__ */ new Map();
-  tags = /* @__PURE__ */ new Map();
-  constructor(options) {
-    const Ctor = resolveWasmScheduler();
-    if (!Ctor) throw new Error("brass-runtime wasm scheduler is not available. Run npm run build:wasm first.");
-    this.machine = new Ctor(
-      options.initialCapacity ?? 1024,
-      options.maxCapacity ?? SCHEDULER_QUEUE_CAPACITY,
-      options.flushBudget ?? FLUSH_BUDGET,
-      options.microThreshold ?? MICRO_THRESHOLD
-    );
-  }
-  enqueue(task, tag) {
-    const ref = this.nextRef++;
-    this.tasks.set(ref, task);
-    this.tags.set(ref, tag);
-    const policy = this.machine.enqueue(ref);
-    if (policy === 3) {
-      this.tasks.delete(ref);
-      this.tags.delete(ref);
-    }
-    return policy;
-  }
-  beginFlush() {
-    return this.machine.begin_flush();
-  }
-  shift() {
-    const ref = this.machine.shift();
-    if (ref === 0) return void 0;
-    const task = this.tasks.get(ref);
-    const tag = this.tags.get(ref) ?? "anonymous";
-    this.tasks.delete(ref);
-    this.tags.delete(ref);
-    return task ? { task, tag } : void 0;
-  }
-  endFlush(ran) {
-    return this.machine.end_flush(ran);
-  }
-  get length() {
-    return this.machine.len();
-  }
-  stats() {
-    return { engine: "wasm", fallbackUsed: false, data: JSON.parse(this.machine.stats_json()) };
-  }
-};
-var Scheduler = class {
-  engine;
-  js;
-  wasm;
-  flushBudget;
-  microThreshold;
-  fallbackUsed;
-  // Cached flush closure — avoids creating a new closure on every requestFlush
-  boundFlush = () => this.flush();
-  constructor(options = {}) {
-    this.flushBudget = options.flushBudget ?? FLUSH_BUDGET;
-    this.microThreshold = options.microThreshold ?? MICRO_THRESHOLD;
-    const requested = options.engine ?? "js";
-    if (requested === "wasm") {
-      this.wasm = new WasmSchedulerState(options);
-      this.engine = "wasm";
-      this.fallbackUsed = false;
-      return;
-    }
-    if (requested === "auto" && resolveWasmScheduler()) {
-      this.wasm = new WasmSchedulerState(options);
-      this.engine = "wasm";
-      this.fallbackUsed = false;
-      return;
-    }
-    this.js = new JsSchedulerState({ ...options, engine: "js" });
-    this.engine = "js";
-    this.fallbackUsed = requested === "auto";
-  }
-  schedule(task, tag = "anonymous") {
-    if (typeof task !== "function") return;
-    if (this.wasm) return this.scheduleWasm(task, tag);
-    this.scheduleJs(task, tag);
-  }
-  stats() {
-    if (this.wasm) return this.wasm.stats();
-    const js = this.js;
-    return {
-      engine: "js",
-      fallbackUsed: this.fallbackUsed,
-      data: {
-        len: js.tasks.length,
-        capacity: js.tasks.capacity,
-        phase: js.flushing ? "flushing" : js.scheduled ? "scheduled" : "idle",
-        scheduledFlushes: js.scheduledFlushes,
-        completedFlushes: js.completedFlushes,
-        enqueuedTasks: js.enqueuedTasks,
-        executedTasks: js.executedTasks,
-        droppedTasks: js.droppedTasks,
-        yieldedByBudget: js.yieldedByBudget
-      }
-    };
-  }
-  scheduleWasm(task, tag) {
-    const policy = this.wasm.enqueue(task, tag);
-    if (policy === 0) this.requestFlush("micro");
-    else if (policy === 1) this.requestFlush("macro");
-  }
-  scheduleJs(task, tag) {
-    const js = this.js;
-    const taskStatus = js.tasks.push(task);
-    const tagStatus = js.tags.push(tag);
-    js.enqueuedTasks++;
-    if ((taskStatus & 2) !== 0 || (tagStatus & 2) !== 0) js.droppedTasks++;
-    if (js.flushing) return;
-    if (!js.scheduled) {
-      js.scheduled = true;
-      js.scheduledFlushes++;
-      const kind = js.tasks.length > this.microThreshold ? "macro" : "micro";
-      this.requestFlush(kind);
-    }
-  }
-  requestFlush(kind) {
-    if (kind === "micro") queueMicrotask(this.boundFlush);
-    else scheduleMacro(this.boundFlush);
-  }
-  flush() {
-    if (this.wasm) return this.flushWasm();
-    this.flushJs();
-  }
-  flushWasm() {
-    const wasm = this.wasm;
-    const budget = wasm.beginFlush();
-    if (budget <= 0) return;
-    let ran = 0;
-    try {
-      while (ran < budget) {
-        const next = wasm.shift();
-        if (!next) break;
-        ran++;
-        try {
-          next.task();
-        } catch (e) {
-          console.error(`[Scheduler] task threw (tag=${next.tag})`, e);
-        }
-      }
-    } finally {
-      const policy = wasm.endFlush(ran);
-      if (policy === 0) this.requestFlush("micro");
-      else if (policy === 1) this.requestFlush("macro");
-    }
-  }
-  flushJs() {
-    const js = this.js;
-    if (js.flushing) return;
-    js.flushing = true;
-    js.scheduled = false;
-    let ran = 0;
-    try {
-      while (ran < this.flushBudget) {
-        const task = js.tasks.shift();
-        if (!task) break;
-        const tag = js.tags.shift();
-        ran++;
-        js.executedTasks++;
-        try {
-          task();
-        } catch (e) {
-          console.error(`[Scheduler] task threw (tag=${tag})`, e);
-        }
-      }
-    } finally {
-      js.flushing = false;
-      js.completedFlushes++;
-      if (js.tasks.length > 0 && !js.scheduled) {
-        js.scheduled = true;
-        js.scheduledFlushes++;
-        const kind = ran >= this.flushBudget || js.tasks.length > this.microThreshold ? "macro" : "micro";
-        if (ran >= this.flushBudget) js.yieldedByBudget++;
-        this.requestFlush(kind);
-      }
-    }
-  }
-};
-var globalScheduler = new Scheduler();
-
-// src/core/runtime/contex.ts
-var emptyContext = { parent: null, patch: /* @__PURE__ */ Object.create(null) };
-
-// src/core/runtime/forkPolicy.ts
-function makeForkPolicy(env, hooks) {
-  const svc = resolveForkServices(env);
-  return {
-    initChild(fiber, parent, scopeId) {
-      const parentCtx = parent?.fiberContext;
-      const trace = forkTrace(svc, parentCtx?.trace ?? null);
-      fiber.fiberContext = {
-        log: parentCtx?.log ?? emptyContext,
-        trace
-      };
-      fiber.parentFiberId = parent?.id;
-      fiber.name = svc.childName(parent?.name);
-      if (scopeId !== void 0) fiber.scopeId = scopeId;
-      hooks.emit(
-        {
-          type: "fiber.start",
-          fiberId: fiber.id,
-          parentFiberId: parent?.id,
-          scopeId: fiber.scopeId,
-          // ✅ ahora viaja
-          name: fiber.name
-        },
-        { fiberId: parent?.id, traceId: parentCtx?.trace?.traceId, spanId: parentCtx?.trace?.spanId }
-      );
-    }
-  };
-}
-function resolveForkServices(env) {
-  const defaultTracer = {
-    newTraceId: () => randomRuntimeId("trace"),
-    newSpanId: () => randomRuntimeId("span")
-  };
-  const brass = env?.brass;
-  const tracer = brass?.tracer ?? defaultTracer;
-  const seed = brass?.traceSeed;
-  const childName = brass?.childName ?? ((p) => p ? `${p}/child` : void 0);
-  return { tracer, seed, childName };
-}
-function randomRuntimeId(prefix) {
-  const cryptoLike = globalThis.crypto;
-  if (typeof cryptoLike?.randomUUID === "function") {
-    return cryptoLike.randomUUID();
-  }
-  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-}
-function forkTrace(svc, parentTrace) {
-  if (parentTrace) {
-    return {
-      traceId: parentTrace.traceId,
-      spanId: svc.tracer.newSpanId(),
-      parentSpanId: parentTrace.spanId,
-      sampled: parentTrace.sampled
-    };
-  }
-  if (svc.seed) return { ...svc.seed };
-  return { traceId: svc.tracer.newTraceId(), spanId: svc.tracer.newSpanId(), sampled: true };
-}
-
-// src/core/runtime/hostAction.ts
-var DefaultHostExecutor = {
-  async execute(action) {
-    return {
-      kind: "error",
-      actionId: action.actionId,
-      error: new Error(`No HostExecutor configured for HostAction kind=${action.kind} target=${action.target}`)
-    };
-  }
-};
-
-// src/core/runtime/engine/JsFiberEngine.ts
-var JsFiberEngine = class {
-  constructor(runtime) {
-    this.runtime = runtime;
-  }
-  runtime;
-  kind = "js";
-  startedFibers = 0;
-  fork(effect, scopeId) {
-    this.startedFibers += 1;
-    const fiber = new RuntimeFiber(this.runtime, effect);
-    if (scopeId !== void 0) fiber.scopeId = scopeId;
-    return fiber;
-  }
-  stats() {
-    return {
-      engine: this.kind,
-      startedFibers: this.startedFibers,
-      runningFibers: 0,
-      suspendedFibers: 0,
-      queuedFibers: 0,
-      completedFibers: 0,
-      failedFibers: 0,
-      interruptedFibers: 0,
-      pendingHostEffects: 0
-    };
-  }
-};
-
-// src/core/runtime/engine/opcodes.ts
-var HostRegistry = class {
-  nextRef = 1;
-  refs = /* @__PURE__ */ new Map();
-  register(value) {
-    const ref = this.nextRef++;
-    this.refs.set(ref, value);
-    return ref;
-  }
-  get(ref) {
-    if (!this.refs.has(ref)) {
-      throw new Error(`Missing host registry ref ${ref}`);
-    }
-    return this.refs.get(ref);
-  }
-  set(ref, value) {
-    this.refs.set(ref, value);
-  }
-  delete(ref) {
-    this.refs.delete(ref);
-  }
-  clear() {
-    this.refs.clear();
-  }
-  size() {
-    return this.refs.size;
-  }
-};
-var ProgramBuilder = class {
-  nodes = [];
-  registry = new HostRegistry();
-  compile(effect) {
-    const root = this.visit(effect);
-    return {
-      program: {
-        version: 1,
-        root,
-        nodes: this.nodes
-      },
-      registry: this.registry
-    };
-  }
-  append(effect) {
-    const previousNodes = this.nodes.length;
-    const root = this.visit(effect);
-    return {
-      root,
-      nodes: this.nodes.slice(previousNodes)
-    };
-  }
-  add(node) {
-    const id = this.nodes.length;
-    this.nodes.push(node);
-    return id;
-  }
-  visit(effect) {
-    const current = effect;
-    switch (current._tag) {
-      case "Succeed":
-        return this.add({ tag: "Succeed", valueRef: this.registry.register(current.value) });
-      case "Fail":
-        return this.add({ tag: "Fail", errorRef: this.registry.register(current.error) });
-      case "Sync":
-        return this.add({ tag: "Sync", fnRef: this.registry.register(current.thunk) });
-      case "Async":
-        return this.add({ tag: "Async", registerRef: this.registry.register(current.register) });
-      case "FlatMap":
-        return this.add({
-          tag: "FlatMap",
-          first: this.visit(current.first),
-          fnRef: this.registry.register(current.andThen)
-        });
-      case "Fold":
-        return this.add({
-          tag: "Fold",
-          first: this.visit(current.first),
-          onFailureRef: this.registry.register(current.onFailure),
-          onSuccessRef: this.registry.register(current.onSuccess)
-        });
-      case "Fork": {
-        const base = {
-          tag: "Fork",
-          effectRef: this.registry.register(current.effect)
-        };
-        return this.add(current.scopeId === void 0 ? base : { ...base, scopeId: current.scopeId });
-      }
-      case "HostAction": {
-        const base = {
-          tag: "HostAction",
-          actionRef: this.registry.register(current.action)
-        };
-        return this.add(current.decode === void 0 ? base : { ...base, decodeRef: this.registry.register(current.decode) });
-      }
-      default:
-        return this.add({ tag: "Fail", errorRef: this.registry.register(new Error(`Unknown Async opcode: ${current?._tag}`)) });
-    }
-  }
-};
-
-// src/core/runtime/engine/FiberHandleImpl.ts
-var EngineFiberHandle = class {
-  constructor(id, runtime, onScheduledStep, onInterrupt, onJoiner, onQueued) {
-    this.onScheduledStep = onScheduledStep;
-    this.onInterrupt = onInterrupt;
-    this.onJoiner = onJoiner;
-    this.onQueued = onQueued;
-    this.id = id;
-    this.runtime = runtime;
-  }
-  onScheduledStep;
-  onInterrupt;
-  onJoiner;
-  onQueued;
-  id;
-  runtime;
-  fiberContext;
-  name;
-  scopeId;
-  parentFiberId;
-  result = null;
-  joiners = [];
-  finalizers = [];
-  finalizersDrained = false;
-  internalStatus = "running";
-  queued = false;
-  status() {
-    if (this.result == null) return "Running";
-    if (this.result._tag === "Failure" && this.result.cause._tag === "Interrupt") return "Interrupted";
-    return "Done";
-  }
-  engineStatus() {
-    return this.internalStatus;
-  }
-  setEngineStatus(status) {
-    this.internalStatus = status;
-  }
-  join(cb) {
-    if (this.result != null) cb(this.result);
-    else {
-      this.onJoiner?.(this.id);
-      this.joiners.push(cb);
-    }
-  }
-  interrupt() {
-    if (this.result != null) return;
-    this.onInterrupt(this.id, Cause.interrupt());
-  }
-  addFinalizer(f) {
-    this.finalizers.push(f);
-  }
-  schedule(tag = "step") {
-    if (this.result != null || this.queued) return;
-    this.queued = true;
-    this.internalStatus = "queued";
-    this.onQueued?.(this.id);
-    this.runtime.scheduler.schedule(() => {
-      this.queued = false;
-      if (this.result != null) return;
-      this.onScheduledStep(this.id);
-    }, `wasm-fiber#${this.id}.${tag}`);
-  }
-  emit(ev) {
-    this.runtime.hooks.emit(ev, {
-      fiberId: this.id,
-      scopeId: this.scopeId,
-      traceId: this.fiberContext?.trace?.traceId,
-      spanId: this.fiberContext?.trace?.spanId
-    });
-  }
-  succeed(value) {
-    this.complete(Exit.succeed(value));
-  }
-  fail(error) {
-    this.complete(Exit.failCause(Cause.fail(error)));
-  }
-  die(defect) {
-    this.complete(Exit.failCause(Cause.die(defect)));
-  }
-  interrupted() {
-    this.complete(Exit.failCause(Cause.interrupt()));
-  }
-  complete(exit) {
-    if (this.result != null) return;
-    this.runFinalizersOnce(exit);
-    this.result = exit;
-    this.internalStatus = exit._tag === "Success" ? "done" : exit.cause._tag === "Interrupt" ? "interrupted" : "failed";
-    const status = exit._tag === "Success" ? "success" : exit.cause._tag === "Interrupt" ? "interrupted" : "failure";
-    this.emit({
-      type: "fiber.end",
-      fiberId: this.id,
-      status,
-      error: exit._tag === "Failure" ? exit.cause : void 0
-    });
-    for (const joiner of this.joiners) joiner(exit);
-    this.joiners.length = 0;
-  }
-  runFinalizersOnce(exit) {
-    if (this.finalizersDrained) return;
-    this.finalizersDrained = true;
-    while (this.finalizers.length > 0) {
-      const finalizer = this.finalizers.pop();
-      try {
-        const eff = finalizer(exit);
-        if (eff && typeof eff === "object" && "_tag" in eff) {
-          this.runtime.fork(eff);
-        }
-      } catch {
-      }
-    }
-  }
-};
-
-// src/core/runtime/engine/bridge/ReferenceWasmBridge.ts
-var ReferenceWasmBridge = class {
-  kind = "wasm-reference";
-  nextFiberId = 1;
-  fibers = /* @__PURE__ */ new Map();
-  started = 0;
-  completed = 0;
-  failed = 0;
-  interrupted = 0;
-  createFiber(program) {
-    const id = this.nextFiberId++;
-    this.started += 1;
-    this.fibers.set(id, {
-      id,
-      program: cloneProgram(program),
-      current: program.root,
-      stack: [],
-      status: "running",
-      lastEvent: void 0
-    });
-    return id;
-  }
-  poll(fiberId) {
-    const fiber = this.mustFiber(fiberId);
-    if (fiber.status === "suspended" && fiber.lastEvent) return fiber.lastEvent;
-    return this.step(fiber);
-  }
-  provideValue(fiberId, valueRef) {
-    const fiber = this.mustFiber(fiberId);
-    fiber.status = "running";
-    fiber.lastEvent = void 0;
-    return this.success(fiber, valueRef);
-  }
-  provideError(fiberId, errorRef) {
-    const fiber = this.mustFiber(fiberId);
-    fiber.status = "running";
-    fiber.lastEvent = void 0;
-    return this.failure(fiber, errorRef);
-  }
-  provideEffect(fiberId, root, nodes) {
-    const fiber = this.mustFiber(fiberId);
-    fiber.status = "running";
-    fiber.lastEvent = void 0;
-    fiber.program.nodes.push(...nodes.map((node) => ({ ...node })));
-    fiber.current = root;
-    return this.step(fiber);
-  }
-  interrupt(fiberId, reasonRef) {
-    const fiber = this.mustFiber(fiberId);
-    fiber.status = "interrupted";
-    fiber.current = void 0;
-    fiber.stack = [];
-    this.interrupted += 1;
-    const event = { kind: "Interrupted", fiberId, reasonRef };
-    fiber.lastEvent = event;
-    return event;
-  }
-  dropFiber(fiberId) {
-    this.fibers.delete(fiberId);
-  }
-  stats() {
-    let running = 0;
-    let suspended = 0;
-    for (const fiber of this.fibers.values()) {
-      if (fiber.status === "running") running += 1;
-      if (fiber.status === "suspended") suspended += 1;
-    }
-    return {
-      started: this.started,
-      live: this.fibers.size,
-      running,
-      suspended,
-      completed: this.completed,
-      failed: this.failed,
-      interrupted: this.interrupted
-    };
-  }
-  mustFiber(fiberId) {
-    const fiber = this.fibers.get(fiberId);
-    if (!fiber) throw new Error(`Fiber ${fiberId} not found`);
-    return fiber;
-  }
-  step(fiber) {
-    while (true) {
-      if (fiber.status === "interrupted") {
-        const event = fiber.lastEvent ?? { kind: "Interrupted", fiberId: fiber.id, reasonRef: 0 };
-        fiber.lastEvent = event;
-        return event;
-      }
-      if (fiber.current === void 0) return this.markFailed(fiber, 0);
-      const node = fiber.program.nodes[fiber.current];
-      if (!node) return this.markFailed(fiber, 0);
-      switch (node.tag) {
-        case "Succeed":
-          fiber.current = void 0;
-          return this.success(fiber, node.valueRef);
-        case "Fail":
-          fiber.current = void 0;
-          return this.failure(fiber, node.errorRef);
-        case "Sync":
-          return this.suspend(fiber, { kind: "InvokeSync", fiberId: fiber.id, fnRef: node.fnRef });
-        case "Async":
-          return this.suspend(fiber, { kind: "InvokeAsync", fiberId: fiber.id, registerRef: node.registerRef });
-        case "FlatMap":
-          fiber.stack.push({ tag: "SuccessCont", fnRef: node.fnRef });
-          fiber.current = node.first;
-          continue;
-        case "Fold":
-          fiber.stack.push({ tag: "FoldCont", onFailureRef: node.onFailureRef, onSuccessRef: node.onSuccessRef });
-          fiber.current = node.first;
-          continue;
-        case "Fork": {
-          const event = node.scopeId === void 0 ? { kind: "InvokeFork", fiberId: fiber.id, effectRef: node.effectRef } : { kind: "InvokeFork", fiberId: fiber.id, effectRef: node.effectRef, scopeId: node.scopeId };
-          return this.suspend(fiber, event);
-        }
-        case "HostAction": {
-          const event = node.decodeRef === void 0 ? { kind: "InvokeHostAction", fiberId: fiber.id, actionRef: node.actionRef } : { kind: "InvokeHostAction", fiberId: fiber.id, actionRef: node.actionRef, decodeRef: node.decodeRef };
-          return this.suspend(fiber, event);
-        }
-      }
-    }
-  }
-  success(fiber, valueRef) {
-    const frame = fiber.stack.pop();
-    if (!frame) return this.markDone(fiber, valueRef);
-    if (frame.tag === "SuccessCont") {
-      return this.suspend(fiber, { kind: "InvokeFlatMap", fiberId: fiber.id, fnRef: frame.fnRef, valueRef });
-    }
-    return this.suspend(fiber, { kind: "InvokeFoldSuccess", fiberId: fiber.id, fnRef: frame.onSuccessRef, valueRef });
-  }
-  failure(fiber, errorRef) {
-    while (fiber.stack.length > 0) {
-      const frame = fiber.stack.pop();
-      if (frame.tag === "FoldCont") {
-        return this.suspend(fiber, { kind: "InvokeFoldFailure", fiberId: fiber.id, fnRef: frame.onFailureRef, errorRef });
-      }
-    }
-    return this.markFailed(fiber, errorRef);
-  }
-  suspend(fiber, event) {
-    fiber.status = "suspended";
-    fiber.lastEvent = event;
-    return event;
-  }
-  markDone(fiber, valueRef) {
-    fiber.status = "done";
-    fiber.current = void 0;
-    this.completed += 1;
-    const event = { kind: "Done", fiberId: fiber.id, valueRef };
-    fiber.lastEvent = event;
-    return event;
-  }
-  markFailed(fiber, errorRef) {
-    fiber.status = "failed";
-    fiber.current = void 0;
-    this.failed += 1;
-    const event = { kind: "Failed", fiberId: fiber.id, errorRef };
-    fiber.lastEvent = event;
-    return event;
-  }
-};
-function cloneProgram(program) {
-  return {
-    version: program.version,
-    root: program.root,
-    nodes: program.nodes.map((node) => ({ ...node }))
-  };
-}
-
-// src/core/runtime/engine/bridge/WasmPackFiberBridge.ts
-var WasmPackFiberBridge = class {
-  kind = "wasm";
-  vm;
-  constructor(modulePath) {
-    const mod = loadWasmModule(modulePath);
-    this.vm = new mod.BrassWasmVm();
-  }
-  createFiber(program) {
-    return this.vm.create_fiber(JSON.stringify(program));
-  }
-  poll(fiberId) {
-    return JSON.parse(this.vm.poll(fiberId));
-  }
-  provideValue(fiberId, valueRef) {
-    return JSON.parse(this.vm.provide_value(fiberId, valueRef));
-  }
-  provideError(fiberId, errorRef) {
-    return JSON.parse(this.vm.provide_error(fiberId, errorRef));
-  }
-  provideEffect(fiberId, root, nodes) {
-    return JSON.parse(this.vm.provide_effect(fiberId, root, JSON.stringify(nodes)));
-  }
-  interrupt(fiberId, reasonRef) {
-    return JSON.parse(this.vm.interrupt(fiberId, reasonRef));
-  }
-  dropFiber(fiberId) {
-    this.vm.drop_fiber(fiberId);
-  }
-  stats() {
-    return JSON.parse(this.vm.stats_json());
-  }
-};
-function loadWasmModule(modulePath) {
-  const mod = resolveWasmModule({ modulePath });
-  if (mod) return mod;
-  const errors = wasmModuleResolutionErrors();
-  throw new Error([
-    "engine='wasm' could not load wasm/pkg/brass_runtime_wasm_engine.js.",
-    "Run `npm run build:wasm` first and make sure wasm/pkg is present in the package.",
-    "For Node 18 + webpack, keep brass-runtime's wasm/pkg files available at runtime or externalize brass-runtime.",
-    ...errors.map((error) => `- ${error}`)
-  ].join("\n"));
-}
-
-// src/core/runtime/engine/bridge/WasmFiberRegistryBridge.ts
-var FIBER_STATE_QUEUED = 0;
-var FIBER_STATE_RUNNING = 1;
-var FIBER_STATE_SUSPENDED = 2;
-var FIBER_STATE_DONE = 3;
-var FIBER_STATE_FAILED = 4;
-var FIBER_STATE_INTERRUPTED = 5;
-var WasmFiberRegistryBridge = class {
-  registry;
-  constructor() {
-    const mod = resolveWasmModule();
-    const Ctor = mod?.BrassWasmFiberRegistry;
-    if (!Ctor) {
-      throw new Error("brass-runtime wasm fiber registry is not available. Run npm run build:wasm first.");
-    }
-    this.registry = new Ctor();
-  }
-  registerFiber(fiberId, parentId, scopeId) {
-    this.registry.register_fiber(fiberId, parentId ?? 0, scopeId ?? 0, Date.now());
-  }
-  markQueued(fiberId) {
-    this.registry.mark_queued(fiberId, Date.now());
-  }
-  markRunning(fiberId) {
-    this.registry.mark_running(fiberId, Date.now());
-  }
-  markSuspended(fiberId) {
-    this.registry.mark_suspended(fiberId, Date.now());
-  }
-  markDone(fiberId, status) {
-    return this.registry.mark_done(fiberId, statusToCode(status), Date.now());
-  }
-  dropFiber(fiberId) {
-    this.registry.drop_fiber(fiberId);
-  }
-  addJoiner(fiberId) {
-    this.registry.add_joiner(fiberId);
-  }
-  wake(fiberId) {
-    return this.registry.wake(fiberId);
-  }
-  drainWakeup() {
-    const id = this.registry.drain_wakeup();
-    return id === 0 ? void 0 : id;
-  }
-  drainWakeups() {
-    const ids = [];
-    for (; ; ) {
-      const id = this.drainWakeup();
-      if (id === void 0) return ids;
-      ids.push(id);
-    }
-  }
-  wakeQueueLength() {
-    return this.registry.wake_queue_len();
-  }
-  stateOf(fiberId) {
-    const code = this.registry.state_of(fiberId);
-    if (code === 4294967295) return "missing";
-    return codeToStatus(code);
-  }
-  stats() {
-    return JSON.parse(this.registry.stats_json());
-  }
-};
-function statusToCode(status) {
-  switch (status) {
-    case "queued":
-      return FIBER_STATE_QUEUED;
-    case "running":
-      return FIBER_STATE_RUNNING;
-    case "suspended":
-      return FIBER_STATE_SUSPENDED;
-    case "done":
-      return FIBER_STATE_DONE;
-    case "failed":
-      return FIBER_STATE_FAILED;
-    case "interrupted":
-      return FIBER_STATE_INTERRUPTED;
-  }
-}
-function codeToStatus(code) {
-  switch (code) {
-    case FIBER_STATE_QUEUED:
-      return "queued";
-    case FIBER_STATE_RUNNING:
-      return "running";
-    case FIBER_STATE_SUSPENDED:
-      return "suspended";
-    case FIBER_STATE_DONE:
-      return "done";
-    case FIBER_STATE_FAILED:
-      return "failed";
-    case FIBER_STATE_INTERRUPTED:
-      return "interrupted";
-    default:
-      return "missing";
-  }
-}
-
-// src/core/runtime/engine/WasmFiberEngine.ts
-var DEFAULT_BUDGET = 4096;
-var WasmFiberEngine = class {
-  constructor(runtime, options = {}) {
-    this.runtime = runtime;
-    this.bridge = options.bridge ?? (options.reference ? new ReferenceWasmBridge() : new WasmPackFiberBridge(options.modulePath));
-    this.kind = this.bridge.kind;
-    this.fiberRegistry = this.kind === "wasm" ? new WasmFiberRegistryBridge() : void 0;
-  }
-  runtime;
-  kind;
-  bridge;
-  startedFibers = 0;
-  runningFibers = 0;
-  suspendedFibers = 0;
-  completedFibers = 0;
-  failedFibers = 0;
-  interruptedFibers = 0;
-  pendingHostEffects = 0;
-  states = /* @__PURE__ */ new Map();
-  fiberRegistry;
-  fork(effect, scopeId) {
-    const builder = new ProgramBuilder();
-    const compiled = builder.compile(effect);
-    const fiberId = this.bridge.createFiber(compiled.program);
-    const controller = new AbortController();
-    const handle = new EngineFiberHandle(
-      fiberId,
-      this.runtime,
-      (id) => this.scheduleWakeup(id),
-      (id, reason) => this.interruptById(id, reason),
-      (id) => this.fiberRegistry?.addJoiner(id),
-      (id) => this.fiberRegistry?.markQueued(id)
-    );
-    if (scopeId !== void 0) handle.scopeId = scopeId;
-    const state = {
-      fiberId,
-      handle,
-      builder,
-      registry: compiled.registry,
-      controller,
-      startedAt: Date.now(),
-      completed: false,
-      status: "running",
-      pendingCleanups: /* @__PURE__ */ new Set()
-    };
-    this.states.set(fiberId, state);
-    this.fiberRegistry?.registerFiber(fiberId, void 0, scopeId);
-    this.startedFibers += 1;
-    this.runningFibers += 1;
-    return handle;
-  }
-  stats() {
-    let hostRefs = 0;
-    for (const state of this.states.values()) hostRefs += state.registry.size();
-    return {
-      engine: this.kind,
-      startedFibers: this.startedFibers,
-      runningFibers: this.runningFibers,
-      suspendedFibers: this.suspendedFibers,
-      queuedFibers: 0,
-      completedFibers: this.completedFibers,
-      failedFibers: this.failedFibers,
-      interruptedFibers: this.interruptedFibers,
-      pendingHostEffects: this.pendingHostEffects,
-      hostRegistryRefs: hostRefs,
-      wasm: this.bridge.stats(),
-      fiberRegistry: this.fiberRegistry?.stats()
-    };
-  }
-  async shutdown() {
-    for (const state of Array.from(this.states.values())) {
-      this.interruptState(state, Cause.interrupt());
-    }
-  }
-  scheduleWakeup(fiberId) {
-    const state = this.states.get(fiberId);
-    if (!state || state.completed) return;
-    if (!this.fiberRegistry) {
-      this.driveById(fiberId);
-      return;
-    }
-    if (!this.fiberRegistry.wake(fiberId)) return;
-    this.drainWakeups();
-  }
-  drainWakeups() {
-    if (!this.fiberRegistry) return;
-    for (const fiberId of this.fiberRegistry.drainWakeups()) {
-      this.driveById(fiberId);
-    }
-  }
-  driveById(fiberId) {
-    const state = this.states.get(fiberId);
-    if (!state || state.completed) return;
-    this.fiberRegistry?.markRunning(fiberId);
-    withCurrentFiber(state.handle, () => this.drive(state));
-  }
-  drive(state, initialEvent) {
-    if (state.completed) return;
-    let budget = DEFAULT_BUDGET;
-    let event = initialEvent ?? this.bridge.poll(state.fiberId);
-    state.status = "running";
-    state.handle.setEngineStatus("running");
-    while (!state.completed && budget-- > 0) {
-      try {
-        switch (event.kind) {
-          case "Continue":
-            event = this.bridge.poll(state.fiberId);
-            continue;
-          case "Done": {
-            const value = state.registry.get(event.valueRef);
-            this.completeSuccess(state, value);
-            return;
-          }
-          case "Failed": {
-            const error = event.errorRef === 0 ? new Error("WASM fiber failed") : state.registry.get(event.errorRef);
-            this.completeFailure(state, error);
-            return;
-          }
-          case "Interrupted": {
-            this.completeInterrupted(state);
-            return;
-          }
-          case "InvokeSync": {
-            const fn = state.registry.get(event.fnRef);
-            try {
-              const valueRef = state.registry.register(fn(this.runtime.env));
-              event = this.bridge.provideValue(state.fiberId, valueRef);
-            } catch (error) {
-              event = this.bridge.provideError(state.fiberId, state.registry.register(error));
-            }
-            continue;
-          }
-          case "InvokeFlatMap": {
-            const fn = state.registry.get(event.fnRef);
-            const value = state.registry.get(event.valueRef);
-            try {
-              const next = fn(value);
-              const patch = state.builder.append(next);
-              event = this.bridge.provideEffect(state.fiberId, patch.root, patch.nodes);
-            } catch (error) {
-              event = this.bridge.provideError(state.fiberId, state.registry.register(error));
-            }
-            continue;
-          }
-          case "InvokeFoldFailure": {
-            const fn = state.registry.get(event.fnRef);
-            const errorValue = state.registry.get(event.errorRef);
-            try {
-              const next = fn(errorValue);
-              const patch = state.builder.append(next);
-              event = this.bridge.provideEffect(state.fiberId, patch.root, patch.nodes);
-            } catch (error) {
-              event = this.bridge.provideError(state.fiberId, state.registry.register(error));
-            }
-            continue;
-          }
-          case "InvokeFoldSuccess": {
-            const fn = state.registry.get(event.fnRef);
-            const value = state.registry.get(event.valueRef);
-            try {
-              const next = fn(value);
-              const patch = state.builder.append(next);
-              event = this.bridge.provideEffect(state.fiberId, patch.root, patch.nodes);
-            } catch (error) {
-              event = this.bridge.provideError(state.fiberId, state.registry.register(error));
-            }
-            continue;
-          }
-          case "InvokeFork": {
-            const effect = state.registry.get(event.effectRef);
-            try {
-              const child = this.runtime.fork(effect, event.scopeId);
-              event = this.bridge.provideValue(state.fiberId, state.registry.register(child));
-            } catch (error) {
-              event = this.bridge.provideError(state.fiberId, state.registry.register(error));
-            }
-            continue;
-          }
-          case "InvokeAsync": {
-            this.scheduleAsync(state, event.registerRef);
-            return;
-          }
-          case "InvokeHostAction": {
-            this.scheduleHostAction(state, event.actionRef, event.decodeRef);
-            return;
-          }
-        }
-      } catch (error) {
-        event = this.bridge.provideError(state.fiberId, state.registry.register(error));
-      }
-    }
-    if (!state.completed) state.handle.schedule("budget-yield");
-  }
-  scheduleAsync(state, registerRef) {
-    this.markSuspended(state, "async");
-    this.pendingHostEffects += 1;
-    const register = state.registry.get(registerRef);
-    let done = false;
-    let asyncRegistered = false;
-    let syncExit = null;
-    const cleanup = () => {
-      done = true;
-      state.pendingCleanups.delete(cleanup);
-    };
-    state.pendingCleanups.add(cleanup);
-    const cb = (exitLike) => {
-      if (done) return;
-      const exit = exitLike;
-      if (!asyncRegistered) {
-        syncExit = exit;
-        return;
-      }
-      cleanup();
-      this.pendingHostEffects = Math.max(0, this.pendingHostEffects - 1);
-      this.markRunning(state, "async");
-      this.resumeWithExit(state, exit);
-    };
-    try {
-      const canceler = register(this.runtime.env, cb);
-      asyncRegistered = true;
-      if (syncExit) {
-        cleanup();
-        this.pendingHostEffects = Math.max(0, this.pendingHostEffects - 1);
-        this.markRunning(state, "async-sync");
-        this.resumeWithExit(state, syncExit);
-        return;
-      }
-      if (typeof canceler === "function") {
-        const cancelCleanup = () => {
-          if (done) return;
-          done = true;
-          try {
-            canceler();
-          } catch {
-          }
-          state.pendingCleanups.delete(cancelCleanup);
-        };
-        state.pendingCleanups.add(cancelCleanup);
-        state.handle.addFinalizer(() => cancelCleanup());
-      }
-    } catch (error) {
-      cleanup();
-      this.pendingHostEffects = Math.max(0, this.pendingHostEffects - 1);
-      this.markRunning(state, "async-register-error");
-      this.resumeWithError(state, error);
-    }
-  }
-  scheduleHostAction(state, actionRef, decodeRef) {
-    this.markSuspended(state, "host-action");
-    this.pendingHostEffects += 1;
-    const action = state.registry.get(actionRef);
-    const startedAt = Date.now();
-    const cleanup = () => {
-      state.pendingCleanups.delete(cleanup);
-    };
-    state.pendingCleanups.add(cleanup);
-    this.runtime.hostExecutor.execute(action, {
-      fiberId: state.fiberId,
-      env: this.runtime.env,
-      signal: state.controller.signal,
-      deadlineAt: action.timeoutMs === void 0 ? void 0 : Date.now() + action.timeoutMs
-    }).then((result) => {
-      cleanup();
-      if (state.completed) return;
-      this.pendingHostEffects = Math.max(0, this.pendingHostEffects - 1);
-      this.markRunning(state, "host-action");
-      try {
-        if (decodeRef !== void 0) {
-          const decode = state.registry.get(decodeRef);
-          this.resumeWithValue(state, decode(result));
-          return;
-        }
-        if (result.kind === "error") {
-          this.resumeWithError(state, result.error);
-          return;
-        }
-        this.resumeWithValue(state, result.value);
-      } catch (error) {
-        this.resumeWithError(state, error);
-      }
-    }).catch((error) => {
-      cleanup();
-      if (state.completed) return;
-      this.pendingHostEffects = Math.max(0, this.pendingHostEffects - 1);
-      this.markRunning(state, "host-action-error");
-      this.resumeWithError(state, error);
-    });
-  }
-  resumeWithExit(state, exit) {
-    if (state.completed) return;
-    if (exit._tag === "Success") {
-      this.resumeWithValue(state, exit.value);
-      return;
-    }
-    const cause = exit.cause;
-    if (cause._tag === "Interrupt") {
-      this.interruptState(state, cause);
-      return;
-    }
-    if (cause._tag === "Fail") {
-      this.resumeWithError(state, cause.error);
-      return;
-    }
-    this.completeDie(state, cause.defect);
-  }
-  resumeWithValue(state, value) {
-    const event = this.bridge.provideValue(state.fiberId, state.registry.register(value));
-    this.runtime.scheduler.schedule(() => withCurrentFiber(state.handle, () => this.drive(state, event)), `wasm-fiber#${state.fiberId}.resume`);
-  }
-  resumeWithError(state, error) {
-    const event = this.bridge.provideError(state.fiberId, state.registry.register(error));
-    this.runtime.scheduler.schedule(() => withCurrentFiber(state.handle, () => this.drive(state, event)), `wasm-fiber#${state.fiberId}.resume-error`);
-  }
-  interruptById(fiberId, reason) {
-    const state = this.states.get(fiberId);
-    if (!state) return;
-    this.interruptState(state, reason);
-  }
-  interruptState(state, reason) {
-    if (state.completed) return;
-    if (!state.controller.signal.aborted) state.controller.abort(reason);
-    for (const cleanup of Array.from(state.pendingCleanups)) cleanup();
-    const event = this.bridge.interrupt(state.fiberId, state.registry.register(reason));
-    this.drive(state, event);
-  }
-  markSuspended(state, reason) {
-    if (state.status !== "suspended") {
-      this.suspendedFibers += 1;
-      state.status = "suspended";
-      this.fiberRegistry?.markSuspended(state.fiberId);
-      state.handle.setEngineStatus("suspended");
-      state.handle.emit({ type: "fiber.suspend", fiberId: state.fiberId, reason });
-    }
-  }
-  markRunning(state, _reason) {
-    if (state.status === "suspended") {
-      this.suspendedFibers = Math.max(0, this.suspendedFibers - 1);
-      state.status = "running";
-      this.fiberRegistry?.markRunning(state.fiberId);
-      state.handle.setEngineStatus("running");
-      state.handle.emit({ type: "fiber.resume", fiberId: state.fiberId });
-    }
-  }
-  completeSuccess(state, value) {
-    if (state.completed) return;
-    state.completed = true;
-    state.status = "done";
-    this.fiberRegistry?.markDone(state.fiberId, "done");
-    this.completedFibers += 1;
-    this.cleanupState(state);
-    state.handle.succeed(value);
-  }
-  completeFailure(state, error) {
-    if (state.completed) return;
-    state.completed = true;
-    state.status = "failed";
-    this.fiberRegistry?.markDone(state.fiberId, "failed");
-    this.failedFibers += 1;
-    this.cleanupState(state);
-    state.handle.fail(error);
-  }
-  completeDie(state, defect) {
-    if (state.completed) return;
-    state.completed = true;
-    state.status = "failed";
-    this.fiberRegistry?.markDone(state.fiberId, "failed");
-    this.failedFibers += 1;
-    this.cleanupState(state);
-    state.handle.die(defect);
-  }
-  completeInterrupted(state) {
-    if (state.completed) return;
-    state.completed = true;
-    state.status = "interrupted";
-    this.fiberRegistry?.markDone(state.fiberId, "interrupted");
-    this.interruptedFibers += 1;
-    this.cleanupState(state);
-    state.handle.interrupted();
-  }
-  cleanupState(state) {
-    this.runningFibers = Math.max(0, this.runningFibers - 1);
-    if (state.status === "suspended") this.suspendedFibers = Math.max(0, this.suspendedFibers - 1);
-    for (const cleanup of Array.from(state.pendingCleanups)) cleanup();
-    state.pendingCleanups.clear();
-    this.bridge.dropFiber(state.fiberId);
-    this.fiberRegistry?.dropFiber(state.fiberId);
-    state.registry.clear();
-    this.states.delete(state.fiberId);
-  }
-};
-
-// src/core/runtime/capabilities.ts
-function runtimeCapabilities() {
-  const mod = resolveWasmModule();
-  return {
-    wasmAvailable: !!mod,
-    wasmFiberEngine: typeof mod?.BrassWasmVm === "function",
-    wasmRingBuffer: typeof mod?.BrassWasmRingBuffer === "function",
-    wasmScheduler: typeof mod?.BrassWasmSchedulerStateMachine === "function",
-    wasmFiberRegistry: typeof mod?.BrassWasmFiberRegistry === "function",
-    wasmStreamChunks: typeof mod?.BrassWasmChunkBuffer === "function"
-  };
-}
-
-// src/core/runtime/runtime.ts
-var NoopHooks = {
-  emit() {
-  }
-};
-var Runtime = class _Runtime {
-  env;
-  scheduler;
-  hooks;
-  hostExecutor;
-  engineMode;
-  wasmOptions;
-  fiberEngine;
-  fallbackUsed;
-  forkPolicy;
-  // opcional: registry para observabilidad
-  registry;
-  constructor(args) {
-    this.env = args.env;
-    this.scheduler = args.scheduler ?? globalScheduler;
-    this.hooks = args.hooks ?? NoopHooks;
-    this.hostExecutor = args.hostExecutor ?? DefaultHostExecutor;
-    this.engineMode = args.engine ?? "auto";
-    this.wasmOptions = args.wasm;
-    this.forkPolicy = makeForkPolicy(this.env, this.hooks);
-    const selected = this.makeFiberEngine(this.engineMode, args.wasm);
-    this.fiberEngine = selected.engine;
-    this.fallbackUsed = selected.fallbackUsed;
-  }
-  makeFiberEngine(mode, wasm) {
-    if (mode === "js") return { engine: new JsFiberEngine(this), fallbackUsed: false };
-    if (mode === "wasm-reference") return { engine: new WasmFiberEngine(this, { ...wasm, reference: true }), fallbackUsed: false };
-    if (mode === "wasm") return { engine: new WasmFiberEngine(this, wasm), fallbackUsed: false };
-    try {
-      const capabilities = runtimeCapabilities();
-      if (capabilities.wasmFiberEngine) {
-        return { engine: new WasmFiberEngine(this, wasm), fallbackUsed: false };
-      }
-    } catch {
-    }
-    return { engine: new JsFiberEngine(this), fallbackUsed: true };
-  }
-  /** Returns true when the runtime has real hooks (not the no-op singleton). */
-  hasActiveHooks() {
-    return this.hooks !== NoopHooks;
-  }
-  /** Deriva un runtime con env extendido (estilo provide/locally) */
-  provide(env) {
-    return new _Runtime({
-      env: Object.assign({}, this.env, env),
-      scheduler: this.scheduler,
-      hooks: this.hooks,
-      engine: this.engineMode,
-      hostExecutor: this.hostExecutor,
-      wasm: this.wasmOptions
-    });
-  }
-  emit(ev) {
-    if (this.hooks === NoopHooks) return;
-    const f = getCurrentFiber();
-    const ctx = {
-      fiberId: f?.id,
-      scopeId: f?.scopeId,
-      // ✅ FIX: era f?.scope
-      traceId: f?.fiberContext?.trace?.traceId,
-      spanId: f?.fiberContext?.trace?.spanId
-    };
-    this.hooks.emit(ev, ctx);
-  }
-  /**
-   * ✅ CAMBIO: fork(effect, scopeId?) y pasa scopeId a forkPolicy
-   */
-  fork(effect, scopeId) {
-    const parent = getCurrentFiber();
-    const fiber = this.fiberEngine.fork(effect, scopeId);
-    if (scopeId !== void 0) fiber.scopeId = scopeId;
-    this.forkPolicy.initChild(fiber, parent, scopeId);
-    fiber.schedule?.("initial-step");
-    return fiber;
-  }
-  stats() {
-    const data = this.fiberEngine.stats();
-    const engine = this.fiberEngine.kind === "js" ? "js" : "wasm";
-    return { engine, fallbackUsed: this.fallbackUsed, data };
-  }
-  capabilities() {
-    return runtimeCapabilities();
-  }
-  shutdown() {
-    return this.fiberEngine.shutdown?.();
-  }
-  unsafeRunAsync(effect, cb) {
-    const fiber = this.fork(effect);
-    fiber.join(cb);
-  }
-  toPromise(effect) {
-    return new Promise((resolve, reject) => {
-      const fiber = this.fork(effect);
-      fiber.join((exit) => {
-        if (exit._tag === "Success") resolve(exit.value);
-        else {
-          const c = exit.cause;
-          if (c?._tag === "Fail") reject(c.error);
-          else reject(new Error("Interrupted"));
-        }
-      });
-    });
-  }
-  // helper: correr un efecto y “tirar” el resultado
-  unsafeRun(effect) {
-    this.unsafeRunAsync(effect, () => {
-    });
-  }
-  delay(ms, eff) {
-    return async((_env, cb) => {
-      const handle = setTimeout(() => {
-        this.unsafeRunAsync(eff, cb);
-      }, ms);
-      return () => clearTimeout(handle);
-    });
-  }
-  // util para crear runtime default
-  static make(env, scheduler = globalScheduler) {
-    return new _Runtime({ env, scheduler });
-  }
-  static makeWithEngine(env, engine, options = {}) {
-    return new _Runtime({ ...options, env, engine });
-  }
-  /** Convenience logger: emits a RuntimeEvent of type "log". */
-  log(level, message, fields) {
-    this.emit({ type: "log", level, message, fields });
-  }
-};
-function fork(effect, env) {
-  return Runtime.make(env ?? {}).fork(effect);
-}
-function unsafeRunAsync(effect, env, cb) {
-  Runtime.make(env ?? {}).unsafeRunAsync(effect, cb);
-}
-function toPromise(effect, env) {
-  return Runtime.make(env ?? {}).toPromise(effect);
-}
-function fromPromiseAbortable(make, onReject) {
-  return {
-    _tag: "Async",
-    register: (env, cb) => {
-      const controller = new AbortController();
-      let done = false;
-      make(controller.signal, env).then((value) => {
-        if (done) return;
-        done = true;
-        cb(Exit.succeed(value));
-      }).catch((err) => {
-        if (done) return;
-        done = true;
-        cb(Exit.failCause(Cause.fail(onReject(err))));
-      });
-      return () => {
-        if (done) return;
-        done = true;
-        controller.abort();
-        cb(Exit.failCause(Cause.interrupt()));
-      };
-    }
-  };
-}
-function unsafeRunFoldWithEnv(eff, env, onFailure, onSuccess) {
-  unsafeRunAsync(eff, env, (ex) => {
-    if (ex._tag === "Failure") onFailure(ex.cause);
-    else onSuccess(ex.value);
-  });
-}
-
-// src/core/runtime/fiber.ts
-var _current = null;
-var STEP = {
-  CONTINUE: "Continue",
-  SUSPEND: "Suspend",
-  DONE: "Done"
-};
-var RUN = {
-  QUEUED: "Queued",
-  RUNNING: "Running",
-  SUSPENDED: "Suspended",
-  DONE: "Done"
-};
-var nextId = 1;
-var DEFAULT_BUDGET2 = 4096;
-var __benchmarkBudget;
-function setBenchmarkBudget(budget) {
-  __benchmarkBudget = budget;
-}
-function getBenchmarkBudget() {
-  return __benchmarkBudget;
-}
-function reassociateFlatMap(cur) {
-  let current = cur;
-  while (current._tag === "FlatMap" && current.first?._tag === "FlatMap") {
-    const inner = current.first;
-    const g = current.andThen;
-    current = {
-      _tag: "FlatMap",
-      first: inner.first,
-      andThen: (a) => ({
-        _tag: "FlatMap",
-        first: inner.andThen(a),
-        andThen: g
-      })
-    };
-  }
-  return current;
-}
-var RuntimeFiber = class {
-  id;
-  // 👇 CLAVE: guardar el runtime en el fiber (para getCurrentRuntime())
-  runtime;
-  closing = null;
-  finishing = false;
-  runState = RUN.RUNNING;
-  interrupted = false;
-  result = null;
-  joiners = [];
-  // estado de evaluación
-  current;
-  stack = [];
-  fiberFinalizers = [];
-  finalizersDrained = false;
-  fiberContext;
-  name;
-  scopeId;
-  /**
-   * Cached closure for the scheduler callback — avoids creating a new
-   * closure on every `schedule()` call.  The tag parameter used by the
-   * scheduler is only part of the label string, not the callback logic,
-   * so a single cached closure is sufficient.
-   */
-  boundStep;
-  constructor(runtime, effect) {
-    this.id = nextId++;
-    this.runtime = runtime;
-    this.current = effect;
-    this.boundStep = () => {
-      withCurrentFiber(this, () => {
-        if (this.runState === RUN.DONE) return;
-        this.runState = RUN.RUNNING;
-        const decision = this.step();
-        switch (decision) {
-          case STEP.CONTINUE:
-            this.schedule("continue");
-            return;
-          case STEP.SUSPEND:
-            this.runState = RUN.SUSPENDED;
-            this.emit({ type: "fiber.suspend", fiberId: this.id });
-            return;
-          case STEP.DONE:
-            this.runState = RUN.DONE;
-            return;
-        }
-      });
-    };
-  }
-  // helpers para no tocar el resto del código
-  get env() {
-    return this.runtime.env;
-  }
-  get scheduler() {
-    return this.runtime.scheduler ?? globalScheduler;
-  }
-  emit(ev) {
-    this.runtime.hooks.emit(ev, {
-      fiberId: this.id,
-      scopeId: this.scopeId,
-      traceId: this.fiberContext?.trace?.traceId,
-      spanId: this.fiberContext?.trace?.spanId
-    });
-  }
-  addFinalizer(f) {
-    this.fiberFinalizers.push(f);
-  }
-  status() {
-    if (this.result == null) return "Running";
-    if (this.result._tag === "Failure" && this.result.cause._tag === "Interrupt") return "Interrupted";
-    return "Done";
-  }
-  join(cb) {
-    if (this.result != null) cb(this.result);
-    else this.joiners.push(cb);
-  }
-  interrupt() {
-    if (this.result != null) return;
-    if (this.interrupted) return;
-    this.interrupted = true;
-    this.schedule("interrupt-step");
-  }
-  schedule(tag = "step") {
-    if (this.runState === RUN.DONE || this.runState === RUN.QUEUED) return;
-    if (this.runState === RUN.SUSPENDED) {
-      this.emit({ type: "fiber.resume", fiberId: this.id });
-    }
-    this.runState = RUN.QUEUED;
-    this.scheduler.schedule(
-      this.boundStep,
-      `fiber#${this.id}.${tag}`
-    );
-  }
-  runFinalizersOnce(exit) {
-    if (this.finalizersDrained) return;
-    this.finalizersDrained = true;
-    while (this.fiberFinalizers.length > 0) {
-      const fin = this.fiberFinalizers.pop();
-      try {
-        const eff = fin(exit);
-        if (eff && typeof eff === "object" && "_tag" in eff) {
-          unsafeRunAsync(eff, this.env, () => {
-          });
-        }
-      } catch {
-      }
-    }
-  }
-  notify(exit) {
-    if (this.result != null) return;
-    if (this.closing != null) return;
-    this.finishing = true;
-    this.closing = exit;
-    this.runFinalizersOnce(exit);
-    this.result = exit;
-    const status = exit._tag === "Success" ? "success" : exit.cause._tag === "Interrupt" ? "interrupted" : "failure";
-    this.emit({
-      type: "fiber.end",
-      fiberId: this.id,
-      status,
-      error: exit._tag === "Failure" ? exit.cause : void 0
-    });
-    for (const j of this.joiners) j(exit);
-    this.joiners.length = 0;
-  }
-  onSuccess(value) {
-    const frame = this.stack.pop();
-    if (!frame) {
-      this.notify(Exit.succeed(value));
-      return;
-    }
-    if (frame._tag === "SuccessCont") {
-      try {
-        this.current = frame.k(value);
-      } catch (e) {
-        this.notify(Exit.failCause(Cause.die(e)));
-      }
-      return;
-    }
-    try {
-      this.current = frame.onSuccess(value);
-    } catch (e) {
-      this.notify(Exit.failCause(Cause.die(e)));
-    }
-  }
-  onFailure(error) {
-    while (this.stack.length > 0) {
-      const fr = this.stack.pop();
-      if (fr._tag === "FoldCont") {
-        try {
-          this.current = fr.onFailure(error);
-          return;
-        } catch (e) {
-          error = e;
-          continue;
-        }
-      }
-    }
-    this.notify(Exit.failCause(Cause.fail(error)));
-  }
-  budget = DEFAULT_BUDGET2;
-  step() {
-    if (this.result != null) return STEP.DONE;
-    if (this.interrupted) {
-      this.notify(Exit.failCause(Cause.interrupt()));
-      return STEP.DONE;
-    }
-    this.budget = __benchmarkBudget ?? DEFAULT_BUDGET2;
-    while (this.budget-- > 0) {
-      this.current = reassociateFlatMap(this.current);
-      const current = this.current;
-      switch (current._tag) {
-        case "Succeed": {
-          this.onSuccess(current.value);
-          break;
-        }
-        case "Fail": {
-          this.onFailure(current.error);
-          break;
-        }
-        case "FlatMap": {
-          this.stack.push({ _tag: "SuccessCont", k: current.andThen });
-          this.current = current.first;
-          break;
-        }
-        case "Fold": {
-          this.stack.push({
-            _tag: "FoldCont",
-            onFailure: current.onFailure,
-            onSuccess: current.onSuccess
-          });
-          this.current = current.first;
-          break;
-        }
-        case "Async": {
-          if (this.finishing) {
-            return this.result != null ? STEP.DONE : STEP.CONTINUE;
-          }
-          let done = false;
-          let asyncRegistered = false;
-          let syncResolved = false;
-          let syncExit = null;
-          const cb = (exit) => {
-            if (done) return;
-            done = true;
-            if (this.result != null || this.closing != null) return;
-            if (!asyncRegistered) {
-              syncResolved = true;
-              syncExit = exit;
-              return;
-            }
-            if (exit._tag === "Success") {
-              this.current = Async.succeed(exit.value);
-              this.schedule("async-resume");
-              return;
-            }
-            const cause = exit.cause;
-            if (cause._tag === "Interrupt") {
-              this.notify(Exit.failCause(Cause.interrupt()));
-              return;
-            }
-            if (cause._tag === "Fail") {
-              this.current = Async.fail(cause.error);
-              this.schedule("async-resume");
-              return;
-            }
-            this.notify(Exit.failCause(Cause.die(cause.defect)));
-          };
-          const canceler = current.register(this.env, cb);
-          asyncRegistered = true;
-          if (syncResolved && syncExit) {
-            const resolvedExit = syncExit;
-            if (resolvedExit._tag === "Success") {
-              this.onSuccess(resolvedExit.value);
-            } else {
-              const cause = resolvedExit.cause;
-              if (cause._tag === "Interrupt") {
-                this.notify(Exit.failCause(Cause.interrupt()));
-              } else if (cause._tag === "Fail") {
-                this.onFailure(cause.error);
-              } else {
-                this.notify(Exit.failCause(Cause.die(cause.defect)));
-              }
-            }
-            break;
-          }
-          if (typeof canceler === "function") {
-            this.addFinalizer(() => {
-              done = true;
-              try {
-                canceler();
-              } catch {
-              }
-            });
-          }
-          return STEP.SUSPEND;
-        }
-        case "Fork": {
-          const child = this.runtime.fork(current.effect, current.scopeId);
-          this.onSuccess(child);
-          break;
-        }
-        case "Sync": {
-          try {
-            const a = current.thunk(this.env);
-            this.onSuccess(a);
-          } catch (e) {
-            this.onFailure(e);
-          }
-          break;
-        }
-        default: {
-          this.onFailure(new Error(`Unknown opcode: ${current._tag}`));
-          return STEP.CONTINUE;
-        }
-      }
-      if (this.result != null) return STEP.DONE;
-    }
-    return STEP.CONTINUE;
-  }
-};
-function getCurrentFiber() {
-  return _current;
-}
-function unsafeGetCurrentRuntime() {
-  const f = getCurrentFiber();
-  if (!f?.runtime) {
-    throw new Error("unsafeGetCurrentRuntime: no current fiber/runtime");
-  }
-  return f.runtime;
-}
-function withCurrentFiber(fiber, f) {
-  const prev = _current;
-  _current = fiber;
-  try {
-    return f();
-  } finally {
-    _current = prev;
-  }
-}
-
-// src/core/runtime/scope.ts
-var nextScopeId = 1;
-function awaitAll(fibers) {
-  return async((_env, cb) => {
-    let remaining = fibers.length;
-    if (remaining === 0) {
-      cb({ _tag: "Success", value: void 0 });
-      return;
-    }
-    for (const f of fibers) {
-      f.join(() => {
-        remaining -= 1;
-        if (remaining === 0) cb({ _tag: "Success", value: void 0 });
-      });
-    }
-  });
-}
-var Scope = class _Scope {
-  constructor(runtime, parentScopeId) {
-    this.runtime = runtime;
-    this.parentScopeId = parentScopeId;
-    this.id = nextScopeId++;
-    const inferredParent = this.parentScopeId ?? getCurrentFiber()?.scopeId;
-    if (this.runtime.hasActiveHooks()) {
-      this.runtime.emit({
-        type: "scope.open",
-        scopeId: this.id,
-        parentScopeId: inferredParent
-      });
-    }
-  }
-  runtime;
-  parentScopeId;
-  id;
-  closed = false;
-  children = /* @__PURE__ */ new Set();
-  subScopes = /* @__PURE__ */ new Set();
-  finalizers = [];
-  /** registra un finalizer (LIFO) */
-  addFinalizer(f) {
-    if (this.closed) {
-      throw new Error("Trying to add finalizer to closed scope");
-    }
-    this.finalizers.push(f);
-  }
-  /** crea un sub scope (mismo runtime) */
-  subScope() {
-    if (this.closed) throw new Error("Scope closed");
-    const s = new _Scope(this.runtime, this.id);
-    this.subScopes.add(s);
-    return s;
-  }
-  /** ✅ fork en este scope */
-  fork(eff) {
-    if (this.closed) throw new Error("Scope closed");
-    const f = this.runtime.fork(eff, this.id);
-    this.children.add(f);
-    f.join(() => this.children.delete(f));
-    return f;
-  }
-  /** close fire-and-forget (no bloquea) */
-  close(exit = { _tag: "Success", value: void 0 }) {
-    this.runtime.fork(this.closeAsync(exit));
-  }
-  /** Emit the scope.close event if hooks are active. */
-  emitCloseEvent(exit) {
-    if (this.runtime.hasActiveHooks()) {
-      const status = exit._tag === "Success" ? "success" : exit.cause._tag === "Interrupt" ? "interrupted" : "failure";
-      this.runtime.emit({
-        type: "scope.close",
-        scopeId: this.id,
-        status,
-        error: exit._tag === "Failure" && exit.cause._tag === "Fail" ? exit.cause.error : void 0
-      });
-    }
-  }
-  /**
-   * Build an effect that executes finalizers in LIFO order.
-   *
-   * Optimization over the original: instead of wrapping every finalizer in
-   * `asyncFold(fin(exit), () => unit(), () => unit())` which creates 3 effect
-   * nodes per finalizer (Fold + 2 Succeed), we use a single Sync thunk per
-   * finalizer that catches errors inline.  When the finalizer returns a
-   * Succeed effect (like `unit()`), the Sync thunk completes without creating
-   * additional effect nodes.
-   */
-  buildFinalizerEffect(exit) {
-    const fins = this.finalizers;
-    if (fins.length === 0) return unit();
-    let chain = unit();
-    for (let i = fins.length - 1; i >= 0; i--) {
-      const fin = fins[i];
-      chain = asyncFlatMap(chain, () => {
-        let result;
-        try {
-          result = fin(exit);
-        } catch {
-          return unit();
-        }
-        if (result._tag === "Succeed") {
-          return unit();
-        }
-        return asyncFold(
-          result,
-          () => unit(),
-          () => unit()
-        );
-      });
-    }
-    return chain;
-  }
-  closeAsync(exit = { _tag: "Success", value: void 0 }, opts = { awaitChildren: true }) {
-    return asyncFlatMap(
-      unit(),
-      () => async((env, cb) => {
-        if (this.closed) {
-          cb({ _tag: "Success", value: void 0 });
-          return;
-        }
-        this.closed = true;
-        const children = Array.from(this.children);
-        const subScopes = Array.from(this.subScopes);
-        for (const child of children) {
-          child.interrupt();
-        }
-        const closeSubs = subScopes.reduceRight(
-          (acc, s) => asyncFlatMap(acc, () => s.closeAsync(exit, opts)),
-          unit()
-        );
-        const runFinalizers = this.buildFinalizerEffect(exit);
-        const needsAwait = opts.awaitChildren && children.length > 0;
-        const awaitChildrenEff = needsAwait ? awaitAll(children) : unit();
-        const hasSubScopes = subScopes.length > 0;
-        const hasNoFinalizers = this.finalizers.length === 0;
-        if (!hasSubScopes && !needsAwait && hasNoFinalizers) {
-          this.emitCloseEvent(exit);
-          cb({ _tag: "Success", value: void 0 });
-          return;
-        }
-        const all = asyncFlatMap(closeSubs, () => asyncFlatMap(awaitChildrenEff, () => runFinalizers));
-        this.runtime.fork(all).join(() => {
-          this.emitCloseEvent(exit);
-          cb({ _tag: "Success", value: void 0 });
-        });
-      })
-    );
-  }
-};
-function withScopeAsync(runtime, f) {
-  return async((_env, cb) => {
-    const scope = new Scope(runtime);
-    let done = false;
-    const completeAfterClose = (exit) => {
-      runtime.fork(scope.closeAsync(exit)).join(() => {
-        if (done) return;
-        done = true;
-        cb(exit);
-      });
-    };
-    const fiber = runtime.fork(f(scope));
-    fiber.join(completeAfterClose);
-    return () => {
-      if (done) return;
-      fiber.interrupt();
-      runtime.fork(scope.closeAsync(Exit.failCause(Cause.interrupt())));
-    };
-  });
-}
-function withScope(runtime, f) {
-  return withScopeAsync(runtime, (scope) => {
-    const out = f(scope);
-    if (out && typeof out === "object" && "_tag" in out) return out;
-    return unit();
-  });
-}
-
-// src/core/stream/structuredConcurrency.ts
-function race(left, right, parentScope) {
-  return async((env, cb) => {
-    const scope = parentScope.subScope();
-    let done = false;
-    const onResult = (exit) => {
-      if (done) return;
-      done = true;
-      scope.close(exit);
-      cb(exit);
-    };
-    const fiberLeft = scope.fork(left);
-    const fiberRight = scope.fork(right);
-    fiberLeft.join(onResult);
-    fiberRight.join(onResult);
-  });
-}
-function zipPar(left, right, parentScope) {
-  return async((env, cb) => {
-    const scope = parentScope.subScope();
-    let leftExit = null;
-    let rightExit = null;
-    let done = false;
-    const checkDone = () => {
-      if (!leftExit || !rightExit || done) return;
-      done = true;
-      if (leftExit._tag === "Success" && rightExit._tag === "Success") {
-        scope.close({ _tag: "Success", value: void 0 });
-        cb({
-          _tag: "Success",
-          value: [leftExit.value, rightExit.value]
-        });
-        return;
-      }
-      let cause;
-      if (leftExit._tag === "Failure") {
-        cause = leftExit.cause;
-      } else if (rightExit._tag === "Failure") {
-        cause = rightExit.cause;
-      } else {
-        throw new Error("zipPar: unreachable state (no Failure exit)");
-      }
-      const errExit = {
-        _tag: "Failure",
-        cause
-      };
-      scope.close(errExit);
-      cb(errExit);
-    };
-    const f1 = scope.fork(left);
-    const f2 = scope.fork(right);
-    f1.join((exit) => {
-      leftExit = exit;
-      checkDone();
-    });
-    f2.join((exit) => {
-      rightExit = exit;
-      checkDone();
-    });
-  });
-}
-function collectAllPar(effects, parentScope) {
-  return async((env, cb) => {
-    const scope = parentScope.subScope();
-    const results = new Array(effects.length);
-    let completed = 0;
-    let done = false;
-    effects.forEach((eff, i) => {
-      const f = scope.fork(eff);
-      f.join((exit) => {
-        if (done) return;
-        if (exit._tag === "Failure") {
-          done = true;
-          const errExit = {
-            _tag: "Failure",
-            cause: exit.cause
-          };
-          scope.close(errExit);
-          cb(errExit);
-          return;
-        }
-        results[i] = exit.value;
-        completed++;
-        if (completed === effects.length) {
-          done = true;
-          const successExit = {
-            _tag: "Success",
-            value: results
-          };
-          scope.close({ _tag: "Success", value: void 0 });
-          cb(successExit);
-        }
-      });
-    });
-  });
-}
-function raceWith(left, right, parentScope, onLeft, onRight) {
-  return async((env, cb) => {
-    const scope = parentScope.subScope();
-    let done = false;
-    const fiberLeft = scope.fork(left);
-    const fiberRight = scope.fork(right);
-    const finish = (next) => {
-      scope.fork(next).join((exitNext) => {
-        scope.close(exitNext);
-        cb(exitNext);
-      });
-    };
-    fiberLeft.join((exitL) => {
-      if (done) return;
-      done = true;
-      finish(onLeft(exitL, fiberRight, scope));
-    });
-    fiberRight.join((exitR) => {
-      if (done) return;
-      done = true;
-      finish(onRight(exitR, fiberLeft, scope));
-    });
-  });
-}
-
-export {
-  Async,
-  asyncFold,
-  asyncCatchAll,
-  asyncMapError,
-  unit,
-  asyncSucceed,
-  asyncFail,
-  asyncSync,
-  asyncTotal,
-  async,
-  asyncMap,
-  asyncFlatMap,
-  acquireRelease,
-  asyncInterruptible,
-  withAsyncPromise,
-  mapAsync,
-  mapTryAsync,
-  none,
-  some,
-  Cause,
-  Exit,
-  succeed,
-  fail,
-  sync,
-  map,
-  flatMap,
-  mapError,
-  catchAll,
-  orElseOptional,
-  end,
-  PushStatus,
-  RingBuffer,
-  resolveWasmModule,
-  makeBoundedRingBuffer,
-  Scheduler,
-  globalScheduler,
-  setBenchmarkBudget,
-  getBenchmarkBudget,
-  RuntimeFiber,
-  getCurrentFiber,
-  unsafeGetCurrentRuntime,
-  withCurrentFiber,
-  DefaultHostExecutor,
-  JsFiberEngine,
-  HostRegistry,
-  ProgramBuilder,
-  EngineFiberHandle,
-  ReferenceWasmBridge,
-  WasmPackFiberBridge,
-  WasmFiberRegistryBridge,
-  WasmFiberEngine,
-  runtimeCapabilities,
-  NoopHooks,
-  Runtime,
-  fork,
-  unsafeRunAsync,
-  toPromise,
-  fromPromiseAbortable,
-  unsafeRunFoldWithEnv,
-  Scope,
-  withScopeAsync,
-  withScope,
-  race,
-  zipPar,
-  collectAllPar,
-  raceWith
-};