ciorent 0.2.1 → 0.3.0

package/README.md

@@ -106,42 +106,69 @@ task1();
 task2();
 ```
 
-### 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.
+### Pubsub
+A fast, simple publish-subscribe API.
 
 ```ts
-import * as channel from 'ciorent/channel';
+import * as topic from 'ciorent/topic';
 import * as co from 'ciorent';
 
-const c = channel.init<number>();
+const messages = topic.init<number>();
 
-const run = async () => {
-  for (let i = 0; i < 5; i++) {
+// A task that publish messages
+const publisher = async () => {
+  for (let i = 0; i < 3; i++) {
     await co.sleep(100);
-    channel.send(c, i);
-    console.log('Sent', i);
+    topic.publish(messages, i);
   }
 
-  // Resolve all waiting promises with `undefined`
-  // This is a way to tell the reciever to not listen to more data
-  channel.flush(c);
-};
+  // Resolve all waiting promises
+  // And clear the value queue
+  topic.flush(messages);
+}
+
+// Spawn 3 tasks that recieve messages
+co.spawn(3, async (id: number) => {
+  const sub = topic.subscribe(messages);
 
-const log = async () => {
   while (true) {
-    // Wait until a value is sent to the channel
-    const x = await channel.recieve(c);
+    // Block until the value is sent
+    const x = await topic.recieve(sub);
     if (x == null) break;
+    console.log(`Task ${id} recieved: ${x}`);
+  }
+});
 
-    console.log('Recieved', x);
-  };
-}
+publisher();
+```
 
-log();
-run();
+### Semaphore
+Semaphore is a concurrency primitive used to control access to a common resource by multiple processes.
 
-// This runs first
-console.log('Starting...');
+```ts
+import * as semaphore from 'ciorent/semaphore';
+import * as co from 'ciorent';
+
+// Only allow 2 task to run concurrently
+const sem = semaphore.init(2);
+
+const task = async (id: number) => {
+  // Acquire the semaphore or wait for the semaphore to be available
+  await semaphore.acquire(sem);
+
+  console.log('Task', id, 'started');
+
+  // Let the main thread schedules other tasks
+  for (let i = 1; i <= 5; i++) await co.pause;
+
+  console.log('Task', id, 'end');
+
+  // Release the semaphore
+  semaphore.release(sem);
+}
+
+// Try to run 5 tasks concurrently
+co.spawn(5, task);
 ```
 
 ### Latch
@@ -171,69 +198,42 @@ task();
 prepare();
 ```
 
-### Semaphore
-Semaphore is a concurrency primitive used to control access to a common resource by multiple processes.
-
-```ts
-import * as semaphore from 'ciorent/semaphore';
-import * as co from 'ciorent';
-
-// Only allow 2 task to run concurrently
-const sem = semaphore.init(2);
-
-const task = async (id: number) => {
-  // Acquire the semaphore or wait for the semaphore to be available
-  await semaphore.pause(sem);
-
-  console.log('Task', id, 'started');
-
-  // Let the main thread schedules other tasks
-  for (let i = 1; i <= 5; i++) await co.pause;
-
-  console.log('Task', id, 'end');
-
-  // Release the semaphore
-  semaphore.signal(sem);
-}
-
-// Try to run 5 tasks concurrently
-co.spawn(5, task);
-```
-
-### Pubsub
-A fast, simple publish-subscribe API.
+### 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.
 
 ```ts
-import * as topic from 'ciorent/topic';
+import * as channel from 'ciorent/channel';
 import * as co from 'ciorent';
 
-const messages = topic.init<number>();
+const c = channel.init<number>();
 
-// A task that publish messages
-const publisher = async () => {
-  for (let i = 0; i < 3; i++) {
+const run = async () => {
+  for (let i = 0; i < 5; i++) {
     await co.sleep(100);
-    topic.publish(messages, i);
+    channel.send(c, i);
+    console.log('Sent', i);
   }
 
-  // Resolve all waiting promises
-  // And clear the value queue
-  topic.flush(messages);
-}
-
-// Spawn 3 tasks that recieve messages
-co.spawn(3, async (id: number) => {
-  const sub = topic.subscribe(messages);
+  // 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) {
-    // Block until the value is sent
-    const x = await topic.recieve(sub);
+    // Wait until a value is sent to the channel
+    const x = await channel.recieve(c);
     if (x == null) break;
-    console.log(`Task ${id} recieved: ${x}`);
-  }
-});
 
-publisher();
+    console.log('Recieved', x);
+  };
+}
+
+log();
+run();
+
+// This runs first
+console.log('Starting...');
 ```
 
 ### Fibers
@@ -243,8 +243,11 @@ Virtual threads with more controlled execution.
 import * as co from 'ciorent';
 import * as fiber from 'ciorent/fiber';
 
+const logTime = (label: string) => console.log(label + ':', Math.floor(performance.now()) + 'ms');
+
 const f1 = fiber.fn(function* () {
   // Wait for a promise
+  console.log('Fiber 1 waiting: 1s');
   yield co.sleep(1000);
 
   // Wait for a promise and return its result
@@ -255,26 +258,21 @@ const f1 = fiber.fn(function* () {
 });
 
 {
+  // 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.resumed(main));
 
-  // Pause the current fiber process
-  fiber.pause(main);
-  console.log('Fiber 2 is paused:', fiber.paused(main));
-
-  // Resume the fiber
-  fiber.resume(main);
-  console.log('Fiber 2 is resumed:', fiber.resumed(main));
-
   // Wait for the fiber process to finish
   await fiber.done(main);
 
@@ -288,8 +286,12 @@ const f1 = fiber.fn(function* () {
   const main = fiber.spawn(f1);
   console.log('Fiber 1 started:', fiber.resumed(main));
 
-  // Stop a fiber
+  // Interrupt a fiber
   fiber.interrupt(main);
+
+  // Execution will be stopped on the last yield
+  await fiber.done(main);
+
   console.log('Fiber 1 interrupted:', fiber.interrupted(main));
 }
 
@@ -297,11 +299,13 @@ const f1 = fiber.fn(function* () {
   console.log('------------------------');
 
   const main = fiber.spawn(f1);
-  console.log('Fiber 1 started:', fiber.resumed(main));
+  logTime('Fiber 1 started');
+
+  // Wait for a time period then interrupt the fiber
+  fiber.timeout(main, 500);
+  await fiber.done(main);
 
-  // Timeout a fiber
-  await fiber.timeout(main, 500);
-  console.log('Fiber 1 stopped:', fiber.interrupted(main));
+  logTime('Fiber 1 interrupted');
 }
 ```
 

package/channel.d.ts

@@ -1,27 +1,20 @@
 /**
  * @module Channels
  */
-import type { QueueNode } from './fixed-queue.js';
+import type { Node as QueueNode } from './queue.js';
+import { type Lock } from './lock.js';
 /**
  * Describe a channel
  */
-export interface Channel<T> {
+export interface Channel<T = any> extends Lock<T> {
     /**
      * The head of the value queue
      */
-    0: QueueNode<T>;
+    2: QueueNode<T>;
     /**
      * The tail of the value queue
      */
-    1: QueueNode<T>;
-    /**
-     * The head of the Promise resolve queue
-     */
-    2: QueueNode<(value?: T) => void>;
-    /**
-     * The tail of the Promise resolve queue
-     */
-    3: QueueNode<(value?: T) => void>;
+    3: QueueNode<T>;
 }
 /**
  * Create a channel
@@ -43,8 +36,4 @@ export declare const recieve: <T>(c: Channel<T>) => Promise<T | undefined>;
  * @param c
  */
 export declare const poll: <T>(c: Channel<T>) => T | undefined;
-/**
- * Resolves all pending promises of a channel
- * @param c
- */
-export declare const flush: <T>(c: Channel<T>) => void;
+export { flush } from './lock.js';

package/channel.js

@@ -1 +1 @@
-export let init=()=>{let qu=[null];let resolveQu=[null,null];return[qu,qu,resolveQu,resolveQu]};export let send=(c,t)=>{if(c[3][0]!==null)(c[3]=c[3][0])[1](t);else c[0]=c[0][0]=[null,t]};export let recieve=(c)=>c[1][0]!==null?Promise.resolve((c[1]=c[1][0])[1]):new Promise((res)=>{c[2]=c[2][0]=[null,res]});export let poll=(c)=>c[1][0]!==null?(c[0]=c[1][0])[1]:undefined;export let flush=(c)=>{while(c[3][0]!==null)(c[3]=c[3][0])[1]()};
+import{acquire as lockAcquire,release as lockRelease,released as lockReleased}from"./lock.js";export let init=()=>{let resolveQu=[null];let qu=[null];return[resolveQu,resolveQu,qu,qu]};export let send=(c,t)=>{if(lockReleased(c))c[2]=c[2][0]=[null,t];else lockRelease(c,t)};export let recieve=(c)=>c[3][0]!==null?Promise.resolve((c[3]=c[3][0])[1]):lockAcquire(c);export let poll=(c)=>c[3][0]!==null?(c[3]=c[3][0])[1]:undefined;export{flush}from"./lock.js";

package/dropping-queue.d.ts

@@ -1,12 +1,12 @@
 /**
  * @module Dropping queues
  */
-import type { FixedQueue } from './fixed-queue.js';
-export { init } from './fixed-queue.js';
+import type { Fixed } from './queue.js';
+export { fixed as init } from './queue.js';
 export { pop } from './sliding-queue.js';
 /**
  * Push an item to a dropping queue
  * @param q - The queue to push to
  * @param item
  */
-export declare const push: <T extends {}>(q: FixedQueue<T>, item: T) => boolean;
+export declare const push: <T extends {}>(q: Fixed<T>, item: T) => boolean;

package/dropping-queue.js

@@ -1 +1 @@
-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};
+export{fixed as init}from"./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.d.ts

@@ -42,6 +42,10 @@ 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

package/fiber.js

@@ -1 +1 @@
-import{sleep}from"./index.js";export let paused=(t)=>t[1]===0;export let resumed=(t)=>t[1]===1;export let completed=(t)=>t[1]===2;export let interrupted=(t)=>t[1]===3;let invoke=async(g,thread)=>{try{let t=g.next();while(!t.done){let v=await t.value;if(thread[1]===0){let r;let p=new Promise((res)=>{r=res});thread[2]=r;await p}if(thread[1]===3)return;t=g.next(v)}thread[1]=2;return t.value}finally{if(thread[1]!==2)thread[1]=3;thread[3].forEach(stop)}};export let fn=(f)=>f;export let spawn=(f,...args)=>{let thread=[null,1,null,[]];thread[0]=invoke(f(thread,...args),thread);return thread};export let pause=(t)=>{if(t[1]===1)t[1]=0};export let resume=(t)=>{if(t[1]===0){t[1]=1;t[2]?.()}};export let interrupt=(t)=>{if(t[1]!==2){if(t[1]===0)t[2]?.();t[1]=3}};export let timeout=async(t,ms)=>{await sleep(ms);interrupt(t)};export function*join(t){return yield t[0]}export let done=(t)=>t[0];export let mount=(child,parent)=>{parent[3].push(child)};export let control=(t,signal)=>{signal.addEventListener("abort",()=>{interrupt(t)})};export function*unwrap(t){return yield t}
+import{sleep}from"./index.js";export let paused=(t)=>t[1]===0;export let resumed=(t)=>t[1]===1;export let completed=(t)=>t[1]===2;export let interrupted=(t)=>t[1]===3;let invoke=async(g,thread)=>{await 0;try{let t=g.next();while(!t.done){let v=await t.value;if(thread[1]===0){let r;let p=new Promise((res)=>{r=res});thread[2]=r;await p}if(thread[1]===3)return;t=g.next(v)}thread[1]=2;return t.value}finally{if(thread[1]!==2)thread[1]=3;thread[3].forEach(interrupt)}};export let fn=(f)=>f;export let spawn=(f,...args)=>{let thread=[null,1,null,[]];thread[0]=invoke(f(thread,...args),thread);return thread};export let pause=(t)=>{if(t[1]===1)t[1]=0};export let resume=(t)=>{if(t[1]===0){t[1]=1;t[2]?.()}};export let interrupt=(t)=>{if(t[1]!==2){if(t[1]===0)t[2]?.();t[1]=3}};export let timeout=async(t,ms)=>{await sleep(ms);interrupt(t)};export function*join(t){return yield t[0]}export let done=(t)=>t[0];export let mount=(child,parent)=>{parent[3].push(child)};export let control=(t,signal)=>{signal.addEventListener("abort",()=>{interrupt(t)})};export function*unwrap(t){return yield t}

package/index.d.ts

@@ -2,7 +2,7 @@
  * @module Other utilities
  */
 /**
- * Yield back to main thread.
+ * Continue the execution on next event loop cycle.
  *
  * You can `await` this **occasionally** in an expensive synchronous operation to avoid
  *
@@ -43,7 +43,6 @@ export declare const spawn: <const T extends any[], const R>(n: number, task: (.
 export declare const debounce: <const Args extends any[]>(f: (...args: Args) => any, ms: number) => ((...args: Args) => void);
 /**
  * Throttle function execution for a time period
- * @param f - The function to throttle (it must not throw errors)
  * @param ms - The time in milliseconds
  * @param limit - The call limit in the time period
  */

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)}));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,...args)=>{for(let i=0;i<n;i++)await task(...args,i)};export let spawn=(n,task,...args)=>{let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(...args,i);return arr};export let debounce=(f,ms)=>{let id;return(...a)=>{clearTimeout(id);id=setTimeout(f,ms,...a)}};export let throttle=(ms,limit)=>{let head=[null];let tail=head;let cur=limit;let scheduled=false;let unlock=()=>{cur=limit;if(tail===head){scheduled=false;return}do{cur--;(tail=tail[0])[1]()}while(cur>0&&tail!==head);setTimeout(unlock,ms)};return()=>{if(cur===0){let r;let p=new Promise((res)=>{r=res});head=head[0]=[null,r];return p}if(!scheduled){scheduled=true;setTimeout(unlock,ms)}cur--;return pause}};
+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,...args)=>{for(let i=0;i<n;i++)await task(...args,i)};export let spawn=(n,task,...args)=>{let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(...args,i);return arr};export let debounce=(f,ms)=>{let id;return(...a)=>{clearTimeout(id);id=setTimeout(f,ms,...a)}};export let throttle=(ms,limit)=>{let head=[null];let tail=head;let cur=limit;let scheduled=false;let unlock=()=>{cur=limit;if(tail===head){scheduled=false;return}do{cur--;(tail=tail[0])[1]()}while(cur>0&&tail!==head);setTimeout(unlock,ms)};return()=>{if(cur===0){return new Promise((res)=>{head=head[0]=[null,res]})}if(!scheduled){scheduled=true;setTimeout(unlock,ms)}cur--;return pause}};

package/lock.d.ts

@@ -0,0 +1,36 @@
+import type { Node as QueueNode } from './queue.js';
+/**
+ * Describe a lock
+ */
+export interface Lock<T = any> {
+    /**
+     * The head of the Promise resolve queue
+     */
+    0: QueueNode<(value?: T) => void>;
+    /**
+     * The tail of the Promise resolve queue
+     */
+    1: QueueNode<(value?: T) => void>;
+}
+/**
+ * Acquire an item
+ * @param lock
+ * @param value
+ */
+export declare const acquire: <T>(lock: Lock<T>) => Promise<T | undefined>;
+/**
+ * Release an item
+ * @param lock
+ * @param value
+ */
+export declare const release: <T>(lock: Lock<T>, value?: T) => void;
+/**
+ * Return true if all items are released
+ * @param lock
+ */
+export declare const released: (lock: Lock) => boolean;
+/**
+ * Release all items of a lock
+ * @param lock
+ */
+export declare const flush: (lock: Lock) => void;

package/lock.js

@@ -0,0 +1 @@
+export let acquire=(lock)=>new Promise((res)=>{lock[0]=lock[0][0]=[null,res]});export let release=(lock,value)=>{(lock[1]=lock[1][0])[1](value)};export let released=(lock)=>lock[1][0]===null;export let flush=(lock)=>{while(lock[1][0]!==null)(lock[1]=lock[1][0])[1]()};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ciorent",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "A lightweight, low-overhead concurrency library",
   "homepage": "https://ciorent.netlify.app",
   "repository": {
@@ -19,13 +19,14 @@
   "types": "./index.d.ts",
   "exports": {
     "./sliding-queue": "./sliding-queue.js",
-    "./fixed-queue": "./fixed-queue.js",
-    "./fiber": "./fiber.js",
-    ".": "./index.js",
+    "./latch": "./latch.js",
+    "./lock": "./lock.js",
     "./dropping-queue": "./dropping-queue.js",
+    "./semaphore": "./semaphore.js",
     "./channel": "./channel.js",
+    "./fiber": "./fiber.js",
+    "./queue": "./queue.js",
     "./topic": "./topic.js",
-    "./semaphore": "./semaphore.js",
-    "./latch": "./latch.js"
+    ".": "./index.js"
   }
 }

package/{fixed-queue.d.ts → queue.d.ts}

@@ -5,7 +5,7 @@
 /**
  * Describe a fixed-sized queue
  */
-export interface FixedQueue<T extends {}> {
+export interface Fixed<T extends {}> {
     /**
      * Pre-allocated queue
      */
@@ -26,9 +26,12 @@ export interface FixedQueue<T extends {}> {
 /**
  * Describe a queue node (singly linked list node)
  */
-export type QueueNode<T> = [next: QueueNode<T> | null, value: T];
+export interface Node<T> {
+    0: Node<T> | null;
+    1: T;
+}
 /**
- * Create a fixed queue.
+ * Create a fixed queue
  * @param n - The queue size
  */
-export declare const init: <T extends {}>(n: number) => FixedQueue<T>;
+export declare const fixed: <T extends {}>(n: number) => Fixed<T>;

package/queue.js

@@ -0,0 +1 @@
+export let fixed=(n)=>[new Array(n),n,-1,-1];

package/semaphore.d.ts

@@ -1,23 +1,15 @@
 /**
  * @module Semaphores
  */
-import type { QueueNode } from './fixed-queue.js';
+import { type Lock } from './lock.js';
 /**
  * Describe a semaphore
  */
-export interface Semaphore {
+export interface Semaphore extends Lock<undefined> {
     /**
      * Current remaining process allowed
      */
-    0: number;
-    /**
-     * The head of the Promise resolve queue
-     */
-    1: QueueNode<() => void>;
-    /**
-     * The tail of the Promise resolve queue
-     */
-    2: QueueNode<() => void>;
+    2: number;
 }
 /**
  * Create a semaphore that allows n accesses
@@ -26,11 +18,11 @@ export declare const init: (n: number) => Semaphore;
 /**
  * Wait until the semaphore allows access
  */
-export declare const pause: (s: Semaphore) => Promise<void>;
+export declare const acquire: (s: Semaphore) => Promise<void>;
 /**
  * Signal to the semaphore to release access
  */
-export declare const signal: (s: Semaphore) => void;
+export declare const release: (s: Semaphore) => void;
 /**
  * Bind a task to a semaphore
  */

package/semaphore.js

@@ -1 +1 @@
-import{pause as resolvedPromise}from"./index.js";export let init=(n)=>{let root=[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][0]=[null,r];return p}return resolvedPromise};export let signal=(s)=>{if(s[0]<0)(s[2]=s[2][0])[1]();s[0]++};export let bind=(f,s)=>async(...a)=>{s[0]--;if(s[0]<0){let r;let p=new Promise((res)=>{r=res});s[1]=s[1][0]=[null,r];await p}try{return await f(...a)}finally{if(s[0]<0)(s[2]=s[2][0])[1]();s[0]++}};
+import{pause as resolvedPromise}from"./index.js";import{acquire as lockAcquire,release as lockRelease}from"./lock.js";export let init=(n)=>{let root=[null];return[root,root,n]};export let acquire=(s)=>{s[2]--;return s[2]>=0?resolvedPromise:lockAcquire(s)};export let release=(s)=>{if(s[2]<0)lockRelease(s);s[2]++};export let bind=(f,s)=>async(...a)=>{s[2]--;if(s[2]<0)await acquire(s);try{return await f(...a)}finally{if(s[2]<0)release(s);s[2]++}};

package/sliding-queue.d.ts

@@ -1,16 +1,16 @@
 /**
  * @module Sliding queues
  */
-import type { FixedQueue } from './fixed-queue.js';
-export { init } from './fixed-queue.js';
+import type { Fixed } from './queue.js';
+export { fixed as init } from './queue.js';
 /**
  * Push an item to a sliding queue
  * @param q - The queue to push to
  * @param item
  */
-export declare const push: <T extends {}>(q: FixedQueue<T>, item: T) => void;
+export declare const push: <T extends {}>(q: Fixed<T>, item: T) => void;
 /**
  * Pop an item from the queue
  * @param q - The queue to pop from
  */
-export declare const pop: <T extends {}>(q: FixedQueue<T>) => T | undefined;
+export declare const pop: <T extends {}>(q: Fixed<T>) => T | undefined;

package/sliding-queue.js

@@ -1 +1 @@
-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}};
+export{fixed as init}from"./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.js';
+import type { Node as QueueNode } from './queue.js';
 /**
  * Describe a topic
  */
@@ -13,11 +13,7 @@ export interface Topic<T extends {}> {
     /**
      * The waiting subscriber resolves
      */
-    1: ((res?: T) => void)[];
-    /**
-     * The waiting subscribers
-     */
-    2: Subscriber<T>[];
+    1: ((res: QueueNode<T>) => void)[];
 }
 /**
  * Create a topic

package/topic.js

@@ -1 +1 @@
-export let init=()=>[[null],[],[]];export let subscribe=(t)=>[t,t[0]];export let publish=(t,value)=>{let head=t[0]=t[0][0]=[null,value];for(let i=0,res=t[1],subs=t[2];i<res.length;i++){res[i](value);subs[i][1]=head}t[1]=[];t[2]=[]};export let flush=(t)=>{let head=t[0]=[null];for(let i=0,res=t[1],subs=t[2];i<res.length;i++){res[i]();subs[i][1]=head}t[1]=[];t[2]=[]};export let poll=(t)=>t[1][0]!==null?(t[1]=t[1][0])[1]:undefined;export let recieve=(t)=>{if(t[1][0]!==null)return Promise.resolve((t[1]=t[1][0])[1]);let topic=t[0];topic[2].push(t);return new Promise((res)=>{topic[1].push(res)})};
+export let init=()=>[[null],[],[]];export let subscribe=(t)=>[t,t[0]];export let publish=(t,value)=>{let head=t[0]=t[0][0]=[null,value];for(let i=0,res=t[1];i<res.length;i++)res[i](head);t[1]=[]};export let flush=(t)=>{let head=t[0]=t[0][0]=[null,undefined];for(let i=0,res=t[1];i<res.length;i++)res[i](head);t[1]=[]};export let poll=(t)=>t[1][0]!==null?(t[1]=t[1][0])[1]:undefined;export let recieve=async(t)=>t[1][0]!==null?(t[1]=t[1][0])[1]:(t[1]=await new Promise((res)=>{t[0][1].push(res)}))[1];

package/fixed-queue.js

@@ -1 +0,0 @@
-export let init=(n)=>[new Array(n),n,-1,-1];