brass-runtime 1.16.0 → 1.17.0

package/dist/{chunk-H55LI6WY.js → chunk-MOO4L7F4.mjs}

@@ -1,6 +1,6 @@
 import {
   Cause
-} from "./chunk-PNVFW245.js";
+} from "./chunk-36I3M4UC.mjs";
 
 // src/http/effectRunner.ts
 function registerHttpEffect(effect, env, cb) {
@@ -59,9 +59,12 @@ function registerHttpEffect(effect, env, cb) {
               run(current.onSuccess(exit.value), cont);
               return;
             }
-            if (exit.cause._tag === "Fail") {
-              run(current.onFailure(exit.cause.error), cont);
-              return;
+            if (Cause.isFailureOnly(exit.cause)) {
+              const failure = Cause.firstFailure(exit.cause);
+              if (failure._tag === "Some") {
+                run(current.onFailure(failure.value), cont);
+                return;
+              }
             }
             cont(exit);
           } catch (e) {
@@ -72,6 +75,14 @@ function registerHttpEffect(effect, env, cb) {
       case "Fork":
         cont({ _tag: "Success", value: void 0 });
         return;
+      case "Interruptibility":
+      case "InterruptibilityRestore":
+      case "FiberRefLocally":
+        run(current.effect, cont);
+        return;
+      case "InterruptibilityMask":
+        run(current.body((effect2) => effect2), cont);
+        return;
     }
   };
   run(effect, finish);

package/dist/chunk-MVGUEJ5Z.cjs

@@ -0,0 +1,370 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// 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 }),
+  interruptibility: (mode, effect) => ({ _tag: "Interruptibility", mode, effect })
+};
+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 }),
+  then: (left, right) => ({ _tag: "Then", left, right }),
+  both: (left, right) => ({ _tag: "Both", left, right }),
+  isCause: isCauseValue,
+  failures: causeFailures,
+  defects: causeDefects,
+  firstFailure: firstCauseFailure,
+  firstDefect: firstCauseDefect,
+  containsFailure: causeContainsFailure,
+  containsDefect: causeContainsDefect,
+  containsInterrupt: causeContainsInterrupt,
+  isInterruptedOnly: causeIsInterruptedOnly,
+  isFailureOnly: causeIsFailureOnly,
+  squash: squashCause,
+  toError: causeToError,
+  pretty: prettyCause,
+  format: prettyCause
+};
+function isCause(value) {
+  return isCauseValue(value);
+}
+function prettyCause(cause, options = {}) {
+  const indent = _nullishCoalesce(options.indent, () => ( "  "));
+  const renderError = _nullishCoalesce(options.renderError, () => ( ((error) => formatCauseValue(error))));
+  const renderDefect = _nullishCoalesce(options.renderDefect, () => ( formatCauseValue));
+  const lines = [];
+  const visit = (current, depth, label) => {
+    const prefix = indent.repeat(depth);
+    const head = label ? `${label}: ` : "";
+    switch (current._tag) {
+      case "Fail":
+        lines.push(`${prefix}${head}Fail(${renderError(current.error)})`);
+        return;
+      case "Die":
+        lines.push(`${prefix}${head}Die(${renderDefect(current.defect)})`);
+        return;
+      case "Interrupt":
+        lines.push(`${prefix}${head}Interrupt`);
+        return;
+      case "Then":
+        lines.push(`${prefix}${head}Then`);
+        visit(current.left, depth + 1, "left");
+        visit(current.right, depth + 1, "right");
+        return;
+      case "Both":
+        lines.push(`${prefix}${head}Both`);
+        visit(current.left, depth + 1, "left");
+        visit(current.right, depth + 1, "right");
+        return;
+    }
+  };
+  visit(cause, 0);
+  if (options.singleLine) return lines.map((line) => line.trim()).join("; ");
+  return lines.join("\n");
+}
+var formatCause = prettyCause;
+function isCauseValue(value) {
+  if (typeof value !== "object" || value === null || !("_tag" in value)) return false;
+  const tag = value._tag;
+  switch (tag) {
+    case "Fail":
+      return "error" in value;
+    case "Die":
+      return "defect" in value;
+    case "Interrupt":
+      return true;
+    case "Then":
+    case "Both":
+      return isCauseValue(value.left) && isCauseValue(value.right);
+    default:
+      return false;
+  }
+}
+function causeFailures(cause) {
+  const failures = [];
+  collectFailures(cause, failures);
+  return failures;
+}
+function collectFailures(cause, out) {
+  switch (cause._tag) {
+    case "Fail":
+      out.push(cause.error);
+      return;
+    case "Then":
+    case "Both":
+      collectFailures(cause.left, out);
+      collectFailures(cause.right, out);
+      return;
+    case "Die":
+    case "Interrupt":
+      return;
+  }
+}
+function causeDefects(cause) {
+  const defects = [];
+  collectDefects(cause, defects);
+  return defects;
+}
+function collectDefects(cause, out) {
+  switch (cause._tag) {
+    case "Die":
+      out.push(cause.defect);
+      return;
+    case "Then":
+    case "Both":
+      collectDefects(cause.left, out);
+      collectDefects(cause.right, out);
+      return;
+    case "Fail":
+    case "Interrupt":
+      return;
+  }
+}
+function firstCauseFailure(cause) {
+  switch (cause._tag) {
+    case "Fail":
+      return some(cause.error);
+    case "Then":
+    case "Both": {
+      const left = firstCauseFailure(cause.left);
+      return left._tag === "Some" ? left : firstCauseFailure(cause.right);
+    }
+    case "Die":
+    case "Interrupt":
+      return none;
+  }
+}
+function firstCauseDefect(cause) {
+  switch (cause._tag) {
+    case "Die":
+      return some(cause.defect);
+    case "Then":
+    case "Both": {
+      const left = firstCauseDefect(cause.left);
+      return left._tag === "Some" ? left : firstCauseDefect(cause.right);
+    }
+    case "Fail":
+    case "Interrupt":
+      return none;
+  }
+}
+function causeContainsFailure(cause) {
+  switch (cause._tag) {
+    case "Fail":
+      return true;
+    case "Then":
+    case "Both":
+      return causeContainsFailure(cause.left) || causeContainsFailure(cause.right);
+    case "Die":
+    case "Interrupt":
+      return false;
+  }
+}
+function causeContainsDefect(cause) {
+  switch (cause._tag) {
+    case "Die":
+      return true;
+    case "Then":
+    case "Both":
+      return causeContainsDefect(cause.left) || causeContainsDefect(cause.right);
+    case "Fail":
+    case "Interrupt":
+      return false;
+  }
+}
+function causeContainsInterrupt(cause) {
+  switch (cause._tag) {
+    case "Interrupt":
+      return true;
+    case "Then":
+    case "Both":
+      return causeContainsInterrupt(cause.left) || causeContainsInterrupt(cause.right);
+    case "Fail":
+    case "Die":
+      return false;
+  }
+}
+function causeIsInterruptedOnly(cause) {
+  return causeContainsInterrupt(cause) && !causeContainsFailure(cause) && !causeContainsDefect(cause);
+}
+function causeIsFailureOnly(cause) {
+  return causeContainsFailure(cause) && !causeContainsInterrupt(cause) && !causeContainsDefect(cause);
+}
+function squashCause(cause) {
+  const failure = firstCauseFailure(cause);
+  if (failure._tag === "Some") return failure.value;
+  const defect = firstCauseDefect(cause);
+  if (defect._tag === "Some") return defect.value instanceof Error ? defect.value : new Error(String(defect.value));
+  if (causeContainsInterrupt(cause)) return new Error("Interrupted");
+  return new Error(prettyCause(cause, { singleLine: true }));
+}
+function causeToError(cause) {
+  const squashed = squashCause(cause);
+  if (squashed instanceof Error) return squashed;
+  return new Error(formatCauseValue(squashed));
+}
+function formatCauseValue(value) {
+  if (value instanceof Error) return `${value.name}: ${value.message}`;
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch (e2) {
+    return String(value);
+  }
+}
+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);
+var uninterruptible = (effect) => ({
+  _tag: "Interruptibility",
+  mode: "uninterruptible",
+  effect
+});
+var interruptible = (effect) => ({
+  _tag: "Interruptibility",
+  mode: "interruptible",
+  effect
+});
+function uninterruptibleMask(body) {
+  return { _tag: "InterruptibilityMask", body };
+}
+function orElseOptional(fa, that) {
+  return asyncFold(
+    fa,
+    (opt) => opt._tag === "Some" ? asyncFail(opt) : that(),
+    asyncSucceed
+  );
+}
+var end = () => fail(none);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Async = Async; exports.asyncFold = asyncFold; exports.asyncCatchAll = asyncCatchAll; exports.asyncMapError = asyncMapError; exports.unit = unit; exports.asyncSucceed = asyncSucceed; exports.asyncFail = asyncFail; exports.asyncSync = asyncSync; exports.asyncTotal = asyncTotal; exports.asyncEffect = asyncEffect; exports.asyncMap = asyncMap; exports.asyncFlatMap = asyncFlatMap; exports.acquireRelease = acquireRelease; exports.asyncInterruptible = asyncInterruptible; exports.withAsyncPromise = withAsyncPromise; exports.mapAsync = mapAsync; exports.mapTryAsync = mapTryAsync; exports.none = none; exports.some = some; exports.Cause = Cause; exports.isCause = isCause; exports.prettyCause = prettyCause; exports.formatCause = formatCause; exports.Exit = Exit; exports.succeed = succeed; exports.fail = fail; exports.sync = sync; exports.map = map; exports.flatMap = flatMap; exports.mapError = mapError; exports.catchAll = catchAll; exports.uninterruptible = uninterruptible; exports.interruptible = interruptible; exports.uninterruptibleMask = uninterruptibleMask; exports.orElseOptional = orElseOptional; exports.end = end;

package/dist/chunk-PD4EJTQC.cjs

@@ -0,0 +1,229 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk52PPNNI4cjs = require('./chunk-52PPNNI4.cjs');
+
+
+
+var _chunkGLE2WY7Zcjs = require('./chunk-GLE2WY7Z.cjs');
+
+
+
+
+var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
+
+// src/core/runtime/fiberRef.ts
+var nextFiberRefId = 1;
+function makeFiberRef(initial) {
+  const ref = {
+    id: nextFiberRefId++,
+    initial,
+    get: () => getFiberRef(ref),
+    set: (value) => setFiberRef(ref, value),
+    update: (f) => updateFiberRef(ref, f),
+    modify: (f) => modifyFiberRef(ref, f),
+    locally: (value, effect) => locallyFiberRef(ref, value, effect),
+    locallyWith: (f, effect) => locallyFiberRefWith(ref, f, effect),
+    unsafeGet: () => unsafeGetFiberRef(ref),
+    unsafeSet: (value) => unsafeSetFiberRef(ref, value)
+  };
+  return ref;
+}
+function getFiberRef(ref) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => unsafeGetFiberRef(ref));
+}
+function setFiberRef(ref, value) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+    unsafeSetFiberRef(ref, value);
+  });
+}
+function updateFiberRef(ref, f) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+    const next = f(unsafeGetFiberRef(ref));
+    unsafeSetFiberRef(ref, next);
+    return next;
+  });
+}
+function modifyFiberRef(ref, f) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+    const [result, next] = f(unsafeGetFiberRef(ref));
+    unsafeSetFiberRef(ref, next);
+    return result;
+  });
+}
+function locallyFiberRef(ref, value, effect) {
+  return {
+    _tag: "FiberRefLocally",
+    refId: ref.id,
+    value,
+    effect
+  };
+}
+function locallyFiberRefWith(ref, f, effect) {
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, getFiberRef(ref), (value) => locallyFiberRef(ref, f(value), effect));
+}
+function unsafeGetFiberRef(ref) {
+  const refs = currentFiberRefs(false);
+  return _optionalChain([refs, 'optionalAccess', _ => _.has, 'call', _2 => _2(ref.id)]) ? refs.get(ref.id) : ref.initial;
+}
+function unsafeSetFiberRef(ref, value) {
+  const refs = currentFiberRefs(true);
+  _optionalChain([refs, 'optionalAccess', _3 => _3.set, 'call', _4 => _4(ref.id, value)]);
+}
+function fiberRefSnapshot() {
+  return new Map(currentFiberRefs(false));
+}
+function currentFiberRefs(create) {
+  const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
+  if (!fiber) return void 0;
+  fiber.fiberContext ??= { log: _chunkGLE2WY7Zcjs.emptyContext, trace: null };
+  if (!fiber.fiberContext.fiberRefs && create) fiber.fiberContext.fiberRefs = /* @__PURE__ */ new Map();
+  return fiber.fiberContext.fiberRefs;
+}
+
+// src/core/runtime/recorder.ts
+function makeRuntimeRecorder(options = {}) {
+  const capacity = Math.max(1, Math.floor(_nullishCoalesce(options.maxEvents, () => ( 2048))));
+  const records = new Array(capacity);
+  let next = 0;
+  let size = 0;
+  let dropped = 0;
+  let seq = 1;
+  const snapshot = () => {
+    const out = [];
+    const start = size === capacity ? next : 0;
+    for (let i = 0; i < size; i++) {
+      const record = records[(start + i) % capacity];
+      if (record) out.push(record);
+    }
+    return out;
+  };
+  const emit = (ev, ctx) => {
+    records[next] = _chunk52PPNNI4cjs.makeRuntimeEventRecord.call(void 0, ev, ctx, seq++);
+    next = (next + 1) % capacity;
+    if (size < capacity) size++;
+    else dropped++;
+  };
+  const clear = () => {
+    records.fill(void 0);
+    next = 0;
+    size = 0;
+    dropped = 0;
+  };
+  const stats = () => {
+    const current = snapshot();
+    return {
+      size,
+      capacity,
+      dropped,
+      ...current[0] ? { firstSeq: current[0].seq } : {},
+      ...current[current.length - 1] ? { lastSeq: current[current.length - 1].seq } : {}
+    };
+  };
+  const recorder = {
+    emit,
+    snapshot,
+    clear,
+    stats,
+    explain: (explainOptions = {}) => explainRuntimeEvents(snapshot(), dropped, explainOptions)
+  };
+  return Object.assign(recorder, { hooks: recorder });
+}
+function explainRuntimeEvents(events, dropped, options) {
+  const maxEvents = Math.max(1, Math.floor(_nullishCoalesce(options.maxEvents, () => ( 80))));
+  const slice = events.length > maxEvents ? events.slice(events.length - maxEvents) : events;
+  const fiberStarts = /* @__PURE__ */ new Map();
+  const fiberSuspends = /* @__PURE__ */ new Map();
+  const lines = [`Runtime flight recorder: ${events.length} event${events.length === 1 ? "" : "s"}${dropped > 0 ? `, ${dropped} dropped` : ""}.`];
+  for (const event of slice) {
+    switch (event.type) {
+      case "fiber.start": {
+        fiberStarts.set(event.fiberId, event);
+        lines.push(`fiber#${event.fiberId} started${event.name ? ` "${event.name}"` : ""}${event.parentFiberId !== void 0 ? ` parent=fiber#${event.parentFiberId}` : ""}`);
+        break;
+      }
+      case "fiber.suspend": {
+        fiberSuspends.set(event.fiberId, event);
+        lines.push(`fiber#${event.fiberId} suspended awaiting ${_nullishCoalesce(event.reason, () => ( "unknown"))}`);
+        break;
+      }
+      case "fiber.resume": {
+        const suspended = fiberSuspends.get(event.fiberId);
+        fiberSuspends.delete(event.fiberId);
+        lines.push(`fiber#${event.fiberId} resumed${suspended ? ` after ${durationMs(suspended, event)} awaiting ${fiberSuspendReason(suspended)}` : ""}`);
+        break;
+      }
+      case "fiber.end": {
+        const started = fiberStarts.get(event.fiberId);
+        const suspended = fiberSuspends.get(event.fiberId);
+        fiberSuspends.delete(event.fiberId);
+        lines.push(`fiber#${event.fiberId} ended ${event.status}${started ? ` after ${durationMs(started, event)}` : ""}${suspended ? ` while awaiting ${fiberSuspendReason(suspended)}` : ""}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      }
+      case "scope.open":
+        lines.push(`scope#${event.scopeId} opened${event.parentScopeId !== void 0 ? ` parent=scope#${event.parentScopeId}` : ""}`);
+        break;
+      case "scope.close":
+        lines.push(`scope#${event.scopeId} closed ${event.status}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      case "supervisor.child.restart":
+        lines.push(`supervisor#${event.supervisorId} restarting child#${event.childId} attempt=${event.restartCount} delay=${event.delayMs}ms${event.reason ? ` reason=${event.reason}` : ""}`);
+        break;
+      case "supervisor.child.escalate":
+        lines.push(`supervisor#${event.supervisorId} escalated child#${event.childId}${event.reason ? ` reason=${event.reason}` : ""}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      case "schedule.decision":
+        lines.push(`schedule${event.name ? ` "${event.name}"` : ""} attempt=${event.attempt} ${event.continue ? "continues" : "stops"} delay=${event.delayMs}ms elapsed=${Math.round(event.elapsedMs)}ms${event.reason ? ` reason=${event.reason}` : ""}`);
+        break;
+      case "log":
+        if (event.level === "warn" || event.level === "error") {
+          lines.push(`${event.level}: ${_nullishCoalesce(event.message, () => ( ""))}${event.fields ? ` ${JSON.stringify(event.fields)}` : ""}`);
+        }
+        break;
+      case "span.start":
+        lines.push(`span started "${event.name}"${event.traceId ? ` trace=${event.traceId}` : ""}`);
+        break;
+      case "span.end":
+        lines.push(`span ended ${event.status}${event.name ? ` "${event.name}"` : ""}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      default:
+        break;
+    }
+  }
+  for (const suspended of fiberSuspends.values()) {
+    lines.push(`fiber#${suspended.fiberId} still suspended for ${durationFromNowMs(suspended)} awaiting ${fiberSuspendReason(suspended)}`);
+  }
+  return lines.join("\n");
+}
+function durationMs(start, end) {
+  return `${Math.max(0, Math.round(end.wallTs - start.wallTs))}ms`;
+}
+function durationFromNowMs(start) {
+  return `${Math.max(0, Math.round(Date.now() - start.wallTs))}ms`;
+}
+function formatUnknown(value) {
+  if (_chunkMVGUEJ5Zcjs.Cause.isCause(value)) return _chunkMVGUEJ5Zcjs.Cause.pretty(value, { singleLine: true });
+  if (value instanceof Error) return value.message;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch (e) {
+    return String(value);
+  }
+}
+function fiberSuspendReason(record) {
+  return record.type === "fiber.suspend" ? _nullishCoalesce(record.reason, () => ( "unknown")) : "unknown";
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.makeFiberRef = makeFiberRef; exports.getFiberRef = getFiberRef; exports.setFiberRef = setFiberRef; exports.updateFiberRef = updateFiberRef; exports.modifyFiberRef = modifyFiberRef; exports.locallyFiberRef = locallyFiberRef; exports.locallyFiberRefWith = locallyFiberRefWith; exports.unsafeGetFiberRef = unsafeGetFiberRef; exports.unsafeSetFiberRef = unsafeSetFiberRef; exports.fiberRefSnapshot = fiberRefSnapshot; exports.makeRuntimeRecorder = makeRuntimeRecorder;