@rdfc/js-runner 3.0.3 → 3.1.0

package/lib/writer.js

@@ -9,6 +9,9 @@ export class WriterInstance {
     awaitingProcessed = [];
     openStreams = 0;
     shouldClose = [];
+    closed = false;
+    _canceled = false;
+    cancelHandlers = new Set();
     runnerId;
     constructor(uri, client, notifyOrchestrator, runnerId, logger) {
         this.client = client;
@@ -17,8 +20,17 @@ export class WriterInstance {
         this.logger = logger;
         this.runnerId = runnerId;
     }
-    awaitProcessed() {
-        return new Promise((res) => this.awaitingProcessed.push(res));
+    get canceled() {
+        return this._canceled;
+    }
+    on(event, listener) {
+        if (event === 'cancel') {
+            this.cancelHandlers.add(listener);
+        }
+        return this;
+    }
+    cancellationError() {
+        return new Error(`Writer for channel ${this.uri} was canceled by the connected reader`);
     }
     async any(any) {
         if ('stream' in any) {
@@ -31,7 +43,16 @@ export class WriterInstance {
             await this.string(any.string);
         }
     }
+    assertCanWrite() {
+        if (this._canceled) {
+            throw this.cancellationError();
+        }
+        if (this.closed) {
+            throw new Error(`Writer for channel ${this.uri} is closed`);
+        }
+    }
     async buffer(buffer) {
+        this.assertCanWrite();
         this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`);
         const localSequenceNumber = this.localSequenceNumber++;
         const handledPromise = this.awaitProcessed();
@@ -41,33 +62,43 @@ export class WriterInstance {
         await handledPromise;
     }
     async stream(buffer, transform) {
+        this.assertCanWrite();
         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 ${JSON.stringify(id)}`);
-        for await (const msg of buffer) {
-            const processedPromise = new Promise((res) => stream.once('data', res));
-            await writeStreamMessageChunk({ data: { data: t(msg) } });
-            await processedPromise;
+        try {
+            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 ${JSON.stringify(id)}`);
+            for await (const msg of buffer) {
+                const processedPromise = new Promise((res) => stream.once('data', res));
+                await writeStreamMessageChunk({ data: { data: t(msg) } });
+                await processedPromise;
+            }
+            stream.end();
+            await handledPromise;
+        }
+        finally {
+            this.openStreams -= 1;
+            if (!stream.writableEnded) {
+                stream.end();
+            }
+            if (this.shouldClose.length > 0) {
+                await this.close();
+            }
         }
-        stream.end();
-        await handledPromise;
-        this.openStreams -= 1;
-        if (this.shouldClose.length > 0)
-            await this.close();
     }
     async string(msg) {
+        this.assertCanWrite();
         this.logger.debug(`${this.uri} sends string ${msg.length} characters`);
         const localSequenceNumber = this.localSequenceNumber++;
         const handledPromise = this.awaitProcessed();
@@ -81,6 +112,11 @@ export class WriterInstance {
         await handledPromise;
     }
     async close(issued = false) {
+        this.closed = true;
+        if (issued && !this._canceled) {
+            this._canceled = true;
+            await this.emitCancel();
+        }
         if (this.openStreams !== 0) {
             await new Promise((resolve) => this.shouldClose.push(resolve));
             return;
@@ -97,14 +133,35 @@ export class WriterInstance {
             resolve = this.shouldClose.pop();
         }
     }
-    handled() {
+    handled(error) {
         if (this.awaitingProcessed.length > 0) {
-            this.awaitingProcessed.shift()();
+            if (error) {
+                this.awaitingProcessed.shift().reject(new Error(error));
+            }
+            else {
+                this.awaitingProcessed.shift().resolve();
+            }
+        }
+        else if (this.closed || this._canceled) {
+            return;
         }
         else {
             this.logger.error('Expected to be waiting for a message to be processed, but this is not the case ' +
                 this.uri);
         }
     }
+    async emitCancel() {
+        await Promise.all(Array.from(this.cancelHandlers).map(async (handler) => {
+            try {
+                await handler();
+            }
+            catch (error) {
+                this.logger.error(`Cancel listener for channel ${this.uri} failed: ${String(error)}`);
+            }
+        }));
+    }
+    awaitProcessed() {
+        return new Promise((resolve, reject) => this.awaitingProcessed.push({ resolve, reject }));
+    }
 }
-//# 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"]}
+//# 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 type Handler<T = void> = [T] extends [void]\n  ? () => void | Promise<void>\n  : (value: T) => void | Promise<void>\n\nexport interface Writer {\n  readonly uri: string\n  readonly canceled: boolean\n  on(event: 'cancel', listener: Handler): this\n\n  /**\n   * Writes a complete buffer to the channel. The Promise resolves once the message is fully processed by the remote.\n   *\n   * @throws Error if the channel is closed or canceled at the moment of the write operation.\n   * @param buffer - The data to send as a Uint8Array\n   * @returns A Promise that resolves when the message is acknowledged as processed by the remote.\n   */\n  buffer(buffer: Uint8Array): Promise<void>\n\n  /**\n   * Writes a stream of data to a separate stream-specific channel.\n   * The Promise resolves once the entire stream is fully processed by the remote.\n   *\n   * @throws Error if the channel is closed or canceled at the moment of initiating a stream-specific channel.\n   * @param buffer - An AsyncIterable that produces the data to send as Uint8Arrays\n   * @returns A Promise that resolves when the entire stream is acknowledged as processed by the remote.\n   */\n  stream(buffer: AsyncIterable<Uint8Array>): Promise<void>\n\n  /**\n   * Writes a stream of data to a separate stream-specific channel.\n   * The Promise resolves once the entire stream is fully processed by the remote.\n   *\n   * @throws Error if the channel is closed or canceled at the moment of initiating a stream-specific channel.\n   * @param buffer - An AsyncIterable that produces the data to send, which will be transformed into Uint8Arrays using the provided transform function\n   * @param transform - A function that transforms items from the buffer AsyncIterable into Uint8Arrays for sending. If not provided, items are assumed to already be Uint8Arrays.\n   * @returns A Promise that resolves when the entire stream is acknowledged as processed by the remote.\n   */\n  stream<T>(\n    buffer: AsyncIterable<T>,\n    transform: (x: T) => Uint8Array,\n  ): Promise<void>\n\n  /**\n   * Writes a string message to the channel. The Promise resolves once the message is fully processed by the remote.\n   *\n   * @throws Error if the channel is closed or canceled at the moment of the write operation.\n   * @param buffer - The string message to send\n   * @returns A Promise that resolves when the message is acknowledged as processed by the remote.\n   */\n  string(buffer: string): Promise<void>\n\n  /**\n   * Writes a message of any supported type (string, buffer, or stream) to the channel.\n   * The Promise resolves once the message is fully processed by the remote.\n   *\n   * @throws Error if the channel is closed or canceled at the moment of the write operation.\n   * @param any - An object containing one of the supported message types (string, buffer, or stream)\n   * @returns A Promise that resolves when the message is acknowledged as processed by the remote.\n   */\n  any(any: Any): Promise<void>\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  close(issued?: boolean): 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  // FIFO of message-level acknowledgements coming back from the orchestrator.\n  private awaitingProcessed: Array<{\n    resolve: () => void\n    reject: (reason: Error) => void\n  }> = []\n\n  private openStreams: number = 0\n  // Close callers wait here while active streams are still flushing.\n  private shouldClose: Array<() => void> = []\n  private closed = false\n  private _canceled = false\n\n  // Processors can subscribe here to stop upstream work when downstream cancels.\n  private readonly cancelHandlers = new Set<Handler>()\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  get canceled(): boolean {\n    return this._canceled\n  }\n\n  on(event: 'cancel', listener: Handler): this {\n    if (event === 'cancel') {\n      this.cancelHandlers.add(listener)\n    }\n\n    return this\n  }\n\n  private cancellationError(): Error {\n    return new Error(\n      `Writer for channel ${this.uri} was canceled by the connected reader`,\n    )\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  private assertCanWrite() {\n    if (this._canceled) {\n      throw this.cancellationError()\n    }\n\n    if (this.closed) {\n      throw new Error(`Writer for channel ${this.uri} is closed`)\n    }\n  }\n\n  async buffer(buffer: Uint8Array): Promise<void> {\n    this.assertCanWrite()\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  ): Promise<void> {\n    this.assertCanWrite()\n    this.openStreams += 1\n    const t = transform || ((x: unknown) => <Uint8Array>x)\n    const stream = this.client.sendStreamMessage()\n\n    try {\n      // Message-level ack that signals the whole stream message is fully handled.\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      // First response confirms stream id registration on the remote side.\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      // TODO: don't await to allow consuming processors to read and handle in parallel.\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    } finally {\n      this.openStreams -= 1\n\n      if (!stream.writableEnded) {\n        stream.end()\n      }\n\n      // If a close call was deferred while streaming, complete it now.\n      if (this.shouldClose.length > 0) {\n        await this.close()\n      }\n    }\n  }\n\n  async string(msg: string): Promise<void> {\n    this.assertCanWrite()\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  async close(issued = false): Promise<void> {\n    this.closed = true\n    if (issued && !this._canceled) {\n      // Remote initiated close: mark writer canceled to fail future writes.\n      this._canceled = true\n\n      // Notify processors so they can stop producing upstream work as well.\n      await this.emitCancel()\n    }\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(error?: string): void {\n    if (this.awaitingProcessed.length > 0) {\n      if (error) {\n        this.awaitingProcessed.shift()!.reject(new Error(error))\n      } else {\n        this.awaitingProcessed.shift()!.resolve()\n      }\n    } else if (this.closed || this._canceled) {\n      // A late ack can arrive after a close/cancel race; nothing to resolve anymore.\n      return\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  private async emitCancel() {\n    await Promise.all(\n      Array.from(this.cancelHandlers).map(async (handler) => {\n        try {\n          await handler()\n        } catch (error: unknown) {\n          this.logger.error(\n            `Cancel listener for channel ${this.uri} failed: ${String(error)}`,\n          )\n        }\n      }),\n    )\n  }\n\n  private awaitProcessed(): Promise<void> {\n    return new Promise((resolve, reject) =>\n      this.awaitingProcessed.push({ resolve, reject }),\n    )\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rdfc/js-runner",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "main": "lib/index.js",
   "type": "module",
   "scripts": {
@@ -37,30 +37,30 @@
     "@rdfjs/types": "^2.0.1",
     "@types/jsonld": "^1.5.15",
     "@types/n3": "^1.26.1",
-    "@types/node": "^25.3.3",
-    "@typescript-eslint/eslint-plugin": "^8.56.1",
-    "@typescript-eslint/parser": "^8.56.1",
-    "@vitest/coverage-v8": "^4.0.18",
+    "@types/node": "^25.5.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.2",
+    "@typescript-eslint/parser": "^8.57.2",
+    "@vitest/coverage-v8": "^4.1.1",
     "eslint": "^10.0.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.5",
-    "globals": "^17.3.0",
+    "globals": "^17.4.0",
     "husky": "^9.1.7",
-    "lint-staged": "^16.3.0",
+    "lint-staged": "^16.4.0",
     "prettier": "^3.8.1",
     "tsc-alias": "^1.8.16",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.56.1",
-    "vitest": "^4.0.18"
+    "typescript-eslint": "^8.57.2",
+    "vitest": "^4.1.1"
   },
   "dependencies": {
     "@grpc/grpc-js": "^1.14.3",
-    "@rdfc/proto": "^0.1.2",
+    "@rdfc/proto": "^0.1.3",
     "@treecg/types": "^0.4.6",
     "jsonld": "^9.0.0",
     "jsonld-streaming-parser": "^5.0.1",
-    "n3": "^2.0.1",
-    "rdf-lens": "^1.3.6",
+    "n3": "^2.0.3",
+    "rdf-lens": "^1.3.7",
     "winston": "^3.19.0",
     "winston-transport": "^4.9.0"
   }

package/src/reader.ts

@@ -33,6 +33,7 @@ export interface Reader {
   streams(): AsyncIterable<AsyncGenerator<Uint8Array>>
   buffers(): AsyncIterable<Uint8Array>
   anys(): AsyncIterable<Any>
+  cancel(): Promise<void>
 }
 
 type Todo<T> = {
@@ -44,12 +45,18 @@ class MyIter<T> implements AsyncIterable<T> {
   private convertor: Convertor<T>
   private queue: Todo<T | undefined>[] = []
   private resolveNext: ((value: undefined) => void) | null = null
+  private closed = false
 
   constructor(convertor: Convertor<T>) {
     this.convertor = convertor
   }
 
   push(buffer: Uint8Array, onComplete: () => void) {
+    if (this.closed) {
+      onComplete()
+      return
+    }
+
     const item = this.convertor.from(buffer)
     this.queue.push({ item, onComplete })
     if (this.resolveNext) {
@@ -59,6 +66,12 @@ class MyIter<T> implements AsyncIterable<T> {
   }
 
   close(onComplete: () => void) {
+    if (this.closed) {
+      onComplete()
+      return
+    }
+
+    this.closed = true
     this.queue.push({ item: undefined, onComplete })
     if (this.resolveNext) {
       this.resolveNext(undefined)
@@ -67,6 +80,11 @@ class MyIter<T> implements AsyncIterable<T> {
   }
 
   async pushStream(chunks: AsyncIterable<DataChunk>, onComplete: () => void) {
+    if (this.closed) {
+      onComplete()
+      return
+    }
+
     // This is an async generator that transforms DataChunks to Buffers
     const stream = (async function* (stream) {
       for await (const chunk of stream) {
@@ -108,6 +126,8 @@ export class ReaderInstance implements Reader {
   private readonly notifyOrchestrator: Writable
 
   private consumers: MyIter<unknown>[] = []
+  private closed = false
+  private canceled = false
 
   constructor(
     uri: string,
@@ -148,6 +168,18 @@ export class ReaderInstance implements Reader {
   handleMsg(msg: ReceivingMessage) {
     this.logger.debug(`${this.uri} handling message`)
 
+    if (this.closed) {
+      this.notifyOrchestrator({
+        processed: {
+          globalSequenceNumber: msg.globalSequenceNumber,
+          channel: this.uri,
+          error:
+            'reader is canceled; message has not been processed by the processor',
+        },
+      })
+      return
+    }
+
     const promises = []
     for (const iter of this.consumers) {
       promises.push(new Promise((res) => iter.push(msg.data, () => res(null))))
@@ -164,11 +196,28 @@ export class ReaderInstance implements Reader {
   }
 
   close() {
+    if (this.closed) {
+      return
+    }
+
+    this.closed = true
     for (const iter of this.consumers) {
       iter.close(() => {})
     }
   }
 
+  async cancel(): Promise<void> {
+    if (this.canceled) {
+      return
+    }
+
+    this.canceled = true
+    this.close()
+    await this.notifyOrchestrator({
+      close: { channel: this.uri },
+    })
+  }
+
   // There is a stream message available for this reader
   async handleStreamingMessage({
     channel,
@@ -176,6 +225,13 @@ export class ReaderInstance implements Reader {
   }: ReceivingStreamMessage) {
     this.logger.debug(`${this.uri} handling streaming message`)
 
+    if (this.closed) {
+      await this.notifyOrchestrator({
+        processed: { globalSequenceNumber, channel },
+      })
+      return
+    }
+
     const chunks = this.client.receiveStreamMessage()
     const writeControlMessage = promisify(chunks.write.bind(chunks))
     const consumersConsumed = []

package/src/runner.ts

@@ -260,7 +260,7 @@ export class Runner {
   private handleProcessed(processed: LocalAck) {
     const writer = this.writers[processed.channel]
     if (writer) {
-      writer.handled()
+      writer.handled(processed.error)
     } else {
       this.logger.error(
         `Received processed message for channel ${processed.channel}, but no writer was present.`,

package/src/testUtils/index.ts

@@ -83,9 +83,13 @@ export class OrchestratorMock {
     // Always bounce processed msgs back to the runner
     connectStream.register(
       (msg) => msg.processed,
-      ({ channel, globalSequenceNumber }, send) => {
+      ({ channel, globalSequenceNumber, error }, send) => {
         send({
-          processed: { channel, localSequenceNumber: globalSequenceNumber },
+          processed: {
+            channel,
+            localSequenceNumber: globalSequenceNumber,
+            error,
+          },
         })
       },
     )