brass-runtime 1.16.0 → 1.17.0

package/dist/{chunk-7LVI2GIN.js → chunk-FH2X7BVP.js}

@@ -3,11 +3,11 @@ import {
   Cause,
   Exit,
   asyncEffect
-} from "./chunk-PNVFW245.js";
+} from "./chunk-UB4B6OFY.js";
 import {
   Schema,
   parseConfig
-} from "./chunk-TDVMADDN.js";
+} from "./chunk-C3MDXTRZ.js";
 
 // src/core/runtime/ringBuffer.ts
 var PushStatus = /* @__PURE__ */ ((PushStatus3) => {
@@ -1029,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);
@@ -1249,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",
@@ -1261,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 {
@@ -1295,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() {
@@ -1368,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,
@@ -1382,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 {
       }
-    }
+    });
   }
 };
 
@@ -2594,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.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.completeDie(state, cause.defect);
+    this.cleanupState(state);
+    state.handle.complete(Exit.failCause(cause));
   }
   resumeWithValue(state, value) {
     this.pendingResumes.set(state.fiberId, { kind: "value", ref: state.registry.register(value) });
@@ -2727,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() {
@@ -2858,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, () => {
@@ -2882,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
@@ -2900,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);
 }
@@ -3126,6 +3472,7 @@ var RuntimeFiber = class {
   stack = [];
   fiberFinalizers = [];
   finalizersDrained = false;
+  interruptibilityDepth = 0;
   fiberContext;
   name;
   scopeId;
@@ -3164,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 = () => {
@@ -3230,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) {
@@ -3241,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;
@@ -3284,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,
@@ -3294,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;
@@ -3388,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;
           }
@@ -3417,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);
@@ -3508,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;
             }
           }
@@ -3634,6 +4067,8 @@ export {
   makeFiberReadyQueue,
   WasmFiberEngine,
   runtimeCapabilities,
+  liveClock,
+  runtimeClockFromEnv,
   NoopHooks,
   Runtime,
   fork,