brass-runtime 1.13.7 → 1.14.0

package/dist/index.mjs

@@ -8,29 +8,39 @@ import {
   foreachStream,
   fromArray,
   fromPull,
+  makeCircuitBreaker,
   managedStream,
   mapStream,
   merge,
   mergeStream,
   rangeStream,
+  retry,
+  retryN,
+  retryWithBackoff,
+  sleep,
   streamFromReadableStream,
+  timeout,
   uncons,
   unwrapScoped,
   widenOpt,
   zip
-} from "./chunk-XNOTJSMZ.mjs";
+} from "./chunk-UWMMYKVK.mjs";
 import {
+  ABI_VERSION,
   Async,
   Cause,
   DefaultHostExecutor,
+  EVENT_WORDS,
   EngineFiberHandle,
+  EventKindCode,
   Exit,
   HostRegistry,
   JsFiberEngine,
+  NONE_U32,
   NoopHooks,
+  OpcodeTagCode,
   ProgramBuilder,
   PushStatus,
-  ReferenceWasmBridge,
   RingBuffer,
   Runtime,
   RuntimeFiber,
@@ -39,6 +49,7 @@ import {
   WasmFiberEngine,
   WasmFiberRegistryBridge,
   WasmPackFiberBridge,
+  abortablePromiseStats,
   acquireRelease,
   async,
   asyncCatchAll,
@@ -53,6 +64,10 @@ import {
   asyncTotal,
   catchAll,
   collectAllPar,
+  decodeEvent,
+  decodeEventBatch,
+  encodeOpcodeNodes,
+  encodeOpcodeProgram,
   end,
   fail,
   flatMap,
@@ -61,7 +76,10 @@ import {
   getBenchmarkBudget,
   getCurrentFiber,
   globalScheduler,
+  inferCallerLaneFromStack,
+  laneTag,
   makeBoundedRingBuffer,
+  makeFiberReadyQueue,
   map,
   mapAsync,
   mapError,
@@ -70,13 +88,17 @@ import {
   orElseOptional,
   race,
   raceWith,
+  resetAbortablePromiseStats,
   resolveWasmModule,
   runtimeCapabilities,
+  runtimeForCaller,
+  sanitizeLaneKey,
   setBenchmarkBudget,
   some,
   succeed,
   sync,
   toPromise,
+  toPromiseByCaller,
   unit,
   unsafeGetCurrentRuntime,
   unsafeRunAsync,
@@ -86,7 +108,7 @@ import {
   withScope,
   withScopeAsync,
   zipPar
-} from "./chunk-7F2R7A2V.mjs";
+} from "./chunk-4N2JEK4H.mjs";
 
 // src/core/types/cancel.ts
 function makeCancelToken() {
@@ -121,6 +143,135 @@ function linkAbortController(token, ac) {
   return token.onCancel(() => ac.abort());
 }
 
+// src/core/runtime/resource.ts
+function bracket(acquire, use, release) {
+  return async((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const scope = new Scope(runtime);
+    const acquireFiber = scope.fork(acquire);
+    acquireFiber.join((acquireExit) => {
+      if (acquireExit._tag === "Failure") {
+        scope.close(acquireExit);
+        cb(acquireExit);
+        return;
+      }
+      const resource = acquireExit.value;
+      const useFiber = scope.fork(use(resource));
+      useFiber.join((useExit) => {
+        const releaseEffect = safeRelease(release, resource, useExit);
+        const releaseFiber = runtime.fork(releaseEffect);
+        releaseFiber.join(() => {
+          scope.close(useExit);
+          cb(useExit);
+        });
+      });
+    });
+    return () => {
+      scope.close(Exit.failCause(Cause.interrupt()));
+    };
+  });
+}
+function safeRelease(release, resource, exit) {
+  return asyncFold(
+    (() => {
+      try {
+        return release(resource, exit);
+      } catch {
+        return unit();
+      }
+    })(),
+    () => unit(),
+    () => unit()
+  );
+}
+function ensuring(effect, finalizer) {
+  return async((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      const fin = asyncFold(
+        (() => {
+          try {
+            return finalizer(exit);
+          } catch {
+            return unit();
+          }
+        })(),
+        () => unit(),
+        () => unit()
+      );
+      runtime.fork(fin).join(() => {
+        cb(exit);
+      });
+    });
+    return () => {
+      fiber.interrupt();
+    };
+  });
+}
+function managed(acquire, release) {
+  return {
+    _tag: "Managed",
+    acquire,
+    release: (resource, exit) => release(resource, exit)
+  };
+}
+function useManaged(m, body) {
+  return bracket(m.acquire, body, m.release);
+}
+function managedAll(manageds) {
+  const acquire = async((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const resources = [];
+    let i = 0;
+    const acquireNext = () => {
+      if (i >= manageds.length) {
+        cb({ _tag: "Success", value: resources });
+        return;
+      }
+      const m = manageds[i];
+      const fiber = runtime.fork(m.acquire);
+      fiber.join((exit) => {
+        if (exit._tag === "Failure") {
+          releaseAcquired(runtime, manageds, resources, exit).then(() => {
+            cb(exit);
+          });
+          return;
+        }
+        resources.push(exit.value);
+        i++;
+        acquireNext();
+      });
+    };
+    acquireNext();
+  });
+  const release = (resources, exit) => {
+    return async((_env, cb) => {
+      const runtime = unsafeGetCurrentRuntime();
+      releaseAcquired(runtime, manageds, resources, exit).then(() => {
+        cb({ _tag: "Success", value: void 0 });
+      });
+    });
+  };
+  return { _tag: "Managed", acquire, release };
+}
+async function releaseAcquired(runtime, manageds, resources, exit) {
+  for (let i = resources.length - 1; i >= 0; i--) {
+    try {
+      const m = manageds[i];
+      await new Promise((resolve) => {
+        const releaseEff = asyncFold(
+          m.release(resources[i], exit),
+          () => unit(),
+          () => unit()
+        );
+        runtime.fork(releaseEff).join(() => resolve());
+      });
+    } catch {
+    }
+  }
+}
+
 // src/core/runtime/linkedQueue.ts
 var LinkedQueue = class {
   head = null;
@@ -163,6 +314,788 @@ var LinkedQueue = class {
   }
 };
 
+// src/core/runtime/semaphore.ts
+function makeSemaphore(n) {
+  const capacity = Math.max(1, Math.floor(n));
+  let available = capacity;
+  let totalAcquired = 0;
+  let totalReleased = 0;
+  const waiters = new LinkedQueue();
+  const acquire = () => {
+    return async((_env, cb) => {
+      if (available > 0) {
+        available--;
+        totalAcquired++;
+        cb({ _tag: "Success", value: void 0 });
+        return;
+      }
+      const node = waiters.push(cb);
+      return () => {
+        waiters.remove(node);
+      };
+    });
+  };
+  const release = () => {
+    totalReleased++;
+    if (waiters.length > 0) {
+      const waiter = waiters.shift();
+      totalAcquired++;
+      waiter({ _tag: "Success", value: void 0 });
+      return;
+    }
+    available++;
+  };
+  const withPermit = (effect) => {
+    return asyncFlatMap(
+      acquire(),
+      () => async((_env, cb) => {
+        const runtime = unsafeGetCurrentRuntime();
+        const fiber = runtime.fork(effect);
+        fiber.join((exit) => {
+          release();
+          cb(exit);
+        });
+        return () => {
+          fiber.interrupt();
+          release();
+        };
+      })
+    );
+  };
+  return {
+    capacity,
+    available: () => available,
+    waiting: () => waiters.length,
+    withPermit,
+    acquire,
+    release
+  };
+}
+
+// src/core/runtime/ref.ts
+function makeRef(initial) {
+  let value = initial;
+  return {
+    get: () => asyncSync(() => value),
+    set: (v) => asyncSync(() => {
+      value = v;
+    }),
+    update: (f) => asyncSync(() => {
+      value = f(value);
+      return value;
+    }),
+    modify: (f) => asyncSync(() => {
+      const [result, next] = f(value);
+      value = next;
+      return result;
+    }),
+    unsafeGet: () => value
+  };
+}
+function derivedRef(parent, get, set) {
+  return {
+    get: () => asyncSync(() => get(parent.unsafeGet())),
+    set: (b) => asyncSync(() => {
+      const current = parent.unsafeGet();
+      parent.set(set(current, b));
+    }),
+    update: (f) => asyncSync(() => {
+      const parentVal = parent.unsafeGet();
+      const currentB = get(parentVal);
+      const newB = f(currentB);
+      const newParent = set(parentVal, newB);
+      parent.unsafeGet = () => newParent;
+      return newB;
+    }),
+    modify: (f) => asyncSync(() => {
+      const parentVal = parent.unsafeGet();
+      const currentB = get(parentVal);
+      const [result, newB] = f(currentB);
+      const newParent = set(parentVal, newB);
+      parent.unsafeGet = () => newParent;
+      return result;
+    }),
+    unsafeGet: () => get(parent.unsafeGet())
+  };
+}
+
+// src/core/runtime/schedule.ts
+function recurs(n) {
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count, _input) => {
+      const next = count + 1;
+      return [{ continue: next < n, delayMs: 0 }, next, next];
+    }
+  };
+}
+function fixed(delayMs) {
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count, _input) => {
+      return [{ continue: true, delayMs }, count + 1, count + 1];
+    }
+  };
+}
+function exponential(baseMs, maxMs = Infinity) {
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count, _input) => {
+      const delay = Math.min(baseMs * Math.pow(2, count), maxMs);
+      return [{ continue: true, delayMs: delay }, count + 1, count + 1];
+    }
+  };
+}
+function jittered(baseMs, maxMs = Infinity) {
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count, _input) => {
+      const cap = Math.min(baseMs * Math.pow(2, count), maxMs);
+      const delay = Math.floor(Math.random() * cap);
+      return [{ continue: true, delayMs: delay }, count + 1, count + 1];
+    }
+  };
+}
+function elapsed(maxMs) {
+  return {
+    _tag: "Schedule",
+    initial: () => performance.now(),
+    step: (startedAt, _input) => {
+      const el = performance.now() - startedAt;
+      return [{ continue: el < maxMs, delayMs: 0 }, startedAt, el];
+    }
+  };
+}
+function whileInput(pred) {
+  return {
+    _tag: "Schedule",
+    initial: () => void 0,
+    step: (_state, input) => {
+      return [{ continue: pred(input), delayMs: 0 }, void 0, input];
+    }
+  };
+}
+function take(schedule, n) {
+  return {
+    _tag: "Schedule",
+    initial: () => ({ inner: schedule.initial(), count: 0 }),
+    step: (state, input) => {
+      if (state.count >= n) return [{ continue: false, delayMs: 0 }, state, void 0];
+      const [decision, nextInner, output] = schedule.step(state.inner, input);
+      const nextState = { inner: nextInner, count: state.count + 1 };
+      return [{ continue: decision.continue && state.count + 1 < n, delayMs: decision.delayMs }, nextState, output];
+    }
+  };
+}
+function andThen(first, second) {
+  return {
+    _tag: "Schedule",
+    initial: () => ({ phase: "first", inner: first.initial() }),
+    step: (state, input) => {
+      if (state.phase === "first") {
+        const [decision2, nextInner2, output2] = first.step(state.inner, input);
+        if (decision2.continue) {
+          return [decision2, { phase: "first", inner: nextInner2 }, output2];
+        }
+        return [{ continue: true, delayMs: decision2.delayMs }, { phase: "second", inner: second.initial() }, output2];
+      }
+      const [decision, nextInner, output] = second.step(state.inner, input);
+      return [decision, { phase: "second", inner: nextInner }, output];
+    }
+  };
+}
+function intersect(left, right) {
+  return {
+    _tag: "Schedule",
+    initial: () => ({ left: left.initial(), right: right.initial() }),
+    step: (state, input) => {
+      const [ld, ls, lo] = left.step(state.left, input);
+      const [rd, rs, ro] = right.step(state.right, input);
+      const cont = ld.continue && rd.continue;
+      const delay = Math.max(ld.delayMs, rd.delayMs);
+      return [{ continue: cont, delayMs: delay }, { left: ls, right: rs }, [lo, ro]];
+    }
+  };
+}
+function union(left, right) {
+  return {
+    _tag: "Schedule",
+    initial: () => ({ left: left.initial(), right: right.initial() }),
+    step: (state, input) => {
+      const [ld, ls, lo] = left.step(state.left, input);
+      const [rd, rs, ro] = right.step(state.right, input);
+      const cont = ld.continue || rd.continue;
+      const delay = Math.min(ld.delayMs, rd.delayMs);
+      return [{ continue: cont, delayMs: delay }, { left: ls, right: rs }, [lo, ro]];
+    }
+  };
+}
+function retryWithSchedule(effect, schedule) {
+  const loop = (state) => asyncFold(
+    effect,
+    (error) => {
+      const [decision, nextState, _output] = schedule.step(state, error);
+      if (!decision.continue) return asyncFail(error);
+      if (decision.delayMs <= 0) return loop(nextState);
+      return asyncFlatMap(sleep(decision.delayMs), () => loop(nextState));
+    },
+    (value) => asyncSucceed(value)
+  );
+  return loop(schedule.initial());
+}
+function repeatWithSchedule(effect, schedule) {
+  const loop = (state, lastValue) => {
+    const [decision, nextState, _output] = schedule.step(state, lastValue);
+    if (!decision.continue) return asyncSucceed(lastValue);
+    if (decision.delayMs <= 0) {
+      return asyncFold(
+        effect,
+        (error) => asyncFail(error),
+        (value) => loop(nextState, value)
+      );
+    }
+    return asyncFlatMap(
+      sleep(decision.delayMs),
+      () => asyncFold(
+        effect,
+        (error) => asyncFail(error),
+        (value) => loop(nextState, value)
+      )
+    );
+  };
+  return asyncFold(
+    effect,
+    (error) => asyncFail(error),
+    (value) => loop(schedule.initial(), value)
+  );
+}
+
+// src/core/runtime/shutdown.ts
+async function gracefulShutdown(runtime, config = {}) {
+  const timeoutMs = config.timeoutMs ?? 3e4;
+  const startedAt = Date.now();
+  config.onStart?.();
+  let timedOut = false;
+  const shutdownPromise = (async () => {
+    try {
+      await runtime.shutdown();
+    } catch {
+    }
+  })();
+  const timeoutPromise = new Promise((resolve) => {
+    setTimeout(() => {
+      timedOut = true;
+      resolve();
+    }, timeoutMs);
+  });
+  await Promise.race([shutdownPromise, timeoutPromise]);
+  const completedAt = Date.now();
+  const stats = {
+    startedAt,
+    completedAt,
+    elapsedMs: completedAt - startedAt,
+    timedOut
+  };
+  if (timedOut) {
+    config.onTimeout?.(stats);
+  } else {
+    config.onComplete?.(stats);
+  }
+  return stats;
+}
+function registerShutdownHooks(runtime, config = {}) {
+  let shuttingDown = false;
+  const handler = (signal) => {
+    if (shuttingDown) {
+      process.exit(1);
+    }
+    shuttingDown = true;
+    console.log(`
+[brass-runtime] Received ${signal}, shutting down gracefully...`);
+    gracefulShutdown(runtime, {
+      ...config,
+      onComplete: (stats) => {
+        config.onComplete?.(stats);
+        if (!config.onComplete) {
+          console.log(`[brass-runtime] Shutdown complete (${stats.elapsedMs}ms)`);
+          process.exit(0);
+        }
+      },
+      onTimeout: (stats) => {
+        config.onTimeout?.(stats);
+        if (!config.onTimeout) {
+          console.log(`[brass-runtime] Shutdown timed out after ${stats.elapsedMs}ms, forcing exit`);
+          process.exit(1);
+        }
+      }
+    });
+  };
+  process.on("SIGTERM", () => handler("SIGTERM"));
+  process.on("SIGINT", () => handler("SIGINT"));
+  return () => {
+    process.removeAllListeners("SIGTERM");
+    process.removeAllListeners("SIGINT");
+  };
+}
+
+// src/core/runtime/testing.ts
+function makeTestRuntime(env, options) {
+  const runtime = Runtime.make(env ?? {});
+  const run = (effect) => runtime.toPromise(effect);
+  const runExit = (effect) => new Promise((resolve) => {
+    runtime.unsafeRunAsync(effect, resolve);
+  });
+  return { runtime, run, runExit };
+}
+async function assertSucceeds(effect, expected, runtime) {
+  const rt = runtime ?? Runtime.make({});
+  const exit = await new Promise((resolve) => {
+    rt.unsafeRunAsync(effect, resolve);
+  });
+  if (exit._tag !== "Success") {
+    throw new Error(`Expected success with ${JSON.stringify(expected)}, got failure: ${JSON.stringify(exit.cause)}`);
+  }
+  if (JSON.stringify(exit.value) !== JSON.stringify(expected)) {
+    throw new Error(`Expected ${JSON.stringify(expected)}, got ${JSON.stringify(exit.value)}`);
+  }
+}
+async function assertFails(effect, expectedError, runtime) {
+  const rt = runtime ?? Runtime.make({});
+  const exit = await new Promise((resolve) => {
+    rt.unsafeRunAsync(effect, resolve);
+  });
+  if (exit._tag !== "Failure") {
+    throw new Error(`Expected failure with ${JSON.stringify(expectedError)}, got success: ${JSON.stringify(exit.value)}`);
+  }
+  const error = exit.cause.error;
+  if (JSON.stringify(error) !== JSON.stringify(expectedError)) {
+    throw new Error(`Expected error ${JSON.stringify(expectedError)}, got ${JSON.stringify(error)}`);
+  }
+}
+async function assertFailsWith(effect, predicate, runtime) {
+  const rt = runtime ?? Runtime.make({});
+  const exit = await new Promise((resolve) => {
+    rt.unsafeRunAsync(effect, resolve);
+  });
+  if (exit._tag !== "Failure") {
+    throw new Error(`Expected failure, got success: ${JSON.stringify(exit.value)}`);
+  }
+  const error = exit.cause.error;
+  if (!predicate(error)) {
+    throw new Error(`Error did not match predicate: ${JSON.stringify(error)}`);
+  }
+}
+async function assertCompletesWithin(effect, maxMs, runtime) {
+  const rt = runtime ?? Runtime.make({});
+  const start = performance.now();
+  const result = await rt.toPromise(effect);
+  const elapsed2 = performance.now() - start;
+  if (elapsed2 > maxMs) {
+    throw new Error(`Effect took ${elapsed2.toFixed(1)}ms, expected < ${maxMs}ms`);
+  }
+  return result;
+}
+function flakyEffect(failCount, successValue, errorValue) {
+  let calls = 0;
+  return async((_env, cb) => {
+    calls++;
+    if (calls <= failCount) {
+      cb({ _tag: "Failure", cause: { _tag: "Fail", error: errorValue } });
+    } else {
+      cb({ _tag: "Success", value: successValue });
+    }
+  });
+}
+function delayedEffect(ms, value) {
+  return async((_env, cb) => {
+    const id = setTimeout(() => cb({ _tag: "Success", value }), ms);
+    return () => clearTimeout(id);
+  });
+}
+function neverEffect() {
+  return async(() => {
+    return () => {
+    };
+  });
+}
+
+// src/core/runtime/layer.ts
+function layer(acquire, release) {
+  return {
+    _tag: "Layer",
+    build: (_deps) => asyncFlatMap(acquire(), (service) => asyncSucceed({
+      service,
+      release: release ? () => release(service) : () => unit()
+    }))
+  };
+}
+function layerFrom() {
+  return (acquire, release) => ({
+    _tag: "Layer",
+    build: (deps) => asyncFlatMap(acquire(deps), (service) => asyncSucceed({
+      service,
+      release: release ? () => release(service) : () => unit()
+    }))
+  });
+}
+function layerSucceed(value) {
+  return {
+    _tag: "Layer",
+    build: () => asyncSucceed({ service: value, release: () => unit() })
+  };
+}
+function layerFail(error) {
+  return {
+    _tag: "Layer",
+    build: () => asyncFail(error)
+  };
+}
+function compose(from, to) {
+  return {
+    _tag: "Layer",
+    build: (deps) => asyncFlatMap(
+      from.build(deps),
+      ({ service: mid, release: releaseMid }) => asyncFold(
+        to.build(mid),
+        (error) => asyncFlatMap(releaseMid(), () => asyncFail(error)),
+        ({ service: out, release: releaseOut }) => asyncSucceed({
+          service: out,
+          release: () => asyncFlatMap(releaseOut(), () => releaseMid())
+        })
+      )
+    )
+  };
+}
+function merge2(left, right) {
+  return {
+    _tag: "Layer",
+    build: (deps) => asyncFlatMap(
+      left.build(deps),
+      ({ service: a, release: releaseA }) => asyncFold(
+        right.build(deps),
+        (error) => asyncFlatMap(releaseA(), () => asyncFail(error)),
+        ({ service: b, release: releaseB }) => asyncSucceed({
+          service: { ...a, ...b },
+          release: () => asyncFlatMap(releaseB(), () => releaseA())
+        })
+      )
+    )
+  };
+}
+function mapLayer(l, f) {
+  return {
+    _tag: "Layer",
+    build: (deps) => asyncFlatMap(
+      l.build(deps),
+      ({ service, release }) => asyncSucceed({ service: f(service), release })
+    )
+  };
+}
+function provideLayer(l, use, deps) {
+  return asyncFlatMap(
+    l.build(deps ?? {}),
+    ({ service, release }) => asyncFold(
+      use(service),
+      (error) => asyncFlatMap(release(), () => asyncFail(error)),
+      (value) => asyncFlatMap(release(), () => asyncSucceed(value))
+    )
+  );
+}
+
+// src/core/runtime/workerPool.ts
+function makeWorkerPool(config = {}) {
+  const size = config.size ?? 4;
+  const maxQueue = config.maxQueue ?? 1e3;
+  const taskTimeoutMs = config.taskTimeoutMs ?? 3e4;
+  let closed = false;
+  let busy = 0;
+  let completed = 0;
+  let failed = 0;
+  let timedOut = 0;
+  const queue = [];
+  const processNext = () => {
+    if (queue.length === 0 || busy >= size) return;
+    const task = queue.shift();
+    busy++;
+    setImmediate(() => {
+      if (task.timeoutId) clearTimeout(task.timeoutId);
+      try {
+        const result = task.fn();
+        busy--;
+        completed++;
+        task.resolve(result);
+        processNext();
+      } catch (e) {
+        busy--;
+        failed++;
+        task.reject({ _tag: "WorkerTaskError", message: String(e) });
+        processNext();
+      }
+    });
+  };
+  const execute = (fn) => {
+    if (closed) return asyncFail({ _tag: "WorkerPoolClosed" });
+    if (queue.length >= maxQueue) {
+      return asyncFail({ _tag: "WorkerPoolFull", queued: queue.length });
+    }
+    return async((_env, cb) => {
+      const task = {
+        fn,
+        resolve: (value) => cb({ _tag: "Success", value }),
+        reject: (error) => cb({ _tag: "Failure", cause: { _tag: "Fail", error } })
+      };
+      task.timeoutId = setTimeout(() => {
+        const idx = queue.indexOf(task);
+        if (idx >= 0) {
+          queue.splice(idx, 1);
+          timedOut++;
+          task.reject({ _tag: "WorkerTaskTimeout", ms: taskTimeoutMs });
+        }
+      }, taskTimeoutMs);
+      queue.push(task);
+      processNext();
+      return () => {
+        const idx = queue.indexOf(task);
+        if (idx >= 0) {
+          queue.splice(idx, 1);
+          if (task.timeoutId) clearTimeout(task.timeoutId);
+        }
+      };
+    });
+  };
+  const run = (taskSource, args = []) => {
+    return execute(() => {
+      const fn = new Function(...args.map((_, i) => `arg${i}`), taskSource);
+      return fn(...args);
+    });
+  };
+  return {
+    execute,
+    run,
+    stats: () => ({
+      size,
+      busy,
+      idle: size - busy,
+      queued: queue.length,
+      completed,
+      failed,
+      timedOut
+    }),
+    shutdown: async () => {
+      closed = true;
+      while (queue.length > 0) {
+        const task = queue.shift();
+        if (task.timeoutId) clearTimeout(task.timeoutId);
+        task.reject({ _tag: "WorkerPoolClosed" });
+      }
+    }
+  };
+}
+
+// src/core/runtime/tracing.ts
+var idCounter = 0;
+function generateId() {
+  return (++idCounter).toString(16).padStart(16, "0");
+}
+function makeTracer(config) {
+  const completedSpans = [];
+  const sampleRate = config.sampleRate ?? 1;
+  const shouldSample = () => {
+    if (sampleRate >= 1) return true;
+    if (sampleRate <= 0) return false;
+    return Math.random() < sampleRate;
+  };
+  const span = (name, effect, attributes) => {
+    if (!shouldSample()) return effect;
+    const spanObj = {
+      name,
+      context: {
+        traceId: generateId(),
+        spanId: generateId()
+      },
+      startTime: performance.now(),
+      status: "unset",
+      attributes: { "service.name": config.serviceName, ...attributes },
+      events: []
+    };
+    return asyncFold(
+      effect,
+      (error) => {
+        spanObj.endTime = performance.now();
+        spanObj.status = "error";
+        spanObj.events.push({
+          name: "error",
+          time: performance.now(),
+          attributes: { "error.message": String(error) }
+        });
+        completedSpans.push(spanObj);
+        config.onSpanEnd?.(spanObj);
+        return asyncFail(error);
+      },
+      (value) => {
+        spanObj.endTime = performance.now();
+        spanObj.status = "ok";
+        completedSpans.push(spanObj);
+        config.onSpanEnd?.(spanObj);
+        return asyncSucceed(value);
+      }
+    );
+  };
+  return {
+    span,
+    spans: () => completedSpans,
+    clear: () => {
+      completedSpans.length = 0;
+    }
+  };
+}
+
+// src/core/runtime/metrics.ts
+var DEFAULT_BOUNDARIES = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 5e3, 1e4];
+function makeMetrics() {
+  const counters = /* @__PURE__ */ new Map();
+  const gauges = /* @__PURE__ */ new Map();
+  const histograms = /* @__PURE__ */ new Map();
+  const key = (name, labels) => labels ? `${name}|${Object.entries(labels).sort().map(([k, v]) => `${k}=${v}`).join(",")}` : name;
+  const counter = (name, labels = {}) => {
+    const k = key(name, labels);
+    if (!counters.has(k)) counters.set(k, { labels, value: 0 });
+    const entry = counters.get(k);
+    return {
+      increment: (n = 1) => {
+        entry.value += Math.max(0, n);
+      },
+      value: () => entry.value
+    };
+  };
+  const gauge = (name, labels = {}) => {
+    const k = key(name, labels);
+    if (!gauges.has(k)) gauges.set(k, { labels, value: 0 });
+    const entry = gauges.get(k);
+    return {
+      set: (v) => {
+        entry.value = v;
+      },
+      increment: (n = 1) => {
+        entry.value += n;
+      },
+      decrement: (n = 1) => {
+        entry.value -= n;
+      },
+      value: () => entry.value
+    };
+  };
+  const histogram = (name, boundaries = DEFAULT_BOUNDARIES, labels = {}) => {
+    const k = key(name, labels);
+    if (!histograms.has(k)) {
+      const sorted = [...boundaries].sort((a, b) => a - b);
+      histograms.set(k, {
+        labels,
+        boundaries: sorted,
+        data: { boundaries: sorted, counts: new Array(sorted.length + 1).fill(0), sum: 0, count: 0, min: Infinity, max: -Infinity }
+      });
+    }
+    const entry = histograms.get(k);
+    return {
+      observe: (value) => {
+        entry.data.sum += value;
+        entry.data.count++;
+        entry.data.min = Math.min(entry.data.min, value);
+        entry.data.max = Math.max(entry.data.max, value);
+        let placed = false;
+        for (let i = 0; i < entry.boundaries.length; i++) {
+          if (value <= entry.boundaries[i]) {
+            entry.data.counts[i]++;
+            placed = true;
+            break;
+          }
+        }
+        if (!placed) entry.data.counts[entry.boundaries.length]++;
+      },
+      buckets: () => ({ ...entry.data }),
+      percentile: (p) => {
+        const target = Math.ceil(entry.data.count * (p / 100));
+        let cumulative = 0;
+        for (let i = 0; i < entry.boundaries.length; i++) {
+          cumulative += entry.data.counts[i];
+          if (cumulative >= target) return entry.boundaries[i];
+        }
+        return entry.data.max;
+      }
+    };
+  };
+  return {
+    counter,
+    gauge,
+    histogram,
+    snapshot: () => ({
+      counters: Array.from(counters.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, value: v.value })),
+      gauges: Array.from(gauges.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, value: v.value })),
+      histograms: Array.from(histograms.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, buckets: v.data }))
+    }),
+    reset: () => {
+      counters.clear();
+      gauges.clear();
+      histograms.clear();
+    }
+  };
+}
+
+// src/core/types/typedError.ts
+function catchTag(effect, tag, handler) {
+  return asyncFold(
+    effect,
+    (error) => {
+      if (typeof error === "object" && error !== null && "_tag" in error && error._tag === tag) {
+        return handler(error);
+      }
+      return asyncFail(error);
+    },
+    (value) => asyncSucceed(value)
+  );
+}
+function catchTags(effect, handlers) {
+  return asyncFold(
+    effect,
+    (error) => {
+      if (typeof error === "object" && error !== null && "_tag" in error) {
+        const handler = handlers[error._tag];
+        if (handler) return handler(error);
+      }
+      return asyncFail(error);
+    },
+    (value) => asyncSucceed(value)
+  );
+}
+function mapError2(effect, f) {
+  return asyncFold(
+    effect,
+    (error) => asyncFail(f(error)),
+    (value) => asyncSucceed(value)
+  );
+}
+function tagError(effect, tag, enrich) {
+  return asyncFold(
+    effect,
+    (error) => {
+      const fields = enrich ? enrich(error) : {};
+      return asyncFail({ _tag: tag, ...fields });
+    },
+    (value) => asyncSucceed(value)
+  );
+}
+function orElse(effect, fallback) {
+  return asyncFold(
+    effect,
+    (error) => fallback(error),
+    (value) => asyncSucceed(value)
+  );
+}
+
 // src/core/stream/queue.ts
 function bounded(capacity, strategy = "backpressure", options = {}) {
   return asyncSync(() => makeQueue(capacity, strategy, options));
@@ -250,6 +1183,61 @@ function makeQueue(capacity, strategy, options) {
         takers.remove(node);
       };
       return canceler;
+    }),
+    offerBatch: (values) => asyncSync(() => {
+      const results = [];
+      for (let i = 0; i < values.length; i++) {
+        if (closed) {
+          results.push(false);
+          continue;
+        }
+        const a = values[i];
+        if (takers.length > 0) {
+          const t = takers.shift();
+          t({ _tag: "Success", value: a });
+          results.push(true);
+          continue;
+        }
+        if (items.length < capacity) {
+          items.push(a);
+          results.push(true);
+          continue;
+        }
+        if (strategy === "dropping") {
+          results.push(false);
+        } else if (strategy === "sliding") {
+          items.shift();
+          items.push(a);
+          results.push(true);
+        } else {
+          results.push(false);
+        }
+      }
+      return results;
+    }),
+    takeBatch: (n) => asyncSync(() => {
+      const results = [];
+      const count = Math.min(n, items.length + offerWaiters.length);
+      for (let i = 0; i < count; i++) {
+        if (items.length > 0) {
+          results.push(items.shift());
+          if (offerWaiters.length > 0 && items.length < capacity) {
+            const w = offerWaiters.shift();
+            items.push(w.a);
+            w.cb(true);
+          }
+        } else if (offerWaiters.length > 0) {
+          const w = offerWaiters.shift();
+          w.cb(true);
+          results.push(w.a);
+        } else {
+          break;
+        }
+      }
+      if (results.length === 0 && closed) {
+        throw QueueClosedErr;
+      }
+      return results;
     })
   };
 }
@@ -431,14 +1419,12 @@ function resolveWasmChunkBuffer() {
   cachedWasmChunkCtor = mod?.BrassWasmChunkBuffer ?? null;
   return cachedWasmChunkCtor;
 }
-var JsChunker = class {
-  constructor(maxChunkSize, fallbackUsed = false) {
+var TsChunker = class {
+  constructor(maxChunkSize) {
     this.maxChunkSize = maxChunkSize;
-    this.fallbackUsed = fallbackUsed;
   }
   maxChunkSize;
-  fallbackUsed;
-  engine = "js";
+  engine = "ts";
   values = [];
   emittedChunks = 0;
   emittedItems = 0;
@@ -472,8 +1458,8 @@ var JsChunker = class {
   }
   stats() {
     return {
-      engine: "js",
-      fallbackUsed: this.fallbackUsed,
+      engine: "ts",
+      fallbackUsed: false,
       data: {
         len: this.values.length,
         maxChunkSize: this.maxChunkSize,
@@ -522,10 +1508,10 @@ var WasmChunker = class {
 };
 function makeStreamChunker(chunkSize, options = {}) {
   const size = Math.max(1, chunkSize | 0);
-  const engine = options.engine ?? "auto";
-  if (engine === "js") return new JsChunker(size, false);
+  const engine = options.engine ?? "ts";
+  if (engine === "ts") return new TsChunker(size);
   if (engine === "wasm") return new WasmChunker(size);
-  return resolveWasmChunkBuffer() ? new WasmChunker(size) : new JsChunker(size, true);
+  throw new Error(`brass-runtime stream chunk engine must be 'ts' or 'wasm'; received '${String(engine)}'`);
 }
 function chunks(input, chunkSize, options = {}) {
   const size = Math.max(1, chunkSize | 0);
@@ -591,21 +1577,430 @@ function mapChunksEffect(chunkSize, f, options = {}) {
   });
 }
 
+// src/core/stream/fusion.ts
+var _fusionEnabled = true;
+var _fusionVerbose = false;
+function setFusionEnabled(enabled) {
+  _fusionEnabled = enabled;
+}
+function isFusionEnabled() {
+  return _fusionEnabled;
+}
+function setFusionVerbose(verbose) {
+  _fusionVerbose = verbose;
+}
+function isFusionVerbose() {
+  return _fusionVerbose;
+}
+function getStats(pipeline) {
+  const p = pipeline;
+  if (p._fusedSteps && Array.isArray(p._fusedSteps)) {
+    const metas = p._fusedSteps;
+    return buildStats(metas);
+  }
+  if (p[PURE_PIPELINE_TAG]) {
+    return null;
+  }
+  return null;
+}
+var PURE_PIPELINE_TAG = /* @__PURE__ */ Symbol("brass:pure-pipeline");
+function makeMapStep(fn) {
+  return (a, _state) => ({ tag: "emit", value: fn(a) });
+}
+function makeFilterStep(pred) {
+  return (a, _state) => pred(a) ? { tag: "emit", value: a } : { tag: "skip" };
+}
+function makeTakeStep(n, counterIndex) {
+  return (a, state) => {
+    if (state.counters[counterIndex] >= n) {
+      return { tag: "halt" };
+    }
+    state.counters[counterIndex]++;
+    return { tag: "emit", value: a };
+  };
+}
+function makeDropStep(n, counterIndex) {
+  return (a, state) => {
+    if (state.counters[counterIndex] < n) {
+      state.counters[counterIndex]++;
+      return { tag: "skip" };
+    }
+    return { tag: "emit", value: a };
+  };
+}
+function initState(counterCount) {
+  return () => ({
+    counters: new Array(counterCount).fill(0)
+  });
+}
+function composeSteps(step1, step2) {
+  return (a, state) => {
+    const r1 = step1(a, state);
+    if (r1.tag !== "emit") return r1;
+    return step2(r1.value, state);
+  };
+}
+function getPureTag(pipeline) {
+  const tagged = pipeline;
+  return tagged[PURE_PIPELINE_TAG] ?? null;
+}
+function getFusedSteps(pipeline) {
+  const p = pipeline;
+  if (p._fusedSteps && Array.isArray(p._fusedSteps)) {
+    return p._fusedSteps;
+  }
+  return null;
+}
+function buildStepFromMetadata(meta, counterIndex) {
+  switch (meta.kind) {
+    case "map":
+      return makeMapStep(meta.fn);
+    case "filter":
+      return makeFilterStep(meta.pred);
+    case "take":
+      return makeTakeStep(meta.n, counterIndex);
+    case "drop":
+      return makeDropStep(meta.n, counterIndex);
+  }
+}
+function buildStats(metas) {
+  const steps = metas.map((m) => {
+    switch (m.kind) {
+      case "map":
+        return { kind: "map" };
+      case "filter":
+        return { kind: "filter" };
+      case "take":
+        return { kind: "take", n: m.n };
+      case "drop":
+        return { kind: "drop", n: m.n };
+    }
+  });
+  return {
+    fusedSteps: steps.length,
+    steps,
+    hasTake: metas.some((m) => m.kind === "take"),
+    hasDrop: metas.some((m) => m.kind === "drop")
+  };
+}
+function countCounters(metas) {
+  let count = 0;
+  for (const m of metas) {
+    if (m.kind === "take" || m.kind === "drop") {
+      count++;
+    }
+  }
+  return count;
+}
+function fuse(pipeline, options) {
+  const verbose = options?.verbose ?? _fusionVerbose;
+  if (options?.enabled === false || !_fusionEnabled && options?.enabled !== true) {
+    if (verbose) {
+      console.log("[FusionEngine] Fusion disabled by options");
+    }
+    return null;
+  }
+  const metas = collectMetadata(pipeline);
+  if (!metas || metas.length === 0) {
+    if (verbose) {
+      console.log("[FusionEngine] Pipeline is not fusable (no pure tags detected)");
+    }
+    return null;
+  }
+  if (verbose) {
+    console.log(
+      `[FusionEngine] Fusing ${metas.length} steps: ${metas.map((m) => m.kind).join(" \u2192 ")}`
+    );
+  }
+  let counterIndex = 0;
+  let composedStep = buildStepFromMetadata(
+    metas[0],
+    metas[0].kind === "take" || metas[0].kind === "drop" ? counterIndex++ : -1
+  );
+  for (let i = 1; i < metas.length; i++) {
+    const meta = metas[i];
+    const idx = meta.kind === "take" || meta.kind === "drop" ? counterIndex++ : -1;
+    composedStep = composeSteps(composedStep, buildStepFromMetadata(meta, idx));
+  }
+  const counterCount = countCounters(metas);
+  const stats = buildStats(metas);
+  return {
+    _tag: "FusedPipeline",
+    step: composedStep,
+    initState: initState(counterCount),
+    stats
+  };
+}
+function collectMetadata(pipeline) {
+  const fusedSteps = getFusedSteps(pipeline);
+  if (fusedSteps) {
+    return fusedSteps;
+  }
+  const tag = getPureTag(pipeline);
+  if (tag) {
+    return [tag];
+  }
+  return null;
+}
+function runFusedArray(input, fused) {
+  const state = fused.initState();
+  const output = [];
+  for (let i = 0; i < input.length; i++) {
+    const result = fused.step(input[i], state);
+    switch (result.tag) {
+      case "emit":
+        output.push(result.value);
+        break;
+      case "skip":
+        break;
+      case "halt":
+        return output;
+    }
+  }
+  return output;
+}
+function drainStreamSync(stream) {
+  const result = [];
+  let cur = stream;
+  while (true) {
+    switch (cur._tag) {
+      case "Empty":
+        return result;
+      case "FromArray": {
+        const arr = cur.values;
+        for (let i = 0; i < arr.length; i++) {
+          result.push(arr[i]);
+        }
+        return result;
+      }
+      case "Emit": {
+        const zio = cur.value;
+        if (zio._tag === "Succeed") {
+          result.push(zio.value);
+          return result;
+        }
+        return null;
+      }
+      case "Concat": {
+        const leftItems = drainStreamSync(cur.left);
+        if (leftItems === null) return null;
+        for (let i = 0; i < leftItems.length; i++) {
+          result.push(leftItems[i]);
+        }
+        cur = cur.right;
+        break;
+      }
+      default:
+        return null;
+    }
+  }
+}
+function applyFused(stream, fused) {
+  const inputArray = drainStreamSync(stream);
+  if (inputArray !== null) {
+    const outputArray = runFusedArray(inputArray, fused);
+    return arrayToStream(outputArray);
+  }
+  const state = fused.initState();
+  const loop = (cur) => fromPull(
+    asyncFold(
+      uncons(cur),
+      // End-of-stream or error: propagate
+      (opt) => asyncFail(opt),
+      ([a, tail]) => {
+        const result = fused.step(a, state);
+        switch (result.tag) {
+          case "emit":
+            return asyncSucceed([result.value, loop(tail)]);
+          case "skip":
+            return uncons(loop(tail));
+          case "halt":
+            return asyncFail(none);
+        }
+      }
+    )
+  );
+  return loop(stream);
+}
+function arrayToStream(values) {
+  if (values.length === 0) return { _tag: "Empty" };
+  return { _tag: "FromArray", values };
+}
+function serializeFusedPipeline(pipeline) {
+  const p = pipeline;
+  let metas = null;
+  if (p._fusedSteps && Array.isArray(p._fusedSteps)) {
+    metas = p._fusedSteps;
+  } else if (p[PURE_PIPELINE_TAG]) {
+    return null;
+  }
+  if (!metas || metas.length === 0) {
+    return null;
+  }
+  const steps = metas.map((meta) => {
+    switch (meta.kind) {
+      case "map":
+        return { kind: "map", fnSource: meta.fn.toString() };
+      case "filter":
+        return { kind: "filter", predSource: meta.pred.toString() };
+      case "take":
+        return { kind: "take", n: meta.n };
+      case "drop":
+        return { kind: "drop", n: meta.n };
+    }
+  });
+  return { version: 1, steps };
+}
+function deserializeFusedPipeline(serialized) {
+  try {
+    if (serialized.version !== 1) {
+      return null;
+    }
+    if (!serialized.steps || serialized.steps.length === 0) {
+      return null;
+    }
+    const metas = [];
+    for (const step of serialized.steps) {
+      switch (step.kind) {
+        case "map": {
+          const fn = new Function("return " + step.fnSource)();
+          if (typeof fn !== "function") return null;
+          metas.push({ kind: "map", fn });
+          break;
+        }
+        case "filter": {
+          const pred = new Function("return " + step.predSource)();
+          if (typeof pred !== "function") return null;
+          metas.push({ kind: "filter", pred });
+          break;
+        }
+        case "take": {
+          if (typeof step.n !== "number" || step.n < 0) return null;
+          metas.push({ kind: "take", n: step.n });
+          break;
+        }
+        case "drop": {
+          if (typeof step.n !== "number" || step.n < 0) return null;
+          metas.push({ kind: "drop", n: step.n });
+          break;
+        }
+        default:
+          return null;
+      }
+    }
+    const carrier = createDeserializedCarrier(metas);
+    return carrier;
+  } catch {
+    return null;
+  }
+}
+function createDeserializedCarrier(metas) {
+  let counterIndex = 0;
+  let composedStep = buildStepFromMetadata(
+    metas[0],
+    metas[0].kind === "take" || metas[0].kind === "drop" ? counterIndex++ : -1
+  );
+  for (let i = 1; i < metas.length; i++) {
+    const meta = metas[i];
+    const idx = meta.kind === "take" || meta.kind === "drop" ? counterIndex++ : -1;
+    composedStep = composeSteps(composedStep, buildStepFromMetadata(meta, idx));
+  }
+  const counterCount = countCounters(metas);
+  const stats = buildStats(metas);
+  const fusedRepr = {
+    _tag: "FusedPipeline",
+    step: composedStep,
+    initState: initState(counterCount),
+    stats
+  };
+  const pipeline = ((input) => {
+    return applyFused(input, fusedRepr);
+  });
+  pipeline._fusedSteps = metas;
+  return pipeline;
+}
+
 // src/core/stream/pipeline.ts
 function via(stream, pipeline) {
+  if (isFusionEnabled()) {
+    const p = pipeline;
+    if (p._fusedSteps || p[PURE_PIPELINE_TAG]) {
+      let fusedRepr = p._cachedFusedRepr;
+      if (!fusedRepr) {
+        fusedRepr = fuse(pipeline);
+        if (fusedRepr) p._cachedFusedRepr = fusedRepr;
+      }
+      if (fusedRepr) {
+        return applyFused(stream, fusedRepr);
+      }
+    }
+  }
   return pipeline(stream);
 }
-function andThen(p1, p2) {
+function andThen2(p1, p2) {
+  const fused = tryFuse(p1, p2);
+  if (fused) return fused;
   return ((input) => p2(p1(input)));
 }
-function compose(p2, p1) {
-  return andThen(p1, p2);
+function collectPureMetas(pipeline) {
+  const p = pipeline;
+  if (p._fusedSteps && Array.isArray(p._fusedSteps)) {
+    return p._fusedSteps;
+  }
+  const tag = p[PURE_PIPELINE_TAG];
+  if (tag) {
+    return [tag];
+  }
+  return null;
+}
+function tryFuse(p1, p2) {
+  if (!isFusionEnabled()) {
+    if (isFusionVerbose()) {
+      console.log("[FusionEngine] andThen: fusion globally disabled, skipping");
+    }
+    return null;
+  }
+  const metas1 = collectPureMetas(p1);
+  const metas2 = collectPureMetas(p2);
+  if (!metas1 || !metas2) {
+    if (isFusionVerbose()) {
+      const reason = !metas1 && !metas2 ? "neither operand is pure" : !metas1 ? "left operand is not pure" : "right operand is not pure";
+      console.log(`[FusionEngine] andThen: cannot fuse \u2014 ${reason}`);
+    }
+    return null;
+  }
+  const combinedMetas = [...metas1, ...metas2];
+  const fusedRepr = fuse(
+    createMetadataCarrier(combinedMetas)
+  );
+  if (!fusedRepr) {
+    return null;
+  }
+  if (isFusionVerbose()) {
+    console.log(
+      `[FusionEngine] andThen: fused ${combinedMetas.length} steps: ${combinedMetas.map((m) => m.kind).join(" \u2192 ")}`
+    );
+  }
+  const fusedPipeline = ((input) => {
+    return applyFused(input, fusedRepr);
+  });
+  fusedPipeline._fusedSteps = combinedMetas;
+  return fusedPipeline;
+}
+function createMetadataCarrier(metas) {
+  const carrier = (() => {
+  });
+  carrier._fusedSteps = metas;
+  return carrier;
+}
+function compose2(p2, p1) {
+  return andThen2(p1, p2);
 }
 function identity() {
   return ((input) => input);
 }
 function mapP(f) {
-  return ((input) => {
+  const pipeline = ((input) => {
     const onError = (opt) => asyncFail(opt);
     const onSuccess = ([a, tail]) => asyncSucceed([f(a), loop(tail)]);
     const loop = (cur) => fromPull(
@@ -613,15 +2008,19 @@ function mapP(f) {
     );
     return loop(input);
   });
+  pipeline[PURE_PIPELINE_TAG] = { kind: "map", fn: f };
+  return pipeline;
 }
 function filterP(pred) {
-  return ((input) => {
+  const pipeline = ((input) => {
     const onError = (opt) => asyncFail(opt);
     const onSuccess = ([a, tail]) => pred(a) ? asyncSucceed([a, loop(tail)]) : next(tail);
     const next = (cur) => asyncFold(uncons(cur), onError, onSuccess);
     const loop = (cur) => fromPull(next(cur));
     return loop(input);
   });
+  pipeline[PURE_PIPELINE_TAG] = { kind: "filter", pred };
+  return pipeline;
 }
 function filterMapP(f) {
   return ((input) => {
@@ -640,7 +2039,7 @@ function filterMapP(f) {
 }
 function takeP(n) {
   const m = Math.max(0, n | 0);
-  return ((input) => {
+  const pipeline = ((input) => {
     const loop = (cur, remaining) => {
       if (remaining <= 0) return emptyStream();
       return fromPull(
@@ -653,10 +2052,12 @@ function takeP(n) {
     };
     return loop(input, m);
   });
+  pipeline[PURE_PIPELINE_TAG] = { kind: "take", n: m };
+  return pipeline;
 }
 function dropP(n) {
   const m = Math.max(0, n | 0);
-  return ((input) => {
+  const pipeline = ((input) => {
     const skip = (cur, remaining) => {
       if (remaining <= 0) return cur;
       return fromPull(
@@ -669,6 +2070,8 @@ function dropP(n) {
     };
     return skip(input, m);
   });
+  pipeline[PURE_PIPELINE_TAG] = { kind: "drop", n: m };
+  return pipeline;
 }
 function mapEffectP(f) {
   return ((input) => {
@@ -731,25 +2134,187 @@ function groupedP(n) {
   });
 }
 
+// src/core/stream/operators.ts
+function throttle(stream, intervalMs) {
+  let lastEmitTime = 0;
+  const loop = (cur) => fromPull(
+    asyncFold(
+      uncons(cur),
+      (opt) => asyncFail(opt),
+      ([a, tail]) => {
+        const now = Date.now();
+        if (now - lastEmitTime >= intervalMs) {
+          lastEmitTime = now;
+          return asyncSucceed([a, loop(tail)]);
+        }
+        return uncons(loop(tail));
+      }
+    )
+  );
+  return loop(stream);
+}
+function debounce(stream, delayMs) {
+  return fromPull(
+    async((_env, cb) => {
+      let lastValue;
+      let hasValue = false;
+      let timerId;
+      let done = false;
+      let tail = stream;
+      const pullNext = () => {
+        if (done) return;
+        const pull = uncons(tail);
+        pull(_env, (exit) => {
+          if (done) return;
+          if (exit._tag === "Failure") {
+            if (hasValue) {
+              const value = lastValue;
+              hasValue = false;
+              clearTimeout(timerId);
+              cb({ _tag: "Success", value: [value, emptyStream()] });
+            } else {
+              cb(exit);
+            }
+            return;
+          }
+          const [a, nextTail] = exit.value;
+          tail = nextTail;
+          lastValue = a;
+          hasValue = true;
+          clearTimeout(timerId);
+          timerId = setTimeout(() => {
+            if (done) return;
+            const value = lastValue;
+            hasValue = false;
+            done = true;
+            cb({ _tag: "Success", value: [value, debounce(tail, delayMs)] });
+          }, delayMs);
+          pullNext();
+        });
+      };
+      pullNext();
+      return () => {
+        done = true;
+        clearTimeout(timerId);
+      };
+    })
+  );
+}
+function zip2(left, right) {
+  const loop = (l, r) => fromPull(
+    asyncFold(
+      uncons(l),
+      (opt) => asyncFail(opt),
+      ([a, lTail]) => asyncFold(
+        uncons(r),
+        (opt) => asyncFail(opt),
+        ([b, rTail]) => asyncSucceed([[a, b], loop(lTail, rTail)])
+      )
+    )
+  );
+  return loop(left, right);
+}
+function zipWith(left, right, f) {
+  const loop = (l, r) => fromPull(
+    asyncFold(
+      uncons(l),
+      (opt) => asyncFail(opt),
+      ([a, lTail]) => asyncFold(
+        uncons(r),
+        (opt) => asyncFail(opt),
+        ([b, rTail]) => asyncSucceed([f(a, b), loop(lTail, rTail)])
+      )
+    )
+  );
+  return loop(left, right);
+}
+function scan(stream, initial, f) {
+  const loop = (cur, acc) => fromPull(
+    asyncFold(
+      uncons(cur),
+      (opt) => asyncFail(opt),
+      ([a, tail]) => {
+        const next = f(acc, a);
+        return asyncSucceed([next, loop(tail, next)]);
+      }
+    )
+  );
+  return concatStream(
+    emitStream(succeed(initial)),
+    loop(stream, initial)
+  );
+}
+function interleave(left, right) {
+  const loop = (l, r, pickLeft) => fromPull(
+    asyncFold(
+      uncons(pickLeft ? l : r),
+      // Current stream ended — drain the other
+      (_opt) => uncons(pickLeft ? r : l),
+      ([a, tail]) => {
+        const nextL = pickLeft ? tail : l;
+        const nextR = pickLeft ? r : tail;
+        return asyncSucceed([a, loop(nextL, nextR, !pickLeft)]);
+      }
+    )
+  );
+  return loop(left, right, true);
+}
+function take2(stream, n) {
+  if (n <= 0) return emptyStream();
+  const loop = (cur, remaining) => {
+    if (remaining <= 0) return emptyStream();
+    return fromPull(
+      asyncFold(
+        uncons(cur),
+        (opt) => asyncFail(opt),
+        ([a, tail]) => asyncSucceed([a, loop(tail, remaining - 1)])
+      )
+    );
+  };
+  return loop(stream, n);
+}
+function drop(stream, n) {
+  if (n <= 0) return stream;
+  const skip = (cur, remaining) => {
+    if (remaining <= 0) return cur;
+    return fromPull(
+      asyncFold(
+        uncons(cur),
+        (opt) => asyncFail(opt),
+        ([_a, tail]) => uncons(skip(tail, remaining - 1))
+      )
+    );
+  };
+  return skip(stream, n);
+}
+
 // src/core/runtime/engineStats.ts
-function engineStats(engine, data, fallbackUsed = false) {
-  return { engine, data, fallbackUsed };
+function engineStats(engine, data) {
+  return { engine, data, fallbackUsed: false };
 }
 function selectedEngineStats(requested, engine, data) {
-  return { requested, engine, data, fallbackUsed: requested === "auto" && engine !== "wasm" };
+  if (requested !== engine) {
+    throw new Error(`brass-runtime strict engine mismatch: requested '${requested}', got '${engine}'`);
+  }
+  return { requested, engine, data, fallbackUsed: false };
 }
 export {
+  ABI_VERSION,
   Async,
   Cause,
   DefaultHostExecutor,
+  EVENT_WORDS,
   EngineFiberHandle,
+  EventKindCode,
   Exit,
   HostRegistry,
   JsFiberEngine,
+  NONE_U32,
   NoopHooks,
+  OpcodeTagCode,
+  PURE_PIPELINE_TAG,
   ProgramBuilder,
   PushStatus,
-  ReferenceWasmBridge,
   RingBuffer,
   Runtime,
   RuntimeFiber,
@@ -758,9 +2323,16 @@ export {
   WasmFiberEngine,
   WasmFiberRegistryBridge,
   WasmPackFiberBridge,
+  abortablePromiseStats,
   acquireRelease,
-  andThen,
+  andThen2 as andThen,
+  andThen as andThenSchedule,
+  applyFused,
+  assertCompletesWithin,
+  assertFails,
+  assertFailsWith,
   assertNever,
+  assertSucceeds,
   async,
   asyncCatchAll,
   asyncFail,
@@ -773,25 +2345,43 @@ export {
   asyncSync,
   asyncTotal,
   bounded,
+  bracket,
   broadcast,
   broadcastToHub,
   buffer,
   bufferP,
   catchAll,
+  catchTag,
+  catchTags,
   chunks,
   chunksP,
   collectAllPar,
   collectStream,
-  compose,
+  compose2 as compose,
+  compose as composeLayer,
   concatStream,
+  debounce,
+  decodeEvent,
+  decodeEventBatch,
+  delayedEffect,
+  derivedRef,
+  deserializeFusedPipeline,
   dropP,
+  drop as dropStream,
+  elapsed,
   emitStream,
   emptyStream,
+  encodeOpcodeNodes,
+  encodeOpcodeProgram,
   end,
   engineStats,
+  ensuring,
+  exponential,
   fail,
   filterMapP,
   filterP,
+  fixed,
+  flakyEffect,
   flatMap,
   flattenStream,
   foreachStream,
@@ -800,16 +2390,41 @@ export {
   fromHub,
   fromPromiseAbortable,
   fromPull,
+  fuse,
   getBenchmarkBudget,
   getCurrentFiber,
+  getStats,
   globalScheduler,
+  gracefulShutdown,
   groupedP,
   identity,
+  inferCallerLaneFromStack,
+  initState,
+  interleave,
+  intersect,
+  isFusionEnabled,
+  isFusionVerbose,
+  jittered,
+  laneTag,
+  layer,
+  layerFail,
+  layerFrom,
+  layerSucceed,
   linkAbortController,
   makeBoundedRingBuffer,
   makeCancelToken,
+  makeCircuitBreaker,
+  makeFiberReadyQueue,
   makeHub,
+  makeMetrics,
+  makeRef,
+  makeSemaphore,
   makeStreamChunker,
+  makeTestRuntime,
+  makeTracer,
+  makeWorkerPool,
+  managed,
+  managedAll,
   managedStream,
   map,
   mapAsync,
@@ -818,38 +2433,71 @@ export {
   mapChunksEffectP,
   mapEffectP,
   mapError,
+  mapError2 as mapErrorTyped,
+  mapLayer,
   mapP,
   mapStream,
   mapTryAsync,
   merge,
+  merge2 as mergeLayer,
   mergeStream,
+  neverEffect,
   none,
+  orElse,
   orElseOptional,
+  provideLayer,
   race,
   raceWith,
   rangeStream,
+  recurs,
+  registerShutdownHooks,
+  repeatWithSchedule,
+  resetAbortablePromiseStats,
+  retry,
+  retryN,
+  retryWithBackoff,
+  retryWithSchedule,
+  runFusedArray,
   runtimeCapabilities,
+  runtimeForCaller,
+  sanitizeLaneKey,
+  scan,
   selectedEngineStats,
+  serializeFusedPipeline,
   setBenchmarkBudget,
+  setFusionEnabled,
+  setFusionVerbose,
+  sleep,
   some,
   streamFromReadableStream,
   succeed,
   sync,
+  tagError,
   takeP,
+  take as takeSchedule,
+  take2 as takeStream,
   tapEffectP,
+  throttle,
+  timeout,
   toPromise,
+  toPromiseByCaller,
   uncons,
+  union,
   unit,
   unsafeGetCurrentRuntime,
   unsafeRunAsync,
   unsafeRunFoldWithEnv,
   unwrapScoped,
+  useManaged,
   via,
+  whileInput,
   widenOpt,
   withAsyncPromise,
   withCurrentFiber,
   withScope,
   withScopeAsync,
   zip,
-  zipPar
+  zipPar,
+  zip2 as zipStream,
+  zipWith
 };