brass-runtime 1.15.0 → 1.16.0

package/dist/{chunk-BDF4AMWX.mjs → chunk-G6IQOE4P.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-NOYZIMUJ.mjs";
+import {
+  Schema,
+  parseConfig
+} from "./chunk-U5KWK3PX.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);
@@ -978,7 +1043,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 +1065,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 +1082,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
@@ -1605,19 +1691,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 +2070,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 +2176,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;
@@ -2666,6 +2739,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 +2760,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 +2826,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);
   }
@@ -3122,7 +3206,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) {
@@ -3514,214 +3602,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 +3612,9 @@ export {
   inferCallerLaneFromStack,
   Scheduler,
   globalScheduler,
+  emptyContext,
+  ctxExtend,
+  ctxToObject,
   DefaultHostExecutor,
   JsFiberEngine,
   HostRegistry,
@@ -3766,8 +3650,5 @@ export {
   RuntimeFiber,
   getCurrentFiber,
   unsafeGetCurrentRuntime,
-  withCurrentFiber,
-  Scope,
-  withScopeAsync,
-  withScope
+  withCurrentFiber
 };