brass-runtime 1.0.1 → 1.2.0

package/README.md

@@ -1,361 +1,138 @@
-# 🛠️ brass-runtime — Mini runtime funcional al estilo ZIO en TypeScript
+# 🛠️ brass-runtime — Mini ZIO-like runtime in TypeScript
 
-**brass-runtime** es un runtime funcional inspirado en **ZIO 2**, escrito en **TypeScript vanilla** y **sin usar Promises ni async/await** como primitiva principal de modelado.
+A small experimental runtime inspired by ZIO 2, implemented in vanilla TypeScript and intentionally built without using `Promise` / `async`/`await` as the primary semantic primitive.
 
-El objetivo del proyecto es explorar cómo construir, desde cero, un sistema de:
-
-- **Efectos puros** (sincrónicos y asincrónicos)
-- **Concurrencia estructurada**
-- **Fibras** (fibers)
-- **Scheduler cooperativo**
-- **Limpieza segura de recursos (acquire / release)**
-- **Scopes estructurados**
-- **Finalizers (a nivel scope y fibra)**
-- **Streams estructurados (ZStream-like) con backpressure**
-
-Todo con un diseño **determinístico**, **pure FP**, y sin depender de `Promise` ni `async/await` para la semántica del modelo.
+Goals: explore typed effects, structured concurrency, fibers, cooperative scheduling, resource safety and streams with backpressure — in a deterministic, pure-FP friendly way.
 
 ---
 
-## ✨ Características principales
-
-### 1. `Effect` sincrónico (núcleo funcional)
-
-En `brass-runtime`, un efecto puro se modela como:
-
-```ts
-type Exit<E, A> =
-  | { _tag: "Success"; value: A }
-  | { _tag: "Failure"; error: E };
+## Key ideas
 
-type Effect<R, E, A> = (env: R) => Exit<E, A>;
-```
-
-Con combinadores típicos de un sistema de efectos:
-
-- `map`
-- `flatMap`
-- `mapError`
-- `catchAll`
-- `zip`
-- `foreach`
-- `collectAll`
-- `as`, `asUnit`, `tap`
-
-Este núcleo no usa `Promise` ni `async/await`. Es **100% sincrónico y determinista**.
+- Pure, sync core effect: `Effect<R, E, A>` and `Exit<E, A>`.
+- An algebraic representation for async work: `Async<R, E, A>` with an explicit interpreter (no `Promise` as runtime primitive).
+- A cooperative `Scheduler` for deterministic task interleaving and fairness.
+- Lightweight `Fiber`s with cooperative interruption, `join`, and LIFO finalizers.
+- Structured `Scope`s that manage child fibers, sub-scopes and finalizers; closing a scope cleans up children deterministically.
+- Resource-safe `acquireRelease` semantics (acquire + release tied to scope finalizers).
+- Structured concurrency combinators: `race`, `zipPar`, `collectAllPar`.
+- ZStream-style streams with backpressure, `Pull` semantics and resource safety.
 
 ---
 
-### 2. `Async` — efectos asincrónicos sin Promises
-
-Para modelar operaciones asincrónicas, `brass-runtime` define un tipo de datos algebraico:
+## What's new (recent changes)
 
-```ts
-type Async<R, E, A> =
-  | { _tag: "Succeed"; value: A }
-  | { _tag: "Fail"; error: E }
-  | { _tag: "Sync"; thunk: (env: R) => A }
-  | { _tag: "Async"; register: (env: R, cb: (exit: Exit<E, A>) => void) => void }
-  | { _tag: "FlatMap"; first: Async<R, E, any>; andThen: (a: any) => Async<R, E, A> };
-```
+- Implemented stream buffering primitives: `buffer` supports bounded buffering with backpressure semantics.
+- Added `fromPromiseAbortable` helper to integrate callback/Promise APIs that support `AbortSignal`, preserving cooperative cancellation.
+- Added `toPromise` for interop convenience (tests/examples use it to await results from the runtime).
+- New example: `src/examples/fromPromise.ts` — demonstrates creating a stream from abortable Promises and using `buffer` + `collectStream`.
+- Misc: tests and examples updated to exercise buffer modes and abortable integration.
 
-Con constructores como:
-
-- `asyncSucceed`
-- `asyncFail`
-- `asyncSync`
-- `asyncTotal`
-- `async` (primitive para integrar APIs callback-based como `setTimeout`, `fs`, etc.)
-- `asyncMap`
-- `asyncFlatMap`
-
-Y un runtime que ejecuta `Async` mediante un **intérprete explícito**, sin usar `Promise`.
+Branch containing recent work: `feature/buffer-pipes`.
 
 ---
 
-### 3. Scheduler cooperativo
-
-El sistema usa un **scheduler cooperativo** con una cola de tareas:
-
-```ts
-class Scheduler {
-  schedule(task: () => void): void;
-}
-```
-
-El `Scheduler` controla:
-
-- el orden en que se ejecutan los pasos de cada fibra,
-- la equidad (fairness),
-- posibles políticas de prioridad.
-
-Esto permite testear y razonar sobre la concurrencia sin depender del azar del event loop.
-
----
-
-### 4. Fibers (fibras)
-
-Cada programa `Async` corre dentro de una **fibra**:
-
-```ts
-type Fiber<E, A> = {
-  id: number;
-  status: () => "Running" | "Done" | "Interrupted";
-  join: (cb: (exit: Exit<E | Interrupted, A>) => void) => void;
-  interrupt: () => void;
-  addFinalizer: (f: (exit: Exit<E | Interrupted, A>) => Async<any, any, any>) => void;
-};
-```
-
-Las fibras proveen:
-
-- concurrencia liviana (miles de fibers),
-- cancelación cooperativa (`interrupt`),
-- `join` para esperar resultados,
-- **finalizers de fibra** (LIFO) que se ejecutan siempre: éxito, fallo o interrupción.
-
----
-
-### 5. Scopes — Concurrencia estructurada
-
-Un **Scope** modela una unidad de concurrencia estructurada:
-
-```ts
-class Scope<R> {
-  fork<E, A>(eff: Async<R, E, A>, env: R): Fiber<E, A>;
-  subScope(): Scope<R>;
-  addFinalizer(f: (exit: Exit<any, any>) => Async<R, any, any>): void;
-  close(exit?: Exit<any, any>): void;
-  isClosed(): boolean;
-}
-```
-
-Un scope:
-
-- rastrea las fibras hijas,
-- rastrea sub-scopes,
-- mantiene una pila de finalizers (LIFO),
-- al cerrarse:
-    - interrumpe fibras hijas,
-    - cierra sub-scopes,
-    - ejecuta finalizers registrados.
-
-Esto da **concurrencia estructurada** al estilo ZIO:
-si algo vive en un `Scope`, se limpia cuando el scope termina.
-
----
-
-### 6. Acquire / Release — Resource Safety
-
-Al estilo `ZIO.acquireRelease`, `brass-runtime` implementa:
-
-```ts
-acquireRelease(
-  acquire: Async<R, E, A>,
-  release: (res: A, exit: Exit<any, any>) => Async<R, any, any>,
-  scope: Scope<R>
-): Async<R, E, A>;
-```
-
-Semántica:
-
-- `acquire` corre dentro del scope,
-- si tiene éxito, registra un finalizer que hace `release(res, exitFinalDelScope)`,
-- el finalizer se ejecuta:
-    - si el scope cierra con éxito,
-    - si hay error,
-    - si hay interrupción/cancelación.
-
-**Garantiza cleanup de recursos** (archivos, sockets, conexiones, etc.) de forma estructurada.
+## Features (status)
+
+- [x] Sync core: `Effect` (pure FP core)
+- [x] Async algebra: `Async` (no Promises in semantics)
+- [x] Cooperative `Scheduler`
+- [x] Fibers with LIFO finalizers and interruption
+- [x] `Scope` (structured concurrency and finalizers)
+- [x] `acquireRelease` / resource safety
+- [x] Structured concurrency: `race`, `zipPar`, `collectAllPar`
+- [x] ZStream-like core (pull-based, resource-aware)
+- [x] Buffering in streams (bounded/backpressure modes)
+- [ ] Merge / zipPar of streams
+- [ ] Hubs / Broadcast / Multicast
+- [ ] Pipelines (`ZPipeline`-style)
+- [ ] Advanced Channels / Sinks
 
 ---
 
-### 7. Structured Concurrency: `race`, `zipPar`, `collectAllPar`
+## API highlights
 
-Sobre fibras, scopes y `Async`, se construyen combinadores de **concurrencia estructurada**:
+Core types
+- `type Exit<E, A> = Success | Failure`
+- `type Effect<R, E, A> = (env: R) => Exit<E, A>`
+- `type Async<R, E, A> = Succeed | Fail | Sync | Async | FlatMap`
 
-#### `race(left, right, scope)`
+Async constructors
+- `asyncSucceed`, `asyncFail`, `asyncSync`, `asyncTotal`
+- `async` primitive for callback integration
+- `asyncMap`, `asyncFlatMap`
+- `fromPromiseAbortable` — integrate APIs that accept `AbortSignal` and support cooperative cancellation
 
-- ejecuta `left` y `right` en paralelo dentro de un scope,
-- el primero que termina “gana”,
-- la fibra perdedora se interrumpe,
-- se propaga el resultado del ganador.
+Fibers / Concurrency
+- `Fiber<E, A>`: `id`, `status()`, `join(cb)`, `interrupt()`, `addFinalizer(...)`
+- `Scheduler.schedule(task: () => void)`
+- `race`, `zipPar`, `collectAllPar` — structured concurrency semantics
 
-#### `zipPar(left, right, scope)`
+Scopes & Resource safety
+- `class Scope<R>`: `fork`, `subScope`, `addFinalizer`, `close`, `isClosed`
+- `acquireRelease(acquire, release, scope)`
 
-- ejecuta ambos efectos en paralelo,
-- si alguno falla → se cancela el otro,
-- si ambos tienen éxito → devuelve `[A, B]`.
-
-#### `collectAllPar(effects, scope)`
-
-- ejecuta una lista de efectos en paralelo,
-- si alguno falla → cancela el resto,
-- si todos completan → devuelve la lista de resultados.
-
-Esto replica la semántica de **ZIO 2 structured concurrency**.
+Streams (ZStream-like)
+- `type Pull<R, E, A> = Async<R, Option<E>, A>`
+- `type ZStream<R, E, A> = { open: (scope: Scope<R>) => Pull<R, E, A> }`
+- Constructors: `empty`, `streamOf`, `fromArray`, `fromPull`
+- Transformations: `map`, `filter`, `fromResource`
+- Buffering: `buffer(stream, capacity, mode)` — bounded buffer with backpressure or dropping modes
+- Interop: `collectStream`, `runCollect`, `toPromise` for awaiting results in examples
 
 ---
 
-### 8. ZStream-like — Streams estructurados con backpressure
-
-`brass-runtime` incluye una base de **streams estructurados** inspirados en `ZStream`:
-
-```ts
-type Pull<R, E, A> = Async<R, Option<E>, A>;
-
-type ZStream<R, E, A> = {
-  open: (scope: Scope<R>) => Pull<R, E, A>;
-};
-```
-
-Donde:
-
-- `Success(a)` → el stream produjo un valor,
-- `Failure(Some(e))` → error,
-- `Failure(None)` → fin del stream.
-
-Constructores básicos:
-
-- `empty`
-- `streamOf`
-- `fromArray`
-
-Transformaciones:
-
-- `map`
-- `filter`
-- `fromResource` (integra acquire/release con streams)
+## Example (what to look at)
 
-Consumo:
+See `src/examples/fromPromise.ts`:
+- Shows `fromPromiseAbortable` producing stream elements with cooperative cancellation.
+- Demonstrates `buffer` with a bounded capacity and backpressure semantics.
+- Uses `collectStream` + `toPromise` to gather stream output in an example-run friendly way.
 
-```ts
-runCollect(stream, env): Async<R, E, A[]>;
-```
-
-El consumo se hace respetando backpressure: cada `pull` produce como mucho un valor,
-y el scope del stream garantiza que todos los recursos/finalizers se limpien al terminar
-(el stream o el consumidor).
+Do not copy the example here — open `src/examples/fromPromise.ts` for details.
 
 ---
 
-## 📁 Estructura sugerida del proyecto
-
-Una posible organización de archivos para tu repo de **brass-runtime**:
+## Running examples and tests
 
-```bash
-src/
-  fibers/    
-  scheduler/    
-  stream/
-  types/
-    
+- Use your editor's run configuration (WebStorm 2025.3.1 recommended) or run with `ts-node` for quick iteration.
+- Typical flow:
+  - Install deps: `npm install`
+  - Run an example directly: `npx ts-node src/examples/fromPromise.ts` (or configure a Node run config that compiles first)
+  - Build: `npm run build` → run compiled files from `dist/`
 
-examples/
-  demo.ts
-  fiberFinalizer.ts
-  resourceExample.ts
-```
+Adjust the commands to your preferred setup. The project intentionally leaves runtime execution flexible (ts-node, esbuild, tsc + node, etc.).
 
 ---
 
-## 🚀 Ejemplo rápido
-
-```ts
-import {
-  asyncTotal,
-  asyncFlatMap,
-  asyncSucceed,
-} from "./asyncEffect";
-import { sleep } from "./std";
-import { Scope } from "./scope";
-import { race } from "./concurrency";
-
-type Env = {};
-
-function task(name: string, ms: number) {
-  return asyncFlatMap(sleep(ms), () =>
-    asyncSucceed(`Terminé ${name}`)
-  );
-}
-
-function main() {
-  const env: Env = {};
-  const scope = new Scope<Env>();
-
-  const fast = task("rápida", 200);
-  const slow = task("lenta", 1000);
-
-  race(fast, slow, scope)(env, exit => {
-    console.log("Resultado race:", exit);
-    scope.close(exit);
-  });
-}
-
-main();
-```
+## Project structure (recommended)
+Examples:
+- `src/examples/fromPromise.ts` (abortable promise -> stream + buffer)
+- `src/examples/resourceExample.ts` (acquire/release + scope)
+- `src/examples/fiberFinalizer.ts` (fiber finalizer LIFO semantics)
 
 ---
 
-## 🧪 Objetivos del proyecto
+## Design notes
 
-- Explorar el diseño de runtimes funcionales modernos (tipo ZIO) en TypeScript.
-- Entender y practicar:
-    - Efectos tipados (`R`, `E`, `A`),
-    - Concurrencia estructurada,
-    - Fibras,
-    - Scopes y finalizers,
-    - Streams con recursos seguros y backpressure.
-- Servir como base educativa y potencialmente como **runtime experimental**
-  para proyectos de ejemplo, demos y pruebas de conceptos FP en TS.
+- Determinism: scheduling is explicit and testable via the cooperative `Scheduler`.
+- No hidden `Promise` semantics: the runtime models async as an algebraic datatype with an explicit interpreter.
+- Resource safety is structural — scopes tie resource lifetimes to lexical structure, ensuring deterministic cleanup.
+- Streaming model uses pull-based backpressure; buffering is explicit and configurable.
 
 ---
 
-## 📝 Estado actual
-
-- [x] Núcleo de efectos sincrónicos (`Effect`)
-- [x] Núcleo de efectos asincrónicos (`Async`) sin Promises
-- [x] Scheduler cooperativo
-- [x] Fibers con finalizers
-- [x] Scopes con finalizers (LIFO)
-- [x] Acquire / Release
-- [x] Concurrencia estructurada (`race`, `zipPar`, `collectAllPar`)
-- [x] Streams básicos (`ZStream`-like) con backpressure y scopes
-- [ ] Buffering en streams
-- [ ] Merge / zipPar de streams
-- [ ] Hubs / Broadcast / Multicast
-- [ ] Pipelines (tipo `ZPipeline`)
-- [ ] Channels / Sinks avanzado
-
----
-
-## 📜 Licencia
+## Contributing
 
-Este proyecto está pensado como laboratorio de ideas FP.
-Se recomienda usar licencia MIT:
-
-```text
-MIT License
-Copyright (c) 2025
-```
+- Branch for current work: `feature/buffer-pipes`.
+- Open issues / PRs welcome. Aim for small, focused PRs that preserve the runtime invariants (no hidden Promise semantics).
+- Tests should exercise scheduling determinism, interruption guarantees and resource cleanup.
 
 ---
 
-## 🤝 Contribuciones
-
-Ideas de mejora, PRs y discusiones de diseño son más que bienvenidas.
+## License
 
-Algunas direcciones interesantes para futuro:
-
-- Integrar fs / net de Node de forma segura vía `Async`,
-- Agregar tests deterministas de concurrencia,
-- Implementar Hubs y Queues al estilo ZIO,
-- Extender ZStream con merges, buffers y pipelines,
-- Explorar integración con TypeScript decorators para “endpoints” basados en efectos.
+MIT License © 2025
 
 ---
 
-Hecho con ❤️ en TypeScript, para aprender y jugar con runtimes funcionales.
-
-**Nombre del proyecto:** `brass-runtime`  
-**Objetivo:** construir un mini ZIO-like runtime en el ecosistema JS/TS, pero manteniendo el control total sobre la semántica de los efectos desde el código de usuario.
+If you need the README translated to Spanish or a trimmed/expanded version for npm package metadata, a shorter project landing page, or a CHANGELOG entry for the branch `feature/buffer-pipes`, provide the preference and a target audience.

package/dist/examples/canceler.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=canceler.d.ts.map

package/dist/examples/canceler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canceler.d.ts","sourceRoot":"","sources":["../../src/examples/canceler.ts"],"names":[],"mappings":""}

package/dist/examples/canceler.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fiber_1 = require("../fibers/fiber");
+const asyncEffect_1 = require("../types/asyncEffect");
+let ticks = 0;
+const effect = (0, asyncEffect_1.async)((_env, cb) => {
+    const id = setInterval(() => {
+        ticks++;
+    }, 10);
+    cb({ _tag: "Success", value: undefined });
+    return () => clearInterval(id);
+});
+(0, fiber_1.unsafeRunAsync)(effect, undefined, (exit) => {
+    console.log("Fiber exit:", exit);
+});
+setTimeout(() => {
+    const t1 = ticks;
+    console.log("ticks @50ms:", t1);
+    setTimeout(() => {
+        const t2 = ticks;
+        console.log("ticks @150ms:", t2);
+        if (t2 > t1 + 1) {
+            console.log("❌ LEAK: el interval siguió vivo después de terminar la fiber");
+        }
+        else {
+            console.log("✅ OK: el interval se limpió (canceler ejecutado)");
+        }
+    }, 100);
+}, 50);
+//# sourceMappingURL=canceler.js.map

package/dist/examples/canceler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canceler.js","sourceRoot":"","sources":["../../src/examples/canceler.ts"],"names":[],"mappings":";;AAAA,2CAA+C;AAC/C,sDAA2C;AAE3C,IAAI,KAAK,GAAG,CAAC,CAAC;AAEd,MAAM,MAAM,GAAG,IAAA,mBAAK,EAAuB,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE;IACpD,MAAM,EAAE,GAAG,WAAW,CAAC,GAAG,EAAE;QACxB,KAAK,EAAE,CAAC;IACZ,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;IAC1C,OAAO,GAAG,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;AACnC,CAAC,CAAC,CAAC;AAEH,IAAA,sBAAc,EAAC,MAAM,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE;IACvC,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;AACrC,CAAC,CAAC,CAAC;AAEH,UAAU,CAAC,GAAG,EAAE;IACZ,MAAM,EAAE,GAAG,KAAK,CAAC;IACjB,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACZ,MAAM,EAAE,GAAG,KAAK,CAAC;QACjB,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;QAEjC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CAAC,8DAA8D,CAAC,CAAC;QAChF,CAAC;aAAM,CAAC;YACJ,OAAO,CAAC,GAAG,CAAC,kDAAkD,CAAC,CAAC;QACpE,CAAC;IACL,CAAC,EAAE,GAAG,CAAC,CAAC;AACZ,CAAC,EAAE,EAAE,CAAC,CAAC"}

package/dist/examples/demo.d.ts

@@ -0,0 +1,3 @@
+import { type Async } from "../types/asyncEffect";
+export declare function sleep(ms: number): Async<unknown, never, void>;
+//# sourceMappingURL=demo.d.ts.map

package/dist/examples/demo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demo.d.ts","sourceRoot":"","sources":["../../src/examples/demo.ts"],"names":[],"mappings":"AAMA,OAAO,EAAS,KAAK,KAAK,EAA8B,MAAM,sBAAsB,CAAC;AAKrF,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAK7D"}

package/dist/examples/demo.js

@@ -1,38 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sleep = sleep;
-const effect_1 = require("../types/effect");
+const fiber_1 = require("../fibers/fiber");
 const stream_1 = require("../stream/stream");
+const scope_1 = require("../scheduler/scope");
 const asyncEffect_1 = require("../types/asyncEffect");
-const fiber_1 = require("../fibers/fiber");
-const withScope_1 = require("../scheduler/withScope");
-function main() {
-    const env = {};
-    const fiberA = (0, fiber_1.fork)(task("A", 1000), env);
-    const fiberB = (0, fiber_1.fork)(task("B", 500), env);
-    fiberA.join((exit) => {
-        console.log("Fiber A:", exit);
+const effect_1 = require("../types/effect"); // succeed ahora devuelve Async
+function sleep(ms) {
+    return (0, asyncEffect_1.async)((_, cb) => {
+        const t = setTimeout(() => cb({ _tag: "Success", value: undefined }), ms);
+        return () => clearTimeout(t);
     });
-    fiberB.join((exit) => {
-        console.log("Fiber B:", exit);
+}
+function task(name, ms) {
+    return (0, asyncEffect_1.asyncFlatMap)(sleep(ms), () => (0, asyncEffect_1.asyncSucceed)(`Terminé ${name} después de ${ms}ms`));
+}
+// Helper: correr un efecto y loguear su Exit
+function run(label, eff, env) {
+    const f = (0, fiber_1.fork)(eff, env);
+    f.join((exit) => {
+        const ex = exit;
+        console.log(label, ex);
     });
+    return f;
+}
+function main() {
+    const env = {};
+    // Fibras simples
+    const fiberA = run("Fiber A:", task("A", 1000), env);
+    const fiberB = run("Fiber B:", task("B", 500), env);
+    // “zip” de efectos (sin helper): flatMap + map
     const eff1 = (0, effect_1.succeed)(10);
     const eff2 = (0, effect_1.succeed)(20);
-    const sumEff = (0, effect_1.zip)(eff1, eff2);
-    const sumExit = sumEff({});
-    console.log("sumExit:", sumExit);
-    const numsEff = (0, effect_1.foreach)([1, 2, 3], (n) => (0, effect_1.succeed)(n * 2));
-    console.log("foreach:", numsEff({}));
+    const sumEff = (0, asyncEffect_1.asyncFlatMap)(eff1, (a) => (0, asyncEffect_1.asyncFlatMap)(eff2, (b) => (0, asyncEffect_1.asyncSucceed)([a, b])));
+    run("zip(eff1, eff2):", sumEff, env);
+    // foreach sobre array (sin helper): secuenciar efectos
+    const nums = [1, 2, 3];
+    const foreachEff = nums.reduce((accEff, n) => (0, asyncEffect_1.asyncFlatMap)(accEff, (acc) => (0, asyncEffect_1.asyncFlatMap)((0, effect_1.succeed)(n * 2), (m) => (0, asyncEffect_1.asyncSucceed)([...acc, m]))), (0, asyncEffect_1.asyncSucceed)([]));
+    run("foreach array:", foreachEff, env);
+    // Stream map + collect (collectStream devuelve Async)
     const s = (0, stream_1.fromArray)([1, 2, 3, 4]);
     const sMapped = (0, stream_1.mapStream)(s, (n) => n * 10);
-    const collected = (0, stream_1.collectStream)(sMapped, env);
-    console.log("Stream mapeado:", collected);
-    (0, withScope_1.withScope)(scope => {
+    const collectedEff = (0, stream_1.collectStream)(sMapped); // <- ahora NO recibe env acá
+    run("Stream mapeado:", collectedEff, env);
+    // Scope
+    (0, scope_1.withScope)((scope) => {
         const f1 = scope.fork(task("A", 1000), env);
         const f2 = scope.fork(task("B", 1500), env);
         const f3 = scope.fork(task("C", 2000), env);
         console.log("Tareas lanzadas dentro del scope");
-        // Si quiero, cancelo todo luego de 1.2s
         setTimeout(() => {
             console.log("CANCELANDO TODO EL SCOPE...");
             scope.close();
@@ -41,15 +57,9 @@ function main() {
         f2.join(console.log);
         f3.join(console.log);
     });
-}
-function sleep(ms) {
-    return (0, asyncEffect_1.async)((_, cb) => {
-        setTimeout(() => {
-            cb({ _tag: "Success", value: undefined });
-        }, ms);
-    });
-}
-function task(name, ms) {
-    return (0, asyncEffect_1.asyncFlatMap)(sleep(ms), () => (0, asyncEffect_1.asyncSucceed)(`Terminé ${name} después de ${ms}ms`));
+    // (opcional) esperar a que terminen A/B si querés
+    fiberA.join(() => { });
+    fiberB.join(() => { });
 }
 main();
+//# sourceMappingURL=demo.js.map

package/dist/examples/demo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"demo.js","sourceRoot":"","sources":["../../src/examples/demo.ts"],"names":[],"mappings":"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"}

package/dist/examples/fiberFinalizer.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fiberFinalizer.d.ts.map

package/dist/examples/fiberFinalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fiberFinalizer.d.ts","sourceRoot":"","sources":["../../src/examples/fiberFinalizer.ts"],"names":[],"mappings":""}