@rdfc/js-runner 3.1.0-alpha.1 → 3.1.0

package/lib/writer.js

@@ -11,7 +11,6 @@ export class WriterInstance {
     shouldClose = [];
     closed = false;
     _canceled = false;
-    cancelSignal = new AbortController();
     cancelHandlers = new Set();
     runnerId;
     constructor(uri, client, notifyOrchestrator, runnerId, logger) {
@@ -33,51 +32,6 @@ export class WriterInstance {
     cancellationError() {
         return new Error(`Writer for channel ${this.uri} was canceled by the connected reader`);
     }
-    emitCancel() {
-        for (const handler of this.cancelHandlers) {
-            try {
-                Promise.resolve(handler()).catch((error) => {
-                    this.logger.error(`Cancel listener for channel ${this.uri} failed: ${String(error)}`);
-                });
-            }
-            catch (error) {
-                this.logger.error(`Cancel listener for channel ${this.uri} failed: ${String(error)}`);
-            }
-        }
-    }
-    assertCanWrite() {
-        if (this._canceled) {
-            throw this.cancellationError();
-        }
-        if (this.closed) {
-            throw new Error(`Writer for channel ${this.uri} is closed`);
-        }
-    }
-    async raceWithCancellation(promise) {
-        this.assertCanWrite();
-        return await new Promise((resolve, reject) => {
-            const onAbort = () => reject(this.cancellationError());
-            this.cancelSignal.signal.addEventListener('abort', onAbort, {
-                once: true,
-            });
-            promise.then((value) => {
-                this.cancelSignal.signal.removeEventListener('abort', onAbort);
-                resolve(value);
-            }, (error) => {
-                this.cancelSignal.signal.removeEventListener('abort', onAbort);
-                reject(error);
-            });
-        });
-    }
-    rejectPendingProcessed(error) {
-        while (this.awaitingProcessed.length > 0) {
-            this.awaitingProcessed.shift().reject(error);
-        }
-    }
-    awaitProcessed() {
-        this.assertCanWrite();
-        return new Promise((resolve, reject) => this.awaitingProcessed.push({ resolve, reject }));
-    }
     async any(any) {
         if ('stream' in any) {
             await this.stream(any.stream);
@@ -89,6 +43,14 @@ 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`);
@@ -115,7 +77,7 @@ export class WriterInstance {
                     runner: this.runnerId,
                 },
             });
-            const id = await this.raceWithCancellation(new Promise((res) => stream.once('data', res)));
+            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));
@@ -150,43 +112,35 @@ export class WriterInstance {
         await handledPromise;
     }
     async close(issued = false) {
-        if (issued) {
-            if (!this.closed) {
-                this._canceled = true;
-                this.emitCancel();
-            }
-            this.closed = true;
-            const cancelError = this.cancellationError();
-            this.rejectPendingProcessed(cancelError);
-            this.cancelSignal.abort(cancelError);
-            let waiting = this.shouldClose.pop();
-            while (waiting) {
-                waiting();
-                waiting = this.shouldClose.pop();
-            }
-            return;
-        }
-        if (this.closed) {
-            return;
+        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;
         }
         this.logger.debug(`${this.uri} closes stream`);
-        this.closed = true;
-        await this.notifyOrchestrator({
-            close: { channel: this.uri },
-        });
+        if (!issued) {
+            await this.notifyOrchestrator({
+                close: { channel: this.uri },
+            });
+        }
         let resolve = this.shouldClose.pop();
         while (resolve) {
             resolve();
             resolve = this.shouldClose.pop();
         }
     }
-    handled() {
+    handled(error) {
         if (this.awaitingProcessed.length > 0) {
-            this.awaitingProcessed.shift().resolve();
+            if (error) {
+                this.awaitingProcessed.shift().reject(new Error(error));
+            }
+            else {
+                this.awaitingProcessed.shift().resolve();
+            }
         }
         else if (this.closed || this._canceled) {
             return;
@@ -196,5 +150,18 @@ export class WriterInstance {
                 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 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  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  // 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  // Shared cancellation signal to abort in-flight waits when the remote closes.\n  private readonly cancelSignal = new AbortController()\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  private emitCancel() {\n    for (const handler of this.cancelHandlers) {\n      try {\n        Promise.resolve(handler()).catch((error: unknown) => {\n          this.logger.error(\n            `Cancel listener for channel ${this.uri} failed: ${String(error)}`,\n          )\n        })\n      } catch (error: unknown) {\n        this.logger.error(\n          `Cancel listener for channel ${this.uri} failed: ${String(error)}`,\n        )\n      }\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  private async raceWithCancellation<T>(promise: Promise<T>): Promise<T> {\n    this.assertCanWrite()\n\n    return await new Promise<T>((resolve, reject) => {\n      const onAbort = () => reject(this.cancellationError())\n      this.cancelSignal.signal.addEventListener('abort', onAbort, {\n        once: true,\n      })\n\n      promise.then(\n        (value) => {\n          // Clean up the abort listener if the original operation finished first.\n          this.cancelSignal.signal.removeEventListener('abort', onAbort)\n          resolve(value)\n        },\n        (error) => {\n          this.cancelSignal.signal.removeEventListener('abort', onAbort)\n          reject(error)\n        },\n      )\n    })\n  }\n\n  private rejectPendingProcessed(error: Error) {\n    // Reject all queued message waits so callers do not hang during cancellation.\n    while (this.awaitingProcessed.length > 0) {\n      this.awaitingProcessed.shift()!.reject(error)\n    }\n  }\n\n  private awaitProcessed(): Promise<void> {\n    this.assertCanWrite()\n    return new Promise((resolve, reject) =>\n      this.awaitingProcessed.push({ resolve, reject }),\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  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  ) {\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 this.raceWithCancellation(\n        new Promise((res) => stream.once('data', res)),\n      )\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    } 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  /**\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    if (issued) {\n      if (!this.closed) {\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        this.emitCancel()\n      }\n      this.closed = true\n\n      const cancelError = this.cancellationError()\n      this.rejectPendingProcessed(cancelError)\n      this.cancelSignal.abort(cancelError)\n\n      // Unblock any local close() callers waiting for streams to settle.\n      let waiting = this.shouldClose.pop()\n      while (waiting) {\n        waiting()\n        waiting = this.shouldClose.pop()\n      }\n      return\n    }\n\n    if (this.closed) {\n      return\n    }\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    this.closed = true\n    await this.notifyOrchestrator({\n      close: { channel: this.uri },\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()!.resolve()\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writer.js","sourceRoot":"","sources":["../src/writer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAA;AA+EhC,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAA;AACjC,MAAM,OAAO,cAAc;IAChB,GAAG,CAAQ;IACpB,mBAAmB,GAAW,CAAC,CAAA;IACd,MAAM,CAAc;IACpB,kBAAkB,CAAU;IAC5B,MAAM,CAAQ;IAGvB,iBAAiB,GAGpB,EAAE,CAAA;IAEC,WAAW,GAAW,CAAC,CAAA;IAEvB,WAAW,GAAsB,EAAE,CAAA;IACnC,MAAM,GAAG,KAAK,CAAA;IACd,SAAS,GAAG,KAAK,CAAA;IAGR,cAAc,GAAG,IAAI,GAAG,EAAW,CAAA;IAEnC,QAAQ,CAAQ;IAEjC,YACE,GAAW,EACX,MAAoB,EACpB,kBAA4B,EAC5B,QAAgB,EAChB,MAAc;QAEd,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAA;QAC5C,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;QACd,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;IAC1B,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAA;IACvB,CAAC;IAED,EAAE,CAAC,KAAe,EAAE,QAAiB;QACnC,IAAI,KAAK,KAAK,QAAQ,EAAE,CAAC;YACvB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QACnC,CAAC;QAED,OAAO,IAAI,CAAA;IACb,CAAC;IAEO,iBAAiB;QACvB,OAAO,IAAI,KAAK,CACd,sBAAsB,IAAI,CAAC,GAAG,uCAAuC,CACtE,CAAA;IACH,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,GAAQ;QAChB,IAAI,QAAQ,IAAI,GAAG,EAAE,CAAC;YACpB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QAC/B,CAAC;QACD,IAAI,QAAQ,IAAI,GAAG,EAAE,CAAC;YACpB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QAC/B,CAAC;QACD,IAAI,QAAQ,IAAI,GAAG,EAAE,CAAC;YACpB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QAC/B,CAAC;IACH,CAAC;IAEO,cAAc;QACpB,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAA;QAChC,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CAAC,sBAAsB,IAAI,CAAC,GAAG,YAAY,CAAC,CAAA;QAC7D,CAAC;IACH,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,MAAkB;QAC7B,IAAI,CAAC,cAAc,EAAE,CAAA;QACrB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,iBAAiB,MAAM,CAAC,MAAM,QAAQ,CAAC,CAAA;QACpE,MAAM,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAA;QACtD,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QAE5C,MAAM,IAAI,CAAC,kBAAkB,CAAC;YAC5B,GAAG,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,mBAAmB,EAAE;SAC9D,CAAC,CAAA;QACF,MAAM,cAAc,CAAA;IACtB,CAAC;IAED,KAAK,CAAC,MAAM,CACV,MAAwB,EACxB,SAAgC;QAEhC,IAAI,CAAC,cAAc,EAAE,CAAA;QACrB,IAAI,CAAC,WAAW,IAAI,CAAC,CAAA;QACrB,MAAM,CAAC,GAAG,SAAS,IAAI,CAAC,CAAC,CAAU,EAAE,EAAE,CAAa,CAAC,CAAC,CAAA;QACtD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAA;QAE9C,IAAI,CAAC;YAEH,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;YAC5C,MAAM,uBAAuB,GAAG,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;YACpE,MAAM,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAA;YACtD,MAAM,uBAAuB,CAAC;gBAC5B,EAAE,EAAE;oBACF,OAAO,EAAE,IAAI,CAAC,GAAG;oBACjB,mBAAmB;oBACnB,MAAM,EAAE,IAAI,CAAC,QAAQ;iBACtB;aACF,CAAC,CAAA;YAGF,MAAM,EAAE,GAAG,MAAM,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAA;YAE/D,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,GAAG,IAAI,CAAC,GAAG,4BAA4B,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAC5D,CAAA;YAGD,IAAI,KAAK,EAAE,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;gBAC/B,MAAM,gBAAgB,GAAG,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAA;gBACvE,MAAM,uBAAuB,CAAC,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAA;gBAEzD,MAAM,gBAAgB,CAAA;YACxB,CAAC;YAED,MAAM,CAAC,GAAG,EAAE,CAAA;YAEZ,MAAM,cAAc,CAAA;QACtB,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,WAAW,IAAI,CAAC,CAAA;YAErB,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;gBAC1B,MAAM,CAAC,GAAG,EAAE,CAAA;YACd,CAAC;YAGD,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAChC,MAAM,IAAI,CAAC,KAAK,EAAE,CAAA;YACpB,CAAC;QACH,CAAC;IACH,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,GAAW;QACtB,IAAI,CAAC,cAAc,EAAE,CAAA;QACrB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,iBAAiB,GAAG,CAAC,MAAM,aAAa,CAAC,CAAA;QACtE,MAAM,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAA;QACtD,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QAE5C,MAAM,IAAI,CAAC,kBAAkB,CAAC;YAC5B,GAAG,EAAE;gBACH,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC;gBACzB,OAAO,EAAE,IAAI,CAAC,GAAG;gBACjB,mBAAmB;aACpB;SACF,CAAC,CAAA;QAEF,MAAM,cAAc,CAAA;IACtB,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,KAAK;QACxB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAA;QAClB,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YAE9B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;YAGrB,MAAM,IAAI,CAAC,UAAU,EAAE,CAAA;QACzB,CAAC;QAED,IAAI,IAAI,CAAC,WAAW,KAAK,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;YACpE,OAAM;QACR,CAAC;QAGD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,gBAAgB,CAAC,CAAA;QAC9C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,CAAC,kBAAkB,CAAC;gBAC5B,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE;aAC7B,CAAC,CAAA;QACJ,CAAC;QAED,IAAI,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAA;QACpC,OAAO,OAAO,EAAE,CAAC;YACf,OAAO,EAAE,CAAA;YACT,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAA;QAClC,CAAC;IACH,CAAC;IAKD,OAAO,CAAC,KAAc;QACpB,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtC,IAAI,KAAK,EAAE,CAAC;gBACV,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAG,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAA;YAC1D,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAG,CAAC,OAAO,EAAE,CAAA;YAC3C,CAAC;QACH,CAAC;aAAM,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAEzC,OAAM;QACR,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,iFAAiF;gBAC/E,IAAI,CAAC,GAAG,CACX,CAAA;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,UAAU;QACtB,MAAM,OAAO,CAAC,GAAG,CACf,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YACpD,IAAI,CAAC;gBACH,MAAM,OAAO,EAAE,CAAA;YACjB,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,+BAA+B,IAAI,CAAC,GAAG,YAAY,MAAM,CAAC,KAAK,CAAC,EAAE,CACnE,CAAA;YACH,CAAC;QACH,CAAC,CAAC,CACH,CAAA;IACH,CAAC;IAEO,cAAc;QACpB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CACrC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CACjD,CAAA;IACH,CAAC;CACF","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.1.0-alpha.1",
+  "version": "3.1.0",
   "main": "lib/index.js",
   "type": "module",
   "scripts": {
@@ -55,7 +55,7 @@
   },
   "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",

package/src/reader.ts

@@ -173,6 +173,8 @@ export class ReaderInstance implements Reader {
         processed: {
           globalSequenceNumber: msg.globalSequenceNumber,
           channel: this.uri,
+          error:
+            'reader is canceled; message has not been processed by the processor',
         },
       })
       return

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,
+          },
         })
       },
     )

package/src/writer.ts

@@ -12,17 +12,71 @@ export interface Writer {
   readonly uri: string
   readonly canceled: boolean
   on(event: 'cancel', listener: Handler): this
+
+  /**
+   * Writes a complete buffer to the channel. The Promise resolves once the message is fully processed by the remote.
+   *
+   * @throws Error if the channel is closed or canceled at the moment of the write operation.
+   * @param buffer - The data to send as a Uint8Array
+   * @returns A Promise that resolves when the message is acknowledged as processed by the remote.
+   */
   buffer(buffer: Uint8Array): Promise<void>
 
+  /**
+   * Writes a stream of data to a separate stream-specific channel.
+   * The Promise resolves once the entire stream is fully processed by the remote.
+   *
+   * @throws Error if the channel is closed or canceled at the moment of initiating a stream-specific channel.
+   * @param buffer - An AsyncIterable that produces the data to send as Uint8Arrays
+   * @returns A Promise that resolves when the entire stream is acknowledged as processed by the remote.
+   */
   stream(buffer: AsyncIterable<Uint8Array>): Promise<void>
+
+  /**
+   * Writes a stream of data to a separate stream-specific channel.
+   * The Promise resolves once the entire stream is fully processed by the remote.
+   *
+   * @throws Error if the channel is closed or canceled at the moment of initiating a stream-specific channel.
+   * @param buffer - An AsyncIterable that produces the data to send, which will be transformed into Uint8Arrays using the provided transform function
+   * @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.
+   * @returns A Promise that resolves when the entire stream is acknowledged as processed by the remote.
+   */
   stream<T>(
     buffer: AsyncIterable<T>,
     transform: (x: T) => Uint8Array,
   ): Promise<void>
 
+  /**
+   * Writes a string message to the channel. The Promise resolves once the message is fully processed by the remote.
+   *
+   * @throws Error if the channel is closed or canceled at the moment of the write operation.
+   * @param buffer - The string message to send
+   * @returns A Promise that resolves when the message is acknowledged as processed by the remote.
+   */
   string(buffer: string): Promise<void>
+
+  /**
+   * Writes a message of any supported type (string, buffer, or stream) to the channel.
+   * The Promise resolves once the message is fully processed by the remote.
+   *
+   * @throws Error if the channel is closed or canceled at the moment of the write operation.
+   * @param any - An object containing one of the supported message types (string, buffer, or stream)
+   * @returns A Promise that resolves when the message is acknowledged as processed by the remote.
+   */
   any(any: Any): Promise<void>
-  close(): Promise<void>
+
+  /**
+   * Gracefully closes this channel.
+   *
+   * Behavior:
+   * - If there are still active streams, closing is deferred until they complete.
+   * - If multiple callers invoke `close()` while waiting, their Promises are queued and
+   *   resolved once the channel actually closes.
+   * - If this side initiated the close (`issued = false`), a close message is sent to the remote.
+   *
+   * @param issued - If true, indicates the close request originated remotely
+   */
+  close(issued?: boolean): Promise<void>
 }
 const encoder = new TextEncoder()
 export class WriterInstance implements Writer {
@@ -44,8 +98,6 @@ export class WriterInstance implements Writer {
   private closed = false
   private _canceled = false
 
-  // Shared cancellation signal to abort in-flight waits when the remote closes.
-  private readonly cancelSignal = new AbortController()
   // Processors can subscribe here to stop upstream work when downstream cancels.
   private readonly cancelHandlers = new Set<Handler>()
 
@@ -83,19 +135,15 @@ export class WriterInstance implements Writer {
     )
   }
 
-  private emitCancel() {
-    for (const handler of this.cancelHandlers) {
-      try {
-        Promise.resolve(handler()).catch((error: unknown) => {
-          this.logger.error(
-            `Cancel listener for channel ${this.uri} failed: ${String(error)}`,
-          )
-        })
-      } catch (error: unknown) {
-        this.logger.error(
-          `Cancel listener for channel ${this.uri} failed: ${String(error)}`,
-        )
-      }
+  async any(any: Any): Promise<void> {
+    if ('stream' in any) {
+      await this.stream(any.stream)
+    }
+    if ('buffer' in any) {
+      await this.buffer(any.buffer)
+    }
+    if ('string' in any) {
+      await this.string(any.string)
     }
   }
 
@@ -109,55 +157,6 @@ export class WriterInstance implements Writer {
     }
   }
 
-  private async raceWithCancellation<T>(promise: Promise<T>): Promise<T> {
-    this.assertCanWrite()
-
-    return await new Promise<T>((resolve, reject) => {
-      const onAbort = () => reject(this.cancellationError())
-      this.cancelSignal.signal.addEventListener('abort', onAbort, {
-        once: true,
-      })
-
-      promise.then(
-        (value) => {
-          // Clean up the abort listener if the original operation finished first.
-          this.cancelSignal.signal.removeEventListener('abort', onAbort)
-          resolve(value)
-        },
-        (error) => {
-          this.cancelSignal.signal.removeEventListener('abort', onAbort)
-          reject(error)
-        },
-      )
-    })
-  }
-
-  private rejectPendingProcessed(error: Error) {
-    // Reject all queued message waits so callers do not hang during cancellation.
-    while (this.awaitingProcessed.length > 0) {
-      this.awaitingProcessed.shift()!.reject(error)
-    }
-  }
-
-  private awaitProcessed(): Promise<void> {
-    this.assertCanWrite()
-    return new Promise((resolve, reject) =>
-      this.awaitingProcessed.push({ resolve, reject }),
-    )
-  }
-
-  async any(any: Any): Promise<void> {
-    if ('stream' in any) {
-      await this.stream(any.stream)
-    }
-    if ('buffer' in any) {
-      await this.buffer(any.buffer)
-    }
-    if ('string' in any) {
-      await this.string(any.string)
-    }
-  }
-
   async buffer(buffer: Uint8Array): Promise<void> {
     this.assertCanWrite()
     this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`)
@@ -173,7 +172,7 @@ export class WriterInstance implements Writer {
   async stream<T = Uint8Array>(
     buffer: AsyncIterable<T>,
     transform?: (x: T) => Uint8Array,
-  ) {
+  ): Promise<void> {
     this.assertCanWrite()
     this.openStreams += 1
     const t = transform || ((x: unknown) => <Uint8Array>x)
@@ -193,14 +192,13 @@ export class WriterInstance implements Writer {
       })
 
       // First response confirms stream id registration on the remote side.
-      const id = await this.raceWithCancellation(
-        new Promise((res) => stream.once('data', res)),
-      )
+      const id = await new Promise((res) => stream.once('data', res))
 
       this.logger.debug(
         `${this.uri} streams message with id ${JSON.stringify(id)}`,
       )
 
+      // TODO: don't await to allow consuming processors to read and handle in parallel.
       for await (const msg of buffer) {
         const processedPromise = new Promise((res) => stream.once('data', res))
         await writeStreamMessageChunk({ data: { data: t(msg) } })
@@ -242,45 +240,15 @@ export class WriterInstance implements Writer {
     await handledPromise
   }
 
-  /**
-   * Gracefully closes this channel.
-   *
-   * Behavior:
-   * - If there are still active streams, closing is deferred until they complete.
-   * - If multiple callers invoke `close()` while waiting, their Promises are queued and
-   *   resolved once the channel actually closes.
-   * - If this side initiated the close (`issued = false`), a close message is sent to the remote.
-   *
-   * @param issued - If true, indicates the close request originated remotely
-   */
   async close(issued = false): Promise<void> {
-    if (issued) {
-      if (!this.closed) {
-        // Remote initiated close: mark writer canceled to fail future writes.
-        this._canceled = true
-
-        // Notify processors so they can stop producing upstream work as well.
-        this.emitCancel()
-      }
-      this.closed = true
-
-      const cancelError = this.cancellationError()
-      this.rejectPendingProcessed(cancelError)
-      this.cancelSignal.abort(cancelError)
+    this.closed = true
+    if (issued && !this._canceled) {
+      // Remote initiated close: mark writer canceled to fail future writes.
+      this._canceled = true
 
-      // Unblock any local close() callers waiting for streams to settle.
-      let waiting = this.shouldClose.pop()
-      while (waiting) {
-        waiting()
-        waiting = this.shouldClose.pop()
-      }
-      return
+      // Notify processors so they can stop producing upstream work as well.
+      await this.emitCancel()
     }
-
-    if (this.closed) {
-      return
-    }
-
     // Case 1: Active streams still running → wait until they finish
     if (this.openStreams !== 0) {
       await new Promise<void>((resolve) => this.shouldClose.push(resolve))
@@ -289,10 +257,11 @@ export class WriterInstance implements Writer {
 
     // Case 2: No active streams → perform actual close
     this.logger.debug(`${this.uri} closes stream`)
-    this.closed = true
-    await this.notifyOrchestrator({
-      close: { channel: this.uri },
-    })
+    if (!issued) {
+      await this.notifyOrchestrator({
+        close: { channel: this.uri },
+      })
+    }
 
     let resolve = this.shouldClose.pop()
     while (resolve) {
@@ -304,9 +273,13 @@ export class WriterInstance implements Writer {
   /**
    * A message is handled, let's notify the fifo {@link awaitProcessed}
    */
-  handled(): void {
+  handled(error?: string): void {
     if (this.awaitingProcessed.length > 0) {
-      this.awaitingProcessed.shift()!.resolve()
+      if (error) {
+        this.awaitingProcessed.shift()!.reject(new Error(error))
+      } else {
+        this.awaitingProcessed.shift()!.resolve()
+      }
     } else if (this.closed || this._canceled) {
       // A late ack can arrive after a close/cancel race; nothing to resolve anymore.
       return
@@ -317,4 +290,24 @@ export class WriterInstance implements Writer {
       )
     }
   }
+
+  private async emitCancel() {
+    await Promise.all(
+      Array.from(this.cancelHandlers).map(async (handler) => {
+        try {
+          await handler()
+        } catch (error: unknown) {
+          this.logger.error(
+            `Cancel listener for channel ${this.uri} failed: ${String(error)}`,
+          )
+        }
+      }),
+    )
+  }
+
+  private awaitProcessed(): Promise<void> {
+    return new Promise((resolve, reject) =>
+      this.awaitingProcessed.push({ resolve, reject }),
+    )
+  }
 }

package/dist/args.d.ts

@@ -1,4 +0,0 @@
-export type Args = {
-  input: string
-}
-export declare function getArgs(): Args