brass-runtime 1.0.1 → 1.1.0

package/dist/examples/demo.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sleep = sleep;
+const fiber_1 = require("../fibers/fiber");
 const effect_1 = require("../types/effect");
 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);
@@ -27,7 +27,7 @@ function main() {
     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 => {
+    (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);

package/dist/examples/fiberFinalizer.js

@@ -1,23 +1,45 @@
 "use strict";
-// fiberFinalizer.ts
 Object.defineProperty(exports, "__esModule", { value: true });
+// fiberFinalizer.ts
 const asyncEffect_1 = require("../types/asyncEffect");
 const fiber_1 = require("../fibers/fiber");
 const demo_1 = require("./demo");
+function formatExit(exit) {
+    if (!exit || typeof exit !== "object")
+        return String(exit);
+    if (exit._tag === "Success")
+        return `Success(value=${JSON.stringify(exit.value)})`;
+    if (exit._tag === "Failure")
+        return `Failure(error=${JSON.stringify(exit.error)})`;
+    return JSON.stringify(exit);
+}
 function main() {
     const env = {};
+    const t0 = Date.now();
     const eff = (0, asyncEffect_1.asyncFlatMap)((0, asyncEffect_1.asyncTotal)(() => console.log("Start")), () => (0, asyncEffect_1.asyncFlatMap)((0, demo_1.sleep)(1000), () => (0, asyncEffect_1.asyncTotal)(() => "done")));
     const fiber = (0, fiber_1.fork)(eff, env);
-    fiber.addFinalizer(exit => (0, asyncEffect_1.asyncTotal)(() => {
-        console.log("RUNNING FINALIZER → exit =", exit._tag);
+    // 👇 Instrumentación del finalizer
+    let finCount = 0;
+    fiber.addFinalizer((exit) => (0, asyncEffect_1.asyncTotal)(() => {
+        var _a;
+        finCount += 1;
+        const ms = Date.now() - t0;
+        const stack = (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.split("\n").slice(1, 8).join("\n");
+        console.log("\n================ FINALIZER START ================");
+        console.log(`time: +${ms}ms`);
+        console.log(`finalizer call #: ${finCount}`);
+        console.log(`exit: ${formatExit(exit)}`);
+        console.log("raw exit object:", exit);
+        console.log("stack (where finalizer ran):\n" + stack);
+        console.log("================= FINALIZER END =================\n");
     }));
     // cancelamos antes de terminar para ver que el finalizer corre
     setTimeout(() => {
-        console.log("Interrupting fiber...");
+        console.log(`\n[+${Date.now() - t0}ms] Interrupting fiber...`);
         fiber.interrupt();
     }, 500);
     fiber.join((exit) => {
-        console.log("Fiber completed:", exit);
+        console.log(`\n[+${Date.now() - t0}ms] Fiber completed:`, exit);
     });
 }
 main();

package/dist/examples/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./demo");
+require("./fiberFinalizer");
+require("./resourceExample");
+require("./test-canceler");

package/dist/examples/resourceExample.js

@@ -1,9 +1,8 @@
 "use strict";
 // src/resourceExample.ts
 Object.defineProperty(exports, "__esModule", { value: true });
-const acquireRelease_1 = require("../scheduler/acquireRelease");
+const scope_1 = require("../scheduler/scope");
 const asyncEffect_1 = require("../types/asyncEffect");
-const withScope_1 = require("../scheduler/withScope");
 function openFile(name) {
     console.log("OPEN FILE:", name);
     return {
@@ -16,9 +15,9 @@ function openFile(name) {
     };
 }
 function main() {
-    (0, withScope_1.withScope)(scope => {
+    (0, scope_1.withScope)(scope => {
         const env = {};
-        const program = (0, acquireRelease_1.acquireRelease)((0, asyncEffect_1.asyncTotal)(() => openFile("data.txt")), (file, exit) => (0, asyncEffect_1.asyncTotal)(() => {
+        const program = (0, asyncEffect_1.acquireRelease)((0, asyncEffect_1.asyncTotal)(() => openFile("data.txt")), (file, exit) => (0, asyncEffect_1.asyncTotal)(() => {
             console.log("Finalizer running due to:", exit._tag);
             file.close();
         }), scope);

package/dist/examples/test-canceler.js

@@ -0,0 +1,29 @@
+"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);

package/dist/fibers/fiber.js

@@ -7,12 +7,17 @@ let nextId = 1;
 class RuntimeFiber {
     constructor(effect, env, scheduler) {
         this.scheduler = scheduler;
+        this.closing = null;
+        this.finishing = false;
         this.statusValue = "Running";
         this.interrupted = false;
         this.result = null;
         this.joiners = [];
         this.stack = [];
         this.fiberFinalizers = [];
+        this.scheduled = false;
+        this.finalizersDrained = false;
+        this.blockedOnAsync = false;
         this.id = nextId++;
         this.current = effect;
         this.env = env;
@@ -24,36 +29,55 @@ class RuntimeFiber {
         return this.statusValue;
     }
     join(cb) {
-        if (this.result != null) {
+        if (this.result != null)
             cb(this.result);
-        }
-        else {
+        else
             this.joiners.push(cb);
-        }
     }
     interrupt() {
+        if (this.result != null)
+            return;
+        if (this.interrupted)
+            return;
         this.interrupted = true;
-        // cancelación cooperativa: el código async puede chequear flags externos
+        this.blockedOnAsync = false;
+        this.schedule("interrupt-step");
     }
-    runFiberFinalizers(exit) {
+    schedule(tag = "step") {
+        if (this.result != null)
+            return;
+        if (this.scheduled)
+            return;
+        this.scheduled = true;
+        this.scheduler.schedule(() => {
+            this.scheduled = false;
+            this.step();
+        }, `fiber#${this.id}.${tag}`);
+    }
+    runFinalizersOnce(exit) {
+        if (this.finalizersDrained)
+            return;
+        this.finalizersDrained = true;
         while (this.fiberFinalizers.length > 0) {
             const fin = this.fiberFinalizers.pop();
-            fin(exit); // fire-and-forget (igual que ZIO)
+            try {
+                fin(exit);
+            }
+            catch { }
         }
     }
-    /** Programa un paso de la fibra en el scheduler */
-    schedule() {
-        this.scheduler.schedule(() => this.step());
-    }
     notify(exit) {
         if (this.result != null)
             return;
-        // ejecutar finalizers de fibra
-        this.runFiberFinalizers(exit);
-        // marcar estado final
+        if (this.closing != null)
+            return;
+        this.finishing = true;
+        this.closing = exit;
+        // ✅ ejecutar finalizers YA (garantiza clearInterval)
+        this.runFinalizersOnce(exit);
+        // completar
         this.statusValue = this.interrupted ? "Interrupted" : "Done";
         this.result = exit;
-        // notificar joiners
         for (const j of this.joiners)
             j(exit);
         this.joiners.length = 0;
@@ -61,20 +85,24 @@ class RuntimeFiber {
     onSuccess(value) {
         const cont = this.stack.pop();
         if (!cont) {
-            // terminamos con éxito
             this.notify({ _tag: "Success", value });
             return;
         }
         this.current = cont(value);
-        this.schedule(); // siguiente paso
+        //this.schedule("onSuccess-step");
     }
     onFailure(error) {
         this.notify({ _tag: "Failure", error });
     }
-    /** Un *paso* de evaluación de la fibra */
     step() {
         if (this.result != null)
-            return; // ya terminó
+            return;
+        if (this.blockedOnAsync)
+            return;
+        if (this.interrupted && this.closing == null) {
+            this.notify({ _tag: "Failure", error: { _tag: "Interrupted" } });
+            return;
+        }
         const current = this.current;
         switch (current._tag) {
             case "Succeed":
@@ -95,28 +123,57 @@ class RuntimeFiber {
             case "FlatMap":
                 this.stack.push(current.andThen);
                 this.current = current.first;
-                this.schedule(); // reducimos el first en otro paso
+                //this.schedule("flatMap-step");
                 return;
-            case "Async":
-                current.register(this.env, (exit) => {
-                    if (this.interrupted && exit._tag === "Success") {
+            case "Async": {
+                if (this.finishing)
+                    return;
+                this.blockedOnAsync = true;
+                let pending = null;
+                let completedSync = false;
+                const resume = () => {
+                    if (!pending)
+                        return;
+                    const exit = pending;
+                    pending = null;
+                    this.blockedOnAsync = false;
+                    if (this.result != null || this.closing != null)
+                        return;
+                    if (this.interrupted) {
                         this.onFailure({ _tag: "Interrupted" });
+                        return;
                     }
-                    else if (exit._tag === "Success") {
+                    if (exit._tag === "Success")
                         this.onSuccess(exit.value);
-                    }
-                    else {
+                    else
                         this.onFailure(exit.error);
-                    }
+                    this.schedule("async-resume");
+                };
+                const canceler = current.register(this.env, (exit) => {
+                    // guardamos el resultado, pero NO ejecutamos todavía
+                    pending = exit;
+                    completedSync = true;
+                    // no llamamos resume acá
                 });
+                if (typeof canceler === "function") {
+                    this.addFinalizer((_exit) => {
+                        try {
+                            canceler();
+                        }
+                        catch { }
+                    });
+                }
+                if (completedSync) {
+                    this.scheduler.schedule(resume, `fiber#${this.id}.async-sync-resume`);
+                }
                 return;
+            }
         }
     }
 }
-// API pública: fork + helper unsafeRunAsync
 function fork(effect, env, scheduler = scheduler_1.globalScheduler) {
     const fiber = new RuntimeFiber(effect, env, scheduler);
-    fiber.schedule(); // arrancamos la primera reducción
+    fiber.schedule("initial-step");
     return fiber;
 }
 // “correr” un Async como antes, pero apoyado en fibras + scheduler

package/dist/index.js

@@ -19,8 +19,6 @@ __exportStar(require("./types/asyncEffect"), exports);
 __exportStar(require("./stream/stream"), exports);
 __exportStar(require("./types/option"), exports);
 __exportStar(require("./types/effect"), exports);
-__exportStar(require("./scheduler/withScope"), exports);
-__exportStar(require("./scheduler/acquireRelease"), exports);
+__exportStar(require("./scheduler/scope"), exports);
 __exportStar(require("./scheduler/scheduler"), exports);
 __exportStar(require("./types/cancel"), exports);
-__exportStar(require("./scheduler/scope"), exports);

package/dist/scheduler/scheduler.js

@@ -5,23 +5,47 @@ class Scheduler {
     constructor() {
         this.queue = [];
         this.flushing = false;
+        this.requested = false;
     }
-    schedule(task) {
-        this.queue.push(task);
-        if (!this.flushing) {
-            this.flush();
-        }
+    // ✅ tag opcional
+    schedule(task, tag = "anonymous") {
+        var _a;
+        this.queue.push({ tag, task });
+        this.requestFlush();
+        // log: tamaño + próximos tags (head)
+        console.log("SCHEDULER", {
+            flushing: this.flushing,
+            q: this.queue.length,
+            next: (_a = this.queue[0]) === null || _a === void 0 ? void 0 : _a.tag,
+            head: this.queue.slice(0, 5).map(t => t.tag),
+        });
+    }
+    requestFlush() {
+        if (this.requested)
+            return;
+        this.requested = true;
+        queueMicrotask(() => this.flush());
     }
     flush() {
+        if (this.flushing)
+            return;
         this.flushing = true;
-        // Versión simple: drena todo de una
-        while (this.queue.length > 0) {
-            const t = this.queue.shift();
-            t();
+        this.requested = false;
+        try {
+            while (this.queue.length > 0) {
+                const { task } = this.queue.shift();
+                try {
+                    task();
+                }
+                catch { }
+            }
+        }
+        finally {
+            this.flushing = false;
+            if (this.queue.length > 0)
+                this.requestFlush();
         }
-        this.flushing = false;
     }
 }
 exports.Scheduler = Scheduler;
-// Un scheduler global para todo el runtime
 exports.globalScheduler = new Scheduler();

package/dist/scheduler/scope.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Scope = void 0;
+exports.withScope = withScope;
 // src/scope.ts
 const fiber_1 = require("../fibers/fiber");
 let nextScopeId = 1;
 class Scope {
-    constructor() {
+    constructor(env) {
+        this.env = env;
         this.closed = false;
         this.children = new Set();
         this.subScopes = new Set();
@@ -23,7 +25,7 @@ class Scope {
     subScope() {
         if (this.closed)
             throw new Error("Scope closed");
-        const s = new Scope();
+        const s = new Scope(this.env);
         this.subScopes.add(s);
         return s;
     }
@@ -54,7 +56,8 @@ class Scope {
         // 3) ejecutar finalizers en orden LIFO
         while (this.finalizers.length > 0) {
             const fin = this.finalizers.pop();
-            fin(exit); // se ejecuta como Async, pero no esperamos
+            const eff = fin(exit);
+            (0, fiber_1.fork)(eff, this.env); // <-- esto hace que se ejecute el Async
         }
         this.children.clear();
         this.subScopes.clear();
@@ -64,3 +67,16 @@ class Scope {
     }
 }
 exports.Scope = Scope;
+/**
+ * Ejecuta una función dentro de un scope estructurado.
+ * Al final (éxito o error), se cierra el scope garantizando cleanup.
+ */
+function withScope(body) {
+    const scope = new Scope({});
+    try {
+        return body(scope);
+    }
+    finally {
+        scope.close();
+    }
+}

package/dist/stream/buffer.js

@@ -0,0 +1,50 @@
+"use strict";
+/*
+import {ZStream} from "./stream";
+
+type Signal<E, A> =
+    | { _tag: "Elem"; value: A }
+    | { _tag: "End" }
+    | { _tag: "Fail"; error: E }
+function buffer<R, E, A>(
+    stream: ZStream<R, E, A>,
+    capacity: number,
+    strategy: "backpressure" | "dropping" | "sliding" = "backpressure",
+): ZStream<R, E, A> {
+    return new ZStream((scope) =>
+        Async.gen(function* (_) {
+            const pullUp = yield* _(stream.open(scope))
+            const q = yield* _(Queue.bounded<Signal<E, A>>(capacity, strategy))
+
+            // Producer fiber: llena la cola
+            const producer = yield* _(Async.forkScoped(scope, // importante: scoped para que se interrumpa al cerrar
+                Async.forever(
+                    pullUp.foldCauseAsync(
+                        // upstream terminó/falló
+                        (cause) =>
+                            cause.match({
+                                end: () => q.offer({ _tag: "End" }).unit(),
+                                fail: (e) => q.offer({ _tag: "Fail", error: e }).unit(),
+                            }),
+                        // got elem
+                        (a) => q.offer({ _tag: "Elem", value: a }).unit(),
+                    )
+                )
+            ))
+
+            // Downstream Pull
+            const pullDown: Pull<R, E, A> = q.take().flatMap((sig) => {
+                switch (sig._tag) {
+                    case "Elem": return Async.succeed(sig.value)
+                    case "End":  return Async.fail(None)        // fin del stream
+                    case "Fail": return Async.fail(Some(sig.error))
+                }
+            })
+
+            // Importante: si el consumidor termina antes,
+            // el scope debería interrumpir producer automáticamente.
+            return pullDown
+        })
+    )
+}
+*/

package/dist/types/asyncEffect.js

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.async = exports.asyncTotal = exports.asyncSync = exports.asyncFail = exports.asyncSucceed = void 0;
+exports.unit = unit;
 exports.asyncMap = asyncMap;
 exports.asyncFlatMap = asyncFlatMap;
 exports.fromPromise = fromPromise;
 exports.tryPromiseAbortable = tryPromiseAbortable;
 exports.fromPromiseAbortable = fromPromiseAbortable;
+exports.acquireRelease = acquireRelease;
+function unit() {
+    return (0, exports.asyncSync)(() => undefined);
+}
 const asyncSucceed = (value) => ({
     _tag: "Succeed",
     value,
@@ -79,3 +84,23 @@ function fromPromiseAbortable(thunk, onError) {
         };
     });
 }
+function acquireRelease(acquire, release, scope) {
+    return asyncFlatMap(acquire, (resource) => {
+        // registrar finalizer
+        scope.addFinalizer((exit) => release(resource, exit));
+        return (0, exports.asyncSucceed)(resource);
+    });
+}
+function registerInterruptible(register) {
+    return (0, exports.async)((env, cb) => {
+        const canceler = register(env, cb);
+        return typeof canceler === "function"
+            ? (0, exports.asyncSync)((_env) => {
+                try {
+                    canceler();
+                }
+                catch { }
+            })
+            : unit();
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brass-runtime",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Effect runtime utilities for TypeScript",
   "license": "ISC",
   "author": "",
@@ -15,7 +15,7 @@
   "scripts": {
     "dev": "ts-node-dev src/examples/demo.ts",
     "build": "tsc",
-    "test": "node -e \"console.log('no tests yet')\"",
+    "test": "tsx src/examples/index.ts",
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
@@ -28,6 +28,7 @@
     "conventional-changelog-conventionalcommits": "^7.x.x",
     "semantic-release": "^25.0.2",
     "ts-node-dev": "^2.0.0",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }
 }

package/dist/scheduler/acquireRelease.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.acquireRelease = acquireRelease;
-const asyncEffect_1 = require("../types/asyncEffect");
-/**
- * acquireRelease:
- *   acquire: Async<R, E, A>
- *   release: (A, Exit) => Async<R, never, void>
- */
-function acquireRelease(acquire, release, scope) {
-    return (0, asyncEffect_1.asyncFlatMap)(acquire, (resource) => {
-        // registrar finalizer
-        scope.addFinalizer((exit) => release(resource, exit));
-        return (0, asyncEffect_1.asyncSucceed)(resource);
-    });
-}

package/dist/scheduler/withScope.js

@@ -1,19 +0,0 @@
-"use strict";
-// src/withScope.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withScope = withScope;
-const scope_1 = require("./scope");
-/**
- * Ejecuta una función dentro de un scope estructurado.
- * Al final (éxito o error), se cierra el scope garantizando cleanup.
- */
-function withScope(body) {
-    const scope = new scope_1.Scope();
-    try {
-        const result = body(scope);
-        return result;
-    }
-    finally {
-        scope.close(); // cleanup garantizado
-    }
-}