@zlink-systems/framework 0.30.3 → 0.32.0

package/dist/runtime/execution/serial-execution-queue.js

@@ -42,7 +42,7 @@ class ZLinkSerialExecutionQueue {
         if (sharedOwner === undefined)
             this.consumer = { running: false, scheduled: false };
     }
-    submit(operation, options = {}, context) {
+    submit(operation, options, context) {
         try {
             return this.admit(operation, options, context);
         }
@@ -50,7 +50,7 @@ class ZLinkSerialExecutionQueue {
             return Promise.reject(error);
         }
     }
-    submitDetached(operation, onError, options = {}, context) {
+    submitDetached(operation, onError, options, context) {
         void this.submit(operation, options, context).catch(onError);
     }
     /**
@@ -58,7 +58,7 @@ class ZLinkSerialExecutionQueue {
      */
     submitContinuation(operation, context) {
         try {
-            return this.admit(operation, { lane: 'application' }, context);
+            return this.admit(operation, undefined, context);
         }
         catch (error) {
             return Promise.reject(error);
@@ -70,14 +70,14 @@ class ZLinkSerialExecutionQueue {
      *
      * @internal
      */
-    admitDurablePrefix(operation, options = {}, context, preparation) {
+    admitDurablePrefix(operation, options, context, preparation) {
         return this.admit(operation, { ...options, lane: 'application' }, context, preparation);
     }
     /**
      * Enqueues work that already owns the host-wide application job permit.
      * It remains held through handler terminal completion.
      */
-    submitPreAdmitted(operation, options = {}, context) {
+    submitPreAdmitted(operation, options, context) {
         return this.admit(operation, options, context);
     }
     /** Holds lifecycle FIFO through an operation result while its application turns can run. */
@@ -88,7 +88,8 @@ class ZLinkSerialExecutionQueue {
         return this.activeLifecycle?.context !== undefined;
     }
     visitPendingApplication(visitor) {
-        for (const record of this.application.records) {
+        for (let index = 0; index < this.application.records.length; index++) {
+            const record = this.application.records[index];
             if (record.mailbox === undefined)
                 visitor(record);
         }
@@ -125,9 +126,8 @@ class ZLinkSerialExecutionQueue {
     admit(operation, options, context, preparation, operationEnvelope = false) {
         if (this.closed)
             throw new Error('The serial execution queue is closed.');
-        const lane = options.lane ?? 'application';
+        const lane = options?.lane ?? 'application';
         const target = lane === 'application' ? this.application : this.lifecycle;
-        let settled = false;
         let released = false;
         let resolveResult;
         let rejectResult;
@@ -149,18 +149,6 @@ class ZLinkSerialExecutionQueue {
                 }
             }
         };
-        const resolve = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            resolveResult(value);
-        };
-        const reject = (reason) => {
-            if (settled)
-                return;
-            settled = true;
-            rejectResult(reason);
-        };
         const record = {
             acceptedSequence: 0n,
             lane,
@@ -169,11 +157,11 @@ class ZLinkSerialExecutionQueue {
             context,
             preparation,
             preparationState: preparation === undefined ? 'ready' : 'idle',
-            resolve,
-            reject,
+            resolve: resolveResult,
+            reject: rejectResult,
             release,
             fail: (reason) => {
-                reject(reason);
+                rejectResult(reason);
                 release();
             }
         };
@@ -189,15 +177,16 @@ class ZLinkSerialExecutionQueue {
             release();
             throw error;
         }
-        options.onAdmitted?.();
-        options.onWithdrawable?.(() => {
+        options?.onAdmitted?.();
+        options?.onWithdrawable?.(() => {
             const index = target.records.indexOf(record);
             if (index < 0)
                 return false;
-            target.records.splice(index, 1);
+            target.records.copyWithin(index, index + 1);
+            target.records.length -= 1;
             record.preparationController?.abort(new Error('Durable record transferred to another handoff.'));
             record.preparation?.cancel();
-            resolve(undefined);
+            resolveResult(undefined);
             release();
             return true;
         });
@@ -211,17 +200,26 @@ class ZLinkSerialExecutionQueue {
             // Ready membership in the existing owner queue is the only notification state.
             if (this.ownerMembership !== undefined)
                 return;
-            this.enqueueMailboxTurn(() => this.consumeMailbox());
+            {
+                // Block-scoped captures keep early returns free of a V8 function context.
+                const mailbox = this;
+                mailbox.enqueueMailboxTurn(() => mailbox.consumeMailbox());
+            }
             return;
         }
         const consumer = this.consumer;
         if (consumer.scheduled || consumer.running)
             return;
-        consumer.scheduled = true;
-        (0, state_lane_1.startOutsideStateLane)(() => queueMicrotask(() => {
-            consumer.scheduled = false;
-            void this.drain();
-        }));
+        {
+            // Same block-scoped capture as the mailbox branch above.
+            const queue = this;
+            const scheduledConsumer = consumer;
+            scheduledConsumer.scheduled = true;
+            (0, state_lane_1.startOutsideStateLane)(() => queueMicrotask(() => {
+                scheduledConsumer.scheduled = false;
+                void queue.drain();
+            }));
+        }
     }
     /** Notifications carry no payload, admission sequence, result Promise, or host permit. */
     enqueueMailboxTurn(operation) {
@@ -244,16 +242,15 @@ class ZLinkSerialExecutionQueue {
     }
     /** Called only by the shared scheduler's consumer, never by a producer. */
     consumeMailbox() {
-        const selection = this.selectNext();
-        if (selection === undefined) {
+        const record = this.selectNext();
+        if (record === undefined) {
             if (!this.hasPendingWork)
                 this.resolveIdleWaiters();
             return;
         }
-        const record = selection.record;
-        if (!this.prepareSelected(selection))
+        if (!this.prepareSelected(record))
             return;
-        this.takeSelected(selection);
+        this.takeSelected(record);
         if (record.preparationState === 'failed') {
             record.preparation?.cancel();
             record.fail(record.preparationError);
@@ -270,11 +267,11 @@ class ZLinkSerialExecutionQueue {
         catch (error) {
             terminal = Promise.reject(error);
         }
-        void terminal.then((value) => this.finishMailbox(record, () => record.resolve(value)), (error) => this.finishMailbox(record, () => record.reject(error)));
+        void terminal.then((value) => this.finishMailbox(record, record.resolve, value), (error) => this.finishMailbox(record, record.reject, error));
     }
-    finishMailbox(record, settle) {
+    finishMailbox(record, settle, value) {
         this.enqueueMailboxTurn(() => {
-            settle();
+            settle(value);
             record.release();
             record.preparation?.cancel();
             this.activeRecord = undefined;
@@ -292,15 +289,14 @@ class ZLinkSerialExecutionQueue {
         let waitingForPreparation = false;
         try {
             for (;;) {
-                const selection = this.selectNext();
-                if (selection === undefined)
+                const record = this.selectNext();
+                if (record === undefined)
                     break;
-                const record = selection.record;
-                if (!this.prepareSelected(selection)) {
+                if (!this.prepareSelected(record)) {
                     waitingForPreparation = true;
                     break;
                 }
-                this.takeSelected(selection);
+                this.takeSelected(record);
                 if (record.preparationState === 'failed') {
                     record.preparation?.cancel();
                     record.fail(record.preparationError);
@@ -357,45 +353,48 @@ class ZLinkSerialExecutionQueue {
             }
         }
     }
-    prepareSelected(selection) {
-        if (selection.lane === 'lifecycle' &&
+    prepareSelected(record) {
+        if (record.lane === 'lifecycle' &&
             this.application.records.length > 0 &&
             !this.cancelPreparationForRearbitration(this.application.records[0]))
             return false;
-        const record = selection.record;
         if (record.preparationState === 'idle')
             this.startPreparation(record);
         return record.preparationState !== 'pending' && record.preparationState !== 'canceling';
     }
     selectNext() {
         const lifecycleOwner = this.activeLifecycle?.context;
-        const applicationRecord = lifecycleOwner === undefined
-            ? this.application.records[0]
-            : this.application.records.find((record) => lifecycleOwner.canExecuteApplication(record));
+        let applicationRecord;
+        if (lifecycleOwner === undefined) {
+            applicationRecord = this.application.records[0];
+        }
+        else {
+            // Capture only inside the lifecycle branch; the common path allocates no context.
+            const owner = lifecycleOwner;
+            applicationRecord = this.application.records.find((record) => owner.canExecuteApplication(record));
+        }
         const applicationReady = applicationRecord !== undefined;
         const lifecycleReady = this.activeLifecycle === undefined && this.lifecycle.records.length > 0;
         if (!applicationReady && !lifecycleReady)
             return undefined;
         if (!applicationReady) {
-            return { lane: 'lifecycle', record: this.lifecycle.records[0] };
+            return this.lifecycle.records[0];
         }
         if (!lifecycleReady) {
-            return { lane: 'application', record: applicationRecord };
+            return applicationRecord;
         }
         if (!this.lifecycleDebt && this.lifecycleStreak < this.lifecycleBurstLimit) {
-            return { lane: 'lifecycle', record: this.lifecycle.records[0] };
+            return this.lifecycle.records[0];
         }
-        return { lane: 'application', record: applicationRecord };
+        return applicationRecord;
     }
-    takeSelected(selection) {
-        const record = selection.lane === 'lifecycle'
-            ? this.takeLifecycle()
-            : this.takeApplication(selection.record);
-        if (record !== selection.record) {
+    takeSelected(selected) {
+        const record = selected.lane === 'lifecycle' ? this.takeLifecycle() : this.takeApplication(selected);
+        if (record !== selected) {
             throw new Error('The selected serial work record changed before owner claim.');
         }
-        if (selection.record.mailbox !== undefined)
-            selection.record.mailbox.ownerMembership = undefined;
+        if (selected.mailbox !== undefined)
+            selected.mailbox.ownerMembership = undefined;
         return record;
     }
     takeLifecycle() {
@@ -413,7 +412,11 @@ class ZLinkSerialExecutionQueue {
         if (this.application.records[0] === selected)
             return this.application.records.shift();
         const index = this.application.records.indexOf(selected);
-        return this.application.records.splice(index, 1)[0];
+        // A missing record (index -1) still reaches the owner-claim fence in takeSelected.
+        const record = this.application.records.at(index);
+        this.application.records.copyWithin(index, index + 1);
+        this.application.records.length = Math.max(0, this.application.records.length - 1);
+        return record;
     }
     startPreparation(record) {
         const preparation = record.preparation;
@@ -471,26 +474,27 @@ class ZLinkSerialExecutionQueue {
         return performance.now() - (this.claimStartedAt ?? performance.now()) >= this.ownerTimeBudget;
     }
     resolveIdleWaiters() {
-        for (const resolve of this.idleWaiters.splice(0))
-            resolve();
+        for (let index = 0; index < this.idleWaiters.length; index++)
+            this.idleWaiters[index]();
+        this.idleWaiters.length = 0;
     }
 }
 exports.ZLinkSerialExecutionQueue = ZLinkSerialExecutionQueue;
 if ((0, state_lane_1.isStructuralGuardEnabled)()) {
     const submit = ZLinkSerialExecutionQueue.prototype.submit;
-    ZLinkSerialExecutionQueue.prototype.submit = function (operation, options = {}, context) {
-        return (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(submit.call(this, operation, options, context), `serial ${options.lane ?? 'application'} ${(0, state_lane_1.diagnosticWorkName)(operation)}`), 'serial completion');
+    ZLinkSerialExecutionQueue.prototype.submit = function (operation, options, context) {
+        return (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(submit.call(this, operation, options, context), `serial ${options?.lane ?? 'application'} ${(0, state_lane_1.diagnosticWorkName)(operation)}`), 'serial completion');
     };
     const submitPreAdmitted = ZLinkSerialExecutionQueue.prototype.submitPreAdmitted;
-    ZLinkSerialExecutionQueue.prototype.submitPreAdmitted = function (operation, options = {}, context) {
-        return (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(submitPreAdmitted.call(this, operation, options, context), `serial ${options.lane ?? 'application'} ${(0, state_lane_1.diagnosticWorkName)(operation)}`), 'serial completion');
+    ZLinkSerialExecutionQueue.prototype.submitPreAdmitted = function (operation, options, context) {
+        return (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(submitPreAdmitted.call(this, operation, options, context), `serial ${options?.lane ?? 'application'} ${(0, state_lane_1.diagnosticWorkName)(operation)}`), 'serial completion');
     };
     const submitContinuation = ZLinkSerialExecutionQueue.prototype.submitContinuation;
     ZLinkSerialExecutionQueue.prototype.submitContinuation = function (operation, context) {
         return (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(submitContinuation.call(this, operation, context), `serial continuation ${(0, state_lane_1.diagnosticWorkName)(operation)}`), 'serial completion');
     };
     const admitDurablePrefix = ZLinkSerialExecutionQueue.prototype.admitDurablePrefix;
-    ZLinkSerialExecutionQueue.prototype.admitDurablePrefix = function (operation, options = {}, context, preparation) {
+    ZLinkSerialExecutionQueue.prototype.admitDurablePrefix = function (operation, options, context, preparation) {
         return (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(admitDurablePrefix.call(this, operation, options, context, preparation), `serial durable ${(0, state_lane_1.diagnosticWorkName)(operation)}`), 'serial completion');
     };
     const submitLifecycleOperation = ZLinkSerialExecutionQueue.prototype.submitLifecycleOperation;

package/dist/runtime/foundation/durable-service-request.d.ts

@@ -1,14 +1,23 @@
+import { type ConnectionAttempt } from '@zlink-systems/zlink';
+import type { OperationHandle, PendingOperation } from './operation-registry';
 export interface PeerRouteObservation {
     readonly generation?: bigint;
     readonly ready: boolean;
+    readonly selected?: boolean;
+    readonly lifecycleGeneration?: bigint;
+    readonly endpoint?: string;
+    /** Immutable socket snapshot; admission selects this target endpoint only while waiting. */
+    readonly connectionAttempts?: readonly ConnectionAttempt[];
 }
 export interface DurableServiceRequestPort {
     readonly requestStopSignal?: AbortSignal;
     observePeerRoute(target: string): PeerRouteObservation;
     observePeerRouteChanged(listener: (target: string) => void): () => void;
     observePeerConnectionIntentRemoved(listener: (target: string) => void): () => void;
-    requestService(target: string, parts: readonly Uint8Array[], timeoutMs: number, onAdmitted?: () => void): Promise<readonly Buffer[]>;
+    requestService(target: string, parts: readonly Uint8Array[], timeoutMs: number, onAdmitted?: () => void, existing?: Pick<PendingOperation<unknown>, 'id' | 'deadlineMs'>, receiver?: undefined, onSubmitted?: () => void): Promise<readonly Buffer[]>;
 }
-/** Actor model §8.1: a ready edge or a typed transport failure owns replay. */
-export declare function requestDurableService(port: DurableServiceRequestPort, target: string, parts: readonly Uint8Array[], deadlineMs: number, operationKind: string, signal?: AbortSignal, onSubmitted?: (signal: AbortSignal) => Promise<void>): Promise<readonly Buffer[]>;
+/** Submit §5: one admission decision for application and lifecycle requests. */
+export declare function admitServiceRequest(port: Pick<DurableServiceRequestPort, 'requestStopSignal' | 'observePeerRoute' | 'observePeerRouteChanged' | 'observePeerConnectionIntentRemoved'>, target: string, pending: OperationHandle<unknown>, start: (remainingMs: number, finished: () => void) => void, failed: (error: unknown) => void, operationKind?: string): void;
+/** The lifecycle adapter preserves its physical reply decoder and sender operation. */
+export declare function requestDurableService(port: DurableServiceRequestPort, target: string, parts: readonly Uint8Array[], pending: PendingOperation<unknown>, operationKind: string, signal?: AbortSignal, onSubmitted?: (signal: AbortSignal) => Promise<void>, onAdmitted?: () => void): Promise<readonly Buffer[]>;
 export declare function durableRequestCanReplay(error: unknown): boolean;

package/dist/runtime/foundation/durable-service-request.js

@@ -1,90 +1,175 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.admitServiceRequest = admitServiceRequest;
 exports.requestDurableService = requestDurableService;
 exports.durableRequestCanReplay = durableRequestCanReplay;
-const abort_1 = require("../abort");
+const zlink_1 = require("@zlink-systems/zlink");
+const request_deadline_1 = require("../messaging/request-deadline");
 const runtime_values_1 = require("../backend/runtime-values");
 const framework_errors_internal_1 = require("../framework-errors-internal");
-/** Actor model §8.1: a ready edge or a typed transport failure owns replay. */
-async function requestDurableService(port, target, parts, deadlineMs, operationKind, signal, onSubmitted) {
-    let wasAdmitted = false;
-    const stop = new AbortController();
-    const exhausted = (cause) => (0, framework_errors_internal_1.createInternalFrameworkException)(wasAdmitted
-        ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded
-        : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operationKind} exhausted its end-to-end deadline.`, true, cause);
-    const timer = setTimeout(() => stop.abort(exhausted()), Math.max(0, Math.ceil(deadlineMs - performance.now())));
-    const unobserveIntent = port.observePeerConnectionIntentRemoved((rid) => {
+/** Submit §5: one admission decision for application and lifecycle requests. */
+function admitServiceRequest(port, target, pending, start, failed, operationKind = 'Request') {
+    let baseline;
+    let submitted = false;
+    let disposed = false;
+    let unobserveRoute = () => { };
+    let unobserveIntent = () => { };
+    const cleanup = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        unobserveRoute();
+        unobserveIntent();
+        port.requestStopSignal?.removeEventListener('abort', stopped);
+        if (pending.promise === undefined)
+            pending.clearFailureDispatcher(cleanup);
+    };
+    const fail = (error) => {
+        if (disposed)
+            return;
+        cleanup();
+        failed(error);
+    };
+    const lifecycleFailure = (error) => {
+        if (!submitted)
+            fail(error);
+        else {
+            cleanup();
+            pending.fail(error);
+        }
+    };
+    const unavailable = (message) => lifecycleFailure((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, message, true));
+    const stopped = () => {
+        const error = port.requestStopSignal?.reason;
+        lifecycleFailure(error);
+        pending.fail(error);
+    };
+    const check = () => {
+        if (disposed || submitted)
+            return true;
+        if (port.requestStopSignal?.aborted === true) {
+            stopped();
+            return true;
+        }
+        if (!pending.isPending()) {
+            cleanup();
+            return true;
+        }
+        try {
+            const remaining = (0, request_deadline_1.remainingRequestTimeout)(operationKind, pending.deadlineMs);
+            const observation = port.observePeerRoute(target);
+            const attempts = baseline !== undefined || !observation.ready
+                ? observation.connectionAttempts?.filter((attempt) => attempt.endpoint === observation.endpoint)
+                : undefined;
+            if (baseline !== undefined &&
+                ((baseline.lifecycleGeneration !== undefined &&
+                    baseline.lifecycleGeneration !== observation.lifecycleGeneration) ||
+                    (baseline.endpoint !== undefined && baseline.endpoint !== observation.endpoint))) {
+                unavailable('Request target descriptor changed.');
+                return true;
+            }
+            // Compare the waiting request's tokens before accepting a recovered route.
+            if (baseline !== undefined &&
+                (baseline.connectionAttempts ?? []).some((previous) => attempts?.some((current) => current.intentId === previous.intentId &&
+                    current.lastFailureId === previous.lastFailureId) !== true)) {
+                unavailable('Request connection intent ended, changed, or failed.');
+                return true;
+            }
+            if (baseline !== undefined &&
+                (baseline.connectionAttempts ?? []).length === 0 &&
+                attempts?.some((attempt) => attempt.lastFailureId !== 0n) === true) {
+                unavailable('Request first connection observation contains a failure.');
+                return true;
+            }
+            if (observation.ready) {
+                submitted = true;
+                unobserveRoute();
+                start(remaining, cleanup);
+                return true;
+            }
+            if (observation.selected !== true &&
+                attempts?.some((attempt) => attempt.state === zlink_1.ConnectionAttemptState.AttemptFailed) === true) {
+                unavailable('Request connection attempt failed.');
+                return true;
+            }
+            if (baseline === undefined || (baseline.connectionAttempts ?? []).length === 0)
+                baseline = { ...observation, connectionAttempts: attempts };
+        }
+        catch (error) {
+            fail(error);
+            return true;
+        }
+        return false;
+    };
+    if (check())
+        return;
+    unobserveRoute = port.observePeerRouteChanged((rid) => {
         if (rid === target)
-            stop.abort((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operationKind} target node lifecycle ended.`, true));
+            check();
     });
+    unobserveIntent = port.observePeerConnectionIntentRemoved((rid) => {
+        if (rid === target)
+            unavailable('Request target node lifecycle ended.');
+    });
+    if (pending.promise === undefined)
+        pending.setFailureDispatcher(cleanup);
+    else
+        void pending.promise.then(cleanup, (error) => {
+            if (!submitted)
+                fail(error);
+            else
+                cleanup();
+        });
+    port.requestStopSignal?.addEventListener('abort', stopped, { once: true });
+    if (port.requestStopSignal?.aborted === true)
+        stopped();
+    else
+        check();
+}
+/** The lifecycle adapter preserves its physical reply decoder and sender operation. */
+function requestDurableService(port, target, parts, pending, operationKind, signal, onSubmitted, onAdmitted) {
+    const stop = new AbortController();
     const cancellation = AbortSignal.any([
         stop.signal,
         ...(signal === undefined ? [] : [signal]),
         ...(port.requestStopSignal === undefined ? [] : [port.requestStopSignal])
     ]);
-    try {
-        for (;;) {
-            cancellation.throwIfAborted();
-            const remainingMs = Math.ceil(deadlineMs - performance.now());
-            if (remainingMs <= 0)
-                throw exhausted();
-            let changed;
-            const transition = new Promise((resolve) => {
-                changed = resolve;
-            });
-            let submittedGeneration;
-            const attemptStop = new AbortController();
-            const attemptSignal = AbortSignal.any([cancellation, attemptStop.signal]);
-            const unobserveRoute = port.observePeerRouteChanged((rid) => {
-                if (rid !== target)
-                    return;
-                const route = port.observePeerRoute(target);
-                if (submittedGeneration === undefined
-                    ? route.ready
-                    : route.generation !== undefined && route.generation !== submittedGeneration) {
-                    changed();
-                    attemptStop.abort();
-                }
-            });
-            try {
-                const route = port.observePeerRoute(target);
-                if (!route.ready) {
-                    await (0, abort_1.awaitWithAbort)(transition, cancellation);
-                    continue;
-                }
-                submittedGeneration = route.generation;
-                const reply = port.requestService(target, parts, remainingMs, () => {
-                    wasAdmitted = true;
-                });
-                const request = onSubmitted === undefined
-                    ? reply
-                    : Promise.race([
-                        reply,
-                        Promise.resolve()
-                            .then(() => onSubmitted(attemptSignal))
-                            .then(() => reply)
-                    ]);
-                const result = await (0, abort_1.awaitWithAbort)(Promise.race([request.then((parts) => ({ parts })), transition.then(() => undefined)]), cancellation);
-                if (result !== undefined)
-                    return result.parts;
-            }
-            catch (error) {
-                cancellation.throwIfAborted();
-                if (!durableRequestCanReplay(error))
-                    throw error;
-                if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'request')
-                    wasAdmitted = true;
-            }
-            finally {
-                attemptStop.abort();
-                unobserveRoute();
-            }
+    const cancelled = () => pending.fail(cancellation.reason);
+    cancellation.addEventListener('abort', cancelled, { once: true });
+    const complete = () => {
+        cancellation.removeEventListener('abort', cancelled);
+        stop.abort();
+    };
+    void pending.promise.then(complete, complete);
+    return new Promise((resolve, reject) => {
+        if (cancellation.aborted) {
+            cancelled();
+            reject(cancellation.reason);
+            return;
         }
-    }
-    finally {
-        clearTimeout(timer);
-        unobserveIntent();
-    }
+        admitServiceRequest(port, target, pending, (remaining, finished) => {
+            const reply = port.requestService(target, parts, remaining, onAdmitted, pending, undefined, onSubmitted === undefined
+                ? undefined
+                : () => {
+                    try {
+                        void onSubmitted(cancellation).catch((error) => pending.fail(error));
+                    }
+                    catch (error) {
+                        pending.fail(error);
+                    }
+                });
+            void reply.then((value) => {
+                finished();
+                resolve(value);
+            }, (error) => {
+                finished();
+                reject(error);
+            });
+        }, (error) => {
+            pending.fail(error);
+            reject(error);
+        }, operationKind);
+    });
 }
 function durableRequestCanReplay(error) {
     if (!(0, runtime_values_1.isZLinkBackendResultError)(error))