ciorent 0.6.1 → 0.7.1

package/README.md

@@ -112,72 +112,50 @@ for (let i = 1; i <= 5; i++) task(i);
 ```
 
 ### Fibers
-Virtual threads with more controlled execution.
+A module to interrupt executions of async functions.
 ```ts
-import { fiber, sleep } from 'ciorent';
+import { signal, sleep } from 'ciorent';
 
 const logTime = (label: string) =>
   console.log(`${label}: ${Math.floor(performance.now())}ms`);
 
-const f1 = fiber.fn(function* () {
+const f1 = async (sig: signal.Signal) => {
   // Wait for a promise
   console.log('Fiber 1 waiting: 1s');
-  yield sleep(1000);
+  await sleep(1000);
 
-  // Wait for a promise and return its result
-  const res = yield* fiber.unwrap(Promise.resolve(1));
-  console.log('Fiber 1 recieved:', res);
+  // Interruption point
+  if (signal.interrupted(sig)) return;
 
-  return Math.random();
-});
+  const res = Math.random();
+  console.log('Fiber 1 result:', res);
 
-{
-  // Start the fiber process on next event loop cycle
-  const main = fiber.spawn(function* (proc) {
-    // Start f1, wait for the process to complete and get the result
-    console.log('Fiber 2: joins fiber 1');
-    const res = yield* fiber.join(fiber.spawn(f1));
-    console.log('Fiber 2 recieved:', res);
-
-    // Start f1 and make its lifetime depends on current fiber
-    console.log('Fiber 2: spawns fiber 1');
-    const childProc = fiber.spawn(f1);
-    fiber.mount(childProc, proc);
-  });
-
-  console.log('Fiber 2 started:', fiber.running(main));
-
-  // Wait for the fiber process to finish
-  await fiber.complete(main);
-
-  // Check finish status
-  console.log('Fiber 2 completed:', fiber.completed(main));
-}
+  return res;
+};
 
 {
   console.log('------------------------');
 
-  const main = fiber.spawn(f1);
-  console.log('Fiber 1 started:', fiber.running(main));
+  console.log('Fiber 1 started');
+  const sig = signal.init();
+  const promise = f1(sig);
 
-  // Interrupt a fiber
-  fiber.interrupt(main);
+  // Interrupt the signal
+  signal.interrupt(sig);
 
-  // Execution will be stopped on the last yield
-  await fiber.complete(main);
+  // Execution will be stopped on the last interruption point
+  await promise;
 
-  console.log('Fiber 1 interrupted:', fiber.interrupted(main));
+  console.log('Fiber 1 interrupted');
 }
 
 {
   console.log('------------------------');
 
-  const main = fiber.spawn(f1);
   logTime('Fiber 1 started');
 
-  // Wait for a time period then interrupt the fiber
-  fiber.timeout(main, 500);
-  await fiber.complete(main);
+  // Interrupt the function after 500ms
+  await f1(signal.duration(500));
 
   logTime('Fiber 1 interrupted');
 }

package/index.d.ts

@@ -29,7 +29,7 @@ export declare const timeout: <T>(promise: Promise<T>, ms: number) => Promise<T
 * @param ms - Sleep duration in milliseconds
 */
 export declare const sleepSync: (ms: number) => void;
-export * as fiber from "./fiber.js";
+export * as signal from "./signal.js";
 export * as latch from "./latch.js";
 export * as rateLimit from "./rate-limit.js";
 export * as semaphore from "./semaphore.js";

package/index.js

@@ -1 +1 @@
-export let nextTick=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.(`timers/promises`).setTimeout??(e=>new Promise(r=>{setTimeout(r,e)}));export let timeout=(e,i)=>Promise.race([e,sleep(i)]);let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??(e=>{Atomics.wait(sharedBuf,0,0,e)});export*as fiber from"./fiber.js";export*as latch from"./latch.js";export*as rateLimit from"./rate-limit.js";export*as semaphore from"./semaphore.js";
+export let nextTick=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.(`timers/promises`).setTimeout??(e=>new Promise(r=>{setTimeout(r,e)}));export let timeout=(e,i)=>Promise.race([e,sleep(i)]);let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??(e=>{Atomics.wait(sharedBuf,0,0,e)});export*as signal from"./signal.js";export*as latch from"./latch.js";export*as rateLimit from"./rate-limit.js";export*as semaphore from"./semaphore.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "ciorent",
-"version": "0.6.1",
+"version": "0.7.1",
 "description": "A lightweight, low-overhead concurrency library",
 "repository": {
 "type": "git",

package/semaphore.js

@@ -1 +1 @@
-export let init=e=>{let t=[,];let n=[t,t,e=>{n[0]=n[0][0]=[,e]},e];return n};export let acquire=async e=>{e[3]--;if(e[3]<0)return new Promise(e[2])};export let release=e=>{if(e[3]<0)(e[1]=e[1][0])[1]();e[3]++};
+export let init=e=>{let t=[,];let n=[t,t,e=>{n[0]=n[0][0]=[,e]},e];return n};export let acquire=async e=>{if(--e[3]<0)return new Promise(e[2])};export let release=e=>{if(e[3]++<0)(e[1]=e[1][0])[1]()};

package/signal.d.ts

@@ -0,0 +1,39 @@
+/**
+* Describe a signal
+*/
+export type Signal = [interrupted: boolean];
+/**
+* Create a signal
+*/
+export declare const init: () => Signal;
+/**
+* Check whether the signal has been interrupted
+* @param t
+*/
+export declare const interrupted: (t: Signal) => boolean;
+/**
+* Interrupt a signal
+* @param t
+*/
+export declare const interrupt: (t: Signal) => void;
+/**
+* Interrupt a signal after a duration
+* @param t
+*/
+export declare const timeout: (t: Signal, ms: number) => Promise<void>;
+/**
+* Link a signal to an `AbortSignal`
+* @param t
+* @param signal
+*/
+export declare const link: (t: Signal, signal: AbortSignal) => void;
+/**
+* Create a signal that interrupts after ms
+* @param ms
+*/
+export declare const duration: (ms: number) => Signal;
+/**
+* Create a signal that aborts when the abort signal aborts
+* @param signal
+*/
+export declare const bind: (signal: AbortSignal) => Signal;

package/signal.js

@@ -0,0 +1 @@
+import{sleep}from".";export let init=()=>[false];export let interrupted=e=>e[0];export let interrupt=e=>{e[0]=true};export let timeout=async(o,s)=>{await sleep(s);interrupt(o)};export let link=(e,o)=>{o.addEventListener(`abort`,()=>interrupt(e))};export let duration=e=>{let o=[false];timeout(o,e);return o};export let bind=e=>{let o=[false];link(o,e);return o};

package/fiber.d.ts

@@ -1,70 +0,0 @@
-/**
-* Describe a fiber process
-*/
-export type Process<TReturn = unknown> = [proc: Promise<TReturn | undefined>, status: 1 | 2 | 3, children: Process[]];
-/**
-* Describe a fiber runtime
-*/
-export type Runtime = <
-	const TReturn,
-	const Args extends any[]
->(gen: (proc: Process<TReturn>, ...args: Args) => Generator<any, TReturn>, ...args: Args) => Process<TReturn>;
-/**
-* Check whether the fiber is running
-*/
-export declare const running: (t: Process) => boolean;
-/**
-* Check whether the fiber has completed
-*/
-export declare const completed: (t: Process) => boolean;
-/**
-* Check whether the fiber has been interrupted
-*/
-export declare const interrupted: (t: Process) => boolean;
-/**
-* Create a fiber function
-* @param f
-*/
-export declare const fn: <const Fn extends (thread: Process, ...args: any[]) => Generator>(f: Fn) => Fn;
-/**
-* A basic fiber runtime
-* @param g
-*/
-export declare const spawn: Runtime;
-/**
-* Interrupt the execution of a fiber
-* @param t
-*/
-export declare const interrupt: (t: Process) => void;
-/**
-* Timeout a fiber
-* @param t
-* @param ms
-*/
-export declare const timeout: (t: Process, ms: number) => Promise<void>;
-/**
-* Wait for a fiber and retrieve its result
-* @param t
-*/
-export declare function join<T extends Process>(t: T): Generator<Awaited<T[0]>, Awaited<T[0]>>;
-/**
-* Wait for a fiber to finish and retrieve its result
-* @param t
-*/
-export declare const complete: <T extends Process>(t: T) => T[0];
-/**
-* Mount child fiber lifetime to parent lifetime
-* @param child
-* @param parent
-*/
-export declare const mount: (child: Process, parent: Process) => void;
-/**
-* Control the fiber with an abort signal
-* @param t
-* @param signal
-*/
-export declare const control: (t: Process, signal: AbortSignal) => void;
-/**
-* Unwrap a promise result
-*/
-export declare function unwrap<T extends Promise<any>>(t: T): Generator<Awaited<T>, Awaited<T>>;

package/fiber.js

@@ -1 +0,0 @@
-import{nextTick,sleep}from"./index.js";export let running=e=>e[1]===1;export let completed=e=>e[1]===2;export let interrupted=e=>e[1]===3;let invoke=async(f,p)=>{await nextTick;try{let e=f.next();while(!e.done){let m=await e.value;if(p[1]===3)return;e=f.next(m)}p[1]=2;return e.value}finally{if(p[1]!==2)p[1]=3;p[2].forEach(interrupt)}};export let fn=e=>e;export let spawn=(e,...f)=>{let p=[,1,[]];p[0]=invoke(e(p,...f),p);return p};export let interrupt=e=>{if(e[1]!==2)e[1]=3};export let timeout=async(e,p)=>{await sleep(p);interrupt(e)};export function*join(e){return yield e[0]}export let complete=e=>e[0];export let mount=(e,f)=>{f[2].push(e)};export let control=(e,f)=>{f.addEventListener(`abort`,()=>{interrupt(e)})};export function*unwrap(e){return yield e}