@rdfc/js-runner 2.0.0 → 3.0.0

package/lib/writer.js

@@ -2,14 +2,23 @@ import { promisify } from 'util';
 const encoder = new TextEncoder();
 export class WriterInstance {
     uri;
+    localSequenceNumber = 1;
     client;
-    write;
+    notifyOrchestrator;
     logger;
-    constructor(uri, client, write, logger) {
+    awaitingProcessed = [];
+    openStreams = 0;
+    shouldClose = [];
+    runnerId;
+    constructor(uri, client, notifyOrchestrator, runnerId, logger) {
         this.client = client;
-        this.write = write;
+        this.notifyOrchestrator = notifyOrchestrator;
         this.uri = uri;
         this.logger = logger;
+        this.runnerId = runnerId;
+    }
+    awaitProcessed() {
+        return new Promise((res) => this.awaitingProcessed.push(res));
     }
     async any(any) {
         if ('stream' in any) {
@@ -24,34 +33,78 @@ export class WriterInstance {
     }
     async buffer(buffer) {
         this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`);
-        await this.write({ msg: { data: buffer, channel: this.uri } });
+        const localSequenceNumber = this.localSequenceNumber++;
+        const handledPromise = this.awaitProcessed();
+        await this.notifyOrchestrator({
+            msg: { data: buffer, channel: this.uri, localSequenceNumber },
+        });
+        await handledPromise;
     }
     async stream(buffer, transform) {
+        this.openStreams += 1;
         const t = transform || ((x) => x);
         const stream = this.client.sendStreamMessage();
+        const handledPromise = this.awaitProcessed();
+        const writeStreamMessageChunk = promisify(stream.write.bind(stream));
+        const localSequenceNumber = this.localSequenceNumber++;
+        await writeStreamMessageChunk({
+            id: {
+                channel: this.uri,
+                localSequenceNumber,
+                runner: this.runnerId,
+            },
+        });
         const id = await new Promise((res) => stream.once('data', res));
-        this.logger.debug(`${this.uri} streams message with id ${id.id}`);
-        await this.write({ streamMsg: { id, channel: this.uri } });
-        const write = promisify(stream.write.bind(stream));
+        this.logger.debug(`${this.uri} streams message with id ${JSON.stringify(id)}`);
         for await (const msg of buffer) {
-            await write({ data: t(msg) });
+            const processedPromise = new Promise((res) => stream.once('data', res));
+            await writeStreamMessageChunk({ data: { data: t(msg) } });
+            await processedPromise;
         }
-        this.logger.debug(`${this.uri} is done streaming message with id ${id.id}`);
         stream.end();
+        await handledPromise;
+        this.openStreams -= 1;
+        if (this.shouldClose.length > 0)
+            await this.close();
     }
     async string(msg) {
         this.logger.debug(`${this.uri} sends string ${msg.length} characters`);
-        await this.write({
-            msg: { data: encoder.encode(msg), channel: this.uri },
+        const localSequenceNumber = this.localSequenceNumber++;
+        const handledPromise = this.awaitProcessed();
+        await this.notifyOrchestrator({
+            msg: {
+                data: encoder.encode(msg),
+                channel: this.uri,
+                localSequenceNumber,
+            },
         });
+        await handledPromise;
     }
     async close(issued = false) {
+        if (this.openStreams !== 0) {
+            await new Promise((resolve) => this.shouldClose.push(resolve));
+            return;
+        }
         this.logger.debug(`${this.uri} closes stream`);
         if (!issued) {
-            await this.write({
+            await this.notifyOrchestrator({
                 close: { channel: this.uri },
             });
         }
+        let resolve = this.shouldClose.pop();
+        while (resolve) {
+            resolve();
+            resolve = this.shouldClose.pop();
+        }
+    }
+    handled() {
+        if (this.awaitingProcessed.length > 0) {
+            this.awaitingProcessed.shift()();
+        }
+        else {
+            this.logger.error('Expected to be waiting for a message to be processed, but this is not the case ' +
+                this.uri);
+        }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writer.js","sourceRoot":"","sources":["../src/writer.ts"],"names":[],"mappings":"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","sourcesContent":["import { FromRunner, RunnerClient } from '@rdfc/proto'\nimport { promisify } from 'util'\nimport { Logger } from 'winston'\nimport { Any } from './reader'\n\ntype Writable = (msg: FromRunner) => Promise<unknown>\nexport interface Writer {\n  readonly uri: string\n  buffer(buffer: Uint8Array): Promise<void>\n\n  stream(buffer: AsyncIterable<Uint8Array>): Promise<void>\n  stream<T>(\n    buffer: AsyncIterable<T>,\n    transform: (x: T) => Uint8Array,\n  ): Promise<void>\n\n  string(buffer: string): Promise<void>\n  any(any: Any): Promise<void>\n  close(): Promise<void>\n}\nconst encoder = new TextEncoder()\nexport class WriterInstance implements Writer {\n  readonly uri: string\n  localSequenceNumber: number = 1\n  private readonly client: RunnerClient\n  private readonly notifyOrchestrator: Writable\n  private readonly logger: Logger\n\n  private awaitingProcessed: Array<() => void> = []\n\n  private openStreams: number = 0\n  private shouldClose: Array<() => void> = []\n\n  private readonly runnerId: string\n\n  constructor(\n    uri: string,\n    client: RunnerClient,\n    notifyOrchestrator: Writable,\n    runnerId: string,\n    logger: Logger,\n  ) {\n    this.client = client\n    this.notifyOrchestrator = notifyOrchestrator\n    this.uri = uri\n    this.logger = logger\n    this.runnerId = runnerId\n  }\n\n  private awaitProcessed(): Promise<void> {\n    return new Promise((res) => this.awaitingProcessed.push(res))\n  }\n\n  async any(any: Any): Promise<void> {\n    if ('stream' in any) {\n      await this.stream(any.stream)\n    }\n    if ('buffer' in any) {\n      await this.buffer(any.buffer)\n    }\n    if ('string' in any) {\n      await this.string(any.string)\n    }\n  }\n\n  async buffer(buffer: Uint8Array): Promise<void> {\n    this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`)\n    const localSequenceNumber = this.localSequenceNumber++\n    const handledPromise = this.awaitProcessed()\n\n    await this.notifyOrchestrator({\n      msg: { data: buffer, channel: this.uri, localSequenceNumber },\n    })\n    await handledPromise\n  }\n\n  async stream<T = Uint8Array>(\n    buffer: AsyncIterable<T>,\n    transform?: (x: T) => Uint8Array,\n  ) {\n    this.openStreams += 1\n    const t = transform || ((x: unknown) => <Uint8Array>x)\n    const stream = this.client.sendStreamMessage()\n\n    const handledPromise = this.awaitProcessed()\n    const writeStreamMessageChunk = promisify(stream.write.bind(stream))\n    const localSequenceNumber = this.localSequenceNumber++\n    await writeStreamMessageChunk({\n      id: {\n        channel: this.uri,\n        localSequenceNumber,\n        runner: this.runnerId,\n      },\n    })\n\n    const id = await new Promise((res) => stream.once('data', res))\n\n    this.logger.debug(\n      `${this.uri} streams message with id ${JSON.stringify(id)}`,\n    )\n\n    for await (const msg of buffer) {\n      const processedPromise = new Promise((res) => stream.once('data', res))\n      await writeStreamMessageChunk({ data: { data: t(msg) } })\n      // Await a message on the stream, indicating that the chunk has been processed\n      await processedPromise\n    }\n\n    stream.end()\n\n    await handledPromise\n\n    this.openStreams -= 1\n\n    if (this.shouldClose.length > 0) await this.close()\n  }\n\n  async string(msg: string): Promise<void> {\n    this.logger.debug(`${this.uri} sends string ${msg.length} characters`)\n    const localSequenceNumber = this.localSequenceNumber++\n    const handledPromise = this.awaitProcessed()\n\n    await this.notifyOrchestrator({\n      msg: {\n        data: encoder.encode(msg),\n        channel: this.uri,\n        localSequenceNumber,\n      },\n    })\n\n    await handledPromise\n  }\n\n  /**\n   * Gracefully closes this channel.\n   *\n   * Behavior:\n   * - If there are still active streams, closing is deferred until they complete.\n   * - If multiple callers invoke `close()` while waiting, their Promises are queued and\n   *   resolved once the channel actually closes.\n   * - If this side initiated the close (`issued = false`), a close message is sent to the remote.\n   *\n   * @param issued - If true, indicates the close request originated remotely\n   */\n  async close(issued = false): Promise<void> {\n    // Case 1: Active streams still running → wait until they finish\n    if (this.openStreams !== 0) {\n      await new Promise<void>((resolve) => this.shouldClose.push(resolve))\n      return\n    }\n\n    // Case 2: No active streams → perform actual close\n    this.logger.debug(`${this.uri} closes stream`)\n    if (!issued) {\n      await this.notifyOrchestrator({\n        close: { channel: this.uri },\n      })\n    }\n\n    let resolve = this.shouldClose.pop()\n    while (resolve) {\n      resolve()\n      resolve = this.shouldClose.pop()\n    }\n  }\n\n  /**\n   * A message is handled, let's notify the fifo {@link awaitProcessed}\n   */\n  handled(): void {\n    if (this.awaitingProcessed.length > 0) {\n      this.awaitingProcessed.shift()!()\n    } else {\n      this.logger.error(\n        'Expected to be waiting for a message to be processed, but this is not the case ' +\n          this.uri,\n      )\n    }\n  }\n}\n"]}

package/minimal.ttl

@@ -0,0 +1,99 @@
+@prefix prov: <http://www.w3.org/ns/prov#>.
+@prefix sds: <https://w3id.org/sds#>.
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+@prefix owl: <http://www.w3.org/2002/07/owl#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix sh: <http://www.w3.org/ns/shacl#>.
+@prefix rdfc: <https://w3id.org/rdf-connect#>.
+
+############################################################
+#                    General statements                    #
+############################################################
+# sds:Activity is a prov:Activity
+sds:Activity rdfs:subClassOf prov:Activity.
+
+# rdfc:Processor too
+rdfc:Processor rdfs:subClassOf sds:Activity.
+
+# sds:implementationOf is subClassOf
+sds:implementationOf rdfs:subPropertyOf rdfs:subClassOf.
+
+############################################################
+#                   Javascript statements                  #
+############################################################
+# specialized for js too
+rdfc:jsImplementationOf rdfs:subPropertyOf sds:implementationOf.
+
+# A node runner, runs things that are rdfc:jsImplementationOf rdfc:Processor  (aka, rdfs:subClassOf prov:Activity)
+rdfc:NodeRunner a rdfc:Runner;
+  rdfc:handlesSubjectsOf rdfc:jsImplementationOf;
+  rdfc:command "npx js-runner".
+
+# This shouldn't be necessary, should work with sh:targetSubjectsOf
+# rdfc:processor_definition <JsProcessorShape>.
+# 
+# Shape that a Js Processor should fulfil;
+[ ] a sh:NodeShape;
+  # This shouldn't be necessary,should work with sh:targetSubjectsOf and this isn't a real Class
+  sh:targetClass <JsProcessorShape>;
+  # We target it with jsImplementationOf
+  sh:targetSubjectsOf rdfc:jsImplementationOf;
+  sh:property [
+    sh:path rdfc:entrypoint;
+    sh:name "location";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:datatype xsd:iri;
+  ], [
+    sh:path rdfc:file;
+    sh:name "file";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:datatype xsd:iri;
+  ], [
+    sh:path rdfc:class;
+    sh:name "clazz";
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ].
+
+############################################################
+#                   Processor statements                   #
+############################################################
+rdfc:FooBarProcessor a owl:Class;
+  rdfs:label "My Epic FooBar Processor";
+  rdfs:description "FooBars everything!";
+  rdfc:jsImplementationOf rdfc:Processor;
+  rdfc:entrypoint <./>;
+  rdfc:file <./lib/processors.js>;
+  rdfc:class "FooBarProcessor".
+
+[ ] a sh:NodeShape;
+  sh:targetClass rdfc:FooBarProcessor;
+  sh:property [
+    sh:path rdfc:reader;
+    sh:name "reader";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:class rdfc:Reader;
+  ], [
+    sh:path rdfc:writer;
+    sh:name "writer";
+    sh:maxCount 1;
+    sh:class rdfc:Writer;
+  ].
+
+############################################################
+#                    Pipeline statements                   #
+############################################################
+<> a rdfc:Pipeline;
+  rdfc:consistsOf [
+    rdfc:instantiates rdfc:NodeRunner;
+    rdfc:processor <foobar>;
+  ].
+
+<incomingMessages> a rdfc:Reader, rdfc:Writer.
+<foobar> a rdfc:FooBarProcessor;
+  rdfc:reader <incomingMessages>;
+  rdfc:writer <incomingMessages>.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rdfc/js-runner",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "main": "lib/index.js",
   "type": "module",
   "scripts": {
@@ -31,6 +31,7 @@
   "devDependencies": {
     "@eslint/js": "^9.21.0",
     "@rdfjs/types": "^2.0.1",
+    "@grpc/grpc-js": "^1.12.6",
     "@types/jest": "^29.5.14",
     "@types/jsonld": "^1.5.15",
     "@types/n3": "^1.21.1",
@@ -53,8 +54,7 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@grpc/grpc-js": "^1.12.6",
-    "@rdfc/proto": "^0.1.2-alpha.1",
+    "@rdfc/proto": "^0.1.2",
     "@treecg/types": "^0.4.6",
     "jsonld": "^8.3.3",
     "jsonld-streaming-parser": "^5.0.0",

package/src/client.ts

@@ -1,14 +1,14 @@
 import * as grpc from '@grpc/grpc-js'
 import { promisify } from 'util'
-import { RunnerClient, RunnerMessage } from '@rdfc/proto'
-import winston from 'winston'
+import { RunnerClient, ToRunner } from '@rdfc/proto'
+import { createLogger } from 'winston'
 import { RpcTransport } from './logger'
 import { Runner } from './runner'
 
 export async function start(addr: string, uri: string) {
   const client = new RunnerClient(addr, grpc.credentials.createInsecure())
 
-  const logger = winston.createLogger({
+  const logger = createLogger({
     transports: [
       new RpcTransport({
         entities: [uri, 'cli'],
@@ -25,25 +25,22 @@ export async function start(addr: string, uri: string) {
 
   await writable({ identify: { uri } })
 
-  let processorsEnd!: (v: unknown) => unknown
-  const processorsEnded = new Promise((res) => (processorsEnd = res))
-  ;(async () => {
+  /* eslint-disable no-async-promise-executor */
+  await new Promise(async (res) => {
     for await (const chunk of stream) {
-      const msg: RunnerMessage = chunk
+      const msg: ToRunner = chunk
       if (msg.proc) {
         await runner.addProcessor(msg.proc)
       }
       if (msg.start) {
-        runner.start().then(processorsEnd)
+        runner.start().then(res)
       }
 
       await runner.handleOrchMessage(msg)
     }
 
     logger.error('Stream ended')
-  })()
-
-  await processorsEnded
+  })
 
   logger.info('All processors are finished')
   stream.end()

package/src/logger.ts

@@ -1,4 +1,4 @@
-import winston, { Logger } from 'winston'
+import { createLogger, LogEntry, Logger } from 'winston'
 import Transport from 'winston-transport'
 
 import * as grpc from '@grpc/grpc-js'
@@ -21,7 +21,7 @@ export class RpcTransport extends Transport {
     this.aliases = opts.aliases || []
   }
 
-  log(info: winston.LogEntry, callback: () => void) {
+  log(info: LogEntry, callback: () => void) {
     if (!this.stream.closed) {
       this.stream.write(
         {
@@ -55,7 +55,7 @@ export function extendLogger(baseLogger: Logger, newEntity: string): Logger {
     return t
   })
 
-  return winston.createLogger({
+  return createLogger({
     level: baseLogger.level,
     format: baseLogger.format,
     defaultMeta: baseLogger.defaultMeta,

package/src/reader.ts

@@ -1,6 +1,11 @@
 import { ClientReadableStream } from '@grpc/grpc-js'
-import { DataChunk, Message, RunnerClient, StreamMessage } from '@rdfc/proto'
-import winston from 'winston'
+import {
+  DataChunk,
+  ReceivingMessage,
+  ReceivingStreamMessage,
+  RunnerClient,
+} from '@rdfc/proto'
+import { Logger } from 'winston'
 import {
   AnyConvertor,
   Convertor,
@@ -8,6 +13,8 @@ import {
   StreamConvertor,
   StringConvertor,
 } from './convertor'
+import { Writable } from './runner'
+import { promisify } from 'util'
 
 export type Any =
   | {
@@ -28,41 +35,47 @@ export interface Reader {
   anys(): AsyncIterable<Any>
 }
 
+type Todo<T> = {
+  item: T
+  onComplete: () => void
+}
+
 class MyIter<T> implements AsyncIterable<T> {
   private convertor: Convertor<T>
-  private queue: (T | undefined)[] = []
+  private queue: Todo<T | undefined>[] = []
   private resolveNext: ((value: undefined) => void) | null = null
 
   constructor(convertor: Convertor<T>) {
     this.convertor = convertor
   }
 
-  push(buffer: Uint8Array) {
+  push(buffer: Uint8Array, onComplete: () => void) {
     const item = this.convertor.from(buffer)
-    this.queue.push(item)
+    this.queue.push({ item, onComplete })
     if (this.resolveNext) {
       this.resolveNext(undefined)
       this.resolveNext = null
     }
   }
 
-  close() {
-    this.queue.push(undefined)
+  close(onComplete: () => void) {
+    this.queue.push({ item: undefined, onComplete })
     if (this.resolveNext) {
       this.resolveNext(undefined)
       this.resolveNext = null
     }
   }
 
-  async pushStream(chunks: ClientReadableStream<DataChunk>) {
+  async pushStream(chunks: AsyncIterable<DataChunk>, onComplete: () => void) {
+    // This is an async generator that transforms DataChunks to Buffers
     const stream = (async function* (stream) {
-      for await (const c of stream) {
-        const chunk: DataChunk = c
+      for await (const chunk of stream) {
         yield chunk.data
       }
     })(chunks)
+
     const item = await this.convertor.fromStream(stream)
-    this.queue.push(item)
+    this.queue.push({ item, onComplete })
     if (this.resolveNext) {
       this.resolveNext(undefined)
       this.resolveNext = null
@@ -72,9 +85,15 @@ class MyIter<T> implements AsyncIterable<T> {
   async *[Symbol.asyncIterator]() {
     while (true) {
       if (this.queue.length > 0) {
-        const item = this.queue.shift()!
-        if (item === undefined) break
+        const { item, onComplete } = this.queue.shift()!
+        if (item === undefined) {
+          onComplete()
+          break
+        }
         yield item
+        // Note: execution pauses at `yield` until the consumer calls `.next()` again.
+        // We call onComplete *after* resuming, so the producer knows the item was actually consumed.
+        onComplete()
       } else {
         await new Promise<undefined>((resolve) => (this.resolveNext = resolve))
       }
@@ -85,58 +104,217 @@ class MyIter<T> implements AsyncIterable<T> {
 export class ReaderInstance implements Reader {
   private client: RunnerClient
   readonly uri: string
-  private logger: winston.Logger
+  private logger: Logger
+  private readonly notifyOrchestrator: Writable
 
-  private iterators: MyIter<unknown>[] = []
+  private consumers: MyIter<unknown>[] = []
 
-  constructor(uri: string, client: RunnerClient, logger: winston.Logger) {
+  constructor(
+    uri: string,
+    client: RunnerClient,
+    notifyOrchestrator: Writable,
+    logger: Logger,
+  ) {
     this.uri = uri
     this.client = client
     this.logger = logger
+    this.notifyOrchestrator = notifyOrchestrator
   }
 
   anys(): AsyncIterable<Any> {
     const iter = new MyIter(AnyConvertor)
-    this.iterators.push(iter)
+    this.consumers.push(iter)
     return iter
   }
 
   strings(): AsyncIterable<string> {
     const iter = new MyIter(StringConvertor)
-    this.iterators.push(iter)
+    this.consumers.push(iter)
     return iter
   }
 
   buffers(): AsyncIterable<Uint8Array> {
     const iter = new MyIter(NoConvertor)
-    this.iterators.push(iter)
+    this.consumers.push(iter)
     return iter
   }
 
   streams(): AsyncIterable<AsyncGenerator<Uint8Array>> {
     const iter = new MyIter(StreamConvertor)
-    this.iterators.push(iter)
+    this.consumers.push(iter)
     return iter
   }
 
-  handleMsg(msg: Message) {
+  handleMsg(msg: ReceivingMessage) {
     this.logger.debug(`${this.uri} handling message`)
-    for (const iter of this.iterators) {
-      iter.push(msg.data)
+
+    const promises = []
+    for (const iter of this.consumers) {
+      promises.push(new Promise((res) => iter.push(msg.data, () => res(null))))
     }
+
+    Promise.all(promises).then(() =>
+      this.notifyOrchestrator({
+        processed: {
+          globalSequenceNumber: msg.globalSequenceNumber,
+          channel: this.uri,
+        },
+      }),
+    )
   }
 
   close() {
-    for (const iter of this.iterators) {
-      iter.close()
+    for (const iter of this.consumers) {
+      iter.close(() => {})
     }
   }
 
-  handleStreamingMessage(msg: StreamMessage) {
+  // There is a stream message available for this reader
+  async handleStreamingMessage({
+    channel,
+    globalSequenceNumber,
+  }: ReceivingStreamMessage) {
     this.logger.debug(`${this.uri} handling streaming message`)
-    const chunks = this.client.receiveStreamMessage(msg.id!)
-    for (const iter of this.iterators) {
-      iter.pushStream(chunks)
+
+    const chunks = this.client.receiveStreamMessage()
+    const writeControlMessage = promisify(chunks.write.bind(chunks))
+    const consumersConsumed = []
+
+    // After each chunk is handled by all consumer, emit a processed message
+    let idx = 0
+    const messageIterators = fanoutStream(
+      chunks,
+      this.consumers.length,
+      async () => {
+        await writeControlMessage({ streamSequenceNumber: idx++ })
+      },
+    )
+
+    for (const consumer of this.consumers) {
+      consumersConsumed.push(
+        new Promise((res) =>
+          consumer.pushStream(messageIterators.pop()!, () => res(null)),
+        ),
+      )
+    }
+
+    await writeControlMessage({ globalSequenceNumber })
+
+    Promise.all(consumersConsumed).then(() => {
+      console.log('Writing processed for streaming message')
+      this.notifyOrchestrator({ processed: { globalSequenceNumber, channel } })
+    })
+  }
+}
+
+/**
+ * Helper function to tee a stream `numConsumers` times
+ * When each tee'd stream has handled a chunk, call {@link onAllHandled}
+ */
+function fanoutStream<T>(
+  stream: ClientReadableStream<T>,
+  numConsumers: number,
+  onAllHandled: () => void | Promise<void>,
+): AsyncIterable<T>[] {
+  type Waiter = (value: IteratorResult<T>) => void
+
+  let ended = false
+  const buffer: T[] = []
+  const pending: Waiter[] = []
+  let activeConsumers = numConsumers
+
+  // consumer bookkeeping
+  let awaitingAck = 0
+
+  function pushChunk(chunk: T) {
+    buffer.push(chunk)
+    flush()
+  }
+
+  function flush() {
+    while (buffer.length > 0 && pending.length > 0) {
+      const chunk = buffer[0] // keep until all consumers ack
+      const waiter = pending.shift()!
+      waiter({ value: chunk, done: false })
+      awaitingAck++
+    }
+  }
+
+  function end() {
+    ended = true
+    while (pending.length > 0) {
+      const waiter = pending.shift()!
+      waiter({ value: undefined, done: true })
     }
   }
+
+  stream.on('data', (chunk: T) => {
+    pushChunk(chunk)
+  })
+
+  stream.on('end', () => {
+    end()
+  })
+
+  stream.on('error', (err) => {
+    while (pending.length > 0) {
+      const waiter = pending.shift()!
+      waiter({ value: undefined, done: true })
+    }
+    throw err
+  })
+
+  function makeIterable(): AsyncIterable<T> {
+    return {
+      [Symbol.asyncIterator]() {
+        return {
+          next(): Promise<IteratorResult<T>> {
+            if (buffer.length > 0) {
+              const chunk = buffer[0]
+              awaitingAck++
+              return Promise.resolve({ value: chunk, done: false })
+            }
+            if (ended) {
+              return Promise.resolve({ value: undefined, done: true })
+            }
+            return new Promise((resolve) => {
+              pending.push(resolve)
+            })
+          },
+          async return() {
+            activeConsumers--
+            if (activeConsumers === 0) {
+              end()
+            }
+            return { value: undefined, done: true }
+          },
+        }
+      },
+    }
+  }
+
+  async function ack() {
+    awaitingAck--
+    if (awaitingAck === 0) {
+      // all consumers done with the current chunk
+      buffer.shift() // drop it
+      await onAllHandled()
+      flush() // continue with next chunk
+    }
+  }
+
+  // wrap consumer so they *must* call ack() after processing
+  function wrap(iterable: AsyncIterable<T>): AsyncIterable<T> {
+    return {
+      async *[Symbol.asyncIterator]() {
+        for await (const item of iterable) {
+          yield item
+          await ack()
+        }
+      },
+    }
+  }
+
+  const rawIterables = Array.from({ length: numConsumers }, makeIterable)
+  return rawIterables.map(wrap)
 }