brass-runtime 1.13.7 → 1.14.0

package/dist/chunk-JT7D6M5H.js

@@ -0,0 +1,3897 @@
+// src/core/types/asyncEffect.ts
+var Async = {
+  succeed: (value) => ({ _tag: "Succeed", value }),
+  fail: (error) => ({ _tag: "Fail", error }),
+  sync: (thunk) => ({ _tag: "Sync", thunk }),
+  async: (register) => ({ _tag: "Async", register })
+};
+function asyncFold(fa, onFailure, onSuccess) {
+  return { _tag: "Fold", first: fa, onFailure, onSuccess };
+}
+function asyncCatchAll(fa, handler) {
+  return asyncFold(
+    fa,
+    (e) => handler(e),
+    (a) => asyncSucceed(a)
+  );
+}
+function asyncMapError(fa, f) {
+  return asyncFold(
+    fa,
+    (e) => asyncFail(f(e)),
+    (a) => asyncSucceed(a)
+  );
+}
+var SUCCEED_UNDEFINED = { _tag: "Succeed", value: void 0 };
+var SUCCEED_TRUE = { _tag: "Succeed", value: true };
+var SUCCEED_FALSE = { _tag: "Succeed", value: false };
+var SUCCEED_NULL = { _tag: "Succeed", value: null };
+var unit = () => SUCCEED_UNDEFINED;
+var asyncSucceed = (value) => {
+  if (value === void 0) return SUCCEED_UNDEFINED;
+  if (value === true) return SUCCEED_TRUE;
+  if (value === false) return SUCCEED_FALSE;
+  if (value === null) return SUCCEED_NULL;
+  return { _tag: "Succeed", value };
+};
+var asyncFail = (error) => ({
+  _tag: "Fail",
+  error
+});
+var asyncSync = (thunk) => ({
+  _tag: "Sync",
+  thunk
+});
+var asyncTotal = (thunk) => asyncSync(() => thunk());
+var async = (register) => ({
+  _tag: "Async",
+  register
+});
+function asyncMap(fa, f) {
+  return asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
+}
+function asyncFlatMap(fa, f) {
+  return {
+    _tag: "FlatMap",
+    first: fa,
+    andThen: f
+  };
+}
+function acquireRelease(acquire, release, scope) {
+  return asyncFlatMap(acquire, (resource) => {
+    scope.addFinalizer((exit) => release(resource, exit));
+    return asyncSucceed(resource);
+  });
+}
+function asyncInterruptible(register) {
+  return async(register);
+}
+var withAsyncPromise = (run) => (eff) => {
+  const anyEff = eff;
+  if (!anyEff.toPromise) {
+    anyEff.toPromise = (env) => run(eff, env);
+    anyEff.unsafeRunPromise = () => run(eff, {});
+  }
+  return anyEff;
+};
+var mapAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
+var mapTryAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSync(() => f(a)));
+
+// src/core/types/option.ts
+var none = { _tag: "None" };
+var some = (value) => ({ _tag: "Some", value });
+
+// src/core/types/effect.ts
+var Cause = {
+  fail: (error) => ({ _tag: "Fail", error }),
+  interrupt: () => ({ _tag: "Interrupt" }),
+  die: (defect) => ({ _tag: "Die", defect })
+};
+var Exit = {
+  succeed: (value) => ({
+    _tag: "Success",
+    value
+  }),
+  failCause: (cause) => ({
+    _tag: "Failure",
+    cause
+  })
+};
+var succeed = (value) => asyncSucceed(value);
+var fail = (error) => asyncFail(error);
+var sync = (thunk) => asyncSync((env) => thunk(env));
+var map = (fa, f) => asyncMap(fa, f);
+var flatMap = (fa, f) => asyncFlatMap(fa, (a) => f(a));
+var mapError = (fa, f) => asyncMapError(fa, f);
+var catchAll = (fa, handler) => asyncFold(
+  fa,
+  (e) => handler(e),
+  (a) => asyncSucceed(a)
+);
+function orElseOptional(fa, that) {
+  return asyncFold(
+    fa,
+    (opt) => opt._tag === "Some" ? asyncFail(opt) : that(),
+    (a) => asyncSucceed(a)
+  );
+}
+var end = () => fail(none);
+
+// src/core/runtime/ringBuffer.ts
+var PushStatus = /* @__PURE__ */ ((PushStatus3) => {
+  PushStatus3[PushStatus3["Ok"] = 0] = "Ok";
+  PushStatus3[PushStatus3["Grew"] = 1] = "Grew";
+  PushStatus3[PushStatus3["Dropped"] = 2] = "Dropped";
+  return PushStatus3;
+})(PushStatus || {});
+var RingBuffer = class {
+  buf;
+  head = 0;
+  tail = 0;
+  size_ = 0;
+  // nuevo
+  maxCap;
+  constructor(initialCapacity = 1024, maxCapacity = initialCapacity) {
+    let initPow = Math.max(2, initialCapacity);
+    initPow--;
+    initPow |= initPow >>> 1;
+    initPow |= initPow >>> 2;
+    initPow |= initPow >>> 4;
+    initPow |= initPow >>> 8;
+    initPow |= initPow >>> 16;
+    initPow++;
+    let maxPow = Math.max(initPow, maxCapacity);
+    maxPow--;
+    maxPow |= maxPow >>> 1;
+    maxPow |= maxPow >>> 2;
+    maxPow |= maxPow >>> 4;
+    maxPow |= maxPow >>> 8;
+    maxPow |= maxPow >>> 16;
+    maxPow++;
+    this.buf = new Array(initPow);
+    this.maxCap = maxPow;
+  }
+  get length() {
+    return this.size_;
+  }
+  get capacity() {
+    return this.buf.length;
+  }
+  isEmpty() {
+    return this.size_ === 0;
+  }
+  push(value) {
+    if (this.size_ === this.buf.length) {
+      if (this.buf.length >= this.maxCap) {
+        return 2 /* Dropped */;
+      }
+      this.grow();
+      this.buf[this.tail] = value;
+      this.tail = this.tail + 1 & this.buf.length - 1;
+      this.size_++;
+      return 0 /* Ok */ | 1 /* Grew */;
+    }
+    this.buf[this.tail] = value;
+    this.tail = this.tail + 1 & this.buf.length - 1;
+    this.size_++;
+    return 0 /* Ok */;
+  }
+  shift() {
+    if (this.size_ === 0) return void 0;
+    const value = this.buf[this.head];
+    this.buf[this.head] = void 0;
+    this.head = this.head + 1 & this.buf.length - 1;
+    this.size_--;
+    return value;
+  }
+  clear() {
+    this.head = 0;
+    this.tail = 0;
+    this.size_ = 0;
+  }
+  grow() {
+    const old = this.buf;
+    const nextLen = Math.min(old.length * 2, this.maxCap);
+    const newBuf = new Array(nextLen);
+    for (let i = 0; i < this.size_; i++) {
+      newBuf[i] = old[this.head + i & old.length - 1];
+    }
+    this.buf = newBuf;
+    this.head = 0;
+    this.tail = this.size_;
+  }
+};
+
+// src/core/runtime/wasmModule.ts
+import { createRequire } from "module";
+var cachedWasmModule;
+var cachedWasmModuleErrors = [];
+function resolveWasmModule(options = {}) {
+  if (!options.fresh && options.modulePath == null && cachedWasmModule !== void 0) {
+    return cachedWasmModule;
+  }
+  const req = getBestRequire();
+  const candidates = wasmModuleCandidates(options.modulePath);
+  const errors = [];
+  if (!req) {
+    errors.push("no CommonJS-compatible require/createRequire was available");
+    return remember(options, null, errors);
+  }
+  for (const candidate of candidates) {
+    try {
+      return remember(options, req(candidate), errors);
+    } catch (error) {
+      errors.push(`${candidate}: ${formatError(error)}`);
+    }
+  }
+  return remember(options, null, errors);
+}
+function wasmModuleResolutionErrors() {
+  return cachedWasmModuleErrors.slice();
+}
+function wasmModuleCandidates(modulePath) {
+  if (modulePath) return [modulePath];
+  return [
+    "brass-runtime/wasm/pkg/brass_runtime_wasm_engine.js",
+    "../wasm/pkg/brass_runtime_wasm_engine.js",
+    "../../../wasm/pkg/brass_runtime_wasm_engine.js",
+    "../../../../../wasm/pkg/brass_runtime_wasm_engine.js",
+    `${getCwd()}/wasm/pkg/brass_runtime_wasm_engine.js`
+  ];
+}
+function remember(options, value, errors) {
+  if (!options.fresh && options.modulePath == null) {
+    cachedWasmModule = value;
+    cachedWasmModuleErrors = errors;
+  }
+  return value;
+}
+function getBestRequire() {
+  return getNonWebpackRequire() ?? getRuntimeRequire() ?? getCreateRequire();
+}
+function getNonWebpackRequire() {
+  try {
+    return (0, eval)(
+      "typeof __non_webpack_require__ === 'function' ? __non_webpack_require__ : undefined"
+    );
+  } catch {
+    return void 0;
+  }
+}
+function getRuntimeRequire() {
+  try {
+    return (0, eval)(
+      "typeof require === 'function' ? require : undefined"
+    );
+  } catch {
+    return void 0;
+  }
+}
+function getCreateRequire() {
+  try {
+    return createRequire(`${getCwd()}/package.json`);
+  } catch {
+    return void 0;
+  }
+}
+function getCwd() {
+  try {
+    return (0, eval)(
+      "typeof process !== 'undefined' ? process.cwd() : ''"
+    );
+  } catch {
+    return "";
+  }
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/core/runtime/boundedRingBuffer.ts
+var cachedWasmCtor;
+function resolveWasmRingBuffer() {
+  if (cachedWasmCtor !== void 0) return cachedWasmCtor;
+  const mod = resolveWasmModule();
+  cachedWasmCtor = mod?.BrassWasmRingBuffer ?? null;
+  return cachedWasmCtor;
+}
+var WasmRingBuffer = class {
+  engine = "wasm";
+  fallbackUsed = false;
+  inner;
+  pushes = 0;
+  shifts = 0;
+  clears = 0;
+  dropped = 0;
+  constructor(initialCapacity, maxCapacity) {
+    const Ctor = resolveWasmRingBuffer();
+    if (!Ctor) {
+      throw new Error("brass-runtime wasm ring buffer is not available. Run npm run build:wasm first.");
+    }
+    this.inner = new Ctor(initialCapacity, maxCapacity);
+  }
+  get length() {
+    return this.inner.len();
+  }
+  get capacity() {
+    return this.inner.capacity();
+  }
+  isEmpty() {
+    return this.inner.is_empty();
+  }
+  push(value) {
+    this.pushes++;
+    const status = this.inner.push(value);
+    if ((status & 2) !== 0) this.dropped++;
+    return status;
+  }
+  shift() {
+    const value = this.inner.shift();
+    if (value !== void 0) this.shifts++;
+    return value === void 0 ? void 0 : value;
+  }
+  clear() {
+    this.clears++;
+    this.inner.clear();
+  }
+  stats() {
+    return {
+      engine: "wasm",
+      fallbackUsed: false,
+      data: {
+        len: this.length,
+        capacity: this.capacity,
+        pushes: this.pushes,
+        shifts: this.shifts,
+        clears: this.clears,
+        dropped: this.dropped
+      }
+    };
+  }
+};
+var TsBoundedRingBuffer = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  inner;
+  engine = "ts";
+  fallbackUsed = false;
+  pushes = 0;
+  shifts = 0;
+  clears = 0;
+  dropped = 0;
+  get length() {
+    return this.inner.length;
+  }
+  get capacity() {
+    return this.inner.capacity;
+  }
+  isEmpty() {
+    return this.inner.isEmpty();
+  }
+  push(value) {
+    this.pushes++;
+    const status = this.inner.push(value);
+    if ((status & 2) !== 0) this.dropped++;
+    return status;
+  }
+  shift() {
+    const value = this.inner.shift();
+    if (value !== void 0) this.shifts++;
+    return value;
+  }
+  clear() {
+    this.clears++;
+    this.inner.clear();
+  }
+  stats() {
+    return {
+      engine: "ts",
+      fallbackUsed: false,
+      data: {
+        len: this.length,
+        capacity: this.capacity,
+        pushes: this.pushes,
+        shifts: this.shifts,
+        clears: this.clears,
+        dropped: this.dropped
+      }
+    };
+  }
+};
+function makeBoundedRingBuffer(initialCapacity, maxCapacity = initialCapacity, options = {}) {
+  const engine = options.engine ?? "ts";
+  if (engine === "ts") {
+    return new TsBoundedRingBuffer(new RingBuffer(initialCapacity, maxCapacity));
+  }
+  if (engine === "wasm") {
+    return new WasmRingBuffer(initialCapacity, maxCapacity);
+  }
+  throw new Error(`brass-runtime ring buffer engine must be 'ts' or 'wasm'; received '${String(engine)}'`);
+}
+
+// src/core/runtime/scheduler.ts
+var FLUSH_BUDGET = 2048;
+var MICRO_THRESHOLD = 4096;
+var SCHEDULER_QUEUE_CAPACITY = 8192;
+var DEFAULT_LANE_CAPACITY = 1024;
+var DEFAULT_LANE_BUDGET = 64;
+var DEFAULT_MAX_LANES = 256;
+var scheduleMacro = (() => {
+  if (typeof globalThis.setImmediate === "function") return (f) => globalThis.setImmediate(f);
+  if (typeof globalThis.MessageChannel === "function") {
+    const ch = new globalThis.MessageChannel();
+    let cb = null;
+    ch.port1.onmessage = () => {
+      const f = cb;
+      cb = null;
+      f?.();
+    };
+    return (f) => {
+      cb = f;
+      ch.port2.postMessage(0);
+    };
+  }
+  return (f) => setTimeout(f, 0);
+})();
+function resolveWasmScheduler() {
+  const mod = resolveWasmModule();
+  return mod?.BrassWasmSchedulerStateMachine ?? null;
+}
+var LaneState = class {
+  constructor(key, initial, max) {
+    this.key = key;
+    this.queue = makeBoundedRingBuffer(initial, max, { engine: "ts" });
+  }
+  key;
+  queue;
+  enqueuedTasks = 0;
+  executedTasks = 0;
+  droppedTasks = 0;
+};
+var JsSchedulerState = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  lanes = /* @__PURE__ */ new Map();
+  laneOrder = [];
+  rrIndex = 0;
+  rrRemaining = 0;
+  flushing = false;
+  scheduled = false;
+  scheduledFlushes = 0;
+  completedFlushes = 0;
+  enqueuedTasks = 0;
+  executedTasks = 0;
+  droppedTasks = 0;
+  yieldedByBudget = 0;
+  totalLength = 0;
+  get totalCapacity() {
+    let n = 0;
+    for (const lane of this.lanes.values()) n += lane.queue.capacity;
+    return n;
+  }
+};
+var WasmSchedulerState = class {
+  machine;
+  nextRef = 1;
+  tasks = /* @__PURE__ */ new Map();
+  tags = /* @__PURE__ */ new Map();
+  constructor(options) {
+    const Ctor = resolveWasmScheduler();
+    if (!Ctor) throw new Error("brass-runtime wasm scheduler is not available. Run npm run build:wasm first.");
+    this.machine = new Ctor(
+      options.initialCapacity ?? 1024,
+      options.maxCapacity ?? SCHEDULER_QUEUE_CAPACITY,
+      options.flushBudget ?? FLUSH_BUDGET,
+      options.microThreshold ?? MICRO_THRESHOLD,
+      options.laneCapacity ?? DEFAULT_LANE_CAPACITY,
+      options.laneBudget ?? DEFAULT_LANE_BUDGET,
+      options.maxLanes ?? DEFAULT_MAX_LANES
+    );
+  }
+  enqueue(task, tag) {
+    const ref = this.nextRef++;
+    this.tasks.set(ref, task);
+    this.tags.set(ref, tag);
+    const policy = this.machine.enqueue(ref, tag);
+    if (policy === 3) {
+      this.tasks.delete(ref);
+      this.tags.delete(ref);
+    }
+    return policy;
+  }
+  enqueueBatch(tasks) {
+    const refs = [];
+    const tags = [];
+    for (const { task, tag } of tasks) {
+      const ref = this.nextRef++;
+      this.tasks.set(ref, task);
+      this.tags.set(ref, tag);
+      refs.push(ref);
+      tags.push(tag);
+    }
+    const policies = this.machine.enqueue_batch(new Uint32Array(refs), tags);
+    for (let i = 0; i < policies.length; i++) {
+      if (policies[i] === 3) {
+        this.tasks.delete(refs[i]);
+        this.tags.delete(refs[i]);
+      }
+    }
+    return Array.from(policies);
+  }
+  beginFlush() {
+    return this.machine.begin_flush();
+  }
+  shift() {
+    const ref = this.machine.shift();
+    if (ref === 0) return void 0;
+    const task = this.tasks.get(ref);
+    const tag = this.tags.get(ref) ?? "anonymous";
+    this.tasks.delete(ref);
+    this.tags.delete(ref);
+    return task ? { task, tag } : void 0;
+  }
+  endFlush(ran) {
+    return this.machine.end_flush(ran);
+  }
+  stats() {
+    return { engine: "wasm", fallbackUsed: false, data: JSON.parse(this.machine.stats_json()) };
+  }
+};
+function sanitizeLaneKey(value) {
+  let key = "";
+  let previousWasColon = false;
+  for (const ch of value.trim()) {
+    if (isLaneWhitespace(ch)) {
+      if (!previousWasColon && key.length > 0) key += ":";
+      previousWasColon = true;
+      continue;
+    }
+    if (isAsciiAlphaNumeric(ch) || ch === "_" || ch === "." || ch === ":" || ch === "/" || ch === "#" || ch === "-") {
+      key += ch;
+      previousWasColon = ch === ":";
+    } else {
+      key += "_";
+      previousWasColon = false;
+    }
+    if (key.length >= 160) break;
+  }
+  return key.length > 0 ? key : "anonymous";
+}
+function isLaneWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v";
+}
+function isAsciiAlphaNumeric(ch) {
+  if (ch.length !== 1) return false;
+  const code = ch.charCodeAt(0);
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function laneTag(lane, tag = "task") {
+  return `lane:${sanitizeLaneKey(lane)}|${tag}`;
+}
+function extractStackLocation(line) {
+  const raw = extractParenthesizedLocation(line) ?? extractAtLocation(line);
+  if (!raw) return void 0;
+  return stripLineAndColumn(raw);
+}
+function extractParenthesizedLocation(line) {
+  const closeIdx = line.lastIndexOf(")");
+  if (closeIdx <= 0) return void 0;
+  const openIdx = line.lastIndexOf("(", closeIdx - 1);
+  if (openIdx < 0 || openIdx + 1 >= closeIdx) return void 0;
+  return line.slice(openIdx + 1, closeIdx).trim();
+}
+function extractAtLocation(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("at ")) return void 0;
+  const afterAt = trimmed.slice(3).trimStart();
+  if (!afterAt) return void 0;
+  const lastSpace = afterAt.lastIndexOf(" ");
+  return (lastSpace >= 0 ? afterAt.slice(lastSpace + 1) : afterAt).trim();
+}
+function stripLineAndColumn(location) {
+  let out = location.trim();
+  out = stripTrailingNumericSegment(out);
+  out = stripTrailingNumericSegment(out);
+  return out;
+}
+function stripTrailingNumericSegment(value) {
+  const colon = value.lastIndexOf(":");
+  if (colon < 0 || colon + 1 >= value.length) return value;
+  for (let i = colon + 1; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 48 || code > 57) return value;
+  }
+  return value.slice(0, colon);
+}
+function normalizeSlashes(value) {
+  return value.replaceAll("\\", "/").trim();
+}
+function isPseudoStackLocation(location) {
+  const normalized = normalizeSlashes(location);
+  return normalized === "<anonymous>" || normalized === "anonymous" || normalized.startsWith("node:") || normalized.includes("/node_modules/") || normalized.startsWith("node_modules/");
+}
+function isInternalRuntimeFrame(location, line) {
+  const normalized = normalizeSlashes(location);
+  const frame = normalizeSlashes(line);
+  return isRuntimeSourcePath(normalized) || isRuntimeDistFile(normalized) || normalized.includes("/node_modules/brass-runtime/") || normalized.endsWith("/node_modules/brass-runtime") || INTERNAL_FRAME_TOKENS.some((token) => frame.includes(token));
+}
+var INTERNAL_FRAME_TOKENS = [
+  "inferCallerLaneFromStack",
+  "Runtime.",
+  "RuntimeFiber.",
+  "EngineFiberHandle.",
+  "WasmFiberEngine.",
+  "JsFiberEngine.",
+  "Scheduler."
+];
+function isRuntimeSourcePath(path) {
+  const marker = "src/core/runtime/";
+  const idx = path.startsWith(marker) ? 0 : path.indexOf(`/${marker}`);
+  if (idx < 0) return false;
+  const offset = idx === 0 ? marker.length : idx + marker.length + 1;
+  const rest = path.slice(offset);
+  return rest !== "__tests__" && !rest.startsWith("__tests__/");
+}
+function isRuntimeDistFile(path) {
+  if (!hasPathSegment(path, "dist")) return false;
+  const file = basename(path);
+  const stem = dropKnownExtension(file);
+  if (stem === file) return false;
+  return stem === "index" || stem.includes("runtime");
+}
+function hasPathSegment(path, segment) {
+  return normalizeSlashes(path).split("/").includes(segment);
+}
+function basename(path) {
+  const normalized = normalizeSlashes(path);
+  const slash = normalized.lastIndexOf("/");
+  return slash < 0 ? normalized : normalized.slice(slash + 1);
+}
+function normalizeCallerLocation(location) {
+  let out = normalizeSlashes(location);
+  if (out.startsWith("file://")) out = out.slice("file://".length);
+  const srcIdx = out.lastIndexOf("/src/");
+  if (srcIdx >= 0) {
+    out = out.slice(srcIdx + 5);
+  } else {
+    const cwd = typeof process !== "undefined" ? normalizeSlashes(process.cwd()) : "";
+    if (cwd && out.startsWith(cwd + "/")) out = out.slice(cwd.length + 1);
+    out = lastPathSegments(out, 2);
+  }
+  return dropKnownExtension(out);
+}
+function lastPathSegments(path, count) {
+  const parts = normalizeSlashes(path).split("/").filter((part) => part.length > 0);
+  if (parts.length <= count) return path;
+  return parts.slice(parts.length - count).join("/");
+}
+function dropKnownExtension(path) {
+  const extensions = [".tsx", ".mts", ".cts", ".jsx", ".mjs", ".cjs", ".ts", ".js"];
+  for (const ext of extensions) {
+    if (path.endsWith(ext)) return path.slice(0, -ext.length);
+  }
+  return path;
+}
+function inferCallerLaneFromStack(stack = new Error().stack, fallback = "anonymous") {
+  const lines = (stack ?? "").split("\n").slice(1);
+  for (const line of lines) {
+    const location = extractStackLocation(line);
+    if (!location) continue;
+    if (isPseudoStackLocation(location)) continue;
+    if (isInternalRuntimeFrame(location, line)) continue;
+    return sanitizeLaneKey(normalizeCallerLocation(location));
+  }
+  return sanitizeLaneKey(fallback);
+}
+var laneKeyCache = /* @__PURE__ */ new Map();
+var LANE_CACHE_MAX = 1024;
+function inferLane(tag) {
+  let cached = laneKeyCache.get(tag);
+  if (cached !== void 0) return cached;
+  const explicit = extractTaggedLane(tag, "lane:");
+  if (explicit) {
+    cached = sanitizeLaneKey(explicit);
+  } else {
+    const caller = extractTaggedLane(tag, "caller:");
+    if (caller) {
+      cached = sanitizeLaneKey(caller);
+    } else {
+      const firstSep = firstSeparatorIndex(tag);
+      const first = firstSep < 0 ? tag : tag.slice(0, firstSep);
+      cached = sanitizeLaneKey(first || "anonymous");
+    }
+  }
+  if (laneKeyCache.size >= LANE_CACHE_MAX) laneKeyCache.clear();
+  laneKeyCache.set(tag, cached);
+  return cached;
+}
+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);
+  return value.length > 0 ? value : void 0;
+}
+function firstSeparatorIndex(value) {
+  let best = -1;
+  for (const sep of [".", "#", "/"]) {
+    const idx = value.indexOf(sep);
+    if (idx >= 0 && (best < 0 || idx < best)) best = idx;
+  }
+  return best;
+}
+var Scheduler = class {
+  engine;
+  js;
+  wasm;
+  flushBudget;
+  microThreshold;
+  laneCapacity;
+  laneBudget;
+  maxLanes;
+  fallbackUsed;
+  boundFlush = () => this.flush();
+  constructor(options = {}) {
+    this.flushBudget = options.flushBudget ?? FLUSH_BUDGET;
+    this.microThreshold = options.microThreshold ?? MICRO_THRESHOLD;
+    this.laneCapacity = options.laneCapacity ?? DEFAULT_LANE_CAPACITY;
+    this.laneBudget = options.laneBudget ?? DEFAULT_LANE_BUDGET;
+    this.maxLanes = options.maxLanes ?? DEFAULT_MAX_LANES;
+    const requested = options.engine ?? "ts";
+    if (requested === "wasm") {
+      this.wasm = new WasmSchedulerState(options);
+      this.engine = "wasm";
+      this.fallbackUsed = false;
+      return;
+    }
+    if (requested === "ts") {
+      this.js = new JsSchedulerState({ ...options, engine: "ts" });
+      this.engine = "ts";
+      this.fallbackUsed = false;
+      return;
+    }
+    throw new Error(`brass-runtime scheduler engine must be 'ts' or 'wasm'; received '${String(requested)}'`);
+  }
+  schedule(task, tag = "anonymous") {
+    if (typeof task !== "function") return "dropped";
+    if (this.wasm) return this.scheduleWasm(task, tag);
+    return this.scheduleJs(task, tag);
+  }
+  scheduleBatch(tasks) {
+    if (this.wasm) return this.scheduleBatchWasm(tasks);
+    return tasks.map(({ fn, tag }) => this.schedule(fn, tag));
+  }
+  stats() {
+    if (this.wasm) return this.wasm.stats();
+    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 } };
+  }
+  scheduleWasm(task, tag) {
+    const policy = this.wasm.enqueue(task, tag);
+    if (policy === 3) return "dropped";
+    if (policy === 0) this.requestFlush("micro");
+    else if (policy === 1) this.requestFlush("macro");
+    return "accepted";
+  }
+  scheduleBatchWasm(tasks) {
+    const validTasks = [];
+    const results = [];
+    const indexMap = [];
+    for (let i = 0; i < tasks.length; i++) {
+      const { fn, tag } = tasks[i];
+      if (typeof fn !== "function") {
+        results.push("dropped");
+      } else {
+        results.push("accepted");
+        indexMap.push(i);
+        validTasks.push({ task: fn, tag });
+      }
+    }
+    if (validTasks.length === 0) return results;
+    const policies = this.wasm.enqueueBatch(validTasks);
+    let needsMicro = false;
+    let needsMacro = false;
+    for (let j = 0; j < policies.length; j++) {
+      const policy = policies[j];
+      const originalIdx = indexMap[j];
+      if (policy === 3) {
+        results[originalIdx] = "dropped";
+      } else if (policy === 0) {
+        needsMicro = true;
+      } else if (policy === 1) {
+        needsMacro = true;
+      }
+    }
+    if (needsMicro) this.requestFlush("micro");
+    else if (needsMacro) this.requestFlush("macro");
+    return results;
+  }
+  getOrCreateLane(key) {
+    const js = this.js;
+    const existing = js.lanes.get(key);
+    if (existing) return existing;
+    if (js.lanes.size >= this.maxLanes) return js.lanes.get("overflow") ?? this.createLane("overflow");
+    return this.createLane(key);
+  }
+  createLane(key) {
+    const js = this.js;
+    const lane = new LaneState(key, this.laneCapacity, this.laneCapacity);
+    js.lanes.set(key, lane);
+    js.laneOrder.push(key);
+    return lane;
+  }
+  scheduleJs(task, tag) {
+    const js = this.js;
+    const lane = this.getOrCreateLane(inferLane(tag));
+    const status = lane.queue.push({ task, tag });
+    lane.enqueuedTasks++;
+    js.enqueuedTasks++;
+    if ((status & 2) !== 0) {
+      lane.droppedTasks++;
+      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";
+  }
+  requestFlush(kind) {
+    if (kind === "micro") queueMicrotask(this.boundFlush);
+    else scheduleMacro(this.boundFlush);
+  }
+  flush() {
+    if (this.wasm) return this.flushWasm();
+    this.flushJs();
+  }
+  flushWasm() {
+    const wasm = this.wasm;
+    const budget = wasm.beginFlush();
+    if (budget <= 0) return;
+    let ran = 0;
+    try {
+      while (ran < budget) {
+        const next = wasm.shift();
+        if (!next) break;
+        ran++;
+        try {
+          next.task();
+        } catch (e) {
+          console.error(`[Scheduler] task threw (tag=${next.tag})`, e);
+        }
+      }
+    } finally {
+      const policy = wasm.endFlush(ran);
+      if (policy === 0) this.requestFlush("micro");
+      else if (policy === 1) this.requestFlush("macro");
+    }
+  }
+  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();
+      if (next) {
+        js.rrRemaining--;
+        currentLane.executedTasks++;
+        js.totalLength--;
+        return next;
+      }
+      js.rrRemaining = 0;
+    }
+    for (let scanned = 0; scanned < n; scanned++) {
+      const idx = js.rrIndex % n;
+      const key = js.laneOrder[idx];
+      js.rrIndex = (idx + 1) % n;
+      const lane = js.lanes.get(key);
+      if (!lane || lane.queue.length === 0) continue;
+      js.rrRemaining = Math.max(0, this.laneBudget - 1);
+      lane.executedTasks++;
+      js.totalLength--;
+      return lane.queue.shift();
+    }
+    return void 0;
+  }
+  flushJs() {
+    const js = this.js;
+    if (js.flushing) return;
+    js.flushing = true;
+    js.scheduled = false;
+    let ran = 0;
+    try {
+      while (ran < this.flushBudget) {
+        const next = this.shiftFromNextLane();
+        if (!next) break;
+        ran++;
+        js.executedTasks++;
+        try {
+          next.task();
+        } catch (e) {
+          console.error(`[Scheduler] task threw (tag=${next.tag})`, 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);
+      }
+    }
+  }
+};
+var globalScheduler = new Scheduler();
+
+// src/core/runtime/hostAction.ts
+var DefaultHostExecutor = {
+  async execute(action) {
+    return {
+      kind: "error",
+      actionId: action.actionId,
+      error: new Error(`No HostExecutor configured for HostAction kind=${action.kind} target=${action.target}`)
+    };
+  }
+};
+
+// src/core/runtime/contex.ts
+var emptyContext = { parent: null, patch: /* @__PURE__ */ Object.create(null) };
+
+// src/core/runtime/forkPolicy.ts
+function makeForkPolicy(env, hooks) {
+  const svc = resolveForkServices(env);
+  return {
+    initChild(fiber, parent, scopeId) {
+      const parentCtx = parent?.fiberContext;
+      const trace = forkTrace(svc, parentCtx?.trace ?? null);
+      fiber.fiberContext = {
+        log: parentCtx?.log ?? emptyContext,
+        trace
+      };
+      fiber.parentFiberId = parent?.id;
+      fiber.name = svc.childName(parent?.name);
+      if (scopeId !== void 0) fiber.scopeId = scopeId;
+      hooks.emit(
+        {
+          type: "fiber.start",
+          fiberId: fiber.id,
+          parentFiberId: parent?.id,
+          scopeId: fiber.scopeId,
+          // ✅ ahora viaja
+          name: fiber.name
+        },
+        { fiberId: parent?.id, traceId: parentCtx?.trace?.traceId, spanId: parentCtx?.trace?.spanId }
+      );
+    }
+  };
+}
+function resolveForkServices(env) {
+  const defaultTracer = {
+    newTraceId: () => randomRuntimeId("trace"),
+    newSpanId: () => randomRuntimeId("span")
+  };
+  const brass = env?.brass;
+  const tracer = brass?.tracer ?? defaultTracer;
+  const seed = brass?.traceSeed;
+  const childName = brass?.childName ?? ((p) => p ? `${p}/child` : void 0);
+  return { tracer, seed, childName };
+}
+function randomRuntimeId(prefix) {
+  const cryptoLike = globalThis.crypto;
+  if (typeof cryptoLike?.randomUUID === "function") {
+    return cryptoLike.randomUUID();
+  }
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function forkTrace(svc, parentTrace) {
+  if (parentTrace) {
+    return {
+      traceId: parentTrace.traceId,
+      spanId: svc.tracer.newSpanId(),
+      parentSpanId: parentTrace.spanId,
+      sampled: parentTrace.sampled
+    };
+  }
+  if (svc.seed) return { ...svc.seed };
+  return { traceId: svc.tracer.newTraceId(), spanId: svc.tracer.newSpanId(), sampled: true };
+}
+
+// src/core/runtime/engine/opcodes.ts
+var REF_INDEX_BITS = 20;
+var REF_INDEX_MASK = (1 << REF_INDEX_BITS) - 1;
+var REF_GENERATION_SHIFT = REF_INDEX_BITS;
+var REF_GENERATION_MASK = (1 << 32 - REF_INDEX_BITS) - 1;
+function encodeRef(index, generation) {
+  return ((generation & REF_GENERATION_MASK) << REF_GENERATION_SHIFT | index & REF_INDEX_MASK) >>> 0;
+}
+function decodeRef(ref) {
+  return {
+    index: ref & REF_INDEX_MASK,
+    generation: ref >>> REF_GENERATION_SHIFT & REF_GENERATION_MASK
+  };
+}
+var HostRegistry = class {
+  slots = [{ value: void 0, generation: 0, occupied: false }];
+  free = [];
+  live = 0;
+  allocated = 0;
+  released = 0;
+  reused = 0;
+  staleReads = 0;
+  register(value) {
+    const index = this.free.pop() ?? this.slots.length;
+    let slot = this.slots[index];
+    if (slot) {
+      this.reused += 1;
+      slot.value = value;
+      slot.occupied = true;
+      slot.generation = slot.generation + 1 & REF_GENERATION_MASK || 1;
+    } else {
+      slot = { value, generation: 1, occupied: true };
+      this.slots[index] = slot;
+    }
+    this.live += 1;
+    this.allocated += 1;
+    return encodeRef(index, slot.generation);
+  }
+  get(ref) {
+    const { index, generation } = decodeRef(ref);
+    const slot = this.slots[index];
+    if (!slot || !slot.occupied || slot.generation !== generation) {
+      this.staleReads += 1;
+      throw new Error(`Missing or stale host registry ref ${ref}`);
+    }
+    return slot.value;
+  }
+  set(ref, value) {
+    const { index, generation } = decodeRef(ref);
+    const slot = this.slots[index];
+    if (!slot || !slot.occupied || slot.generation !== generation) {
+      this.staleReads += 1;
+      throw new Error(`Missing or stale host registry ref ${ref}`);
+    }
+    slot.value = value;
+  }
+  delete(ref) {
+    const { index, generation } = decodeRef(ref);
+    const slot = this.slots[index];
+    if (!slot || !slot.occupied || slot.generation !== generation) return;
+    slot.value = void 0;
+    slot.occupied = false;
+    this.live = Math.max(0, this.live - 1);
+    this.released += 1;
+    this.free.push(index);
+  }
+  clear() {
+    for (let index = 1; index < this.slots.length; index++) {
+      const slot = this.slots[index];
+      if (!slot?.occupied) continue;
+      slot.value = void 0;
+      slot.occupied = false;
+      this.free.push(index);
+      this.released += 1;
+    }
+    this.live = 0;
+  }
+  size() {
+    return this.live;
+  }
+  stats() {
+    return {
+      live: this.live,
+      capacity: Math.max(0, this.slots.length - 1),
+      allocated: this.allocated,
+      released: this.released,
+      reused: this.reused,
+      staleReads: this.staleReads
+    };
+  }
+};
+var ProgramBuilder = class {
+  nodes = [];
+  registry = new HostRegistry();
+  compile(effect) {
+    const root = this.visit(effect);
+    return {
+      program: {
+        version: 1,
+        root,
+        nodes: this.nodes
+      },
+      registry: this.registry
+    };
+  }
+  append(effect) {
+    const previousNodes = this.nodes.length;
+    const root = this.visit(effect);
+    return {
+      root,
+      nodes: this.nodes.slice(previousNodes)
+    };
+  }
+  add(node) {
+    const id = this.nodes.length;
+    this.nodes.push(node);
+    return id;
+  }
+  visit(effect) {
+    const current = effect;
+    switch (current._tag) {
+      case "Succeed":
+        return this.add({ tag: "Succeed", valueRef: this.registry.register(current.value) });
+      case "Fail":
+        return this.add({ tag: "Fail", errorRef: this.registry.register(current.error) });
+      case "Sync":
+        return this.add({ tag: "Sync", fnRef: this.registry.register(current.thunk) });
+      case "Async":
+        return this.add({ tag: "Async", registerRef: this.registry.register(current.register) });
+      case "FlatMap":
+        return this.add({
+          tag: "FlatMap",
+          first: this.visit(current.first),
+          fnRef: this.registry.register(current.andThen)
+        });
+      case "Fold":
+        return this.add({
+          tag: "Fold",
+          first: this.visit(current.first),
+          onFailureRef: this.registry.register(current.onFailure),
+          onSuccessRef: this.registry.register(current.onSuccess)
+        });
+      case "Fork": {
+        const base = {
+          tag: "Fork",
+          effectRef: this.registry.register(current.effect)
+        };
+        return this.add(current.scopeId === void 0 ? base : { ...base, scopeId: current.scopeId });
+      }
+      case "HostAction": {
+        const base = {
+          tag: "HostAction",
+          actionRef: this.registry.register(current.action)
+        };
+        return this.add(current.decode === void 0 ? base : { ...base, decodeRef: this.registry.register(current.decode) });
+      }
+      default:
+        return this.add({ tag: "Fail", errorRef: this.registry.register(new Error(`Unknown Async opcode: ${current?._tag}`)) });
+    }
+  }
+};
+
+// src/core/runtime/engine/FiberHandleImpl.ts
+var EngineFiberHandle = class {
+  constructor(id, runtime, onScheduledStep, onInterrupt, onJoiner, onQueued, onScheduleDropped, onScheduleRequest) {
+    this.onScheduledStep = onScheduledStep;
+    this.onInterrupt = onInterrupt;
+    this.onJoiner = onJoiner;
+    this.onQueued = onQueued;
+    this.onScheduleDropped = onScheduleDropped;
+    this.onScheduleRequest = onScheduleRequest;
+    this.id = id;
+    this.runtime = runtime;
+  }
+  onScheduledStep;
+  onInterrupt;
+  onJoiner;
+  onQueued;
+  onScheduleDropped;
+  onScheduleRequest;
+  id;
+  runtime;
+  fiberContext;
+  name;
+  scopeId;
+  parentFiberId;
+  lane;
+  result = null;
+  joiners = [];
+  finalizers = [];
+  finalizersDrained = false;
+  internalStatus = "running";
+  queued = false;
+  status() {
+    if (this.result == null) return "Running";
+    if (this.result._tag === "Failure" && this.result.cause._tag === "Interrupt") return "Interrupted";
+    return "Done";
+  }
+  engineStatus() {
+    return this.internalStatus;
+  }
+  setEngineStatus(status) {
+    this.internalStatus = status;
+  }
+  markDequeued() {
+    this.queued = false;
+    if (this.result == null && this.internalStatus === "queued") {
+      this.internalStatus = "running";
+    }
+  }
+  join(cb) {
+    if (this.result != null) cb(this.result);
+    else {
+      this.onJoiner?.(this.id);
+      this.joiners.push(cb);
+    }
+  }
+  interrupt() {
+    if (this.result != null) return;
+    this.onInterrupt(this.id, Cause.interrupt());
+  }
+  addFinalizer(f) {
+    this.finalizers.push(f);
+  }
+  schedule(tag = "step") {
+    if (this.result != null || this.queued) return;
+    this.queued = true;
+    this.internalStatus = "queued";
+    this.onQueued?.(this.id);
+    const label = `wasm-fiber#${this.id}.${tag}`;
+    const result = this.onScheduleRequest ? this.onScheduleRequest(this.id, label) : this.scheduleWithRuntime(label);
+    if (result === "dropped") {
+      this.queued = false;
+      this.onScheduleDropped?.(this.id, label);
+    }
+  }
+  scheduleWithRuntime(label) {
+    const lane = this.lane ?? this.runtime.lane;
+    return this.runtime.scheduler.schedule(() => {
+      this.markDequeued();
+      if (this.result != null) return;
+      this.onScheduledStep(this.id);
+    }, lane ? laneTag(lane, label) : label);
+  }
+  emit(ev) {
+    this.runtime.hooks.emit(ev, {
+      fiberId: this.id,
+      scopeId: this.scopeId,
+      traceId: this.fiberContext?.trace?.traceId,
+      spanId: this.fiberContext?.trace?.spanId
+    });
+  }
+  succeed(value) {
+    this.complete(Exit.succeed(value));
+  }
+  fail(error) {
+    this.complete(Exit.failCause(Cause.fail(error)));
+  }
+  die(defect) {
+    this.complete(Exit.failCause(Cause.die(defect)));
+  }
+  interrupted() {
+    this.complete(Exit.failCause(Cause.interrupt()));
+  }
+  complete(exit) {
+    if (this.result != null) return;
+    this.runFinalizersOnce(exit);
+    this.result = exit;
+    this.internalStatus = exit._tag === "Success" ? "done" : exit.cause._tag === "Interrupt" ? "interrupted" : "failed";
+    const status = exit._tag === "Success" ? "success" : exit.cause._tag === "Interrupt" ? "interrupted" : "failure";
+    this.emit({
+      type: "fiber.end",
+      fiberId: this.id,
+      status,
+      error: exit._tag === "Failure" ? exit.cause : void 0
+    });
+    for (const joiner of this.joiners) joiner(exit);
+    this.joiners.length = 0;
+  }
+  runFinalizersOnce(exit) {
+    if (this.finalizersDrained) return;
+    this.finalizersDrained = true;
+    while (this.finalizers.length > 0) {
+      const finalizer = this.finalizers.pop();
+      try {
+        const eff = finalizer(exit);
+        if (eff && typeof eff === "object" && "_tag" in eff) {
+          this.runtime.fork(eff);
+        }
+      } catch {
+      }
+    }
+  }
+};
+
+// src/core/runtime/engine/binaryAbi.ts
+var ABI_VERSION = 1;
+var EVENT_WORDS = 5;
+var NONE_U32 = 4294967295;
+var OpcodeTagCode = /* @__PURE__ */ ((OpcodeTagCode2) => {
+  OpcodeTagCode2[OpcodeTagCode2["Succeed"] = 0] = "Succeed";
+  OpcodeTagCode2[OpcodeTagCode2["Fail"] = 1] = "Fail";
+  OpcodeTagCode2[OpcodeTagCode2["Sync"] = 2] = "Sync";
+  OpcodeTagCode2[OpcodeTagCode2["Async"] = 3] = "Async";
+  OpcodeTagCode2[OpcodeTagCode2["FlatMap"] = 4] = "FlatMap";
+  OpcodeTagCode2[OpcodeTagCode2["Fold"] = 5] = "Fold";
+  OpcodeTagCode2[OpcodeTagCode2["Fork"] = 6] = "Fork";
+  OpcodeTagCode2[OpcodeTagCode2["HostAction"] = 7] = "HostAction";
+  return OpcodeTagCode2;
+})(OpcodeTagCode || {});
+var EventKindCode = /* @__PURE__ */ ((EventKindCode2) => {
+  EventKindCode2[EventKindCode2["Continue"] = 0] = "Continue";
+  EventKindCode2[EventKindCode2["Done"] = 1] = "Done";
+  EventKindCode2[EventKindCode2["Failed"] = 2] = "Failed";
+  EventKindCode2[EventKindCode2["Interrupted"] = 3] = "Interrupted";
+  EventKindCode2[EventKindCode2["InvokeSync"] = 4] = "InvokeSync";
+  EventKindCode2[EventKindCode2["InvokeAsync"] = 5] = "InvokeAsync";
+  EventKindCode2[EventKindCode2["InvokeFlatMap"] = 6] = "InvokeFlatMap";
+  EventKindCode2[EventKindCode2["InvokeFoldFailure"] = 7] = "InvokeFoldFailure";
+  EventKindCode2[EventKindCode2["InvokeFoldSuccess"] = 8] = "InvokeFoldSuccess";
+  EventKindCode2[EventKindCode2["InvokeFork"] = 9] = "InvokeFork";
+  EventKindCode2[EventKindCode2["InvokeHostAction"] = 10] = "InvokeHostAction";
+  return EventKindCode2;
+})(EventKindCode || {});
+function encodeOpcodeProgram(program) {
+  const out = new Uint32Array(3 + program.nodes.length * 4);
+  out[0] = ABI_VERSION;
+  out[1] = program.root >>> 0;
+  out[2] = program.nodes.length >>> 0;
+  writeNodes(out, 3, program.nodes);
+  return out;
+}
+function encodeOpcodeNodes(nodes) {
+  const out = new Uint32Array(1 + nodes.length * 4);
+  out[0] = nodes.length >>> 0;
+  writeNodes(out, 1, nodes);
+  return out;
+}
+function writeNodes(out, offset, nodes) {
+  let i = offset;
+  for (const node of nodes) {
+    switch (node.tag) {
+      case "Succeed":
+        out[i++] = 0 /* Succeed */;
+        out[i++] = node.valueRef >>> 0;
+        out[i++] = 0;
+        out[i++] = 0;
+        break;
+      case "Fail":
+        out[i++] = 1 /* Fail */;
+        out[i++] = node.errorRef >>> 0;
+        out[i++] = 0;
+        out[i++] = 0;
+        break;
+      case "Sync":
+        out[i++] = 2 /* Sync */;
+        out[i++] = node.fnRef >>> 0;
+        out[i++] = 0;
+        out[i++] = 0;
+        break;
+      case "Async":
+        out[i++] = 3 /* Async */;
+        out[i++] = node.registerRef >>> 0;
+        out[i++] = 0;
+        out[i++] = 0;
+        break;
+      case "FlatMap":
+        out[i++] = 4 /* FlatMap */;
+        out[i++] = node.first >>> 0;
+        out[i++] = node.fnRef >>> 0;
+        out[i++] = 0;
+        break;
+      case "Fold":
+        out[i++] = 5 /* Fold */;
+        out[i++] = node.first >>> 0;
+        out[i++] = node.onFailureRef >>> 0;
+        out[i++] = node.onSuccessRef >>> 0;
+        break;
+      case "Fork":
+        out[i++] = 6 /* Fork */;
+        out[i++] = node.effectRef >>> 0;
+        out[i++] = node.scopeId === void 0 ? NONE_U32 : node.scopeId >>> 0;
+        out[i++] = 0;
+        break;
+      case "HostAction":
+        out[i++] = 7 /* HostAction */;
+        out[i++] = node.actionRef >>> 0;
+        out[i++] = node.decodeRef === void 0 ? NONE_U32 : node.decodeRef >>> 0;
+        out[i++] = 0;
+        break;
+    }
+  }
+}
+function decodeEvent(words, offset = 0) {
+  const kind = words[offset] >>> 0;
+  const fiberId = words[offset + 1];
+  const a = words[offset + 2] >>> 0;
+  const b = words[offset + 3] >>> 0;
+  const c = words[offset + 4] >>> 0;
+  switch (kind) {
+    case 0 /* Continue */:
+      return { kind: "Continue", fiberId };
+    case 1 /* Done */:
+      return { kind: "Done", fiberId, valueRef: a };
+    case 2 /* Failed */:
+      return { kind: "Failed", fiberId, errorRef: a };
+    case 3 /* Interrupted */:
+      return { kind: "Interrupted", fiberId, reasonRef: a };
+    case 4 /* InvokeSync */:
+      return { kind: "InvokeSync", fiberId, fnRef: a };
+    case 5 /* InvokeAsync */:
+      return { kind: "InvokeAsync", fiberId, registerRef: a };
+    case 6 /* InvokeFlatMap */:
+      return { kind: "InvokeFlatMap", fiberId, fnRef: a, valueRef: b };
+    case 7 /* InvokeFoldFailure */:
+      return { kind: "InvokeFoldFailure", fiberId, fnRef: a, errorRef: b };
+    case 8 /* InvokeFoldSuccess */:
+      return { kind: "InvokeFoldSuccess", fiberId, fnRef: a, valueRef: b };
+    case 9 /* InvokeFork */:
+      return c === NONE_U32 || b === NONE_U32 ? { kind: "InvokeFork", fiberId, effectRef: a } : { kind: "InvokeFork", fiberId, effectRef: a, scopeId: b };
+    case 10 /* InvokeHostAction */:
+      return b === NONE_U32 ? { kind: "InvokeHostAction", fiberId, actionRef: a } : { kind: "InvokeHostAction", fiberId, actionRef: a, decodeRef: b };
+    default:
+      return { kind: "Failed", fiberId, errorRef: 0 };
+  }
+}
+function decodeEventBatch(words) {
+  if (!words || words.length === 0) return [];
+  const count = words[0] >>> 0;
+  const events = [];
+  const max = Math.min(count, Math.floor((words.length - 1) / EVENT_WORDS));
+  for (let i = 0; i < max; i++) {
+    events.push(decodeEvent(words, 1 + i * EVENT_WORDS));
+  }
+  return events;
+}
+
+// src/core/runtime/engine/bridge/WasmPackFiberBridge.ts
+var VM_METRIC_NAMES = [
+  "started",
+  "live",
+  "running",
+  "suspended",
+  "completed",
+  "failed",
+  "interrupted",
+  "boundaryCalls",
+  "batchesEmitted",
+  "eventsEmitted",
+  "eventsPerBoundaryCall",
+  "maxEventsPerBoundaryCall",
+  "binaryPrograms",
+  "jsonPrograms",
+  "binaryPatches",
+  "jsonPatches",
+  "zeroCopyPrograms",
+  "zeroCopyPatches",
+  "zeroCopyEventBatches",
+  "fiberSlabLive",
+  "fiberSlabCapacity",
+  "fiberSlabReused",
+  "fiberSlabReleased",
+  "fiberSlabStaleReads"
+];
+var WasmPackFiberBridge = class {
+  kind = "wasm";
+  supportsBinary;
+  supportsZeroCopy;
+  supportsNoJsonMetrics;
+  vm;
+  jsonEventCalls = 0;
+  binaryEventCalls = 0;
+  zeroCopyEventCalls = 0;
+  eventsReceived = 0;
+  maxEventsPerCall = 0;
+  jsonPrograms = 0;
+  binaryPrograms = 0;
+  zeroCopyPrograms = 0;
+  jsonPatches = 0;
+  binaryPatches = 0;
+  zeroCopyPatches = 0;
+  constructor(modulePath) {
+    const mod = loadWasmModule(modulePath);
+    this.vm = new mod.BrassWasmVm();
+    this.supportsBinary = typeof this.vm.create_fiber_bin === "function" && typeof this.vm.drive_batch_bin === "function" && typeof this.vm.provide_value_bin === "function" && typeof this.vm.provide_error_bin === "function" && typeof this.vm.provide_effect_bin === "function" && typeof this.vm.interrupt_bin === "function";
+    this.supportsZeroCopy = typeof this.vm.memory === "function" && typeof this.vm.prepare_program_words === "function" && typeof this.vm.prepare_patch_words === "function" && typeof this.vm.create_fiber_from_program_words === "function" && typeof this.vm.drive_batch_ptr === "function" && typeof this.vm.event_batch_len === "function" && typeof this.vm.provide_value_ptr === "function" && typeof this.vm.provide_error_ptr === "function" && typeof this.vm.provide_effect_from_words === "function" && typeof this.vm.interrupt_ptr === "function";
+    this.supportsNoJsonMetrics = typeof this.vm.metrics_snapshot_ptr === "function" && typeof this.vm.metrics_snapshot_len === "function" && typeof this.vm.memory === "function";
+    this.assertStrictWasmHotPath();
+  }
+  createFiber(program) {
+    const words = encodeOpcodeProgram(program);
+    this.writeWords(this.vm.prepare_program_words(words.length), words);
+    this.zeroCopyPrograms += 1;
+    return this.vm.create_fiber_from_program_words(words.length);
+  }
+  poll(fiberId) {
+    return this.driveBatch(fiberId, 1)[0] ?? { kind: "Continue", fiberId };
+  }
+  driveBatch(fiberId, budget) {
+    return this.decodeZeroCopy(this.vm.drive_batch_ptr(fiberId, budget));
+  }
+  provideValue(fiberId, valueRef) {
+    return this.provideValueBatch(fiberId, valueRef, 1)[0] ?? { kind: "Continue", fiberId };
+  }
+  provideValueBatch(fiberId, valueRef, budget) {
+    return this.decodeZeroCopy(this.vm.provide_value_ptr(fiberId, valueRef, budget));
+  }
+  provideError(fiberId, errorRef) {
+    return this.provideErrorBatch(fiberId, errorRef, 1)[0] ?? { kind: "Continue", fiberId };
+  }
+  provideErrorBatch(fiberId, errorRef, budget) {
+    return this.decodeZeroCopy(this.vm.provide_error_ptr(fiberId, errorRef, budget));
+  }
+  provideEffect(fiberId, root, nodes) {
+    return this.provideEffectBatch(fiberId, root, nodes, 1)[0] ?? { kind: "Continue", fiberId };
+  }
+  provideEffectBatch(fiberId, root, nodes, budget) {
+    const words = encodeOpcodeNodes(nodes);
+    this.writeWords(this.vm.prepare_patch_words(words.length), words);
+    this.zeroCopyPatches += 1;
+    return this.decodeZeroCopy(this.vm.provide_effect_from_words(fiberId, root, words.length, budget));
+  }
+  interrupt(fiberId, reasonRef) {
+    return this.interruptBatch(fiberId, reasonRef, 1)[0] ?? { kind: "Interrupted", fiberId, reasonRef };
+  }
+  interruptBatch(fiberId, reasonRef, budget) {
+    return this.decodeZeroCopy(this.vm.interrupt_ptr(fiberId, reasonRef, budget));
+  }
+  dropFiber(fiberId) {
+    this.vm.drop_fiber(fiberId);
+  }
+  stats() {
+    const wasmStats = this.readMetricsSnapshot();
+    const eventCalls = this.binaryEventCalls + this.jsonEventCalls + this.zeroCopyEventCalls;
+    return {
+      ...wasmStats,
+      bridge: {
+        supportsBinary: this.supportsBinary,
+        supportsZeroCopy: this.supportsZeroCopy,
+        supportsNoJsonMetrics: this.supportsNoJsonMetrics,
+        zeroCopyEventCalls: this.zeroCopyEventCalls,
+        binaryEventCalls: this.binaryEventCalls,
+        jsonEventCalls: this.jsonEventCalls,
+        eventsReceived: this.eventsReceived,
+        eventsPerCall: eventCalls === 0 ? 0 : this.eventsReceived / eventCalls,
+        maxEventsPerCall: this.maxEventsPerCall,
+        zeroCopyPrograms: this.zeroCopyPrograms,
+        binaryPrograms: this.binaryPrograms,
+        jsonPrograms: this.jsonPrograms,
+        zeroCopyPatches: this.zeroCopyPatches,
+        binaryPatches: this.binaryPatches,
+        jsonPatches: this.jsonPatches
+      }
+    };
+  }
+  assertStrictWasmHotPath() {
+    const missing = [];
+    const required = [
+      "memory",
+      "prepare_program_words",
+      "prepare_patch_words",
+      "create_fiber_from_program_words",
+      "drive_batch_ptr",
+      "event_batch_len",
+      "provide_value_ptr",
+      "provide_error_ptr",
+      "provide_effect_from_words",
+      "interrupt_ptr",
+      "metrics_snapshot_ptr",
+      "metrics_snapshot_len"
+    ];
+    for (const name of required) {
+      if (typeof this.vm[name] !== "function") missing.push(name);
+    }
+    if (missing.length > 0) {
+      throw new Error([
+        "engine='wasm' requires the strict Rust/WASM hot path; TS/JSON/binary fallbacks are disabled.",
+        "Run `npm run build:wasm` from the phase-4+ Rust sources and make sure wasm/pkg is current.",
+        `Missing WASM exports: ${missing.join(", ")}`
+      ].join("\n"));
+    }
+  }
+  decodeZeroCopy(ptr) {
+    this.zeroCopyEventCalls += 1;
+    const len = this.vm.event_batch_len?.() ?? 0;
+    const words = this.readU32(ptr, len);
+    const events = decodeEventBatch(words);
+    this.eventsReceived += events.length;
+    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");
+    return memory;
+  }
+  readU32(ptr, len) {
+    if (ptr === 0 || len === 0) return new Uint32Array(0);
+    return new Uint32Array(this.memory().buffer, ptr, len);
+  }
+  readF64(ptr, len) {
+    if (ptr === 0 || len === 0) return new Float64Array(0);
+    return new Float64Array(this.memory().buffer, ptr, len);
+  }
+  writeWords(ptr, words) {
+    if (ptr === 0 && words.length > 0) throw new Error("brass-runtime WASM returned a null word pointer");
+    new Uint32Array(this.memory().buffer, ptr, words.length).set(words);
+  }
+  readMetricsSnapshot() {
+    const ptr = this.vm.metrics_snapshot_ptr?.() ?? 0;
+    const len = this.vm.metrics_snapshot_len?.() ?? 0;
+    const view = this.readF64(ptr, len);
+    const out = {};
+    for (let i = 0; i < Math.min(view.length, VM_METRIC_NAMES.length); i++) {
+      out[VM_METRIC_NAMES[i]] = view[i];
+    }
+    return out;
+  }
+};
+function loadWasmModule(modulePath) {
+  const mod = resolveWasmModule({ modulePath });
+  if (mod) return mod;
+  const errors = wasmModuleResolutionErrors();
+  throw new Error([
+    "engine='wasm' could not load wasm/pkg/brass_runtime_wasm_engine.js.",
+    "Run `npm run build:wasm` first and make sure wasm/pkg is present in the package.",
+    "For Node 18 + webpack, keep brass-runtime's wasm/pkg files available at runtime or externalize brass-runtime.",
+    ...errors.map((error) => `- ${error}`)
+  ].join("\n"));
+}
+
+// src/core/runtime/engine/bridge/WasmFiberRegistryBridge.ts
+var FIBER_STATE_QUEUED = 0;
+var FIBER_STATE_RUNNING = 1;
+var FIBER_STATE_SUSPENDED = 2;
+var FIBER_STATE_DONE = 3;
+var FIBER_STATE_FAILED = 4;
+var FIBER_STATE_INTERRUPTED = 5;
+var WasmFiberRegistryBridge = class {
+  registry;
+  constructor() {
+    const mod = resolveWasmModule();
+    const Ctor = mod?.BrassWasmFiberRegistry;
+    if (!Ctor) {
+      throw new Error("brass-runtime wasm fiber registry is not available. Run npm run build:wasm first.");
+    }
+    this.registry = new Ctor();
+  }
+  registerFiber(fiberId, parentId, scopeId) {
+    this.registry.register_fiber(fiberId, parentId ?? 0, scopeId ?? 0, Date.now());
+  }
+  markQueued(fiberId) {
+    this.registry.mark_queued(fiberId, Date.now());
+  }
+  markRunning(fiberId) {
+    this.registry.mark_running(fiberId, Date.now());
+  }
+  markSuspended(fiberId) {
+    this.registry.mark_suspended(fiberId, Date.now());
+  }
+  markDone(fiberId, status) {
+    return this.registry.mark_done(fiberId, statusToCode(status), Date.now());
+  }
+  dropFiber(fiberId) {
+    this.registry.drop_fiber(fiberId);
+  }
+  addJoiner(fiberId) {
+    this.registry.add_joiner(fiberId);
+  }
+  wake(fiberId) {
+    return this.registry.wake(fiberId);
+  }
+  drainWakeup() {
+    const id = this.registry.drain_wakeup();
+    return id === 0 ? void 0 : id;
+  }
+  drainWakeups() {
+    const ids = [];
+    for (; ; ) {
+      const id = this.drainWakeup();
+      if (id === void 0) return ids;
+      ids.push(id);
+    }
+  }
+  wakeQueueLength() {
+    return this.registry.wake_queue_len();
+  }
+  stateOf(fiberId) {
+    const code = this.registry.state_of(fiberId);
+    if (code === 4294967295) return "missing";
+    return codeToStatus(code);
+  }
+  stats() {
+    return JSON.parse(this.registry.stats_json());
+  }
+};
+function statusToCode(status) {
+  switch (status) {
+    case "queued":
+      return FIBER_STATE_QUEUED;
+    case "running":
+      return FIBER_STATE_RUNNING;
+    case "suspended":
+      return FIBER_STATE_SUSPENDED;
+    case "done":
+      return FIBER_STATE_DONE;
+    case "failed":
+      return FIBER_STATE_FAILED;
+    case "interrupted":
+      return FIBER_STATE_INTERRUPTED;
+  }
+}
+function codeToStatus(code) {
+  switch (code) {
+    case FIBER_STATE_QUEUED:
+      return "queued";
+    case FIBER_STATE_RUNNING:
+      return "running";
+    case FIBER_STATE_SUSPENDED:
+      return "suspended";
+    case FIBER_STATE_DONE:
+      return "done";
+    case FIBER_STATE_FAILED:
+      return "failed";
+    case FIBER_STATE_INTERRUPTED:
+      return "interrupted";
+    default:
+      return "missing";
+  }
+}
+
+// src/core/runtime/engine/bridge/WasmFiberReadyQueueBridge.ts
+var POLICY_MICRO = 0;
+var POLICY_MACRO = 1;
+var POLICY_DROPPED = 3;
+var DEFAULT_FLUSH_BUDGET = 2048;
+var DEFAULT_LANE_CAPACITY2 = 1024;
+var DEFAULT_LANE_BUDGET2 = 64;
+var DEFAULT_MAX_LANES2 = 256;
+function resolveWasmReadyQueue() {
+  const mod = resolveWasmModule();
+  return mod?.BrassWasmFiberReadyQueue ?? null;
+}
+function decodePolicy(policy) {
+  switch (policy) {
+    case POLICY_MICRO:
+      return "micro";
+    case POLICY_MACRO:
+      return "macro";
+    case POLICY_DROPPED:
+      return "dropped";
+    default:
+      return "none";
+  }
+}
+function makeFiberReadyQueue(options = {}) {
+  const requested = options.engine ?? "ts";
+  if (requested === "ts") return new TsFiberReadyQueue(options);
+  if (requested === "wasm") {
+    const Ctor = resolveWasmReadyQueue();
+    if (!Ctor) throw new Error("brass-runtime wasm fiber ready queue is not available. Run npm run build:wasm first.");
+    return new WasmFiberReadyQueue(Ctor, options);
+  }
+  throw new Error(`brass-runtime fiber ready queue engine must be 'ts' or 'wasm'; received '${String(requested)}'`);
+}
+var WasmFiberReadyQueue = class {
+  engine = "wasm";
+  queue;
+  laneCache = /* @__PURE__ */ new Map();
+  constructor(Ctor, options) {
+    this.queue = new Ctor(
+      options.flushBudget ?? DEFAULT_FLUSH_BUDGET,
+      options.microThreshold ?? DEFAULT_FLUSH_BUDGET * 2,
+      options.laneCapacity ?? DEFAULT_LANE_CAPACITY2,
+      options.laneBudget ?? DEFAULT_LANE_BUDGET2,
+      options.maxLanes ?? DEFAULT_MAX_LANES2
+    );
+    if (typeof this.queue.intern_lane !== "function" || typeof this.queue.enqueue_fiber_lane !== "function") {
+      throw new Error("brass-runtime wasm fiber ready queue requires laneId/interning exports; TS/string fallback is disabled");
+    }
+  }
+  enqueue(fiberId, tag) {
+    const laneKey = inferLane2(tag);
+    let laneId = this.laneCache.get(laneKey);
+    if (laneId === void 0) {
+      laneId = this.queue.intern_lane(laneKey);
+      this.laneCache.set(laneKey, laneId);
+    }
+    return decodePolicy(this.queue.enqueue_fiber_lane(fiberId, laneId));
+  }
+  beginFlush() {
+    return this.queue.begin_flush();
+  }
+  shift() {
+    const fiberId = this.queue.shift_fiber();
+    return fiberId === 0 ? void 0 : fiberId;
+  }
+  endFlush(ran) {
+    return decodePolicy(this.queue.end_flush(ran));
+  }
+  len() {
+    return this.queue.len();
+  }
+  clear() {
+    this.queue.clear();
+  }
+  stats() {
+    return {
+      engine: this.engine,
+      fallbackUsed: false,
+      data: JSON.parse(this.queue.stats_json())
+    };
+  }
+};
+var TsFiberReadyQueue = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  engine = "ts";
+  lanes = /* @__PURE__ */ new Map();
+  laneOrder = [];
+  rrIndex = 0;
+  rrRemaining = 0;
+  phase = "idle";
+  totalLen = 0;
+  scheduledFlushes = 0;
+  completedFlushes = 0;
+  enqueuedFibers = 0;
+  executedFibers = 0;
+  droppedFibers = 0;
+  yieldedByBudget = 0;
+  enqueue(fiberId, tag) {
+    const lane = this.getOrCreateLane(inferLane2(tag));
+    this.enqueuedFibers += 1;
+    lane.enqueuedFibers += 1;
+    const capacity = this.options.laneCapacity ?? DEFAULT_LANE_CAPACITY2;
+    if (lane.len >= capacity) {
+      this.droppedFibers += 1;
+      lane.droppedFibers += 1;
+      return "dropped";
+    }
+    lane.queue[(lane.head + lane.len) % capacity] = fiberId;
+    lane.len += 1;
+    this.totalLen += 1;
+    if (this.phase !== "idle") return "none";
+    this.phase = "scheduled";
+    this.scheduledFlushes += 1;
+    return this.totalLen > (this.options.microThreshold ?? DEFAULT_FLUSH_BUDGET * 2) ? "macro" : "micro";
+  }
+  beginFlush() {
+    if (this.phase === "flushing") return 0;
+    if (this.totalLen === 0) {
+      this.phase = "idle";
+      return 0;
+    }
+    this.phase = "flushing";
+    return Math.min(this.options.flushBudget ?? DEFAULT_FLUSH_BUDGET, this.totalLen);
+  }
+  shift() {
+    const n = this.laneOrder.length;
+    if (n === 0) return void 0;
+    if (this.rrRemaining > 0) {
+      const idx = (this.rrIndex + n - 1) % n;
+      const lane = this.lanes.get(this.laneOrder[idx]);
+      const fiberId = lane ? this.shiftLane(lane) : void 0;
+      if (fiberId !== void 0) {
+        this.rrRemaining -= 1;
+        return fiberId;
+      }
+      this.rrRemaining = 0;
+    }
+    for (let scanned = 0; scanned < n; scanned++) {
+      const idx = this.rrIndex % n;
+      this.rrIndex = (idx + 1) % n;
+      const lane = this.lanes.get(this.laneOrder[idx]);
+      if (!lane || lane.len === 0) continue;
+      this.rrRemaining = Math.max(0, (this.options.laneBudget ?? DEFAULT_LANE_BUDGET2) - 1);
+      return this.shiftLane(lane);
+    }
+    return void 0;
+  }
+  endFlush(ran) {
+    this.completedFlushes += 1;
+    if (this.totalLen === 0) {
+      this.phase = "idle";
+      return "none";
+    }
+    this.phase = "scheduled";
+    this.scheduledFlushes += 1;
+    if (ran >= (this.options.flushBudget ?? DEFAULT_FLUSH_BUDGET)) {
+      this.yieldedByBudget += 1;
+      return "macro";
+    }
+    return this.totalLen > (this.options.microThreshold ?? DEFAULT_FLUSH_BUDGET * 2) ? "macro" : "micro";
+  }
+  len() {
+    return this.totalLen;
+  }
+  clear() {
+    for (const lane of this.lanes.values()) {
+      lane.queue.length = 0;
+      lane.head = 0;
+      lane.len = 0;
+    }
+    this.totalLen = 0;
+    this.phase = "idle";
+    this.rrIndex = 0;
+    this.rrRemaining = 0;
+  }
+  stats() {
+    const lanes = Array.from(this.lanes.values()).map((lane) => ({
+      key: lane.key,
+      len: lane.len,
+      capacity: this.options.laneCapacity ?? DEFAULT_LANE_CAPACITY2,
+      enqueuedFibers: lane.enqueuedFibers,
+      executedFibers: lane.executedFibers,
+      droppedFibers: lane.droppedFibers
+    }));
+    return {
+      engine: this.engine,
+      fallbackUsed: false,
+      data: {
+        phase: this.phase,
+        len: this.totalLen,
+        scheduledFlushes: this.scheduledFlushes,
+        completedFlushes: this.completedFlushes,
+        enqueuedFibers: this.enqueuedFibers,
+        executedFibers: this.executedFibers,
+        droppedFibers: this.droppedFibers,
+        yieldedByBudget: this.yieldedByBudget,
+        lanes
+      }
+    };
+  }
+  getOrCreateLane(key) {
+    const existing = this.lanes.get(key);
+    if (existing) return existing;
+    const laneKey = this.lanes.size >= (this.options.maxLanes ?? DEFAULT_MAX_LANES2) ? "overflow" : key;
+    const overflow = this.lanes.get(laneKey);
+    if (overflow) return overflow;
+    const lane = { key: laneKey, queue: [], head: 0, len: 0, enqueuedFibers: 0, executedFibers: 0, droppedFibers: 0 };
+    this.lanes.set(laneKey, lane);
+    this.laneOrder.push(laneKey);
+    return lane;
+  }
+  shiftLane(lane) {
+    if (lane.len === 0) return void 0;
+    const capacity = this.options.laneCapacity ?? DEFAULT_LANE_CAPACITY2;
+    const fiberId = lane.queue[lane.head];
+    lane.queue[lane.head] = 0;
+    lane.head = (lane.head + 1) % capacity;
+    lane.len -= 1;
+    this.totalLen -= 1;
+    this.executedFibers += 1;
+    lane.executedFibers += 1;
+    return fiberId;
+  }
+};
+function inferLane2(tag) {
+  const explicit = extractTaggedLane2(tag, "lane:");
+  if (explicit) return sanitizeLaneKey(explicit);
+  const caller = extractTaggedLane2(tag, "caller:");
+  if (caller) return sanitizeLaneKey(caller);
+  const firstSep = firstSeparatorIndex2(tag);
+  const first = firstSep < 0 ? tag : tag.slice(0, firstSep);
+  return sanitizeLaneKey(first || "anonymous");
+}
+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);
+  return value.length > 0 ? value : void 0;
+}
+function firstSeparatorIndex2(value) {
+  let best = -1;
+  for (const sep of [".", "#", "/"]) {
+    const idx = value.indexOf(sep);
+    if (idx >= 0 && (best < 0 || idx < best)) best = idx;
+  }
+  return best;
+}
+
+// src/core/runtime/engine/bridge/WasmTimerWheelBridge.ts
+var WasmTimerWheelBridge = class {
+  wheel;
+  timer;
+  onExpired;
+  constructor(Ctor, options) {
+    this.wheel = new Ctor(toU64(options.tickMs ?? 10), options.bucketCount ?? 4096);
+    this.onExpired = options.onExpired;
+  }
+  schedule(subjectId, kind, deadlineMs) {
+    const id = this.wheel.schedule_deadline(subjectId, kind, toU64(deadlineMs));
+    this.schedulePump();
+    return id;
+  }
+  cancel(timerId) {
+    if (timerId === void 0) return;
+    this.wheel.cancel(timerId);
+    this.schedulePump();
+  }
+  flush(nowMs = Date.now()) {
+    const ptr = this.wheel.advance_time(toU64(nowMs));
+    const events = this.readEvents(ptr, this.wheel.expired_len());
+    if (events.length > 0) this.onExpired(events);
+    this.schedulePump();
+  }
+  dispose() {
+    if (this.timer !== void 0) clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+  stats() {
+    return {
+      live: this.wheel.metric_u64(0),
+      scheduled: this.wheel.metric_u64(1),
+      canceled: this.wheel.metric_u64(2),
+      expired: this.wheel.metric_u64(3),
+      buckets: this.wheel.metric_u64(4)
+    };
+  }
+  schedulePump() {
+    if (this.timer !== void 0) clearTimeout(this.timer);
+    this.timer = void 0;
+    const next = this.wheel.next_deadline_ms();
+    if (!Number.isFinite(next) || next < 0) return;
+    const delay = Math.max(0, Math.min(2 ** 31 - 1, Math.floor(next - Date.now())));
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      this.flush();
+    }, delay);
+    if (typeof this.timer.unref === "function") this.timer.unref();
+  }
+  readEvents(ptr, len) {
+    if (ptr === 0 || len <= 1) return [];
+    const words = new Uint32Array(this.wheel.memory().buffer, ptr, len);
+    const count = words[0] >>> 0;
+    const out = [];
+    for (let i = 0; i < count; i++) {
+      const base = 1 + i * 5;
+      if (base + 4 >= words.length) break;
+      const lo = words[base + 3] >>> 0;
+      const hi = words[base + 4] >>> 0;
+      out.push({
+        timerId: words[base] >>> 0,
+        subjectId: words[base + 1] >>> 0,
+        kind: words[base + 2] >>> 0,
+        deadlineMs: hi * 4294967296 + lo
+      });
+    }
+    return out;
+  }
+};
+function makeWasmTimerWheel(options) {
+  const mod = resolveWasmModule();
+  const Ctor = mod?.BrassWasmTimerWheel;
+  if (!Ctor) throw new Error("brass-runtime wasm timer wheel is not available. Run npm run build:wasm first.");
+  return new WasmTimerWheelBridge(Ctor, options);
+}
+function toU64(value) {
+  return BigInt(Math.max(0, Math.floor(value)));
+}
+
+// src/core/runtime/engine/WasmFiberEngine.ts
+var DEFAULT_BUDGET = 4096;
+var TIMER_KIND_HOST_ACTION = 1;
+var WasmFiberEngine = class {
+  constructor(runtime, options = {}) {
+    this.runtime = runtime;
+    this.bridge = options.bridge ?? new WasmPackFiberBridge(options.modulePath);
+    if (this.bridge.kind !== "wasm") {
+      throw new Error("brass-runtime strict mode requires a real WASM bridge; wasm-reference/TS fallback bridges are not allowed");
+    }
+    this.kind = this.bridge.kind;
+    this.fiberRegistry = new WasmFiberRegistryBridge();
+    this.readyQueue = makeFiberReadyQueue({ engine: "wasm" });
+    this.timerWheel = makeWasmTimerWheel({ onExpired: (events) => this.onTimerExpired(events) });
+  }
+  runtime;
+  kind;
+  bridge;
+  readyQueue;
+  startedFibers = 0;
+  runningFibers = 0;
+  suspendedFibers = 0;
+  completedFibers = 0;
+  failedFibers = 0;
+  interruptedFibers = 0;
+  pendingHostEffects = 0;
+  readyDrainScheduled = false;
+  readyDraining = false;
+  states = /* @__PURE__ */ new Map();
+  pendingResumes = /* @__PURE__ */ new Map();
+  fiberRegistry;
+  timerWheel;
+  fork(effect, scopeId) {
+    const builder = new ProgramBuilder();
+    const compiled = builder.compile(effect);
+    const fiberId = this.bridge.createFiber(compiled.program);
+    const controller = new AbortController();
+    const handle = new EngineFiberHandle(
+      fiberId,
+      this.runtime,
+      (id) => this.driveById(id),
+      (id, reason) => this.interruptById(id, reason),
+      (id) => this.fiberRegistry?.addJoiner(id),
+      (id) => this.fiberRegistry?.markQueued(id),
+      (id, label) => this.schedulerDropped(id, label),
+      (id, label) => this.enqueueFiberById(id, label)
+    );
+    if (scopeId !== void 0) handle.scopeId = scopeId;
+    const state = {
+      fiberId,
+      handle,
+      builder,
+      registry: compiled.registry,
+      controller,
+      startedAt: Date.now(),
+      completed: false,
+      status: "running",
+      pendingCleanups: /* @__PURE__ */ new Set(),
+      hostActionToken: 0
+    };
+    this.states.set(fiberId, state);
+    this.fiberRegistry?.registerFiber(fiberId, void 0, scopeId);
+    this.startedFibers += 1;
+    this.runningFibers += 1;
+    return handle;
+  }
+  stats() {
+    let hostRefs = 0;
+    let hostCapacity = 0;
+    let hostAllocated = 0;
+    let hostReleased = 0;
+    let hostReused = 0;
+    let hostStaleReads = 0;
+    for (const state of this.states.values()) {
+      const stats = state.registry.stats();
+      hostRefs += stats.live;
+      hostCapacity += stats.capacity;
+      hostAllocated += stats.allocated;
+      hostReleased += stats.released;
+      hostReused += stats.reused;
+      hostStaleReads += stats.staleReads;
+    }
+    return {
+      engine: this.kind,
+      startedFibers: this.startedFibers,
+      runningFibers: this.runningFibers,
+      suspendedFibers: this.suspendedFibers,
+      queuedFibers: this.readyQueue.len(),
+      completedFibers: this.completedFibers,
+      failedFibers: this.failedFibers,
+      interruptedFibers: this.interruptedFibers,
+      pendingHostEffects: this.pendingHostEffects,
+      hostRegistryRefs: hostRefs,
+      hostRegistryStats: {
+        live: hostRefs,
+        capacity: hostCapacity,
+        allocated: hostAllocated,
+        released: hostReleased,
+        reused: hostReused,
+        staleReads: hostStaleReads
+      },
+      wasm: this.bridge.stats(),
+      fiberRegistry: this.fiberRegistry?.stats(),
+      readyQueue: this.readyQueue.stats(),
+      timerWheel: this.timerWheel?.stats()
+    };
+  }
+  async shutdown() {
+    for (const state of Array.from(this.states.values())) {
+      this.interruptState(state, Cause.interrupt());
+    }
+    this.readyQueue.clear();
+    this.timerWheel?.dispose();
+  }
+  scheduleWakeup(fiberId) {
+    const state = this.states.get(fiberId);
+    if (!state || state.completed) return;
+    if (!this.fiberRegistry) {
+      this.enqueueFiber(state, "wakeup");
+      return;
+    }
+    if (!this.fiberRegistry.wake(fiberId)) return;
+    this.drainWakeups();
+  }
+  drainWakeups() {
+    if (!this.fiberRegistry) return;
+    for (const fiberId of this.fiberRegistry.drainWakeups()) {
+      this.enqueueFiberById(fiberId, `wasm-fiber#${fiberId}.wakeup`);
+    }
+  }
+  enqueueFiber(state, label) {
+    const result = this.enqueueFiberById(state.fiberId, label);
+    if (result === "dropped") {
+      this.completeDie(state, new Error(`Brass WASM ready queue dropped ${label} because the lane queue is full`));
+    }
+  }
+  enqueueFiberById(fiberId, label) {
+    const state = this.states.get(fiberId);
+    if (!state || state.completed) return "dropped";
+    const tag = this.schedulerTag(state, label);
+    const policy = this.readyQueue.enqueue(fiberId, tag);
+    if (policy === "dropped") return "dropped";
+    this.requestReadyDrain(tag);
+    return "accepted";
+  }
+  requestReadyDrain(tag = laneTag("brass:wasm-ready", "drain")) {
+    if (this.readyDrainScheduled || this.readyDraining) return;
+    this.readyDrainScheduled = true;
+    const result = this.runtime.scheduler.schedule(() => this.drainReadyQueue(), tag);
+    if (result === "dropped") {
+      this.readyDrainScheduled = false;
+      const dropped = [];
+      while (this.readyQueue.len() > 0) {
+        const budget = this.readyQueue.beginFlush();
+        for (let i = 0; i < budget; i++) {
+          const id = this.readyQueue.shift();
+          if (id !== void 0) dropped.push(id);
+        }
+        this.readyQueue.endFlush(budget);
+      }
+      for (const id of dropped) this.schedulerDropped(id, `wasm-fiber#${id}.ready-drain`);
+    }
+  }
+  drainReadyQueue() {
+    this.readyDrainScheduled = false;
+    if (this.readyDraining) return;
+    this.readyDraining = true;
+    const budget = this.readyQueue.beginFlush();
+    let ran = 0;
+    try {
+      while (ran < budget) {
+        const fiberId = this.readyQueue.shift();
+        if (fiberId === void 0) break;
+        ran += 1;
+        this.driveById(fiberId);
+      }
+    } finally {
+      this.readyDraining = false;
+      const policy = this.readyQueue.endFlush(ran);
+      if (policy === "micro" || policy === "macro") this.requestReadyDrain();
+    }
+  }
+  driveById(fiberId) {
+    const state = this.states.get(fiberId);
+    if (!state || state.completed) return;
+    state.handle.markDequeued();
+    this.fiberRegistry?.markRunning(fiberId);
+    const initialEvents = this.consumePendingResume(state);
+    withCurrentFiber(state.handle, () => this.drive(state, initialEvents));
+  }
+  consumePendingResume(state) {
+    const pending = this.pendingResumes.get(state.fiberId);
+    if (!pending) return void 0;
+    this.pendingResumes.delete(state.fiberId);
+    if (pending.kind === "value") {
+      return this.bridge.provideValueBatch?.(state.fiberId, pending.ref, DEFAULT_BUDGET) ?? [this.bridge.provideValue(state.fiberId, pending.ref)];
+    }
+    return this.bridge.provideErrorBatch?.(state.fiberId, pending.ref, DEFAULT_BUDGET) ?? [this.bridge.provideError(state.fiberId, pending.ref)];
+  }
+  drive(state, initialEvents) {
+    if (state.completed) return;
+    let budget = DEFAULT_BUDGET;
+    const events = initialEvents ? [...initialEvents] : [];
+    state.status = "running";
+    state.handle.setEngineStatus("running");
+    while (!state.completed && budget-- > 0) {
+      try {
+        if (events.length === 0) {
+          const next = this.bridge.driveBatch?.(state.fiberId, budget + 1) ?? [this.bridge.poll(state.fiberId)];
+          events.push(...next);
+          if (events.length === 0) events.push({ kind: "Continue", fiberId: state.fiberId });
+        }
+        const event = events.shift();
+        switch (event.kind) {
+          case "Continue":
+            continue;
+          case "Done": {
+            const value = state.registry.get(event.valueRef);
+            this.completeSuccess(state, value);
+            return;
+          }
+          case "Failed": {
+            const error = event.errorRef === 0 ? new Error("WASM fiber failed") : state.registry.get(event.errorRef);
+            this.completeFailure(state, error);
+            return;
+          }
+          case "Interrupted": {
+            this.completeInterrupted(state);
+            return;
+          }
+          case "InvokeSync": {
+            const fn = state.registry.get(event.fnRef);
+            try {
+              const valueRef = state.registry.register(fn(this.runtime.env));
+              events.unshift(...this.bridge.provideValueBatch?.(state.fiberId, valueRef, budget + 1) ?? [this.bridge.provideValue(state.fiberId, valueRef)]);
+            } catch (error) {
+              events.unshift(...this.bridge.provideErrorBatch?.(state.fiberId, state.registry.register(error), budget + 1) ?? [this.bridge.provideError(state.fiberId, state.registry.register(error))]);
+            }
+            continue;
+          }
+          case "InvokeFlatMap": {
+            const fn = state.registry.get(event.fnRef);
+            const value = state.registry.get(event.valueRef);
+            try {
+              const next = fn(value);
+              const patch = state.builder.append(next);
+              events.unshift(...this.bridge.provideEffectBatch?.(state.fiberId, patch.root, patch.nodes, budget + 1) ?? [this.bridge.provideEffect(state.fiberId, patch.root, patch.nodes)]);
+            } catch (error) {
+              events.unshift(...this.bridge.provideErrorBatch?.(state.fiberId, state.registry.register(error), budget + 1) ?? [this.bridge.provideError(state.fiberId, state.registry.register(error))]);
+            }
+            continue;
+          }
+          case "InvokeFoldFailure": {
+            const fn = state.registry.get(event.fnRef);
+            const errorValue = state.registry.get(event.errorRef);
+            try {
+              const next = fn(errorValue);
+              const patch = state.builder.append(next);
+              events.unshift(...this.bridge.provideEffectBatch?.(state.fiberId, patch.root, patch.nodes, budget + 1) ?? [this.bridge.provideEffect(state.fiberId, patch.root, patch.nodes)]);
+            } catch (error) {
+              events.unshift(...this.bridge.provideErrorBatch?.(state.fiberId, state.registry.register(error), budget + 1) ?? [this.bridge.provideError(state.fiberId, state.registry.register(error))]);
+            }
+            continue;
+          }
+          case "InvokeFoldSuccess": {
+            const fn = state.registry.get(event.fnRef);
+            const value = state.registry.get(event.valueRef);
+            try {
+              const next = fn(value);
+              const patch = state.builder.append(next);
+              events.unshift(...this.bridge.provideEffectBatch?.(state.fiberId, patch.root, patch.nodes, budget + 1) ?? [this.bridge.provideEffect(state.fiberId, patch.root, patch.nodes)]);
+            } catch (error) {
+              events.unshift(...this.bridge.provideErrorBatch?.(state.fiberId, state.registry.register(error), budget + 1) ?? [this.bridge.provideError(state.fiberId, state.registry.register(error))]);
+            }
+            continue;
+          }
+          case "InvokeFork": {
+            const effect = state.registry.get(event.effectRef);
+            try {
+              const child = this.runtime.fork(effect, event.scopeId);
+              events.unshift(...this.bridge.provideValueBatch?.(state.fiberId, state.registry.register(child), budget + 1) ?? [this.bridge.provideValue(state.fiberId, state.registry.register(child))]);
+            } catch (error) {
+              events.unshift(...this.bridge.provideErrorBatch?.(state.fiberId, state.registry.register(error), budget + 1) ?? [this.bridge.provideError(state.fiberId, state.registry.register(error))]);
+            }
+            continue;
+          }
+          case "InvokeAsync": {
+            this.scheduleAsync(state, event.registerRef);
+            return;
+          }
+          case "InvokeHostAction": {
+            this.scheduleHostAction(state, event.actionRef, event.decodeRef);
+            return;
+          }
+        }
+      } catch (error) {
+        events.unshift(...this.bridge.provideErrorBatch?.(state.fiberId, state.registry.register(error), budget + 1) ?? [this.bridge.provideError(state.fiberId, state.registry.register(error))]);
+      }
+    }
+    if (!state.completed) this.enqueueFiber(state, "budget-yield");
+  }
+  scheduleAsync(state, registerRef) {
+    this.markSuspended(state, "async");
+    this.pendingHostEffects += 1;
+    const register = state.registry.get(registerRef);
+    let done = false;
+    let asyncRegistered = false;
+    let syncExit = null;
+    let cancelCleanup;
+    const cleanup = () => {
+      done = true;
+      state.pendingCleanups.delete(cleanup);
+      if (cancelCleanup) {
+        state.pendingCleanups.delete(cancelCleanup);
+        cancelCleanup = void 0;
+      }
+    };
+    const cb = (exitLike) => {
+      if (done) return;
+      const exit = exitLike;
+      if (!asyncRegistered) {
+        syncExit = exit;
+        return;
+      }
+      cleanup();
+      this.pendingHostEffects = Math.max(0, this.pendingHostEffects - 1);
+      this.markRunning(state, "async");
+      this.resumeWithExit(state, exit);
+    };
+    try {
+      const canceler = register(this.runtime.env, cb);
+      asyncRegistered = true;
+      if (syncExit) {
+        cleanup();
+        this.pendingHostEffects = Math.max(0, this.pendingHostEffects - 1);
+        this.markRunning(state, "async-sync");
+        this.resumeWithExit(state, syncExit);
+        return;
+      }
+      if (typeof canceler === "function") {
+        cancelCleanup = () => {
+          if (done) return;
+          done = true;
+          state.pendingCleanups.delete(cleanup);
+          if (cancelCleanup) state.pendingCleanups.delete(cancelCleanup);
+          cancelCleanup = void 0;
+          try {
+            canceler();
+          } catch {
+          }
+        };
+        state.pendingCleanups.add(cancelCleanup);
+        state.handle.addFinalizer(() => cancelCleanup?.());
+      }
+    } catch (error) {
+      cleanup();
+      this.pendingHostEffects = Math.max(0, this.pendingHostEffects - 1);
+      this.markRunning(state, "async-register-error");
+      this.resumeWithError(state, error);
+    }
+  }
+  scheduleHostAction(state, actionRef, decodeRef2) {
+    this.markSuspended(state, "host-action");
+    this.pendingHostEffects += 1;
+    const action = state.registry.get(actionRef);
+    const token = ++state.hostActionToken;
+    const deadlineAt = action.timeoutMs === void 0 ? void 0 : Date.now() + action.timeoutMs;
+    const cleanup = () => {
+      state.pendingCleanups.delete(cleanup);
+      this.timerWheel?.cancel(state.deadlineTimerId);
+      if (state.hostActionToken === token) state.deadlineTimerId = void 0;
+    };
+    state.pendingCleanups.add(cleanup);
+    if (deadlineAt !== void 0 && this.timerWheel) {
+      state.deadlineTimerId = this.timerWheel.schedule(state.fiberId, TIMER_KIND_HOST_ACTION, deadlineAt);
+    }
+    this.runtime.hostExecutor.execute(action, {
+      fiberId: state.fiberId,
+      env: this.runtime.env,
+      signal: state.controller.signal,
+      deadlineAt
+    }).then((result) => {
+      if (state.completed || state.hostActionToken !== token) return;
+      cleanup();
+      this.pendingHostEffects = Math.max(0, this.pendingHostEffects - 1);
+      this.markRunning(state, "host-action");
+      try {
+        if (decodeRef2 !== void 0) {
+          const decode = state.registry.get(decodeRef2);
+          this.resumeWithValue(state, decode(result));
+          return;
+        }
+        if (result.kind === "error") {
+          this.resumeWithError(state, result.error);
+          return;
+        }
+        this.resumeWithValue(state, result.value);
+      } catch (error) {
+        this.resumeWithError(state, error);
+      }
+    }).catch((error) => {
+      if (state.completed || state.hostActionToken !== token) return;
+      cleanup();
+      this.pendingHostEffects = Math.max(0, this.pendingHostEffects - 1);
+      this.markRunning(state, "host-action-error");
+      this.resumeWithError(state, error);
+    });
+  }
+  onTimerExpired(events) {
+    for (const event of events) {
+      if (event.kind !== TIMER_KIND_HOST_ACTION) continue;
+      const state = this.states.get(event.subjectId);
+      if (!state || state.completed || state.deadlineTimerId !== event.timerId) continue;
+      state.deadlineTimerId = void 0;
+      state.hostActionToken += 1;
+      if (!state.controller.signal.aborted) {
+        state.controller.abort(new Error(`Brass host action timed out at ${event.deadlineMs}ms deadline`));
+      }
+      this.pendingHostEffects = Math.max(0, this.pendingHostEffects - 1);
+      this.markRunning(state, "host-action-timeout");
+      this.resumeWithError(state, new Error(`Brass host action timed out at ${event.deadlineMs}ms deadline`));
+    }
+  }
+  resumeWithExit(state, exit) {
+    if (state.completed) return;
+    if (exit._tag === "Success") {
+      this.resumeWithValue(state, exit.value);
+      return;
+    }
+    const cause = exit.cause;
+    if (cause._tag === "Interrupt") {
+      this.interruptState(state, cause);
+      return;
+    }
+    if (cause._tag === "Fail") {
+      this.resumeWithError(state, cause.error);
+      return;
+    }
+    this.completeDie(state, cause.defect);
+  }
+  resumeWithValue(state, value) {
+    this.pendingResumes.set(state.fiberId, { kind: "value", ref: state.registry.register(value) });
+    this.enqueueFiber(state, `wasm-fiber#${state.fiberId}.resume`);
+  }
+  resumeWithError(state, error) {
+    this.pendingResumes.set(state.fiberId, { kind: "error", ref: state.registry.register(error) });
+    this.enqueueFiber(state, `wasm-fiber#${state.fiberId}.resume-error`);
+  }
+  schedulerTag(state, label) {
+    const lane = state.handle.lane ?? this.runtime.lane;
+    return lane ? laneTag(lane, label) : label;
+  }
+  schedulerDropped(fiberId, label) {
+    const state = this.states.get(fiberId);
+    if (!state || state.completed) return;
+    this.completeDie(state, new Error(`Brass scheduler dropped ${label} because the lane queue is full`));
+  }
+  interruptById(fiberId, reason) {
+    const state = this.states.get(fiberId);
+    if (!state) return;
+    this.interruptState(state, reason);
+  }
+  interruptState(state, reason) {
+    if (state.completed) return;
+    if (!state.controller.signal.aborted) state.controller.abort(reason);
+    for (const cleanup of Array.from(state.pendingCleanups)) cleanup();
+    const events = this.bridge.interruptBatch?.(state.fiberId, state.registry.register(reason), DEFAULT_BUDGET) ?? [this.bridge.interrupt(state.fiberId, state.registry.register(reason))];
+    this.drive(state, events);
+  }
+  markSuspended(state, reason) {
+    if (state.status !== "suspended") {
+      this.suspendedFibers += 1;
+      state.status = "suspended";
+      this.fiberRegistry?.markSuspended(state.fiberId);
+      state.handle.setEngineStatus("suspended");
+      state.handle.emit({ type: "fiber.suspend", fiberId: state.fiberId, reason });
+    }
+  }
+  markRunning(state, _reason) {
+    if (state.status === "suspended") {
+      this.suspendedFibers = Math.max(0, this.suspendedFibers - 1);
+      state.status = "running";
+      this.fiberRegistry?.markRunning(state.fiberId);
+      state.handle.setEngineStatus("running");
+      state.handle.emit({ type: "fiber.resume", fiberId: state.fiberId });
+    }
+  }
+  completeSuccess(state, value) {
+    if (state.completed) return;
+    state.completed = true;
+    state.status = "done";
+    this.fiberRegistry?.markDone(state.fiberId, "done");
+    this.completedFibers += 1;
+    this.cleanupState(state);
+    state.handle.succeed(value);
+  }
+  completeFailure(state, error) {
+    if (state.completed) return;
+    state.completed = true;
+    state.status = "failed";
+    this.fiberRegistry?.markDone(state.fiberId, "failed");
+    this.failedFibers += 1;
+    this.cleanupState(state);
+    state.handle.fail(error);
+  }
+  completeDie(state, defect) {
+    if (state.completed) return;
+    state.completed = true;
+    state.status = "failed";
+    this.fiberRegistry?.markDone(state.fiberId, "failed");
+    this.failedFibers += 1;
+    this.cleanupState(state);
+    state.handle.die(defect);
+  }
+  completeInterrupted(state) {
+    if (state.completed) return;
+    state.completed = true;
+    state.status = "interrupted";
+    this.fiberRegistry?.markDone(state.fiberId, "interrupted");
+    this.interruptedFibers += 1;
+    this.cleanupState(state);
+    state.handle.interrupted();
+  }
+  cleanupState(state) {
+    this.runningFibers = Math.max(0, this.runningFibers - 1);
+    if (state.status === "suspended") this.suspendedFibers = Math.max(0, this.suspendedFibers - 1);
+    this.timerWheel?.cancel(state.deadlineTimerId);
+    state.deadlineTimerId = void 0;
+    for (const cleanup of Array.from(state.pendingCleanups)) cleanup();
+    state.pendingCleanups.clear();
+    this.pendingResumes.delete(state.fiberId);
+    this.bridge.dropFiber(state.fiberId);
+    this.fiberRegistry?.dropFiber(state.fiberId);
+    state.registry.clear();
+    this.states.delete(state.fiberId);
+  }
+};
+
+// src/core/runtime/capabilities.ts
+function runtimeCapabilities() {
+  const mod = resolveWasmModule();
+  return {
+    wasmAvailable: !!mod,
+    wasmFiberEngine: typeof mod?.BrassWasmVm === "function",
+    wasmRingBuffer: typeof mod?.BrassWasmRingBuffer === "function",
+    wasmScheduler: typeof mod?.BrassWasmSchedulerStateMachine === "function",
+    wasmFiberRegistry: typeof mod?.BrassWasmFiberRegistry === "function",
+    wasmFiberReadyQueue: typeof mod?.BrassWasmFiberReadyQueue === "function",
+    wasmBinaryAbi: hasBinaryVmAbi(mod),
+    wasmStreamChunks: typeof mod?.BrassWasmChunkBuffer === "function"
+  };
+}
+function hasBinaryVmAbi(mod) {
+  const Ctor = mod?.BrassWasmVm;
+  if (typeof Ctor !== "function") return false;
+  try {
+    const vm = new Ctor();
+    return typeof vm.create_fiber_bin === "function" && typeof vm.drive_batch_bin === "function" && typeof vm.provide_value_bin === "function" && typeof vm.provide_error_bin === "function" && typeof vm.provide_effect_bin === "function" && typeof vm.interrupt_bin === "function";
+  } catch {
+    return false;
+  }
+}
+
+// src/core/runtime/runtime.ts
+var NoopHooks = {
+  emit() {
+  }
+};
+function normalizeRuntimeEngineMode(value) {
+  if (value === "ts" || value === "wasm") return value;
+  throw new Error(`brass-runtime engine must be either 'ts' or 'wasm' in strict mode; received '${String(value)}'`);
+}
+function unreachableEngine(value) {
+  throw new Error(`brass-runtime unsupported engine '${String(value)}'`);
+}
+var Runtime = class _Runtime {
+  env;
+  scheduler;
+  hooks;
+  hostExecutor;
+  engineMode;
+  wasmOptions;
+  fiberEngine;
+  fallbackUsed;
+  forkPolicy;
+  lane;
+  inferLane;
+  // opcional: registry para observabilidad
+  registry;
+  constructor(args) {
+    this.env = args.env;
+    this.scheduler = args.scheduler ?? globalScheduler;
+    this.lane = args.lane;
+    this.inferLane = args.inferLane ?? true;
+    this.hooks = args.hooks ?? NoopHooks;
+    this.hostExecutor = args.hostExecutor ?? DefaultHostExecutor;
+    this.engineMode = normalizeRuntimeEngineMode(args.engine ?? "ts");
+    this.wasmOptions = args.wasm;
+    this.forkPolicy = makeForkPolicy(this.env, this.hooks);
+    this.fiberEngine = this.makeFiberEngine(this.engineMode, args.wasm);
+    this.fallbackUsed = false;
+  }
+  makeFiberEngine(mode, wasm) {
+    if (mode === "ts") return new JsFiberEngine(this);
+    if (mode === "wasm") return new WasmFiberEngine(this, wasm);
+    return unreachableEngine(mode);
+  }
+  /** Returns true when the runtime has real hooks (not the no-op singleton). */
+  hasActiveHooks() {
+    return this.hooks !== NoopHooks;
+  }
+  /** Deriva un runtime con env extendido (estilo provide/locally) */
+  provide(env) {
+    return new _Runtime({
+      env: Object.assign({}, this.env, env),
+      scheduler: this.scheduler,
+      hooks: this.hooks,
+      engine: this.engineMode,
+      hostExecutor: this.hostExecutor,
+      wasm: this.wasmOptions,
+      lane: this.lane,
+      inferLane: this.inferLane
+    });
+  }
+  /**
+   * Returns a derived runtime that schedules all work in a caller/lane.
+   * Brass does not need to know the caller implementation; it only sees this stable key.
+   */
+  withLane(lane) {
+    return new _Runtime({
+      env: this.env,
+      scheduler: this.scheduler,
+      hooks: this.hooks,
+      engine: this.engineMode,
+      hostExecutor: this.hostExecutor,
+      wasm: this.wasmOptions,
+      lane,
+      inferLane: this.inferLane
+    });
+  }
+  resolveFiberLane(parent) {
+    if (this.lane !== void 0) return this.lane;
+    const parentLane = parent?.lane;
+    if (typeof parentLane === "string" && parentLane.length > 0) return parentLane;
+    if (!this.inferLane) return void 0;
+    return inferCallerLaneFromStack(void 0, "runtime");
+  }
+  emit(ev) {
+    if (this.hooks === NoopHooks) return;
+    const f = getCurrentFiber();
+    const ctx = {
+      fiberId: f?.id,
+      scopeId: f?.scopeId,
+      // ✅ FIX: era f?.scope
+      traceId: f?.fiberContext?.trace?.traceId,
+      spanId: f?.fiberContext?.trace?.spanId
+    };
+    this.hooks.emit(ev, ctx);
+  }
+  /**
+   * ✅ CAMBIO: fork(effect, scopeId?) y pasa scopeId a forkPolicy
+   */
+  fork(effect, scopeId) {
+    const parent = getCurrentFiber();
+    const fiber = this.fiberEngine.fork(effect, scopeId);
+    const lane = this.resolveFiberLane(parent);
+    if (lane !== void 0) fiber.lane = lane;
+    if (scopeId !== void 0) fiber.scopeId = scopeId;
+    this.forkPolicy.initChild(fiber, parent, scopeId);
+    fiber.schedule?.("initial-step");
+    return fiber;
+  }
+  stats() {
+    const data = this.fiberEngine.stats();
+    return { engine: this.fiberEngine.kind, fallbackUsed: false, data };
+  }
+  capabilities() {
+    return runtimeCapabilities();
+  }
+  shutdown() {
+    return this.fiberEngine.shutdown?.();
+  }
+  unsafeRunAsync(effect, cb) {
+    const fiber = this.fork(effect);
+    fiber.join(cb);
+  }
+  toPromise(effect) {
+    return new Promise((resolve, reject) => {
+      const fiber = this.fork(effect);
+      fiber.join((exit) => {
+        if (exit._tag === "Success") resolve(exit.value);
+        else {
+          const c = exit.cause;
+          if (c?._tag === "Fail") reject(c.error);
+          else if (c?._tag === "Die") reject(c.defect instanceof Error ? c.defect : new Error(String(c.defect)));
+          else reject(new Error("Interrupted"));
+        }
+      });
+    });
+  }
+  // helper: correr un efecto y “tirar” el resultado
+  unsafeRun(effect) {
+    this.unsafeRunAsync(effect, () => {
+    });
+  }
+  delay(ms, eff) {
+    return async((_env, cb) => {
+      const handle = setTimeout(() => {
+        this.unsafeRunAsync(eff, cb);
+      }, ms);
+      return () => clearTimeout(handle);
+    });
+  }
+  // util para crear runtime default
+  static make(env, scheduler = globalScheduler) {
+    return new _Runtime({ env, scheduler });
+  }
+  static makeWithEngine(env, engine, options = {}) {
+    return new _Runtime({ ...options, env, engine });
+  }
+  /** Convenience logger: emits a RuntimeEvent of type "log". */
+  log(level, message, fields) {
+    this.emit({ type: "log", level, message, fields });
+  }
+};
+function fork(effect, env) {
+  return Runtime.make(env ?? {}).fork(effect);
+}
+function runtimeForCaller(caller, env) {
+  return Runtime.make(env ?? {}).withLane(caller);
+}
+function toPromiseByCaller(caller, effect, env) {
+  return runtimeForCaller(caller, env).toPromise(effect);
+}
+function unsafeRunAsync(effect, env, cb) {
+  Runtime.make(env ?? {}).unsafeRunAsync(effect, cb);
+}
+function toPromise(effect, env) {
+  return Runtime.make(env ?? {}).toPromise(effect);
+}
+var abortablePromiseTotals = {
+  active: 0,
+  started: 0,
+  succeeded: 0,
+  failed: 0,
+  interrupted: 0,
+  timedOut: 0,
+  lateSettlements: 0
+};
+var abortablePromiseLabels = /* @__PURE__ */ new Map();
+var getAbortablePromiseLabelStats = (label) => {
+  const existing = abortablePromiseLabels.get(label);
+  if (existing) return existing;
+  const created = {
+    label,
+    active: 0,
+    started: 0,
+    succeeded: 0,
+    failed: 0,
+    interrupted: 0,
+    timedOut: 0,
+    lateSettlements: 0
+  };
+  abortablePromiseLabels.set(label, created);
+  return created;
+};
+var recordAbortablePromiseStart = (label) => {
+  const byLabel = getAbortablePromiseLabelStats(label);
+  abortablePromiseTotals.active++;
+  abortablePromiseTotals.started++;
+  byLabel.active++;
+  byLabel.started++;
+};
+var recordAbortablePromiseFinish = (label, outcome) => {
+  const byLabel = getAbortablePromiseLabelStats(label);
+  if (abortablePromiseTotals.active > 0) abortablePromiseTotals.active--;
+  if (byLabel.active > 0) byLabel.active--;
+  switch (outcome) {
+    case "success":
+      abortablePromiseTotals.succeeded++;
+      byLabel.succeeded++;
+      return;
+    case "failure":
+      abortablePromiseTotals.failed++;
+      byLabel.failed++;
+      return;
+    case "interrupt":
+      abortablePromiseTotals.interrupted++;
+      byLabel.interrupted++;
+      return;
+    case "timeout":
+      abortablePromiseTotals.timedOut++;
+      byLabel.timedOut++;
+      return;
+  }
+};
+var recordAbortablePromiseLateSettlement = (label) => {
+  const byLabel = getAbortablePromiseLabelStats(label);
+  abortablePromiseTotals.lateSettlements++;
+  byLabel.lateSettlements++;
+};
+function abortablePromiseStats() {
+  return {
+    ...abortablePromiseTotals,
+    byLabel: Array.from(abortablePromiseLabels.values()).map((x) => ({ ...x })).sort((a, b) => b.active - a.active || b.started - a.started || a.label.localeCompare(b.label))
+  };
+}
+function resetAbortablePromiseStats() {
+  abortablePromiseTotals.active = 0;
+  abortablePromiseTotals.started = 0;
+  abortablePromiseTotals.succeeded = 0;
+  abortablePromiseTotals.failed = 0;
+  abortablePromiseTotals.interrupted = 0;
+  abortablePromiseTotals.timedOut = 0;
+  abortablePromiseTotals.lateSettlements = 0;
+  abortablePromiseLabels.clear();
+}
+var normalizeAbortablePromiseLabel = (label) => {
+  const value = label?.trim();
+  return value && value.length > 0 ? value.slice(0, 160) : "anonymous";
+};
+var makeTimeoutReason = (timeoutMs, label) => ({
+  _tag: "Timeout",
+  timeoutMs,
+  message: `Abortable promise '${label}' timed out after ${timeoutMs}ms`
+});
+function fromPromiseAbortable(make, onReject, options = {}) {
+  return {
+    _tag: "Async",
+    register: (env, cb) => {
+      const controller = new AbortController();
+      const label = normalizeAbortablePromiseLabel(options.label);
+      const timeoutMs = options.timeoutMs !== void 0 && Number.isFinite(options.timeoutMs) ? Math.max(0, Math.floor(options.timeoutMs)) : void 0;
+      const startedAt = performance.now();
+      let done = false;
+      let timeoutHandle;
+      const cleanup = () => {
+        if (timeoutHandle !== void 0) {
+          clearTimeout(timeoutHandle);
+          timeoutHandle = void 0;
+        }
+      };
+      const finish = (outcome, exit, error) => {
+        if (done) return;
+        done = true;
+        cleanup();
+        recordAbortablePromiseFinish(label, outcome);
+        options.onFinish?.({
+          label,
+          outcome,
+          durationMs: Math.round(performance.now() - startedAt),
+          error
+        });
+        cb(exit);
+      };
+      recordAbortablePromiseStart(label);
+      options.onStart?.(label);
+      if (timeoutMs !== void 0 && timeoutMs > 0) {
+        timeoutHandle = setTimeout(() => {
+          const reason = options.timeoutReason?.() ?? makeTimeoutReason(timeoutMs, label);
+          try {
+            controller.abort(reason);
+          } catch {
+            controller.abort();
+          }
+          finish("timeout", Exit.failCause(Cause.fail(onReject(reason))), reason);
+        }, timeoutMs);
+      }
+      let promise;
+      try {
+        promise = make(controller.signal, env);
+      } catch (err) {
+        finish("failure", Exit.failCause(Cause.fail(onReject(err))), err);
+        return () => void 0;
+      }
+      promise.then((value) => {
+        if (done) {
+          recordAbortablePromiseLateSettlement(label);
+          return;
+        }
+        finish("success", Exit.succeed(value));
+      }).catch((err) => {
+        if (done) {
+          recordAbortablePromiseLateSettlement(label);
+          return;
+        }
+        finish("failure", Exit.failCause(Cause.fail(onReject(err))), err);
+      });
+      return () => {
+        if (done) return;
+        try {
+          controller.abort();
+        } catch {
+        }
+        finish("interrupt", Exit.failCause(Cause.interrupt()));
+      };
+    }
+  };
+}
+function unsafeRunFoldWithEnv(eff, env, onFailure, onSuccess) {
+  unsafeRunAsync(eff, env, (ex) => {
+    if (ex._tag === "Failure") onFailure(ex.cause);
+    else onSuccess(ex.value);
+  });
+}
+
+// src/core/runtime/fiber.ts
+var _current = null;
+var STEP = {
+  CONTINUE: "Continue",
+  SUSPEND: "Suspend",
+  DONE: "Done"
+};
+var TRAMPOLINE = {
+  CONTINUE: 0,
+  // exited trampoline, more work to do via normal switch
+  SUSPEND: 1,
+  // hit an async that didn't resolve synchronously
+  DONE: 2
+  // fiber completed (success or failure)
+};
+var RUN = {
+  QUEUED: "Queued",
+  RUNNING: "Running",
+  SUSPENDED: "Suspended",
+  DONE: "Done"
+};
+var nextId = 1;
+var DEFAULT_BUDGET2 = 16384;
+var __benchmarkBudget;
+function setBenchmarkBudget(budget) {
+  __benchmarkBudget = budget;
+}
+function getBenchmarkBudget() {
+  return __benchmarkBudget;
+}
+var RuntimeFiber = class {
+  id;
+  // 👇 CLAVE: guardar el runtime en el fiber (para getCurrentRuntime())
+  runtime;
+  closing = null;
+  finishing = false;
+  runState = RUN.RUNNING;
+  interrupted = false;
+  result = null;
+  joiners = [];
+  // estado de evaluación
+  current;
+  stack = [];
+  fiberFinalizers = [];
+  finalizersDrained = false;
+  fiberContext;
+  name;
+  scopeId;
+  lane;
+  /**
+   * Cached closure for the scheduler callback — avoids creating a new
+   * closure on every `schedule()` call.  The tag parameter used by the
+   * scheduler is only part of the label string, not the callback logic,
+   * so a single cached closure is sufficient.
+   */
+  boundStep;
+  // Reusable async callback state — avoids allocating a closure per Async step.
+  // These fields are reset at the start of each Async case and reused.
+  _syncResolved = false;
+  _syncExit = null;
+  _asyncRegistered = false;
+  _asyncDetach;
+  _asyncCb;
+  constructor(runtime, effect) {
+    this.id = nextId++;
+    this.runtime = runtime;
+    this.current = effect;
+    this._asyncCb = (exit) => {
+      if (this._syncResolved) return;
+      if (this.result != null || this.closing != null) return;
+      if (!this._asyncRegistered) {
+        this._syncResolved = true;
+        this._syncExit = exit;
+        return;
+      }
+      this._syncResolved = true;
+      this._asyncDetach?.();
+      this._asyncDetach = void 0;
+      if (exit._tag === "Success") {
+        this.current = Async.succeed(exit.value);
+        this.schedule("async-resume");
+        return;
+      }
+      const cause = exit.cause;
+      if (cause._tag === "Interrupt") {
+        this.notify(Exit.failCause(Cause.interrupt()));
+      } else if (cause._tag === "Fail") {
+        this.current = Async.fail(cause.error);
+        this.schedule("async-resume");
+      } else {
+        this.notify(Exit.failCause(Cause.die(cause.defect)));
+      }
+    };
+    this.boundStep = () => {
+      withCurrentFiber(this, () => {
+        if (this.runState === RUN.DONE) return;
+        this.runState = RUN.RUNNING;
+        const decision = this.step();
+        switch (decision) {
+          case STEP.CONTINUE:
+            this.schedule("continue");
+            return;
+          case STEP.SUSPEND:
+            this.runState = RUN.SUSPENDED;
+            this.emit({ type: "fiber.suspend", fiberId: this.id });
+            return;
+          case STEP.DONE:
+            this.runState = RUN.DONE;
+            return;
+        }
+      });
+    };
+  }
+  // helpers para no tocar el resto del código
+  get env() {
+    return this.runtime.env;
+  }
+  get scheduler() {
+    return this.runtime.scheduler ?? globalScheduler;
+  }
+  emit(ev) {
+    this.runtime.hooks.emit(ev, {
+      fiberId: this.id,
+      scopeId: this.scopeId,
+      traceId: this.fiberContext?.trace?.traceId,
+      spanId: this.fiberContext?.trace?.spanId
+    });
+  }
+  addFinalizer(f) {
+    this.fiberFinalizers.push({ run: f });
+  }
+  /**
+   * Internal finalizers used for suspend cancelers. They are detached as soon
+   * as the async operation completes, so completed HTTP/promises do not keep
+   * canceler closures alive until the fiber itself finishes.
+   */
+  addTransientFinalizer(f) {
+    const rec = { run: f };
+    this.fiberFinalizers.push(rec);
+    return () => {
+      rec.run = void 0;
+    };
+  }
+  status() {
+    if (this.result == null) return "Running";
+    if (this.result._tag === "Failure" && this.result.cause._tag === "Interrupt") return "Interrupted";
+    return "Done";
+  }
+  join(cb) {
+    if (this.result != null) cb(this.result);
+    else this.joiners.push(cb);
+  }
+  interrupt() {
+    if (this.result != null) return;
+    if (this.interrupted) return;
+    this.interrupted = true;
+    this.schedule("interrupt-step");
+  }
+  schedule(tag = "step") {
+    if (this.runState === RUN.DONE || this.runState === RUN.QUEUED) return;
+    if (this.runState === RUN.SUSPENDED) {
+      this.emit({ type: "fiber.resume", fiberId: this.id });
+    }
+    this.runState = RUN.QUEUED;
+    const label = `fiber#${this.id}.${tag}`;
+    const result = this.scheduler.schedule(
+      this.boundStep,
+      this.lane ? laneTag(this.lane, label) : label
+    );
+    if (result === "dropped") {
+      this.runState = RUN.DONE;
+      this.notify(Exit.failCause(Cause.die(new Error(`Brass scheduler dropped ${label} because the lane queue is full`))));
+    }
+  }
+  runFinalizersOnce(exit) {
+    if (this.finalizersDrained) return;
+    this.finalizersDrained = true;
+    while (this.fiberFinalizers.length > 0) {
+      const fin = this.fiberFinalizers.pop();
+      const run = fin.run;
+      fin.run = void 0;
+      if (!run) continue;
+      try {
+        const eff = run(exit);
+        if (eff && typeof eff === "object" && "_tag" in eff) {
+          unsafeRunAsync(eff, this.env, () => {
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  notify(exit) {
+    if (this.result != null) return;
+    if (this.closing != null) return;
+    this.finishing = true;
+    this.closing = exit;
+    this.runFinalizersOnce(exit);
+    this.result = exit;
+    const status = exit._tag === "Success" ? "success" : exit.cause._tag === "Interrupt" ? "interrupted" : "failure";
+    this.emit({
+      type: "fiber.end",
+      fiberId: this.id,
+      status,
+      error: exit._tag === "Failure" ? exit.cause : void 0
+    });
+    for (const j of this.joiners) j(exit);
+    this.joiners.length = 0;
+  }
+  onSuccess(value) {
+    const frame = this.stack.pop();
+    if (!frame) {
+      this.notify(Exit.succeed(value));
+      return;
+    }
+    if (frame._tag === "SuccessCont") {
+      try {
+        this.current = frame.k(value);
+      } catch (e) {
+        this.notify(Exit.failCause(Cause.die(e)));
+      }
+      return;
+    }
+    try {
+      this.current = frame.onSuccess(value);
+    } catch (e) {
+      this.notify(Exit.failCause(Cause.die(e)));
+    }
+  }
+  onFailure(error) {
+    while (this.stack.length > 0) {
+      const fr = this.stack.pop();
+      if (fr._tag === "FoldCont") {
+        try {
+          this.current = fr.onFailure(error);
+          return;
+        } catch (e) {
+          error = e;
+          continue;
+        }
+      }
+    }
+    this.notify(Exit.failCause(Cause.fail(error)));
+  }
+  budget = DEFAULT_BUDGET2;
+  step() {
+    if (this.result != null) return STEP.DONE;
+    if (this.interrupted) {
+      this.notify(Exit.failCause(Cause.interrupt()));
+      return STEP.DONE;
+    }
+    this.budget = __benchmarkBudget ?? DEFAULT_BUDGET2;
+    while (this.budget-- > 0) {
+      if (this.current._tag === "FlatMap") {
+        const trampolineResult = this.syncTrampoline();
+        if (trampolineResult === TRAMPOLINE.DONE) {
+          return STEP.DONE;
+        }
+        if (trampolineResult === TRAMPOLINE.SUSPEND) {
+          return STEP.SUSPEND;
+        }
+        if (this.result != null) return STEP.DONE;
+        if (this.budget <= 0) return STEP.CONTINUE;
+      }
+      const current = this.current;
+      switch (current._tag) {
+        case "Succeed": {
+          this.onSuccess(current.value);
+          break;
+        }
+        case "Fail": {
+          this.onFailure(current.error);
+          break;
+        }
+        case "FlatMap": {
+          this.stack.push({ _tag: "SuccessCont", k: current.andThen });
+          this.current = current.first;
+          break;
+        }
+        case "Fold": {
+          this.stack.push({
+            _tag: "FoldCont",
+            onFailure: current.onFailure,
+            onSuccess: current.onSuccess
+          });
+          this.current = current.first;
+          break;
+        }
+        case "Async": {
+          if (this.finishing) {
+            return this.result != null ? STEP.DONE : STEP.CONTINUE;
+          }
+          this._syncResolved = false;
+          this._syncExit = null;
+          this._asyncRegistered = false;
+          const canceler = current.register(this.env, this._asyncCb);
+          this._asyncRegistered = true;
+          if (this._syncResolved && this._syncExit) {
+            const resolvedExit = this._syncExit;
+            this._syncExit = null;
+            if (resolvedExit._tag === "Success") {
+              this.onSuccess(resolvedExit.value);
+            } else {
+              const cause = resolvedExit.cause;
+              if (cause._tag === "Interrupt") {
+                this.notify(Exit.failCause(Cause.interrupt()));
+              } else if (cause._tag === "Fail") {
+                this.onFailure(cause.error);
+              } else {
+                this.notify(Exit.failCause(Cause.die(cause.defect)));
+              }
+            }
+            break;
+          }
+          if (typeof canceler === "function") {
+            this._asyncDetach = this.addTransientFinalizer(() => {
+              if (this._syncResolved) return;
+              this._syncResolved = true;
+              this._asyncDetach = void 0;
+              try {
+                canceler();
+              } catch {
+              }
+            });
+          }
+          return STEP.SUSPEND;
+        }
+        case "Fork": {
+          const child = this.runtime.fork(current.effect, current.scopeId);
+          this.onSuccess(child);
+          break;
+        }
+        case "Sync": {
+          try {
+            const a = current.thunk(this.env);
+            this.onSuccess(a);
+          } catch (e) {
+            this.onFailure(e);
+          }
+          break;
+        }
+        default: {
+          this.onFailure(new Error(`Unknown opcode: ${current._tag}`));
+          return STEP.CONTINUE;
+        }
+      }
+      if (this.result != null) return STEP.DONE;
+    }
+    return STEP.CONTINUE;
+  }
+  /**
+   * Sync trampoline: processes FlatMap chains in a tight loop without the
+   * overhead of the general switch/case. Handles:
+   * - FlatMap(Async(sync), k) — the queue/stream hot path
+   * - FlatMap(Succeed(v), k) — pure value chains
+   * - FlatMap(Sync(f), k) — synchronous thunks
+   * - FlatMap(FlatMap(...), k) — left-associated chains (reassociates inline)
+   * - FlatMap(Fold(...), k) — pushes fold frame and continues
+   *
+   * Returns TRAMPOLINE.CONTINUE when it hits a node it can't handle,
+   * leaving this.current set to that node for the normal switch to process.
+   */
+  syncTrampoline() {
+    while (this.budget-- > 0) {
+      let cur = this.current;
+      while (cur._tag === "FlatMap" && cur.first?._tag === "FlatMap") {
+        this.stack.push({ _tag: "SuccessCont", k: cur.andThen });
+        cur = cur.first;
+      }
+      if (cur._tag !== "FlatMap") {
+        this.current = cur;
+        return TRAMPOLINE.CONTINUE;
+      }
+      const first = cur.first;
+      const andThen = cur.andThen;
+      switch (first._tag) {
+        case "Succeed": {
+          try {
+            this.current = andThen(first.value);
+          } catch (e) {
+            this.notify(Exit.failCause(Cause.die(e)));
+            return TRAMPOLINE.DONE;
+          }
+          continue;
+        }
+        case "Sync": {
+          try {
+            const value = first.thunk(this.env);
+            this.current = andThen(value);
+          } catch (e) {
+            this.notify(Exit.failCause(Cause.die(e)));
+            return TRAMPOLINE.DONE;
+          }
+          continue;
+        }
+        case "Fail": {
+          this.stack.push({ _tag: "SuccessCont", k: andThen });
+          this.current = first;
+          return TRAMPOLINE.CONTINUE;
+        }
+        case "Async": {
+          if (this.finishing) {
+            this.current = cur;
+            return TRAMPOLINE.CONTINUE;
+          }
+          this._syncResolved = false;
+          this._syncExit = null;
+          this._asyncRegistered = false;
+          const canceler = first.register(this.env, this._asyncCb);
+          this._asyncRegistered = true;
+          if (this._syncResolved && this._syncExit) {
+            const exit = this._syncExit;
+            this._syncExit = null;
+            if (exit._tag === "Success") {
+              try {
+                this.current = andThen(exit.value);
+              } catch (e) {
+                this.notify(Exit.failCause(Cause.die(e)));
+                return TRAMPOLINE.DONE;
+              }
+              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)));
+              }
+              return this.result != null ? TRAMPOLINE.DONE : TRAMPOLINE.CONTINUE;
+            }
+          }
+          this.stack.push({ _tag: "SuccessCont", k: andThen });
+          if (typeof canceler === "function") {
+            this._asyncDetach = this.addTransientFinalizer(() => {
+              if (this._syncResolved) return;
+              this._syncResolved = true;
+              this._asyncDetach = void 0;
+              try {
+                canceler();
+              } catch {
+              }
+            });
+          }
+          return TRAMPOLINE.SUSPEND;
+        }
+        case "Fold": {
+          this.stack.push({ _tag: "SuccessCont", k: andThen });
+          this.stack.push({
+            _tag: "FoldCont",
+            onFailure: first.onFailure,
+            onSuccess: first.onSuccess
+          });
+          this.current = first.first;
+          continue;
+        }
+        default: {
+          this.stack.push({ _tag: "SuccessCont", k: andThen });
+          this.current = first;
+          return TRAMPOLINE.CONTINUE;
+        }
+      }
+    }
+    return TRAMPOLINE.CONTINUE;
+  }
+};
+function getCurrentFiber() {
+  return _current;
+}
+function unsafeGetCurrentRuntime() {
+  const f = getCurrentFiber();
+  if (!f?.runtime) {
+    throw new Error("unsafeGetCurrentRuntime: no current fiber/runtime");
+  }
+  return f.runtime;
+}
+function withCurrentFiber(fiber, f) {
+  const prev = _current;
+  _current = fiber;
+  try {
+    return f();
+  } finally {
+    _current = prev;
+  }
+}
+
+// src/core/runtime/engine/JsFiberEngine.ts
+var JsFiberEngine = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  runtime;
+  kind = "ts";
+  startedFibers = 0;
+  fork(effect, scopeId) {
+    this.startedFibers += 1;
+    const fiber = new RuntimeFiber(this.runtime, effect);
+    if (scopeId !== void 0) fiber.scopeId = scopeId;
+    return fiber;
+  }
+  stats() {
+    return {
+      engine: this.kind,
+      startedFibers: this.startedFibers,
+      runningFibers: 0,
+      suspendedFibers: 0,
+      queuedFibers: 0,
+      completedFibers: 0,
+      failedFibers: 0,
+      interruptedFibers: 0,
+      pendingHostEffects: 0
+    };
+  }
+};
+
+// src/core/runtime/scope.ts
+var nextScopeId = 1;
+function awaitAll(fibers) {
+  return async((_env, cb) => {
+    let remaining = fibers.length;
+    if (remaining === 0) {
+      cb({ _tag: "Success", value: void 0 });
+      return;
+    }
+    for (const f of fibers) {
+      f.join(() => {
+        remaining -= 1;
+        if (remaining === 0) cb({ _tag: "Success", value: void 0 });
+      });
+    }
+  });
+}
+var Scope = class _Scope {
+  constructor(runtime, parentScopeId) {
+    this.runtime = runtime;
+    this.parentScopeId = parentScopeId;
+    this.id = nextScopeId++;
+    const inferredParent = this.parentScopeId ?? getCurrentFiber()?.scopeId;
+    if (this.runtime.hasActiveHooks()) {
+      this.runtime.emit({
+        type: "scope.open",
+        scopeId: this.id,
+        parentScopeId: inferredParent
+      });
+    }
+  }
+  runtime;
+  parentScopeId;
+  id;
+  closed = false;
+  children = /* @__PURE__ */ new Set();
+  subScopes = /* @__PURE__ */ new Set();
+  finalizers = [];
+  /** registra un finalizer (LIFO) */
+  addFinalizer(f) {
+    if (this.closed) {
+      throw new Error("Trying to add finalizer to closed scope");
+    }
+    this.finalizers.push(f);
+  }
+  /** crea un sub scope (mismo runtime) */
+  subScope() {
+    if (this.closed) throw new Error("Scope closed");
+    const s = new _Scope(this.runtime, this.id);
+    this.subScopes.add(s);
+    return s;
+  }
+  /** ✅ fork en este scope */
+  fork(eff) {
+    if (this.closed) throw new Error("Scope closed");
+    const f = this.runtime.fork(eff, this.id);
+    this.children.add(f);
+    f.join(() => this.children.delete(f));
+    return f;
+  }
+  /** close fire-and-forget (no bloquea) */
+  close(exit = { _tag: "Success", value: void 0 }) {
+    this.runtime.fork(this.closeAsync(exit));
+  }
+  /** Emit the scope.close event if hooks are active. */
+  emitCloseEvent(exit) {
+    if (this.runtime.hasActiveHooks()) {
+      const status = exit._tag === "Success" ? "success" : exit.cause._tag === "Interrupt" ? "interrupted" : "failure";
+      this.runtime.emit({
+        type: "scope.close",
+        scopeId: this.id,
+        status,
+        error: exit._tag === "Failure" && exit.cause._tag === "Fail" ? exit.cause.error : void 0
+      });
+    }
+  }
+  /**
+   * Build an effect that executes finalizers in LIFO order.
+   *
+   * Optimization over the original: instead of wrapping every finalizer in
+   * `asyncFold(fin(exit), () => unit(), () => unit())` which creates 3 effect
+   * nodes per finalizer (Fold + 2 Succeed), we use a single Sync thunk per
+   * finalizer that catches errors inline.  When the finalizer returns a
+   * Succeed effect (like `unit()`), the Sync thunk completes without creating
+   * additional effect nodes.
+   */
+  buildFinalizerEffect(exit) {
+    const fins = this.finalizers;
+    if (fins.length === 0) return unit();
+    let chain = unit();
+    for (let i = fins.length - 1; i >= 0; i--) {
+      const fin = fins[i];
+      chain = asyncFlatMap(chain, () => {
+        let result;
+        try {
+          result = fin(exit);
+        } catch {
+          return unit();
+        }
+        if (result._tag === "Succeed") {
+          return unit();
+        }
+        return asyncFold(
+          result,
+          () => unit(),
+          () => unit()
+        );
+      });
+    }
+    return chain;
+  }
+  closeAsync(exit = { _tag: "Success", value: void 0 }, opts = { awaitChildren: true }) {
+    return asyncFlatMap(
+      unit(),
+      () => async((env, cb) => {
+        if (this.closed) {
+          cb({ _tag: "Success", value: void 0 });
+          return;
+        }
+        this.closed = true;
+        const children = Array.from(this.children);
+        const subScopes = Array.from(this.subScopes);
+        for (const child of children) {
+          child.interrupt();
+        }
+        const closeSubs = subScopes.reduceRight(
+          (acc, s) => asyncFlatMap(acc, () => s.closeAsync(exit, opts)),
+          unit()
+        );
+        const runFinalizers = this.buildFinalizerEffect(exit);
+        const needsAwait = opts.awaitChildren && children.length > 0;
+        const awaitChildrenEff = needsAwait ? awaitAll(children) : unit();
+        const hasSubScopes = subScopes.length > 0;
+        const hasNoFinalizers = this.finalizers.length === 0;
+        if (!hasSubScopes && !needsAwait && hasNoFinalizers) {
+          this.emitCloseEvent(exit);
+          cb({ _tag: "Success", value: void 0 });
+          return;
+        }
+        const all = asyncFlatMap(closeSubs, () => asyncFlatMap(awaitChildrenEff, () => runFinalizers));
+        this.runtime.fork(all).join(() => {
+          this.emitCloseEvent(exit);
+          cb({ _tag: "Success", value: void 0 });
+        });
+      })
+    );
+  }
+};
+function withScopeAsync(runtime, f) {
+  return async((_env, cb) => {
+    const scope = new Scope(runtime);
+    let done = false;
+    const completeAfterClose = (exit) => {
+      runtime.fork(scope.closeAsync(exit)).join(() => {
+        if (done) return;
+        done = true;
+        cb(exit);
+      });
+    };
+    const fiber = runtime.fork(f(scope));
+    fiber.join(completeAfterClose);
+    return () => {
+      if (done) return;
+      fiber.interrupt();
+      runtime.fork(scope.closeAsync(Exit.failCause(Cause.interrupt())));
+    };
+  });
+}
+function withScope(runtime, f) {
+  return withScopeAsync(runtime, (scope) => {
+    const out = f(scope);
+    if (out && typeof out === "object" && "_tag" in out) return out;
+    return unit();
+  });
+}
+
+// src/core/stream/structuredConcurrency.ts
+function race(left, right, parentScope) {
+  return async((env, cb) => {
+    const scope = parentScope.subScope();
+    let done = false;
+    const onResult = (exit) => {
+      if (done) return;
+      done = true;
+      scope.close(exit);
+      cb(exit);
+    };
+    const fiberLeft = scope.fork(left);
+    const fiberRight = scope.fork(right);
+    fiberLeft.join(onResult);
+    fiberRight.join(onResult);
+  });
+}
+function zipPar(left, right, parentScope) {
+  return async((env, cb) => {
+    const scope = parentScope.subScope();
+    let leftExit = null;
+    let rightExit = null;
+    let done = false;
+    const checkDone = () => {
+      if (!leftExit || !rightExit || done) return;
+      done = true;
+      if (leftExit._tag === "Success" && rightExit._tag === "Success") {
+        scope.close({ _tag: "Success", value: void 0 });
+        cb({
+          _tag: "Success",
+          value: [leftExit.value, rightExit.value]
+        });
+        return;
+      }
+      let cause;
+      if (leftExit._tag === "Failure") {
+        cause = leftExit.cause;
+      } else if (rightExit._tag === "Failure") {
+        cause = rightExit.cause;
+      } else {
+        throw new Error("zipPar: unreachable state (no Failure exit)");
+      }
+      const errExit = {
+        _tag: "Failure",
+        cause
+      };
+      scope.close(errExit);
+      cb(errExit);
+    };
+    const f1 = scope.fork(left);
+    const f2 = scope.fork(right);
+    f1.join((exit) => {
+      leftExit = exit;
+      checkDone();
+    });
+    f2.join((exit) => {
+      rightExit = exit;
+      checkDone();
+    });
+  });
+}
+function collectAllPar(effects, parentScope) {
+  return async((env, cb) => {
+    const scope = parentScope.subScope();
+    const results = new Array(effects.length);
+    let completed = 0;
+    let done = false;
+    effects.forEach((eff, i) => {
+      const f = scope.fork(eff);
+      f.join((exit) => {
+        if (done) return;
+        if (exit._tag === "Failure") {
+          done = true;
+          const errExit = {
+            _tag: "Failure",
+            cause: exit.cause
+          };
+          scope.close(errExit);
+          cb(errExit);
+          return;
+        }
+        results[i] = exit.value;
+        completed++;
+        if (completed === effects.length) {
+          done = true;
+          const successExit = {
+            _tag: "Success",
+            value: results
+          };
+          scope.close({ _tag: "Success", value: void 0 });
+          cb(successExit);
+        }
+      });
+    });
+  });
+}
+function raceWith(left, right, parentScope, onLeft, onRight) {
+  return async((env, cb) => {
+    const scope = parentScope.subScope();
+    let done = false;
+    const fiberLeft = scope.fork(left);
+    const fiberRight = scope.fork(right);
+    const finish = (next) => {
+      scope.fork(next).join((exitNext) => {
+        scope.close(exitNext);
+        cb(exitNext);
+      });
+    };
+    fiberLeft.join((exitL) => {
+      if (done) return;
+      done = true;
+      finish(onLeft(exitL, fiberRight, scope));
+    });
+    fiberRight.join((exitR) => {
+      if (done) return;
+      done = true;
+      finish(onRight(exitR, fiberLeft, scope));
+    });
+  });
+}
+
+export {
+  Async,
+  asyncFold,
+  asyncCatchAll,
+  asyncMapError,
+  unit,
+  asyncSucceed,
+  asyncFail,
+  asyncSync,
+  asyncTotal,
+  async,
+  asyncMap,
+  asyncFlatMap,
+  acquireRelease,
+  asyncInterruptible,
+  withAsyncPromise,
+  mapAsync,
+  mapTryAsync,
+  none,
+  some,
+  Cause,
+  Exit,
+  succeed,
+  fail,
+  sync,
+  map,
+  flatMap,
+  mapError,
+  catchAll,
+  orElseOptional,
+  end,
+  PushStatus,
+  RingBuffer,
+  resolveWasmModule,
+  makeBoundedRingBuffer,
+  sanitizeLaneKey,
+  laneTag,
+  inferCallerLaneFromStack,
+  Scheduler,
+  globalScheduler,
+  DefaultHostExecutor,
+  JsFiberEngine,
+  HostRegistry,
+  ProgramBuilder,
+  EngineFiberHandle,
+  ABI_VERSION,
+  EVENT_WORDS,
+  NONE_U32,
+  OpcodeTagCode,
+  EventKindCode,
+  encodeOpcodeProgram,
+  encodeOpcodeNodes,
+  decodeEvent,
+  decodeEventBatch,
+  WasmPackFiberBridge,
+  WasmFiberRegistryBridge,
+  makeFiberReadyQueue,
+  WasmFiberEngine,
+  runtimeCapabilities,
+  NoopHooks,
+  Runtime,
+  fork,
+  runtimeForCaller,
+  toPromiseByCaller,
+  unsafeRunAsync,
+  toPromise,
+  abortablePromiseStats,
+  resetAbortablePromiseStats,
+  fromPromiseAbortable,
+  unsafeRunFoldWithEnv,
+  setBenchmarkBudget,
+  getBenchmarkBudget,
+  RuntimeFiber,
+  getCurrentFiber,
+  unsafeGetCurrentRuntime,
+  withCurrentFiber,
+  Scope,
+  withScopeAsync,
+  withScope,
+  race,
+  zipPar,
+  collectAllPar,
+  raceWith
+};