brass-runtime 1.15.0 → 1.16.1

package/dist/{chunk-BDF4AMWX.mjs → chunk-GYM3LLGS.mjs}

@@ -1,121 +1,13 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// 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, handler, asyncSucceed);
-}
-function asyncMapError(fa, f) {
-  return asyncFold(fa, (e) => asyncFail(f(e)), asyncSucceed);
-}
-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 asyncEffect = (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 asyncEffect(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, f);
-var mapError = (fa, f) => asyncMapError(fa, f);
-var catchAll = (fa, handler) => asyncFold(fa, handler, asyncSucceed);
-function orElseOptional(fa, that) {
-  return asyncFold(
-    fa,
-    (opt) => opt._tag === "Some" ? asyncFail(opt) : that(),
-    asyncSucceed
-  );
-}
-var end = () => fail(none);
+import {
+  Async,
+  Cause,
+  Exit,
+  asyncEffect
+} from "./chunk-36I3M4UC.mjs";
+import {
+  Schema,
+  parseConfig
+} from "./chunk-DNFJLJMW.mjs";
 
 // src/core/runtime/ringBuffer.ts
 var PushStatus = /* @__PURE__ */ ((PushStatus3) => {
@@ -441,13 +333,47 @@ function resolveWasmScheduler() {
 var LaneState = class {
   constructor(key, initial, max) {
     this.key = key;
+    this.initial = initial;
+    this.max = max;
     this.queue = makeBoundedRingBuffer(initial, max, { engine: "ts" });
   }
   key;
+  initial;
+  max;
   queue;
+  tagQueue;
+  sharedTag;
   enqueuedTasks = 0;
   executedTasks = 0;
   droppedTasks = 0;
+  recordTag(tag, queuedBefore) {
+    if (this.tagQueue) {
+      this.tagQueue.push(tag);
+      return;
+    }
+    if (queuedBefore === 0 || this.sharedTag === void 0) {
+      this.sharedTag = tag;
+      return;
+    }
+    if (this.sharedTag === tag) return;
+    const tags = makeBoundedRingBuffer(this.initial, this.max, { engine: "ts" });
+    for (let i = 0; i < queuedBefore; i++) tags.push(this.sharedTag);
+    tags.push(tag);
+    this.tagQueue = tags;
+  }
+  shiftTag() {
+    if (this.tagQueue) {
+      const tag2 = this.tagQueue.shift() ?? this.sharedTag ?? this.key;
+      if (this.queue.length === 0) {
+        this.tagQueue = void 0;
+        this.sharedTag = void 0;
+      }
+      return tag2;
+    }
+    const tag = this.sharedTag ?? this.key;
+    if (this.queue.length === 0) this.sharedTag = void 0;
+    return tag;
+  }
 };
 var JsSchedulerState = class {
   constructor(options) {
@@ -473,6 +399,27 @@ var JsSchedulerState = class {
     return n;
   }
 };
+var JsSingleSchedulerState = class {
+  constructor(options) {
+    this.options = options;
+    this.queue = makeBoundedRingBuffer(
+      options.initialCapacity ?? 1024,
+      options.maxCapacity ?? SCHEDULER_QUEUE_CAPACITY,
+      { engine: "ts" }
+    );
+  }
+  options;
+  queue;
+  flushing = false;
+  scheduled = false;
+  scheduledFlushes = 0;
+  completedFlushes = 0;
+  enqueuedTasks = 0;
+  executedTasks = 0;
+  droppedTasks = 0;
+  yieldedByBudget = 0;
+  totalLength = 0;
+};
 var WasmSchedulerState = class {
   machine;
   nextRef = 1;
@@ -710,9 +657,9 @@ function inferLane(tag) {
 }
 function extractTaggedLane(tag, prefix) {
   if (!tag.startsWith(prefix)) return void 0;
-  const end2 = tag.indexOf("|", prefix.length);
-  if (end2 < 0) return void 0;
-  const value = tag.slice(prefix.length, end2);
+  const end = tag.indexOf("|", prefix.length);
+  if (end < 0) return void 0;
+  const value = tag.slice(prefix.length, end);
   return value.length > 0 ? value : void 0;
 }
 function firstSeparatorIndex(value) {
@@ -726,6 +673,7 @@ function firstSeparatorIndex(value) {
 var Scheduler = class {
   engine;
   js;
+  jsSingle;
   wasm;
   flushBudget;
   microThreshold;
@@ -734,6 +682,7 @@ var Scheduler = class {
   maxLanes;
   fallbackUsed;
   boundFlush = () => this.flush();
+  shiftedTag = "anonymous";
   constructor(options = {}) {
     this.flushBudget = options.flushBudget ?? FLUSH_BUDGET;
     this.microThreshold = options.microThreshold ?? MICRO_THRESHOLD;
@@ -748,7 +697,11 @@ var Scheduler = class {
       return;
     }
     if (requested === "ts") {
-      this.js = new JsSchedulerState({ ...options, engine: "ts" });
+      if (options.laneMode === "single") {
+        this.jsSingle = new JsSingleSchedulerState({ ...options, engine: "ts" });
+      } else {
+        this.js = new JsSchedulerState({ ...options, engine: "ts" });
+      }
       this.engine = "ts";
       this.fallbackUsed = false;
       return;
@@ -758,14 +711,42 @@ var Scheduler = class {
   schedule(task, tag = "anonymous") {
     if (typeof task !== "function") return "dropped";
     if (this.wasm) return this.scheduleWasm(task, tag);
+    if (this.jsSingle) return this.scheduleJsSingle(task);
     return this.scheduleJs(task, tag);
   }
   scheduleBatch(tasks) {
     if (this.wasm) return this.scheduleBatchWasm(tasks);
+    if (this.jsSingle) return this.scheduleBatchJsSingle(tasks);
     return tasks.map(({ fn, tag }) => this.schedule(fn, tag));
   }
   stats() {
     if (this.wasm) return this.wasm.stats();
+    if (this.jsSingle) {
+      const js2 = this.jsSingle;
+      return {
+        engine: "ts",
+        fallbackUsed: false,
+        data: {
+          len: js2.totalLength,
+          capacity: js2.queue.capacity,
+          phase: js2.flushing ? "flushing" : js2.scheduled ? "scheduled" : "idle",
+          scheduledFlushes: js2.scheduledFlushes,
+          completedFlushes: js2.completedFlushes,
+          enqueuedTasks: js2.enqueuedTasks,
+          executedTasks: js2.executedTasks,
+          droppedTasks: js2.droppedTasks,
+          yieldedByBudget: js2.yieldedByBudget,
+          lanes: [{
+            key: "single",
+            len: js2.queue.length,
+            capacity: js2.queue.capacity,
+            enqueuedTasks: js2.enqueuedTasks,
+            executedTasks: js2.executedTasks,
+            droppedTasks: js2.droppedTasks
+          }]
+        }
+      };
+    }
     const js = this.js;
     const lanes = Array.from(js.lanes.values()).map((lane) => ({ key: lane.key, len: lane.queue.length, capacity: lane.queue.capacity, enqueuedTasks: lane.enqueuedTasks, executedTasks: lane.executedTasks, droppedTasks: lane.droppedTasks }));
     return { engine: "ts", fallbackUsed: false, data: { len: js.totalLength, capacity: js.totalCapacity, 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, lanes } };
@@ -821,13 +802,44 @@ var Scheduler = class {
     const js = this.js;
     const lane = new LaneState(key, this.laneCapacity, this.laneCapacity);
     js.lanes.set(key, lane);
-    js.laneOrder.push(key);
+    js.laneOrder.push(lane);
     return lane;
   }
+  scheduleJsSingle(task) {
+    const js = this.jsSingle;
+    const status = js.queue.push(task);
+    js.enqueuedTasks++;
+    if ((status & 2) !== 0) {
+      js.droppedTasks++;
+      if (!js.flushing && !js.scheduled && js.totalLength > 0) {
+        js.scheduled = true;
+        js.scheduledFlushes++;
+        this.requestFlush(js.totalLength > this.microThreshold ? "macro" : "micro");
+      }
+      return "dropped";
+    }
+    js.totalLength++;
+    if (js.flushing) return "accepted";
+    if (!js.scheduled) {
+      js.scheduled = true;
+      js.scheduledFlushes++;
+      this.requestFlush(js.totalLength > this.microThreshold ? "macro" : "micro");
+    }
+    return "accepted";
+  }
+  scheduleBatchJsSingle(tasks) {
+    const results = new Array(tasks.length);
+    for (let i = 0; i < tasks.length; i++) {
+      const task = tasks[i].fn;
+      results[i] = typeof task === "function" ? this.scheduleJsSingle(task) : "dropped";
+    }
+    return results;
+  }
   scheduleJs(task, tag) {
     const js = this.js;
     const lane = this.getOrCreateLane(inferLane(tag));
-    const status = lane.queue.push({ task, tag });
+    const queuedBefore = lane.queue.length;
+    const status = lane.queue.push(task);
     lane.enqueuedTasks++;
     js.enqueuedTasks++;
     if ((status & 2) !== 0) {
@@ -840,6 +852,7 @@ var Scheduler = class {
       }
       return "dropped";
     }
+    lane.recordTag(tag, queuedBefore);
     js.totalLength++;
     if (js.flushing) return "accepted";
     if (!js.scheduled) {
@@ -855,6 +868,7 @@ var Scheduler = class {
   }
   flush() {
     if (this.wasm) return this.flushWasm();
+    if (this.jsSingle) return this.flushJsSingle();
     this.flushJs();
   }
   flushWasm() {
@@ -879,15 +893,47 @@ var Scheduler = class {
       else if (policy === 1) this.requestFlush("macro");
     }
   }
+  flushJsSingle() {
+    const js = this.jsSingle;
+    if (js.flushing) return;
+    js.flushing = true;
+    js.scheduled = false;
+    let ran = 0;
+    try {
+      while (ran < this.flushBudget) {
+        const task = js.queue.shift();
+        if (!task) break;
+        js.totalLength--;
+        ran++;
+        js.executedTasks++;
+        try {
+          task();
+        } catch (e) {
+          console.error("[Scheduler] task threw (laneMode=single)", e);
+        }
+      }
+    } finally {
+      js.flushing = false;
+      js.completedFlushes++;
+      if (js.totalLength > 0 && !js.scheduled) {
+        js.scheduled = true;
+        js.scheduledFlushes++;
+        const kind = ran >= this.flushBudget || js.totalLength > this.microThreshold ? "macro" : "micro";
+        if (ran >= this.flushBudget) js.yieldedByBudget++;
+        this.requestFlush(kind);
+      }
+    }
+  }
   shiftFromNextLane() {
     const js = this.js;
     const n = js.laneOrder.length;
     if (n === 0) return void 0;
     if (js.rrRemaining > 0) {
       const currentIdx = (js.rrIndex + n - 1) % n;
-      const currentLane = js.lanes.get(js.laneOrder[currentIdx]);
-      const next = currentLane?.queue.shift();
+      const currentLane = js.laneOrder[currentIdx];
+      const next = currentLane.queue.shift();
       if (next) {
+        this.shiftedTag = currentLane.shiftTag();
         js.rrRemaining--;
         currentLane.executedTasks++;
         js.totalLength--;
@@ -897,14 +943,15 @@ var Scheduler = class {
     }
     for (let scanned = 0; scanned < n; scanned++) {
       const idx = js.rrIndex % n;
-      const key = js.laneOrder[idx];
+      const lane = js.laneOrder[idx];
       js.rrIndex = (idx + 1) % n;
-      const lane = js.lanes.get(key);
-      if (!lane || lane.queue.length === 0) continue;
+      if (lane.queue.length === 0) continue;
       js.rrRemaining = Math.max(0, this.laneBudget - 1);
       lane.executedTasks++;
       js.totalLength--;
-      return lane.queue.shift();
+      const next = lane.queue.shift();
+      if (next) this.shiftedTag = lane.shiftTag();
+      return next;
     }
     return void 0;
   }
@@ -921,9 +968,9 @@ var Scheduler = class {
         ran++;
         js.executedTasks++;
         try {
-          next.task();
+          next();
         } catch (e) {
-          console.error(`[Scheduler] task threw (tag=${next.tag})`, e);
+          console.error(`[Scheduler] task threw (tag=${this.shiftedTag})`, e);
         }
       }
     } finally {
@@ -941,6 +988,27 @@ var Scheduler = class {
 };
 var globalScheduler = new Scheduler();
 
+// src/core/runtime/contex.ts
+var emptyContext = { parent: null, patch: /* @__PURE__ */ Object.create(null) };
+function ctxExtend(parent, patch) {
+  return { parent, patch };
+}
+function ctxToObject(ctx) {
+  const out = /* @__PURE__ */ Object.create(null);
+  const seen = /* @__PURE__ */ new Set();
+  let cur = ctx;
+  while (cur) {
+    for (const k of Object.keys(cur.patch)) {
+      if (!seen.has(k)) {
+        out[k] = cur.patch[k];
+        seen.add(k);
+      }
+    }
+    cur = cur.parent;
+  }
+  return out;
+}
+
 // src/core/runtime/hostAction.ts
 var DefaultHostExecutor = {
   async execute(action) {
@@ -952,9 +1020,6 @@ var DefaultHostExecutor = {
   }
 };
 
-// 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);
@@ -964,7 +1029,8 @@ function makeForkPolicy(env, hooks) {
       const trace = forkTrace(svc, parentCtx?.trace ?? null);
       fiber.fiberContext = {
         log: parentCtx?.log ?? emptyContext,
-        trace
+        trace,
+        fiberRefs: parentCtx?.fiberRefs ? new Map(parentCtx.fiberRefs) : void 0
       };
       fiber.parentFiberId = parent?.id;
       fiber.name = svc.childName(parent?.name);
@@ -978,7 +1044,16 @@ function makeForkPolicy(env, hooks) {
           // ✅ ahora viaja
           name: fiber.name
         },
-        { fiberId: parent?.id, traceId: parentCtx?.trace?.traceId, spanId: parentCtx?.trace?.spanId }
+        {
+          fiberId: fiber.id,
+          scopeId: fiber.scopeId,
+          traceId: trace?.traceId,
+          spanId: trace?.spanId,
+          parentSpanId: trace?.parentSpanId,
+          traceState: trace?.traceState,
+          baggage: trace?.baggage,
+          sampled: trace?.sampled
+        }
       );
     }
   };
@@ -991,8 +1066,9 @@ function resolveForkServices(env) {
   const brass = env?.brass;
   const tracer = brass?.tracer ?? defaultTracer;
   const seed = brass?.traceSeed;
+  const baggage = brass?.baggage;
   const childName = brass?.childName ?? ((p) => p ? `${p}/child` : void 0);
-  return { tracer, seed, childName };
+  return { tracer, seed, baggage, childName };
 }
 function randomRuntimeId(prefix) {
   const cryptoLike = globalThis.crypto;
@@ -1007,11 +1083,22 @@ function forkTrace(svc, parentTrace) {
       traceId: parentTrace.traceId,
       spanId: svc.tracer.newSpanId(),
       parentSpanId: parentTrace.spanId,
-      sampled: parentTrace.sampled
+      sampled: parentTrace.sampled,
+      traceState: parentTrace.traceState,
+      baggage: parentTrace.baggage
     };
   }
-  if (svc.seed) return { ...svc.seed };
-  return { traceId: svc.tracer.newTraceId(), spanId: svc.tracer.newSpanId(), sampled: true };
+  if (svc.seed) {
+    const baggage2 = svc.seed.baggage ?? svc.baggage;
+    return baggage2 ? { ...svc.seed, baggage: baggage2 } : { ...svc.seed };
+  }
+  const baggage = svc.baggage;
+  return {
+    traceId: svc.tracer.newTraceId(),
+    spanId: svc.tracer.newSpanId(),
+    sampled: true,
+    ...baggage ? { baggage } : {}
+  };
 }
 
 // src/core/runtime/engine/opcodes.ts
@@ -1163,6 +1250,13 @@ var ProgramBuilder = class {
         };
         return this.add(current.scopeId === void 0 ? base : { ...base, scopeId: current.scopeId });
       }
+      case "Interruptibility":
+      case "InterruptibilityRestore":
+        return this.visit(current.effect);
+      case "FiberRefLocally":
+        return this.visit(desugarFiberRefLocally(current.refId, current.value, current.effect));
+      case "InterruptibilityMask":
+        return this.visit(current.body((effect2) => effect2));
       case "HostAction": {
         const base = {
           tag: "HostAction",
@@ -1175,6 +1269,49 @@ var ProgramBuilder = class {
     }
   }
 };
+function desugarFiberRefLocally(refId, value, effect) {
+  return {
+    _tag: "FlatMap",
+    first: {
+      _tag: "Sync",
+      thunk: () => enterFiberRefLocal(refId, value)
+    },
+    andThen: (restore) => ({
+      _tag: "Fold",
+      first: effect,
+      onFailure: (error) => restoreThen(restore, { _tag: "Fail", error }),
+      onSuccess: (result) => restoreThen(restore, { _tag: "Succeed", value: result })
+    })
+  };
+}
+function restoreThen(restore, next) {
+  return {
+    _tag: "FlatMap",
+    first: {
+      _tag: "Sync",
+      thunk: () => restore()
+    },
+    andThen: () => next
+  };
+}
+function enterFiberRefLocal(refId, value) {
+  const fiber = getCurrentFiber();
+  if (!fiber) return () => void 0;
+  fiber.fiberContext ??= { log: emptyContext, trace: null };
+  const refs = fiber.fiberContext.fiberRefs ??= /* @__PURE__ */ new Map();
+  const hadValue = refs.has(refId);
+  const previousValue = refs.get(refId);
+  refs.set(refId, value);
+  let active = true;
+  const restore = () => {
+    if (!active) return;
+    active = false;
+    if (hadValue) refs.set(refId, previousValue);
+    else refs.delete(refId);
+  };
+  fiber.addFinalizer?.(() => restore());
+  return restore;
+}
 
 // src/core/runtime/engine/FiberHandleImpl.ts
 var EngineFiberHandle = class {
@@ -1209,7 +1346,7 @@ var EngineFiberHandle = class {
   queued = false;
   status() {
     if (this.result == null) return "Running";
-    if (this.result._tag === "Failure" && this.result.cause._tag === "Interrupt") return "Interrupted";
+    if (this.result._tag === "Failure" && Cause.isInterruptedOnly(this.result.cause)) return "Interrupted";
     return "Done";
   }
   engineStatus() {
@@ -1282,8 +1419,8 @@ var EngineFiberHandle = class {
     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.internalStatus = exit._tag === "Success" ? "done" : Cause.isInterruptedOnly(exit.cause) ? "interrupted" : "failed";
+    const status = exit._tag === "Success" ? "success" : Cause.isInterruptedOnly(exit.cause) ? "interrupted" : "failure";
     this.emit({
       type: "fiber.end",
       fiberId: this.id,
@@ -1296,16 +1433,18 @@ var EngineFiberHandle = class {
   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);
+    withCurrentFiber(this, () => {
+      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 {
         }
-      } catch {
       }
-    }
+    });
   }
 };
 
@@ -1605,19 +1744,6 @@ var WasmPackFiberBridge = class {
     this.maxEventsPerCall = Math.max(this.maxEventsPerCall, events.length);
     return events;
   }
-  decodeBinary(words) {
-    this.binaryEventCalls += 1;
-    const events = decodeEventBatch(words);
-    this.eventsReceived += events.length;
-    this.maxEventsPerCall = Math.max(this.maxEventsPerCall, events.length);
-    return events;
-  }
-  decodeJson(json) {
-    this.jsonEventCalls += 1;
-    this.eventsReceived += 1;
-    this.maxEventsPerCall = Math.max(this.maxEventsPerCall, 1);
-    return JSON.parse(json);
-  }
   memory() {
     const memory = this.vm.memory?.();
     if (!memory?.buffer) throw new Error("brass-runtime WASM memory is not available");
@@ -1997,9 +2123,9 @@ function inferLane2(tag) {
 }
 function extractTaggedLane2(tag, prefix) {
   if (!tag.startsWith(prefix)) return void 0;
-  const end2 = tag.indexOf("|", prefix.length);
-  if (end2 < 0) return void 0;
-  const value = tag.slice(prefix.length, end2);
+  const end = tag.indexOf("|", prefix.length);
+  if (end < 0) return void 0;
+  const value = tag.slice(prefix.length, end);
   return value.length > 0 ? value : void 0;
 }
 function firstSeparatorIndex2(value) {
@@ -2103,7 +2229,7 @@ var WasmFiberEngine = class {
     }
     this.kind = this.bridge.kind;
     this.fiberRegistry = new WasmFiberRegistryBridge();
-    this.readyQueue = makeFiberReadyQueue({ engine: "wasm" });
+    this.readyQueue = makeFiberReadyQueue({ engine: "wasm", ...options.readyQueue });
     this.timerWheel = makeWasmTimerWheel({ onExpired: (events) => this.onTimerExpired(events) });
   }
   runtime;
@@ -2521,15 +2647,32 @@ var WasmFiberEngine = class {
       return;
     }
     const cause = exit.cause;
-    if (cause._tag === "Interrupt") {
+    if (Cause.isInterruptedOnly(cause)) {
       this.interruptState(state, cause);
       return;
     }
-    if (cause._tag === "Fail") {
-      this.resumeWithError(state, cause.error);
-      return;
+    if (Cause.isFailureOnly(cause)) {
+      const failure = Cause.firstFailure(cause);
+      if (failure._tag === "Some") {
+        this.resumeWithError(state, failure.value);
+        return;
+      }
     }
-    this.completeDie(state, cause.defect);
+    this.completeCause(state, cause);
+  }
+  completeCause(state, cause) {
+    if (state.completed) return;
+    state.completed = true;
+    const interrupted = Cause.isInterruptedOnly(cause);
+    state.status = interrupted ? "interrupted" : "failed";
+    this.fiberRegistry?.markDone(state.fiberId, interrupted ? "interrupted" : "failed");
+    if (interrupted) {
+      this.interruptedFibers += 1;
+    } else {
+      this.failedFibers += 1;
+    }
+    this.cleanupState(state);
+    state.handle.complete(Exit.failCause(cause));
   }
   resumeWithValue(state, value) {
     this.pendingResumes.set(state.fiberId, { kind: "value", ref: state.registry.register(value) });
@@ -2654,6 +2797,21 @@ function hasBinaryVmAbi(mod) {
   }
 }
 
+// src/core/runtime/clock.ts
+var liveClock = {
+  now: () => {
+    if (typeof performance !== "undefined" && typeof performance.now === "function") {
+      return performance.now();
+    }
+    return Date.now();
+  },
+  setTimeout: (task, ms) => setTimeout(task, Math.max(0, Math.floor(ms))),
+  clearTimeout: (timer) => clearTimeout(timer)
+};
+function runtimeClockFromEnv(env) {
+  return env?.brass?.clock ?? liveClock;
+}
+
 // src/core/runtime/runtime.ts
 var NoopHooks = {
   emit() {
@@ -2666,6 +2824,12 @@ function normalizeRuntimeEngineMode(value) {
 function unreachableEngine(value) {
   throw new Error(`brass-runtime unsupported engine '${String(value)}'`);
 }
+var runtimeOptionsSchema = Schema.object({
+  env: Schema.any(),
+  lane: Schema.string({ minLength: 1 }).optional(),
+  inferLane: Schema.boolean().optional(),
+  engine: Schema.enum(["ts", "wasm"]).optional()
+}, { unknownKeys: "passthrough" });
 var Runtime = class _Runtime {
   env;
   scheduler;
@@ -2681,6 +2845,7 @@ var Runtime = class _Runtime {
   // opcional: registry para observabilidad
   registry;
   constructor(args) {
+    parseConfig("RuntimeOptions", runtimeOptionsSchema, args);
     this.env = args.env;
     this.scheduler = args.scheduler ?? globalScheduler;
     this.lane = args.lane;
@@ -2746,7 +2911,11 @@ var Runtime = class _Runtime {
       scopeId: f?.scopeId,
       // ✅ FIX: era f?.scope
       traceId: f?.fiberContext?.trace?.traceId,
-      spanId: f?.fiberContext?.trace?.spanId
+      spanId: f?.fiberContext?.trace?.spanId,
+      parentSpanId: f?.fiberContext?.trace?.parentSpanId,
+      traceState: f?.fiberContext?.trace?.traceState,
+      baggage: f?.fiberContext?.trace?.baggage,
+      sampled: f?.fiberContext?.trace?.sampled
     };
     this.hooks.emit(ev, ctx);
   }
@@ -2774,23 +2943,46 @@ var Runtime = class _Runtime {
     return this.fiberEngine.shutdown?.();
   }
   unsafeRunAsync(effect, cb) {
+    if (this.tryRunNativeTopLevel(effect, cb)) return;
     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);
+      const complete = (exit) => {
+        if (exit._tag === "Success") {
+          resolve(exit.value);
+          return;
+        }
+        const failure = Cause.firstFailure(exit.cause);
+        if (failure._tag === "Some") reject(failure.value);
         else {
-          const c = exit.cause;
-          if (c?._tag === "Fail") reject(c.error);
-          else if (c?._tag === "Die") reject(c.defect instanceof Error ? c.defect : new Error(String(c.defect)));
-          else reject(new Error("Interrupted"));
+          const defect = Cause.firstDefect(exit.cause);
+          if (defect._tag === "Some") {
+            reject(defect.value instanceof Error ? defect.value : new Error(String(defect.value)));
+          } else if (Cause.containsInterrupt(exit.cause)) {
+            reject(new Error("Interrupted"));
+          } else {
+            reject(Cause.toError(exit.cause));
+          }
         }
+      };
+      if (this.tryRunNativeTopLevel(effect, complete)) return;
+      const fiber = this.fork(effect);
+      fiber.join((exit) => {
+        complete(exit);
       });
     });
   }
+  tryRunNativeTopLevel(effect, cb) {
+    if (this.hooks !== NoopHooks) return false;
+    if (getCurrentFiber() !== null) return false;
+    if (this.scheduler !== globalScheduler) return false;
+    if (this.lane !== void 0 || this.inferLane) return false;
+    if (this.engineMode !== "ts") return false;
+    new NativeTopLevelRunner(this, effect, cb).start();
+    return true;
+  }
   // helper: correr un efecto y “tirar” el resultado
   unsafeRun(effect) {
     this.unsafeRunAsync(effect, () => {
@@ -2798,10 +2990,11 @@ var Runtime = class _Runtime {
   }
   delay(ms, eff) {
     return asyncEffect((_env, cb) => {
-      const handle = setTimeout(() => {
+      const clock = runtimeClockFromEnv(this.env);
+      const handle = clock.setTimeout(() => {
         this.unsafeRunAsync(eff, cb);
       }, ms);
-      return () => clearTimeout(handle);
+      return () => clock.clearTimeout(handle);
     });
   }
   // util para crear runtime default
@@ -2816,6 +3009,243 @@ var Runtime = class _Runtime {
     this.emit({ type: "log", level, message, fields });
   }
 };
+var NATIVE_FAST_PATH_STEP_BUDGET = 32768;
+var NativeTopLevelRunner = class {
+  constructor(runtime, effect, cb) {
+    this.runtime = runtime;
+    this.current = effect;
+    this.joiners.push(cb);
+    this.frame = {
+      id: 0,
+      runtime,
+      name: "native-fast-path",
+      fiberContext: { trace: null },
+      lane: runtime.lane,
+      status: () => this.result ? "Done" : "Running",
+      join: (joiner) => {
+        if (this.result) joiner(this.result);
+        else this.joiners.push(joiner);
+      },
+      interrupt: () => void 0,
+      addFinalizer: (finalizer) => {
+        this.finalizers.push(finalizer);
+      }
+    };
+  }
+  runtime;
+  current;
+  stack = [];
+  joiners = [];
+  finalizers = [];
+  result;
+  yielded = false;
+  frame;
+  start() {
+    this.runLoop();
+  }
+  runLoop() {
+    this.withFrame(() => {
+      this.yielded = false;
+      let budget = NATIVE_FAST_PATH_STEP_BUDGET;
+      while (!this.result && budget-- > 0) {
+        const current = this.current;
+        switch (current._tag) {
+          case "Succeed":
+            this.onSuccess(current.value);
+            break;
+          case "Fail":
+            this.onCause(Cause.fail(current.error));
+            break;
+          case "Sync":
+            try {
+              this.onSuccess(current.thunk(this.runtime.env));
+            } catch (error) {
+              this.onCause(Cause.fail(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.runAsync(current)) break;
+            return;
+          case "Fork":
+            this.onSuccess(this.runtime.fork(current.effect, current.scopeId));
+            break;
+          case "Interruptibility":
+            this.stack.push({ _tag: "InterruptibilityCont" });
+            this.current = current.effect;
+            break;
+          case "InterruptibilityMask":
+            this.stack.push({ _tag: "InterruptibilityCont" });
+            try {
+              this.current = current.body((effect) => ({
+                _tag: "InterruptibilityRestore",
+                depth: 0,
+                effect
+              }));
+            } catch (error) {
+              this.onCause(Cause.die(error));
+            }
+            break;
+          case "InterruptibilityRestore":
+            this.stack.push({ _tag: "InterruptibilityCont" });
+            this.current = current.effect;
+            break;
+          case "FiberRefLocally": {
+            const refs = this.fiberRefs();
+            const hadValue = refs.has(current.refId);
+            const previousValue = refs.get(current.refId);
+            refs.set(current.refId, current.value);
+            this.stack.push({
+              _tag: "FiberRefCont",
+              refId: current.refId,
+              hadValue,
+              previousValue
+            });
+            this.current = current.effect;
+            break;
+          }
+          default:
+            this.onCause(Cause.fail(new Error(`Unknown opcode: ${current._tag}`)));
+            break;
+        }
+      }
+      if (!this.result && !this.yielded) {
+        this.yielded = true;
+        queueMicrotask(() => this.runLoop());
+      }
+    });
+  }
+  runAsync(current) {
+    let registered = false;
+    let settled = false;
+    let syncExit;
+    const resume = (exit) => {
+      if (settled) return;
+      settled = true;
+      if (!registered) {
+        syncExit = exit;
+        return;
+      }
+      queueMicrotask(() => this.resumeAsync(exit));
+    };
+    try {
+      current.register(this.runtime.env, resume);
+    } catch (error) {
+      this.onCause(Cause.die(error));
+      return true;
+    }
+    registered = true;
+    if (syncExit) {
+      this.consumeExit(syncExit);
+      return true;
+    }
+    return false;
+  }
+  resumeAsync(exit) {
+    if (this.result) return;
+    this.withFrame(() => this.consumeExit(exit));
+    if (!this.result) this.runLoop();
+  }
+  consumeExit(exit) {
+    if (exit._tag === "Success") this.onSuccess(exit.value);
+    else this.onCause(exit.cause);
+  }
+  onSuccess(value) {
+    let currentValue = value;
+    while (true) {
+      const frame = this.stack.pop();
+      if (!frame) {
+        this.notify(Exit.succeed(currentValue));
+        return;
+      }
+      if (frame._tag === "InterruptibilityCont") continue;
+      if (frame._tag === "FiberRefCont") {
+        this.restoreFiberRef(frame);
+        continue;
+      }
+      if (frame._tag === "SuccessCont") {
+        try {
+          this.current = frame.k(currentValue);
+        } catch (error) {
+          this.notify(Exit.failCause(Cause.die(error)));
+        }
+        return;
+      }
+      try {
+        this.current = frame.onSuccess(currentValue);
+      } catch (error) {
+        this.notify(Exit.failCause(Cause.die(error)));
+      }
+      return;
+    }
+  }
+  onCause(cause) {
+    let currentCause = cause;
+    while (this.stack.length > 0) {
+      const frame = this.stack.pop();
+      if (frame._tag === "InterruptibilityCont") continue;
+      if (frame._tag === "FiberRefCont") {
+        this.restoreFiberRef(frame);
+        continue;
+      }
+      if (frame._tag === "FoldCont") {
+        if (!Cause.isFailureOnly(currentCause)) continue;
+        const failure = Cause.firstFailure(currentCause);
+        if (failure._tag === "None") break;
+        try {
+          this.current = frame.onFailure(failure.value);
+          return;
+        } catch (error) {
+          currentCause = Cause.fail(error);
+          continue;
+        }
+      }
+    }
+    this.notify(Exit.failCause(currentCause));
+  }
+  notify(exit) {
+    if (this.result) return;
+    this.result = exit;
+    this.runFinalizers(exit);
+    for (const joiner of this.joiners) joiner(exit);
+    this.joiners.length = 0;
+  }
+  runFinalizers(exit) {
+    while (this.finalizers.length > 0) {
+      const finalizer = this.finalizers.pop();
+      try {
+        const result = finalizer(exit);
+        if (result && typeof result === "object" && "_tag" in result) {
+          this.runtime.unsafeRunAsync(result, () => void 0);
+        }
+      } catch {
+      }
+    }
+  }
+  fiberRefs() {
+    this.frame.fiberContext.fiberRefs ??= /* @__PURE__ */ new Map();
+    return this.frame.fiberContext.fiberRefs;
+  }
+  restoreFiberRef(frame) {
+    const refs = this.fiberRefs();
+    if (frame.hadValue) refs.set(frame.refId, frame.previousValue);
+    else refs.delete(frame.refId);
+  }
+  withFrame(body) {
+    return withCurrentFiber(this.frame, body);
+  }
+};
 function fork(effect, env) {
   return Runtime.make(env ?? {}).fork(effect);
 }
@@ -3042,6 +3472,7 @@ var RuntimeFiber = class {
   stack = [];
   fiberFinalizers = [];
   finalizersDrained = false;
+  interruptibilityDepth = 0;
   fiberContext;
   name;
   scopeId;
@@ -3080,14 +3511,8 @@ var RuntimeFiber = class {
         this.schedule("async-resume");
         return;
       }
-      const cause = exit.cause;
-      if (cause._tag === "Interrupt") {
-        this.notify(Exit.failCause(Cause.interrupt()));
-      } else if (cause._tag === "Fail") {
-        this.current = Async.fail(cause.error);
+      if (this.onCause(exit.cause)) {
         this.schedule("async-resume");
-      } else {
-        this.notify(Exit.failCause(Cause.die(cause.defect)));
       }
     };
     this.boundStep = () => {
@@ -3122,7 +3547,11 @@ var RuntimeFiber = class {
       fiberId: this.id,
       scopeId: this.scopeId,
       traceId: this.fiberContext?.trace?.traceId,
-      spanId: this.fiberContext?.trace?.spanId
+      spanId: this.fiberContext?.trace?.spanId,
+      parentSpanId: this.fiberContext?.trace?.parentSpanId,
+      traceState: this.fiberContext?.trace?.traceState,
+      baggage: this.fiberContext?.trace?.baggage,
+      sampled: this.fiberContext?.trace?.sampled
     });
   }
   addFinalizer(f) {
@@ -3142,7 +3571,7 @@ var RuntimeFiber = class {
   }
   status() {
     if (this.result == null) return "Running";
-    if (this.result._tag === "Failure" && this.result.cause._tag === "Interrupt") return "Interrupted";
+    if (this.result._tag === "Failure" && Cause.isInterruptedOnly(this.result.cause)) return "Interrupted";
     return "Done";
   }
   join(cb) {
@@ -3153,7 +3582,9 @@ var RuntimeFiber = class {
     if (this.result != null) return;
     if (this.interrupted) return;
     this.interrupted = true;
-    this.schedule("interrupt-step");
+    if (this.isInterruptible()) {
+      this.schedule("interrupt-step");
+    }
   }
   schedule(tag = "step") {
     if (this.runState === RUN.DONE || this.runState === RUN.QUEUED) return;
@@ -3196,7 +3627,7 @@ var RuntimeFiber = class {
     this.closing = exit;
     this.runFinalizersOnce(exit);
     this.result = exit;
-    const status = exit._tag === "Success" ? "success" : exit.cause._tag === "Interrupt" ? "interrupted" : "failure";
+    const status = exit._tag === "Success" ? "success" : Cause.isInterruptedOnly(exit.cause) ? "interrupted" : "failure";
     this.emit({
       type: "fiber.end",
       fiberId: this.id,
@@ -3206,46 +3637,109 @@ var RuntimeFiber = class {
     for (const j of this.joiners) j(exit);
     this.joiners.length = 0;
   }
+  isInterruptible() {
+    return this.interruptibilityDepth === 0;
+  }
+  shouldInterruptNow() {
+    return this.interrupted && this.isInterruptible();
+  }
+  enterInterruptibility(mode) {
+    const previousDepth = this.interruptibilityDepth;
+    this.interruptibilityDepth = mode === "uninterruptible" ? previousDepth + 1 : 0;
+    return previousDepth;
+  }
+  restoreInterruptibility(previousDepth) {
+    this.interruptibilityDepth = Math.max(0, previousDepth);
+  }
+  fiberRefs() {
+    const ctx = this.fiberContext;
+    if (!ctx.fiberRefs) ctx.fiberRefs = /* @__PURE__ */ new Map();
+    return ctx.fiberRefs;
+  }
+  restoreFiberRef(frame) {
+    const refs = this.fiberRefs();
+    if (frame.hadValue) refs.set(frame.refId, frame.previousValue);
+    else refs.delete(frame.refId);
+  }
   onSuccess(value) {
-    const frame = this.stack.pop();
-    if (!frame) {
-      this.notify(Exit.succeed(value));
-      return;
-    }
-    if (frame._tag === "SuccessCont") {
+    let currentValue = value;
+    while (true) {
+      const frame = this.stack.pop();
+      if (!frame) {
+        if (this.shouldInterruptNow()) {
+          this.notify(Exit.failCause(Cause.interrupt()));
+        } else {
+          this.notify(Exit.succeed(currentValue));
+        }
+        return;
+      }
+      if (frame._tag === "InterruptibilityCont") {
+        this.restoreInterruptibility(frame.previousDepth);
+        if (this.shouldInterruptNow()) {
+          this.notify(Exit.failCause(Cause.interrupt()));
+          return;
+        }
+        continue;
+      }
+      if (frame._tag === "FiberRefCont") {
+        this.restoreFiberRef(frame);
+        continue;
+      }
+      if (frame._tag === "SuccessCont") {
+        try {
+          this.current = frame.k(currentValue);
+        } catch (e) {
+          this.notify(Exit.failCause(Cause.die(e)));
+        }
+        return;
+      }
       try {
-        this.current = frame.k(value);
+        this.current = frame.onSuccess(currentValue);
       } 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) {
+    this.onCause(Cause.fail(error));
+  }
+  onCause(cause) {
+    let currentCause = cause;
     while (this.stack.length > 0) {
       const fr = this.stack.pop();
+      if (fr._tag === "InterruptibilityCont") {
+        this.restoreInterruptibility(fr.previousDepth);
+        if (this.shouldInterruptNow() && !Cause.isInterruptedOnly(currentCause)) {
+          currentCause = Cause.then(currentCause, Cause.interrupt());
+        }
+        continue;
+      }
+      if (fr._tag === "FiberRefCont") {
+        this.restoreFiberRef(fr);
+        continue;
+      }
       if (fr._tag === "FoldCont") {
+        if (!Cause.isFailureOnly(currentCause)) continue;
+        const failure = Cause.firstFailure(currentCause);
+        if (failure._tag === "None") break;
         try {
-          this.current = fr.onFailure(error);
-          return;
+          this.current = fr.onFailure(failure.value);
+          return true;
         } catch (e) {
-          error = e;
+          currentCause = Cause.fail(e);
           continue;
         }
       }
     }
-    this.notify(Exit.failCause(Cause.fail(error)));
+    this.notify(Exit.failCause(currentCause));
+    return false;
   }
   budget = DEFAULT_BUDGET2;
   step() {
     if (this.result != null) return STEP.DONE;
-    if (this.interrupted) {
-      this.notify(Exit.failCause(Cause.interrupt()));
+    if (this.shouldInterruptNow()) {
+      this.onCause(Cause.interrupt());
       return STEP.DONE;
     }
     this.budget = __benchmarkBudget ?? DEFAULT_BUDGET2;
@@ -3300,14 +3794,7 @@ var RuntimeFiber = class {
             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)));
-              }
+              this.onCause(resolvedExit.cause);
             }
             break;
           }
@@ -3329,6 +3816,47 @@ var RuntimeFiber = class {
           this.onSuccess(child);
           break;
         }
+        case "Interruptibility": {
+          const previousDepth = this.enterInterruptibility(current.mode);
+          this.stack.push({ _tag: "InterruptibilityCont", previousDepth });
+          this.current = current.effect;
+          break;
+        }
+        case "InterruptibilityMask": {
+          const previousDepth = this.enterInterruptibility("uninterruptible");
+          this.stack.push({ _tag: "InterruptibilityCont", previousDepth });
+          try {
+            this.current = current.body((effect) => ({
+              _tag: "InterruptibilityRestore",
+              depth: previousDepth,
+              effect
+            }));
+          } catch (e) {
+            this.onCause(Cause.die(e));
+          }
+          break;
+        }
+        case "InterruptibilityRestore": {
+          const previousDepth = this.interruptibilityDepth;
+          this.restoreInterruptibility(current.depth);
+          this.stack.push({ _tag: "InterruptibilityCont", previousDepth });
+          this.current = current.effect;
+          break;
+        }
+        case "FiberRefLocally": {
+          const refs = this.fiberRefs();
+          const hadValue = refs.has(current.refId);
+          const previousValue = refs.get(current.refId);
+          refs.set(current.refId, current.value);
+          this.stack.push({
+            _tag: "FiberRefCont",
+            refId: current.refId,
+            hadValue,
+            previousValue
+          });
+          this.current = current.effect;
+          break;
+        }
         case "Sync": {
           try {
             const a = current.thunk(this.env);
@@ -3420,14 +3948,7 @@ var RuntimeFiber = class {
               continue;
             } else {
               this.stack.push({ _tag: "SuccessCont", k: andThen });
-              const cause = exit.cause;
-              if (cause._tag === "Fail") {
-                this.onFailure(cause.error);
-              } else if (cause._tag === "Interrupt") {
-                this.notify(Exit.failCause(Cause.interrupt()));
-              } else {
-                this.notify(Exit.failCause(Cause.die(cause.defect)));
-              }
+              this.onCause(exit.cause);
               return this.result != null ? TRAMPOLINE.DONE : TRAMPOLINE.CONTINUE;
             }
           }
@@ -3514,214 +4035,7 @@ var JsFiberEngine = class {
   }
 };
 
-// src/core/runtime/scope.ts
-var nextScopeId = 1;
-function awaitAll(fibers) {
-  return asyncEffect((_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(),
-      () => asyncEffect((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 asyncEffect((_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();
-  });
-}
-
 export {
-  __require,
-  Async,
-  asyncFold,
-  asyncCatchAll,
-  asyncMapError,
-  unit,
-  asyncSucceed,
-  asyncFail,
-  asyncSync,
-  asyncTotal,
-  asyncEffect,
-  asyncMap,
-  asyncFlatMap,
-  acquireRelease,
-  asyncInterruptible,
-  withAsyncPromise,
-  mapAsync,
-  mapTryAsync,
-  none,
-  some,
-  Cause,
-  Exit,
-  succeed,
-  fail,
-  sync,
-  map,
-  flatMap,
-  mapError,
-  catchAll,
-  orElseOptional,
-  end,
   PushStatus,
   RingBuffer,
   resolveWasmModule,
@@ -3731,6 +4045,9 @@ export {
   inferCallerLaneFromStack,
   Scheduler,
   globalScheduler,
+  emptyContext,
+  ctxExtend,
+  ctxToObject,
   DefaultHostExecutor,
   JsFiberEngine,
   HostRegistry,
@@ -3750,6 +4067,8 @@ export {
   makeFiberReadyQueue,
   WasmFiberEngine,
   runtimeCapabilities,
+  liveClock,
+  runtimeClockFromEnv,
   NoopHooks,
   Runtime,
   fork,
@@ -3766,8 +4085,5 @@ export {
   RuntimeFiber,
   getCurrentFiber,
   unsafeGetCurrentRuntime,
-  withCurrentFiber,
-  Scope,
-  withScopeAsync,
-  withScope
+  withCurrentFiber
 };