ciorent 0.0.16 → 0.0.18

package/README.md

@@ -23,47 +23,77 @@ const task = semaphore.task(
 cio.concurrent(6, task);
 ```
 
-## Latch
-Latch is a synchronization primitive that allows one process to wait until another completes an operation before continuing execution.
+## Fibers
+Virtual threads with more controlled execution.
 
 ```ts
-import * as latch from 'ciorent/latch';
 import * as cio from 'ciorent';
+import * as fiber from 'ciorent/fiber';
 
-const fetchLatch = latch.init();
+function* thread1() {
+  console.log('Fiber 1 started');
+  yield;
+  console.log('Fiber 1 done');
+}
 
-const task = async () => {
-  // Blocks until the latch is open
-  await latch.pause(fetchLatch);
+function* thread2() {
+  console.log('Fiber 2 started');
 
-  const res = await fetch('http://example.com');
-  console.log('Fetch status:', res.status);
-}
+  yield;
+  console.log('Fiber 2 resumed');
 
-const prepare = () => {
-  console.log('Run before fetch:', performance.now().toFixed(2));
+  // Wait for a promise
+  yield* fiber.wait(cio.sleep(1000));
+  console.log('Fiber 2 waited for 1s');
+
+  // Start task 1 and wait for it to be done
+  yield* fiber.join(
+    fiber.start(thread1())
+  );
+
+  console.log('Fiber 2 done');
 }
 
-const main = async () => {
-  const p = task();
-  await cio.sleep(500);
-  prepare();
+// Start running the thread
+fiber.start(thread2());
+```
 
-  // Allows all previously blocked tasks to run
-  latch.open(fetchLatch);
+## Channel
+Channel is a synchronization primitive via message passing. A message may be sent over a channel, and another process is able to receive messages sent over a channel it has a reference to.
 
-  // Reclose the latch
-  // Tasks that aren't blocked yet will be blocked
-  latch.reset(fetchLatch);
+```ts
+import * as channel from 'ciorent/channel';
+import * as cio from 'ciorent';
 
-  return p;
+const c = channel.init<number>();
+
+const run = async () => {
+  for (let i = 0; i < 10; i++) {
+    await cio.sleep(10);
+    channel.send(c, i);
+    console.log('Sent', i);
+  }
+
+  // Resolve all waiting promises with `undefined`
+  // This is a way to tell the reciever to not listen to more data
+  channel.flush(c);
+};
+
+const log = async () => {
+  while (true) {
+    // Wait until a value is sent
+    const x = await channel.recieve(c);
+    if (x == null) break;
+
+    console.log('Recieved', x);
+  };
 }
 
-// Run fetch after 500ms
-await main();
+run();
+log();
 
-// Run fetch after another 500ms
-await main();
+// This runs first
+console.log('Starting...');
 ```
 
 ## Pubsub
@@ -102,42 +132,47 @@ cio.concurrent(5, async (id: number) => {
 publisher();
 ```
 
-## Channel
-Channel is a synchronization primitive via message passing. A message may be sent over a channel, and another process is able to receive messages sent over a channel it has a reference to.
+## Latch
+Latch is a synchronization primitive that allows one process to wait until another completes an operation before continuing execution.
 
 ```ts
-import * as channel from 'ciorent/channel';
+import * as latch from 'ciorent/latch';
 import * as cio from 'ciorent';
 
-const c = channel.init<number>();
+const fetchLatch = latch.init();
 
-const run = async () => {
-  for (let i = 0; i < 10; i++) {
-    await cio.sleep(10);
-    channel.send(c, i);
-    console.log('Sent', i);
-  }
+const task = async () => {
+  // Blocks until the latch is open
+  await latch.pause(fetchLatch);
 
-  // Resolve all waiting promises with `undefined`
-  // This is a way to tell the reciever to not listen to more data
-  channel.flush(c);
-};
+  const res = await fetch('http://example.com');
+  console.log('Fetch status:', res.status);
+}
 
-const log = async () => {
-  while (true) {
-    // Wait until a value is sent
-    const x = await channel.recieve(c);
-    if (x == null) break;
+const prepare = () => {
+  console.log('Run before fetch:', performance.now().toFixed(2));
+}
 
-    console.log('Recieved', x);
-  };
+const main = async () => {
+  const p = task();
+  await cio.sleep(500);
+  prepare();
+
+  // Allows all previously blocked tasks to run
+  latch.open(fetchLatch);
+
+  // Reclose the latch
+  // Tasks that aren't blocked yet will be blocked
+  latch.reset(fetchLatch);
+
+  return p;
 }
 
-run();
-log();
+// Run fetch after 500ms
+await main();
 
-// This runs first
-console.log('Starting...');
+// Run fetch after another 500ms
+await main();
 ```
 
 ## Utilities
@@ -174,10 +209,13 @@ task2();
 ### Sleep
 A cross-runtime sleep function.
 ```ts
-import { sleep } from 'ciorent';
+import { sleep, sleepSync } from 'ciorent';
 
 await sleep(500);
 console.log('Hi');
+
+sleepSync(500);
+console.log('Hi');
 ```
 
 ### Spawning tasks

package/channel.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Channels
  */
-import type { QueueNode } from './fixed-queue';
+import type { QueueNode } from './fixed-queue.js';
 /**
  * Describe a channel
  */

package/dropping-queue.d.ts

@@ -1,9 +1,9 @@
 /**
  * @module Dropping queues
  */
-import type { FixedQueue } from './fixed-queue';
-export { init } from './fixed-queue';
-export { pop } from './sliding-queue';
+import type { FixedQueue } from './fixed-queue.js';
+export { init } from './fixed-queue.js';
+export { pop } from './sliding-queue.js';
 /**
  * Push an item to a dropping queue
  * @param q - The queue to push to

package/dropping-queue.js

@@ -1 +1 @@
-export{init}from"./fixed-queue";export{pop}from"./sliding-queue";export let push=(q,item)=>{if(q[0][(q[2]+1)%q[1]]!=null)return false;q[0][q[2]=(q[2]+1)%q[1]]=item;return true};
+export{init}from"./fixed-queue.js";export{pop}from"./sliding-queue.js";export let push=(q,item)=>{if(q[0][(q[2]+1)%q[1]]!=null)return false;q[0][q[2]=(q[2]+1)%q[1]]=item;return true};

package/fiber/index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @module Fiber
+ */
+/**
+ * When the fiber is paused
+ */
+export declare const paused: (t: Thread) => boolean;
+/**
+ * When the fiber is running
+ */
+export declare const running: (t: Thread) => boolean;
+/**
+ * When the fiber is done
+ */
+export declare const done: (t: Thread) => boolean;
+/**
+ * Describe a fiber
+ */
+export interface Thread<T = unknown, TReturn = unknown> {
+    /**
+     * The original generator
+     */
+    0: Generator<T, TReturn>;
+    /**
+     * The waiting promise
+     */
+    1: Promise<T | TReturn>;
+    /**
+     * Fiber status
+     */
+    2: 0 | 1 | 2;
+    /**
+     * Callback to continue running the fiber
+     */
+    3: null | (() => void);
+}
+/**
+ * Describe a fiber runtime
+ */
+export type Runtime = <const T, const TReturn>(gen: Generator<T, TReturn>) => Thread<T, TReturn>;
+/**
+ * A basic fiber runtime
+ * @param g
+ */
+export declare const start: Runtime;
+/**
+ * Pause the execution of a fiber
+ * @param t
+ */
+export declare const pause: (t: Thread) => void;
+/**
+ * Resume the execution of a fiber
+ * @param t
+ */
+export declare const resume: (t: Thread) => void;
+/**
+ * Stop the execution of a fiber and retrieve the result
+ * @param t
+ */
+export declare const stop: <T extends Thread>(t: T) => T[1];
+/**
+ * Wait for a fiber and retrieve its result
+ * @param t
+ */
+export declare function join<T extends Thread>(t: T): Generator<Awaited<T[1]>, Awaited<T[1]>>;
+/**
+ * Wait for a fiber to finish and retrieve its result
+ * @param t
+ */
+export declare const finish: <T extends Thread>(t: T) => T[1];
+/**
+ * Wait for a promise to resolve then retrieve its result
+ */
+export declare function wait<T extends Promise<any>>(t: T): Generator<Awaited<T>, Awaited<T>>;

package/fiber/index.js

@@ -0,0 +1 @@
+export let paused=(t)=>t[2]===0;export let running=(t)=>t[2]===1;export let done=(t)=>t[2]===2;let invoke=async(g,thread)=>{let t=g.next();while(!t.done){let v=await t.value;if(thread[2]===0){let r;let p=new Promise((res)=>{r=res});thread[3]=r;await p}if(thread[2]===2)return v;t=g.next(v)}thread[2]=2;return t.value};export let start=(g)=>{let thread=[g,null,1,null];thread[1]=invoke(g,thread);return thread};export let pause=(t)=>{if(t[2]===1)t[2]=0};export let resume=(t)=>{if(t[2]===0){t[2]=1;t[3]?.()}};export let stop=(t)=>{if(t[2]===0){t[2]=2;t[3]()}else t[2]=2;return t[1]};export function*join(t){return yield t[1]}export let finish=(t)=>t[1];export function*wait(t){return yield t}

package/fixed-queue.d.ts

@@ -26,10 +26,7 @@ export interface FixedQueue<T extends {}> {
 /**
  * Describe a queue node (singly linked list node)
  */
-export type QueueNode<T> = [
-    value: T,
-    next: QueueNode<T> | null
-];
+export type QueueNode<T> = [value: T, next: QueueNode<T> | null];
 /**
  * Create a fixed queue.
  * @param n - The queue size

package/index.d.ts

@@ -14,6 +14,13 @@ export declare const pause: Promise<void>;
  * @param ms - Sleep duration in milliseconds
  */
 export declare const sleep: (ms: number) => Promise<void>;
+/**
+ * Sleep for a duration synchronously.
+ *
+ * On the browser it only works in workers.
+ * @param ms - Sleep duration in milliseconds
+ */
+export declare const sleepSync: (ms: number) => void;
 /**
  * Spawn n tasks that runs sequentially
  * @param n

package/index.js

@@ -1 +1 @@
-export let pause=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.("timers/promises").setTimeout??((ms)=>new Promise((res)=>{setTimeout(res,ms)}));export let sequential=async(n,task)=>{for(let i=0;i<n;i++)await task(i)};export let concurrent=(n,task)=>{let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(i);return Promise.all(arr)};
+export let pause=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.("timers/promises").setTimeout??((ms)=>new Promise((res)=>{setTimeout(res,ms)}));let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??((ms)=>{Atomics.wait(sharedBuf,0,0,ms)});export let sequential=async(n,task)=>{for(let i=0;i<n;i++)await task(i)};export let concurrent=(n,task)=>{let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(i);return Promise.all(arr)};

package/latch.d.ts

@@ -4,10 +4,7 @@
 /**
  * Describe a latch
  */
-export type Latch = [
-    pause: Promise<void>,
-    open: () => void
-];
+export type Latch = [pause: Promise<void>, open: () => void];
 /**
  * Create a latch
  */

package/latch.js

@@ -1 +1 @@
-import{pause as endPromise}from".";export let init=()=>{let r;return[new Promise((res)=>{r=res}),r]};export let pause=(latch)=>latch[0];export let open=(latch)=>{latch[1]();latch[0]=endPromise};export let reset=(latch)=>{if(latch[0]===endPromise){let r;latch[0]=new Promise((res)=>{r=res});latch[1]=r}};
+import{pause as endPromise}from"./index.js";export let init=()=>{let r;return[new Promise((res)=>{r=res}),r]};export let pause=(latch)=>latch[0];export let open=(latch)=>{latch[1]();latch[0]=endPromise};export let reset=(latch)=>{if(latch[0]===endPromise){let r;latch[0]=new Promise((res)=>{r=res});latch[1]=r}};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ciorent",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "A lightweight, low-overhead concurrency library",
   "homepage": "https://ciorent.netlify.app",
   "repository": {
@@ -17,27 +17,16 @@
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",
-  "scripts": {
-    "task": "bun scripts/task.ts",
-    "build:test": "bun task build && bun docs && bun test",
-    "build:publish": "bun build:test && bun task report-size && bun task publish",
-    "lint": "eslint ./src",
-    "lint:fix": "eslint ./src --fix",
-    "docs": "typedoc"
-  },
-  "devDependencies": {
-    "@stylistic/eslint-plugin": "latest",
-    "@types/bun": "latest",
-    "@types/uglify-js": "latest",
-    "eslint": "latest",
-    "eslint-plugin-jsdoc": "latest",
-    "mitata": "latest",
-    "terser": "^5.39.0",
-    "tsx": "latest",
-    "typedoc": "^0.27.9",
-    "typedoc-material-theme": "^1.3.0",
-    "typedoc-plugin-inline-sources": "^1.2.1",
-    "typescript": "latest",
-    "typescript-eslint": "latest"
+  "exports": {
+    "./fixed-queue": "./fixed-queue.js",
+    "./sliding-queue": "./sliding-queue.js",
+    ".": "./index.js",
+    "./dropping-queue": "./dropping-queue.js",
+    "./semaphore": "./semaphore.js",
+    "./channel": "./channel.js",
+    "./fiber": "./fiber/index.js",
+    "./latch": "./latch.js",
+    "./concurrent": "./concurrent.d.ts",
+    "./topic": "./topic.js"
   }
-}
+}

package/semaphore.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Semaphores
  */
-import type { QueueNode } from './fixed-queue';
+import type { QueueNode } from './fixed-queue.js';
 /**
  * Describe a semaphore
  */
@@ -34,7 +34,7 @@ export declare const signal: (s: Semaphore) => void;
 /**
  * Wrap a task to bind to a custom semaphore later
  */
-export declare const wrap: <Args extends any[], Return extends Promise<any>>(f: (...args: Args) => Return) => (s: Semaphore, ...a: Args) => Return;
+export declare const wrap: <Args extends any[], Return extends Promise<any>>(f: (...args: Args) => Return) => ((s: Semaphore, ...a: Args) => Return);
 /**
  * Create a task that acquire a semaphore and release the access when it's finished
  */

package/semaphore.js

@@ -1 +1 @@
-import{pause as resolvedPromise}from".";export let init=(n)=>{let root=[null,null];return[n,root,root]};export let pause=(s)=>{s[0]--;if(s[0]<0){let r;let p=new Promise((res)=>{r=res});s[1]=s[1][1]=[r,null];return p}return resolvedPromise};export let signal=(s)=>{if(s[0]<0)(s[2]=s[2][1])[0]();s[0]++};export let wrap=(f)=>async(s,...a)=>{s[0]--;if(s[0]<0){let r;let p=new Promise((res)=>{r=res});s[1]=s[1][1]=[r,null];await p}try{return await f(...a)}finally{signal(s)}};export let task=(s,f)=>{f=wrap(f);return(...a)=>f(s,...a)};
+import{pause as resolvedPromise}from"./index.js";export let init=(n)=>{let root=[null,null];return[n,root,root]};export let pause=(s)=>{s[0]--;if(s[0]<0){let r;let p=new Promise((res)=>{r=res});s[1]=s[1][1]=[r,null];return p}return resolvedPromise};export let signal=(s)=>{if(s[0]<0)(s[2]=s[2][1])[0]();s[0]++};export let wrap=(f)=>async(s,...a)=>{s[0]--;if(s[0]<0){let r;let p=new Promise((res)=>{r=res});s[1]=s[1][1]=[r,null];await p}try{return await f(...a)}finally{signal(s)}};export let task=(s,f)=>{f=wrap(f);return(...a)=>f(s,...a)};

package/sliding-queue.d.ts

@@ -1,8 +1,8 @@
 /**
  * @module Sliding queues
  */
-import type { FixedQueue } from './fixed-queue';
-export { init } from './fixed-queue';
+import type { FixedQueue } from './fixed-queue.js';
+export { init } from './fixed-queue.js';
 /**
  * Push an item to a sliding queue
  * @param q - The queue to push to

package/sliding-queue.js

@@ -1 +1 @@
-export{init}from"./fixed-queue";export let push=(q,item)=>{q[0][q[2]=(q[2]+1)%q[1]]=item};export let pop=(q)=>{let val=q[0][(q[3]+1)%q[1]];if(val!=null){q[0][q[3]=(q[3]+1)%q[1]]=null;return val}};
+export{init}from"./fixed-queue.js";export let push=(q,item)=>{q[0][q[2]=(q[2]+1)%q[1]]=item};export let pop=(q)=>{let val=q[0][(q[3]+1)%q[1]];if(val!=null){q[0][q[3]=(q[3]+1)%q[1]]=null;return val}};

package/topic.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Pubsub
  */
-import type { QueueNode } from './fixed-queue';
+import type { QueueNode } from './fixed-queue.js';
 /**
  * Describe a topic
  */