@zlink-systems/framework 0.10.0 → 0.12.0

package/dist/runtime/spots/spot-timer.js

@@ -59,7 +59,9 @@ class ZLinkSpotTimerRegistry {
             : undefined;
         if (this.executionBarrier !== undefined)
             executionSerial?.setExecutionBarrier(this.executionBarrier);
+        let callbackStarted = false;
         const timer = startOutsideStateLane(() => new ZLinkManagedTimer(name, periodMs, normalizeTimerOptions(options), async (tick) => {
+            callbackStarted = false;
             const timerFlow = (0, flow_context_1.createInboundFlow)(undefined, 'Timer', this.flowCreationEnabled());
             const operation = () => {
                 const current = this.timers.get(name);
@@ -68,6 +70,7 @@ class ZLinkSpotTimerRegistry {
                 }
                 if (!this.executionAllowed())
                     return undefined;
+                callbackStarted = true;
                 return (0, flow_context_1.runWithFlow)(timerFlow, () => handler.handle(spot, tick));
             };
             if (this.executeTimer !== undefined) {
@@ -76,9 +79,7 @@ class ZLinkSpotTimerRegistry {
             else {
                 await executionSerial.execute(operation);
             }
-        }, reportFailure, () => this.executeTimer === undefined
-            ? !executionSerial.isExecuting
-            : this.isTimerExecuting?.(name) !== true, this.clock));
+        }, reportFailure, () => callbackStarted, this.clock));
         const registered = await this.lane.run(() => this.completeAddCore(name, prepared.generation, handlerType.name, timer));
         if (!registered)
             await timer.cancel(signal);
@@ -86,13 +87,18 @@ class ZLinkSpotTimerRegistry {
     }
     async dispose() {
         const timers = await this.lane.run(() => {
-            const active = [...this.timers.values()].map((entry) => entry.timer);
+            const active = [...this.timers.entries()].map(([name, entry]) => ({
+                name,
+                timer: entry.timer,
+                wait: this.executeTimer === undefined
+                    ? true
+                    : this.isTimerExecuting?.(name) !== true
+            }));
             this.timers.clear();
             return active;
         });
-        for (const timer of timers) {
-            await timer.dispose();
-        }
+        const finalizations = timers.map(({ timer }) => timer.dispose());
+        await Promise.all(finalizations.filter((_, index) => timers[index].wait));
     }
     async captureRelocation() {
         const timers = await this.lane.run(() => [...this.timers.entries()].sort(([left], [right]) => left.localeCompare(right)));
@@ -155,6 +161,7 @@ class ZLinkRegisteredTimer {
     name;
     generation;
     timer;
+    finalization;
     constructor(registry, name, generation, timer) {
         this.registry = registry;
         this.name = name;
@@ -165,7 +172,16 @@ class ZLinkRegisteredTimer {
         return this.timer.isDisposed;
     }
     cancel(signal) {
-        return this.registry.cancel(this.name, this.generation, this.timer, signal);
+        if (this.finalization !== undefined)
+            return this.finalization;
+        try {
+            (0, abort_1.throwIfAborted)(signal);
+        }
+        catch (failure) {
+            return Promise.reject(failure);
+        }
+        this.finalization = this.registry.cancel(this.name, this.generation, this.timer);
+        return this.finalization;
     }
     dispose() {
         return this.cancel();
@@ -188,6 +204,8 @@ class ZLinkManagedTimer {
     lastScheduledIndex = 0n;
     timeout;
     running = Promise.resolve();
+    dispatchFailure;
+    finalization;
     constructor(name, periodMs, options, onTick, onFailure, shouldWaitForRunningOnCancel = () => true, clock = systemTimerClock) {
         this.name = name;
         this.periodMs = periodMs;
@@ -203,9 +221,27 @@ class ZLinkManagedTimer {
     get isDisposed() {
         return this.disposed;
     }
-    async cancel(_signal) {
-        const prepared = await this.lane.run(() => this.cancelCore());
-        await prepared.running;
+    cancel(_signal) {
+        if (this.finalization !== undefined)
+            return this.finalization.promise;
+        let resolve;
+        let reject;
+        const promise = new Promise((complete, fail) => {
+            resolve = complete;
+            reject = fail;
+        });
+        const finalization = { promise, resolve, reject };
+        this.finalization = finalization;
+        try {
+            const preparation = this.lane.run(() => this.cancelCore());
+            void preparation.then(start => {
+                void this.completeFinalization(start, finalization).then(undefined, reject);
+            }, reject);
+        }
+        catch (failure) {
+            reject(failure);
+        }
+        return promise;
     }
     dispose() {
         return this.cancel();
@@ -264,7 +300,10 @@ class ZLinkManagedTimer {
             : Math.max(0, Number(this.lastScheduledIndex + 1n) * this.periodMs - this.elapsedMs());
         this.timeout = this.clock.setTimeout(() => {
             this.timeout = undefined;
-            this.running = startOutsideStateLane(() => this.fire()).catch(() => undefined);
+            const execution = startOutsideStateLane(() => this.fire());
+            this.running = execution.then(() => undefined, cause => this.lane.run(() => {
+                this.dispatchFailure ??= { cause };
+            }));
         }, delayMs);
     }
     async fire() {
@@ -284,14 +323,44 @@ class ZLinkManagedTimer {
         await this.lane.run(() => this.completeFireCore(prepared.scheduledIndex, shouldContinue));
     }
     cancelCore() {
-        if (this.disposed)
-            return { running: Promise.resolve() };
         this.disposed = true;
-        if (this.timeout !== undefined) {
-            this.clock.clearTimeout(this.timeout);
-            this.timeout = undefined;
+        const timeout = this.timeout;
+        this.timeout = undefined;
+        return {
+            timeout,
+            running: this.shouldWaitForRunningOnCancel()
+                ? this.running
+                : Promise.resolve()
+        };
+    }
+    async completeFinalization(start, finalization) {
+        const failures = [];
+        if (start.timeout !== undefined) {
+            try {
+                this.clock.clearTimeout(start.timeout);
+            }
+            catch (failure) {
+                failures.push(failure);
+            }
+        }
+        try {
+            await start.running;
+        }
+        catch (failure) {
+            failures.push(failure);
+        }
+        const dispatchFailure = await this.lane.run(() => this.dispatchFailure);
+        if (dispatchFailure !== undefined)
+            failures.push(dispatchFailure.cause);
+        if (failures.length === 0) {
+            finalization.resolve();
+        }
+        else if (failures.length === 1) {
+            finalization.reject(failures[0]);
+        }
+        else {
+            finalization.reject(new AggregateError(failures, `Timer '${this.name}' cleanup failed.`));
         }
-        return { running: this.shouldWaitForRunningOnCancel() ? this.running : Promise.resolve() };
     }
     prepareCaptureCore() {
         if (this.disposed)

package/dist/runtime/streams/session-serial-executor.js

@@ -5,9 +5,7 @@ const serial_execution_queue_1 = require("../execution/serial-execution-queue");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
 class ZLinkSessionSerialExecutor {
-    scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue(async (record) => this.execute(record), {
-        capacityError: (lane) => (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.WorkerQueueFull, `Stream Session ${lane} execution capacity is full.`, true)
-    });
+    scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue(async (record) => this.execute(record), {});
     closed = false;
     executeApplication(work, options = {}, onRejected) {
         return this.submit(work, 'application', options, onRejected);

package/dist/runtime/streams/stream-session-runtime.d.ts

@@ -131,7 +131,7 @@ export declare class ZLinkStreamSessionNodeRuntime {
     private stopped;
     private readonly receiveAbortController;
     private receiveLoop;
-    private readonly receiveIdleWaiter;
+    private readonly receiveWake;
     private receiveWorkSinceYield;
     constructor(options: ZLinkStreamSessionNodeRuntimeOptions & ZLinkStreamLivenessOptions);
     start(): void;
@@ -159,7 +159,7 @@ export declare class ZLinkStreamSessionNodeRuntime {
     private removePendingConnectionMetadata;
     private resolveMonitorSession;
     private enqueueEndpointlessDisconnect;
-    private waitReceiveLoopIdle;
+    private waitReceiveLoopWake;
     private wakeReceiveLoop;
     private getOrCreateSession;
 }

package/dist/runtime/streams/stream-session-runtime.js

@@ -30,31 +30,21 @@ const systemLivenessClock = {
     setTimer: (callback, delayMs) => setTimeout(callback, delayMs),
     clearTimer: (timer) => clearTimeout(timer)
 };
-class ZLinkStreamIdleWaiter {
-    delayMs;
+class ZLinkStreamReceiveWake {
     pending;
     resolvePending;
-    timer;
     finish = () => {
-        if (this.timer !== undefined) {
-            clearTimeout(this.timer);
-            this.timer = undefined;
-        }
         const resolve = this.resolvePending;
         this.pending = undefined;
         this.resolvePending = undefined;
         resolve?.();
     };
-    constructor(delayMs) {
-        this.delayMs = delayMs;
-    }
     wait() {
         if (this.pending !== undefined)
             return this.pending;
         this.pending = new Promise((resolve) => {
             this.resolvePending = resolve;
         });
-        this.timer = setTimeout(this.finish, this.delayMs);
         return this.pending;
     }
     wake() {
@@ -664,7 +654,7 @@ class ZLinkStreamSessionNodeRuntime {
     stopped = false;
     receiveAbortController = new AbortController();
     receiveLoop;
-    receiveIdleWaiter = new ZLinkStreamIdleWaiter(5);
+    receiveWake = new ZLinkStreamReceiveWake();
     receiveWorkSinceYield = 0;
     constructor(options) {
         this.options = options;
@@ -734,14 +724,15 @@ class ZLinkStreamSessionNodeRuntime {
                 }
                 if (!this.options.readablePoller.wait(0)) {
                     permit.releaseAfterInternalProcessing();
-                    await this.waitReceiveLoopIdle();
+                    await this.waitReceiveLoopWake(signal);
                     continue;
                 }
                 packet = this.takePacket();
                 if (!this.options.socket.recvPacket(packet, ZLINK_RECV_DONT_WAIT)) {
+                    this.options.readablePoller.markDrained();
                     permit.releaseAfterInternalProcessing();
                     this.recyclePacket(packet);
-                    await this.waitReceiveLoopIdle();
+                    await this.waitReceiveLoopWake(signal);
                     continue;
                 }
                 packetTransferred = true;
@@ -757,11 +748,11 @@ class ZLinkStreamSessionNodeRuntime {
                 if (!this.isReceiveStopped(signal) && !packetTransferred) {
                     this.options.onError?.(error);
                     this.receiveWorkSinceYield = 0;
-                    await this.waitReceiveLoopIdle();
+                    await new Promise((resolve) => setImmediate(resolve));
                 }
                 else if (!this.isReceiveStopped(signal)) {
                     this.receiveWorkSinceYield = 0;
-                    await this.waitReceiveLoopIdle();
+                    await new Promise((resolve) => setImmediate(resolve));
                 }
                 continue;
             }
@@ -1091,11 +1082,14 @@ class ZLinkStreamSessionNodeRuntime {
             pending.session.enqueueDisconnected(pending.error);
         });
     }
-    waitReceiveLoopIdle() {
-        return this.receiveIdleWaiter.wait();
+    async waitReceiveLoopWake(signal) {
+        await Promise.race([
+            this.options.readablePoller.waitForReadable(signal),
+            this.receiveWake.wait()
+        ]);
     }
     wakeReceiveLoop() {
-        this.receiveIdleWaiter.wake();
+        this.receiveWake.wake();
     }
     getOrCreateSession(routingId) {
         const sessionId = (0, managed_stream_1.streamSessionIdFromRoutingId)(routingId);

package/dist/runtime/workers/index.d.ts

@@ -6,7 +6,6 @@ export interface ZLinkWorkerRuntimeOptions {
     readonly minThreads: number;
     readonly maxThreads: number;
     readonly idleTimeoutMs: number;
-    readonly maxQueueLength: number;
 }
 export declare function resolveWorkerRuntimeOptions(options?: ZLinkWorkerOptions): ZLinkWorkerRuntimeOptions;
 export declare class ZLinkWorkerRuntime {

package/dist/runtime/workers/index.js

@@ -13,13 +13,11 @@ function resolveWorkerRuntimeOptions(options) {
     const resolved = {
         minThreads: options?.minThreads ?? InternalDefaults_1.DEFAULT_WORKER_MIN_THREADS,
         maxThreads: options?.maxThreads ?? (0, InternalDefaults_1.defaultWorkerMaxThreads)(),
-        idleTimeoutMs: options?.idleTimeoutMs ?? InternalDefaults_1.DEFAULT_WORKER_IDLE_TIMEOUT_MS,
-        maxQueueLength: options?.maxQueueLength ?? InternalDefaults_1.DEFAULT_WORKER_QUEUE_LENGTH
+        idleTimeoutMs: options?.idleTimeoutMs ?? InternalDefaults_1.DEFAULT_WORKER_IDLE_TIMEOUT_MS
     };
     requireNonNegativeInteger('Worker minThreads', resolved.minThreads);
     requirePositiveInteger('Worker maxThreads', resolved.maxThreads);
     requireNonNegativeInteger('Worker idleTimeoutMs', resolved.idleTimeoutMs);
-    requirePositiveInteger('Worker maxQueueLength', resolved.maxQueueLength);
     if (resolved.maxThreads < resolved.minThreads) {
         throw new configuration_1.ZLinkConfigurationException('Worker maxThreads must be greater than or equal to minThreads.');
     }
@@ -53,9 +51,6 @@ class ZLinkCpuWorkerPool {
         if (signal?.aborted === true) {
             return Promise.reject((0, abort_1.createAbortError)());
         }
-        if (this.queueCount >= this.options.maxQueueLength) {
-            return Promise.reject(workerQueueFull(this.options.maxQueueLength));
-        }
         return new Promise((resolve, reject) => {
             const job = {
                 source: work.toString(),
@@ -446,9 +441,6 @@ class ZLinkSerialDeliveredPromise {
         return this.then((value) => this.serial.execute(() => { onfinally?.(); return value; }), (reason) => this.serial.execute(() => { onfinally?.(); throw reason; }));
     }
 }
-function workerQueueFull(maxQueueLength) {
-    return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.WorkerQueueFull, `CPU worker queue is full (maxQueueLength=${maxQueueLength}).`, true);
-}
 function workerTimedOut(timeoutMs) {
     return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.WorkerTimedOut, `Worker job timed out after ${timeoutMs}ms.`, true);
 }

package/package.json

@@ -1,7 +1,13 @@
 {
   "name": "@zlink-systems/framework",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zlink-systems/zlink.git",
+    "directory": "framework/languages/node/packages/framework"
+  },
+  "homepage": "https://zlink.systems/",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -13,7 +19,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.221.0",
-    "@zlink-systems/stream-wire": "0.10.0",
-    "@zlink-systems/zlink": "0.17.3"
+    "@zlink-systems/stream-wire": "0.12.0",
+    "@zlink-systems/zlink": "1.1.0"
   }
 }

package/src/contracts/Configuration/EndpointNotation.ts

@@ -1,6 +1,7 @@
 /**
- * Deterministic endpoint-notation normalization (endpoint 표기 정책,
- * doc/plan/endpoint-notation-policy.ko.md).
+ * Deterministic endpoint-notation normalization (endpoint 표기 정책),
+ * applied identically across all four language bindings so endpoint
+ * strings compare equal.
  *
  * `new URL()` cannot represent this domain: it throws on bracketed IPv6
  * literals that carry a zone id (`tcp://[fe80::1%eth0]:80`, even with the
@@ -16,7 +17,7 @@
  * public connect/disconnect APIs). Everything downstream compares the
  * resulting strings with plain `===`.
  *
- * Rules (policy 2.2), applied only to authority-bearing schemes
+ * Rules, applied only to authority-bearing schemes
  * (`tcp`, `tls`, `ws`, `wss` -- schemes whose grammar after `scheme://` is
  * `host:port`):
  *  - scheme: lowercased
@@ -39,7 +40,7 @@
  * `normalizeEndpoint(normalizeEndpoint(x)) === normalizeEndpoint(x)`.
  *
  * DNS names are never resolved. `localhost` and `127.0.0.1` remain distinct
- * endpoints (policy 2.1).
+ * endpoints.
  */
 
 const SCHEME_PATTERN = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/(.*)$/s;

package/src/contracts/Configuration/InternalDefaults.ts

@@ -6,7 +6,6 @@ export const DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE = 64 * 1024;
 /** Defaults shared by registration normalization and the runtime worker pool. */
 export const DEFAULT_WORKER_MIN_THREADS = 0;
 export const DEFAULT_WORKER_IDLE_TIMEOUT_MS = 30_000;
-export const DEFAULT_WORKER_QUEUE_LENGTH = 1024;
 
 export function defaultWorkerMaxThreads(): number {
   return Math.max(2, os.availableParallelism());

package/src/contracts/Configuration/RegistrationNormalizers.ts

@@ -25,8 +25,7 @@ import {
   defaultWorkerMaxThreads,
   DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE,
   DEFAULT_WORKER_IDLE_TIMEOUT_MS,
-  DEFAULT_WORKER_MIN_THREADS,
-  DEFAULT_WORKER_QUEUE_LENGTH
+  DEFAULT_WORKER_MIN_THREADS
 } from './InternalDefaults';
 
 export function normalizeWorkerOptions(
@@ -37,8 +36,7 @@ export function normalizeWorkerOptions(
   return {
     minThreads: partial.minThreads ?? DEFAULT_WORKER_MIN_THREADS,
     maxThreads: partial.maxThreads ?? defaultWorkerMaxThreads(),
-    idleTimeoutMs: partial.idleTimeoutMs ?? DEFAULT_WORKER_IDLE_TIMEOUT_MS,
-    maxQueueLength: partial.maxQueueLength ?? DEFAULT_WORKER_QUEUE_LENGTH
+    idleTimeoutMs: partial.idleTimeoutMs ?? DEFAULT_WORKER_IDLE_TIMEOUT_MS
   };
 }
 

package/src/contracts/Configuration/RegistrationTypes.ts

@@ -104,16 +104,13 @@ export interface ZLinkLocationRegistration {
 /**
  * CPU worker-thread pool settings. I/O workers do not consume this pool.
  * `minThreads` keeps a warm baseline, `maxThreads` bounds active CPU jobs,
- * `idleTimeoutMs` reclaims workers above the baseline, and `maxQueueLength`
- * bounds queued jobs. The registration normalizer supplies defaults when a
- * JavaScript caller omits a field: `0`, `max(2, availableParallelism())`,
- * `30000`, and `1024`, respectively.
+ * `idleTimeoutMs` reclaims workers above the baseline. The registration
+ * normalizer supplies defaults when a JavaScript caller omits a field.
  */
 export interface ZLinkWorkerOptions {
   readonly minThreads: number;
   readonly maxThreads: number;
   readonly idleTimeoutMs: number;
-  readonly maxQueueLength: number;
 }
 
 export interface ZLinkCodecSerializerRegistration {

package/src/contracts/Configuration/RegistrationValidators.ts

@@ -97,7 +97,6 @@ function validateWorkerOptions(worker: ZLinkWorkerOptions | undefined): void {
   requireNonNegativeInteger('Worker minThreads', worker.minThreads);
   requirePositiveInteger('Worker maxThreads', worker.maxThreads);
   requireNonNegativeInteger('Worker idleTimeoutMs', worker.idleTimeoutMs);
-  requirePositiveInteger('Worker maxQueueLength', worker.maxQueueLength);
   if (worker.maxThreads < worker.minThreads) {
     throw new ZLinkConfigurationException(
       'Worker maxThreads must be greater than or equal to minThreads.'

package/src/contracts/Errors/ZLinkFrameworkException.ts

@@ -6,13 +6,12 @@ export enum ZLinkFrameworkErrorKind {
   NotConfigured = 3,
   Rejected = 4,
   Unavailable = 5,
-  CapacityExceeded = 6,
-  DeadlineExceeded = 7,
-  ShuttingDown = 8,
-  ProtocolError = 9,
-  InvalidOperation = 10,
-  DataLost = 11,
-  InternalFailure = 12
+  DeadlineExceeded = 6,
+  ShuttingDown = 7,
+  ProtocolError = 8,
+  InvalidOperation = 9,
+  DataLost = 10,
+  InternalFailure = 11
 }
 
 export class ZLinkFrameworkException extends Error {

package/src/runtime/actors/actor-client.ts

@@ -916,7 +916,7 @@ function submitted(): ZLinkSubmitResult {
 //  the reply comes from a remote target, so a fine framework failure code
 //  refines the coarse terminal, and a terminal-only conflict/busy is the
 //  target's owner/queue state (retryable stale/Unavailable), never a
-//  source-owned CapacityExceeded. Backpressure never appears on this reply
+//  source-owned queue exhaustion. Backpressure never appears on this reply
 //  path. Internal kinds are preserved so the stale-actor re-resolve retry
 //  (isStaleActorError) keeps working.
 function actorFailureCodeKind(

package/src/runtime/actors/actor-mailbox.ts

@@ -5,10 +5,6 @@ import {
   type ZLinkSerialWorkOptions,
   type ZLinkSerialWorkRecord
 } from '../execution/serial-execution-queue';
-import {
-  ZLinkFrameworkInternalErrorKind,
-  createInternalFrameworkException
-} from '../framework-errors-internal';
 import { runZLinkActorExecution } from './actor-execution-context';
 import {
   bindApplicationJobPermit,
@@ -25,14 +21,7 @@ export class ZLinkActorSerialExecutor {
   ) {
     this.scheduler = new ZLinkSerialExecutionQueue(
       (record) => this.runRecord(record),
-      {
-        ...options,
-        capacityError: options?.capacityError ?? (() =>
-          createInternalFrameworkException(
-            ZLinkFrameworkInternalErrorKind.WorkerQueueFull,
-            'Actor execution queue capacity was exceeded.'
-          ))
-      }
+      options
     );
   }
 

package/src/runtime/backend/contracts/index.ts

@@ -578,6 +578,8 @@ export interface ZLinkBackendSubscriberSocket extends ZLinkBackendConnectableSoc
 
 export interface ZLinkBackendReadablePoller {
   wait(timeoutMs: number): boolean;
+  waitForReadable(signal?: AbortSignal): Promise<boolean>;
+  markDrained(): void;
   dispose(): void;
 }
 

package/src/runtime/backend/mesh-completion-table.ts

@@ -1,16 +1,11 @@
 import { ZLinkBufferMessage as Message } from './runtime-message';
+import type { Message as ZLinkMessage } from '../../contracts/Common/Message';
 import type {
   MeshOperationId,
   ReceiveKindData,
   ReceiveRecord
 } from '../foundation/service-runtime-contracts';
 import { operationIdentityKey } from '../foundation/operation-identity';
-import {
-  ZLinkFrameworkErrorKind,
-  ZLinkFrameworkException
-} from '../../contracts';
-
-export const ZLINK_MESH_COMPLETION_CAPACITY = 4_096;
 
 export interface ZLinkMeshCompletionDiagnostic {
   readonly kind: 'unknownOrLate';
@@ -36,14 +31,7 @@ export class ZLinkMeshCompletionTable {
   private readonly pending = new Map<string, PendingCompletion>();
   private disposed = false;
 
-  constructor(
-    private readonly maxPendingOperations = ZLINK_MESH_COMPLETION_CAPACITY,
-    private readonly onDiagnostic?: (diagnostic: ZLinkMeshCompletionDiagnostic) => void
-  ) {
-    if (!Number.isSafeInteger(maxPendingOperations) || maxPendingOperations <= 0) {
-      throw new RangeError('maxPendingOperations must be a positive safe integer.');
-    }
-  }
+  constructor(private readonly onDiagnostic?: (diagnostic: ZLinkMeshCompletionDiagnostic) => void) {}
 
   /**
    * Submits and registers without yielding control to the event loop. Mesh
@@ -63,12 +51,6 @@ export class ZLinkMeshCompletionTable {
         signal.reason ?? new DOMException('The operation was aborted.', 'AbortError')
       );
     }
-    if (this.pending.size >= this.maxPendingOperations) {
-      return Promise.reject(new ZLinkFrameworkException(
-        ZLinkFrameworkErrorKind.CapacityExceeded,
-        `Mesh completion capacity ${this.maxPendingOperations} is exhausted.`
-      ));
-    }
     const operationId = operation();
     // The backend submission callback can synchronously re-enter `dispose()`.
     // TypeScript's control-flow analysis cannot observe mutation through it.
@@ -117,7 +99,7 @@ export class ZLinkMeshCompletionTable {
     this.pending.delete(key);
     pending.removeAbort?.();
     try {
-      pending.resolve(copyCompletion(record));
+      pending.resolve(retainCompletion(record));
     } catch (error) {
       pending.reject(error);
     }
@@ -144,16 +126,23 @@ export class ZLinkMeshCompletionTable {
 
 }
 
-function copyCompletion(record: ReceiveRecord): ZLinkMeshCompletion {
+function retainCompletion(record: ReceiveRecord): ZLinkMeshCompletion {
   return {
     terminalResult: record.terminalResult,
     failureErrno: record.failureErrno,
     operationKind: record.operationKind,
     kindData: record.kindData,
-    parts: record.parts.map((part) => Message.fromOwned(Buffer.from(part.data())))
+    parts: record.parts.map(retainCompletionPart)
   };
 }
 
+function retainCompletionPart(part: ZLinkMessage): Message {
+  // A runtime message already owns a managed Buffer and close() is a no-op.
+  // Binding-native messages can expose native storage through data(), which
+  // becomes invalid when their owner closes; materialize that one boundary copy.
+  return part instanceof Message ? part : Message.fromOwned(Buffer.from(part.data()));
+}
+
 export function closeMeshCompletion(completion: ZLinkMeshCompletion): void {
   closeParts(completion.parts);
 }