@zlink-systems/framework 0.26.0 → 0.27.0

package/dist/runtime/foundation/service-discovery-registry.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceDiscoveryRegistry = void 0;
+const RegistrationBuilderPolicy_1 = require("../../contracts/Configuration/RegistrationBuilderPolicy");
+const service_weighted_selection_1 = require("./service-weighted-selection");
 /** Dedicated discovery state; fanout publishers never reuse RouteMesh peer rows. */
 class ServiceDiscoveryRegistry {
+    clientServerChanged = new Set();
+    onClientServerChanged(listener) {
+        this.clientServerChanged.add(listener);
+        return () => {
+            this.clientServerChanged.delete(listener);
+        };
+    }
+    dispose(error) {
+        for (const listener of this.clientServerChanged)
+            listener(error);
+        this.clientServerChanged.clear();
+    }
     clientServers = new Map();
     fanoutPublishers = new Map();
     clientServerSelections = new Map();
@@ -56,6 +70,10 @@ class ServiceDiscoveryRegistry {
         }
         return selection.select();
     }
+    hasReadyClientServer(channelName) {
+        return [...this.clientServers.values()].some(({ descriptor }) => descriptor.channelName === channelName &&
+            (descriptor.state === 'serving' || descriptor.state === 'retiring'));
+    }
     clientServerDescriptors(channelName) {
         return [...this.clientServers.values()]
             .map((value) => value.descriptor)
@@ -94,6 +112,8 @@ class ServiceDiscoveryRegistry {
         if (this.clientServerSelections.has(channelName)) {
             this.clientServerSelections.get(channelName).rebuild();
         }
+        for (const listener of this.clientServerChanged)
+            listener();
     }
     clientServerCandidates(channelName) {
         return [...this.clientServers.values()]
@@ -150,8 +170,8 @@ function validateClientServer(descriptor) {
     requireText(descriptor.securityIdentity, 'securityIdentity');
     requireText(descriptor.advertisedEndpoint, 'advertisedEndpoint');
     validateRevision(descriptor.lifecycleGeneration, descriptor.descriptorRevision);
-    if (!Number.isInteger(descriptor.weight) || descriptor.weight < 0 || descriptor.weight > 10_000) {
-        throw new RangeError('ClientServer weight must be an integer in 0..10000.');
+    if (!(0, RegistrationBuilderPolicy_1.isValidPublicWeight)(descriptor.weight)) {
+        throw new RangeError(`ClientServer weight must be an integer in 0..${RegistrationBuilderPolicy_1.ZLINK_MAX_PUBLIC_WEIGHT}.`);
     }
     if (!Number.isSafeInteger(descriptor.effectiveMaxMessageBytes) ||
         descriptor.effectiveMaxMessageBytes < 1) {
@@ -174,4 +194,3 @@ function requireText(value, field) {
         throw new TypeError(`${field} must be non-empty text without NUL.`);
     }
 }
-const service_weighted_selection_1 = require("./service-weighted-selection");

package/dist/runtime/foundation/service-instance-activation-recovery-codec.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeInstanceActivationRecoveryEnvelope = encodeInstanceActivationRecoveryEnvelope;
 exports.decodeInstanceActivationRecoveryEnvelope = decodeInstanceActivationRecoveryEnvelope;
+const service_wire_binary_primitives_1 = require("./service-wire-binary-primitives");
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 const service_relocation_runtime_1 = require("./service-relocation-runtime");
 const service_wire_m6a_codec_1 = require("./service-wire-m6a-codec");
 const service_metadata_codec_1 = require("./service-metadata-codec");
@@ -175,8 +177,10 @@ function requireOperation(value) {
 }
 function textBytes(value, name) {
     const bytes = Buffer.from(value, 'utf8');
-    if (bytes.byteLength < 1 || bytes.byteLength > 255 || bytes.includes(0)) {
-        throw new RangeError(`${name} must contain 1..255 UTF-8 bytes without NUL.`);
+    if (bytes.byteLength < 1 ||
+        bytes.byteLength > service_wire_binary_primitives_1.SERVICE_WIRE_TEXT8_MAX_BYTES ||
+        bytes.includes(0)) {
+        throw new RangeError(`${name} must contain 1..${service_wire_binary_primitives_1.SERVICE_WIRE_TEXT8_MAX_BYTES} UTF-8 bytes without NUL.`);
     }
     return bytes;
 }
@@ -189,12 +193,12 @@ function writeText8(target, offset, value) {
     return offset + 1 + value.byteLength;
 }
 function validatePositiveU64(value, name) {
-    if (value <= 0n || value > 0xffffffffffffffffn) {
+    if (value <= 0n || value > stream_wire_1.UINT64_MAX) {
         throw new RangeError(`${name} is out of range.`);
     }
 }
 function validateU64(value, name) {
-    if (value < 0n || value > 0xffffffffffffffffn) {
+    if (value < 0n || value > stream_wire_1.UINT64_MAX) {
         throw new RangeError(`${name} is out of range.`);
     }
 }

package/dist/runtime/foundation/service-liveness-registry.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceLivenessRegistry = exports.DEFAULT_SERVICE_PEER_TIMEOUT_MS = exports.DEFAULT_SERVICE_PROBE_INTERVAL_MS = void 0;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 exports.DEFAULT_SERVICE_PROBE_INTERVAL_MS = 5_000;
 exports.DEFAULT_SERVICE_PEER_TIMEOUT_MS = 15_000;
 /** Uses monotonic milliseconds and never treats application traffic as a probe ACK. */
@@ -101,7 +102,7 @@ class ServiceLivenessRegistry {
     }
     allocateProbeId() {
         const result = this.nextProbeId++;
-        if (this.nextProbeId > 0xffffffffffffffffn)
+        if (this.nextProbeId > stream_wire_1.UINT64_MAX)
             this.nextProbeId = 1n;
         return result;
     }

package/dist/runtime/foundation/service-maintenance-runtime.d.ts

@@ -42,4 +42,3 @@ export declare class ServiceMaintenanceRuntime {
     private publishCore;
     private notify;
 }
-export declare function classifyRelocationRecovery(publishedReference: boolean, payloadPresent: boolean, checksumMatches: boolean, inventoryMatches: boolean): 'resume' | 'orphan' | 'relocationDataLost';

package/dist/runtime/foundation/service-maintenance-runtime.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceMaintenanceRuntime = void 0;
-exports.classifyRelocationRecovery = classifyRelocationRecovery;
 const node_async_hooks_1 = require("node:async_hooks");
 const state_lane_1 = require("../execution/state-lane");
 const detachedStateLaneResource = new node_async_hooks_1.AsyncResource('zlink:service-maintenance-runtime');
@@ -210,8 +209,3 @@ exports.ServiceMaintenanceRuntime = ServiceMaintenanceRuntime;
 function startOutsideStateLane(work) {
     return detachedStateLaneResource.runInAsyncScope(work);
 }
-function classifyRelocationRecovery(publishedReference, payloadPresent, checksumMatches, inventoryMatches) {
-    if (!publishedReference)
-        return payloadPresent ? 'orphan' : 'resume';
-    return payloadPresent && checksumMatches && inventoryMatches ? 'resume' : 'relocationDataLost';
-}

package/dist/runtime/foundation/service-metadata-codec.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeServiceMetadataFrame = encodeServiceMetadataFrame;
 exports.validateServiceMetadataFrame = validateServiceMetadataFrame;
-const MAX_METADATA_BYTES = 1024;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true });
 function encodeServiceMetadataFrame(entries) {
     if (entries.size > 0xff) {
@@ -19,8 +19,8 @@ function encodeServiceMetadataFrame(entries) {
     return validateServiceMetadataFrame(Buffer.concat(encoded));
 }
 function validateServiceMetadataFrame(frame) {
-    if (frame.byteLength > MAX_METADATA_BYTES) {
-        throw new RangeError('Application metadata frame exceeds 1024 bytes.');
+    if (frame.byteLength > stream_wire_1.ZLINK_STREAM_MAX_METADATA_BYTES) {
+        throw new RangeError(`Application metadata frame exceeds ${stream_wire_1.ZLINK_STREAM_MAX_METADATA_BYTES} bytes.`);
     }
     const bytes = Buffer.from(frame);
     let offset = 0;

package/dist/runtime/foundation/service-relocation-aggregate-committer.d.ts

@@ -20,16 +20,13 @@ export interface ServicePreparedRelocationAggregate {
     readonly fence: ZLinkAggregateFence;
     readonly plan: ServiceRelocationAggregatePlan;
 }
-type AggregateStore = Pick<ZLinkObjectCreationStore, 'prepareAggregate' | 'commitAggregate' | 'abortAggregate'> & Pick<ZLinkAuthorityStore, 'readAuthority'>;
-/** Commits every owner and membership row through one Location Store fence. */
+type AggregateStore = Pick<ZLinkObjectCreationStore, 'prepareAggregate' | 'abortAggregate'> & Pick<ZLinkAuthorityStore, 'readAuthority'>;
+/** Prepares and aborts relocation through one Location Store fence. */
 export declare class ServiceRelocationAggregateCommitter {
     private readonly store;
     constructor(store: AggregateStore);
     prepare(plan: ServiceRelocationAggregatePlan, signal?: AbortSignal): Promise<ServicePreparedRelocationAggregate>;
     private authorityStoreVersionsUnchanged;
-    commit(prepared: ServicePreparedRelocationAggregate, signal?: AbortSignal): Promise<ReadonlyMap<string, ZLinkAuthoritySnapshot>>;
     abort(prepared: ServicePreparedRelocationAggregate, signal?: AbortSignal): Promise<void>;
-    private commitFence;
-    private readCommittedParticipants;
 }
 export {};

package/dist/runtime/foundation/service-relocation-aggregate-committer.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceRelocationAggregateCommitter = void 0;
 const service_relocation_runtime_1 = require("./service-relocation-runtime");
 const MAX_PREPARE_CONFLICT_ATTEMPTS = 8;
-/** Commits every owner and membership row through one Location Store fence. */
+/** Prepares and aborts relocation through one Location Store fence. */
 class ServiceRelocationAggregateCommitter {
     store;
     constructor(store) {
@@ -52,59 +52,12 @@ class ServiceRelocationAggregateCommitter {
         }
         return true;
     }
-    async commit(prepared, signal) {
-        try {
-            await this.commitFence(prepared.fence, signal);
-        }
-        catch (firstError) {
-            // A lost commit response is reconciled by repeating the exact durable fence.
-            try {
-                await this.commitFence(prepared.fence, signal);
-            }
-            catch {
-                throw firstError;
-            }
-        }
-        return await this.readCommittedParticipants(prepared.plan, signal);
-    }
     async abort(prepared, signal) {
         const result = await this.store.abortAggregate(prepared.fence, signal);
         if (result.kind !== 'aborted' && result.kind !== 'alreadyAborted') {
             throw new Error(`Location Store rejected relocation aggregate abort: ${result.kind}.`);
         }
     }
-    async commitFence(fence, signal) {
-        const result = await this.store.commitAggregate(fence, signal);
-        if (result.kind !== 'committed' && result.kind !== 'alreadyCommitted') {
-            throw new Error(`Location Store rejected relocation aggregate commit: ${result.kind}.`);
-        }
-    }
-    async readCommittedParticipants(plan, signal) {
-        const committed = new Map();
-        for (const participant of plan.participants) {
-            const current = await this.store.readAuthority(participant.key, signal);
-            if (current.kind !== 'snapshot' ||
-                current.objectGeneration !== participant.expected.objectGeneration ||
-                current.storeVersion.value === participant.expected.storeVersion.value ||
-                !Buffer.from(current.payload).equals(Buffer.from(participant.authorityPayload))) {
-                throw new Error('Committed relocation aggregate does not match its exact participant plan.');
-            }
-            if (participant.ownerTransition === 'newOwner') {
-                if (current.ownerId !== plan.targetOwner.ownerId ||
-                    current.ownerLeaseGeneration !== plan.targetOwner.leaseGeneration ||
-                    current.authorityOwnerGeneration <= participant.expected.authorityOwnerGeneration) {
-                    throw new Error('Committed relocation participant has a different owner fence.');
-                }
-            }
-            else if (current.ownerId !== participant.expected.ownerId ||
-                current.ownerLeaseGeneration !== participant.expected.ownerLeaseGeneration ||
-                current.authorityOwnerGeneration !== participant.expected.authorityOwnerGeneration) {
-                throw new Error('Preserved relocation participant changed its owner fence.');
-            }
-            committed.set(participant.key.value, current);
-        }
-        return committed;
-    }
 }
 exports.ServiceRelocationAggregateCommitter = ServiceRelocationAggregateCommitter;
 function validateAndEncodeParticipants(plan) {

package/dist/runtime/foundation/service-relocation-object-owner.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceRelocationObjectRestoreOwner = exports.ServiceRelocationObjectCaptureOwner = exports.ServiceCapturedObjectRelocation = void 0;
+const DEFAULT_RELOCATION_CALLBACK_CONCURRENCY = 8;
 class ServiceCapturedObjectRelocation {
     envelope;
     units;
@@ -56,7 +57,7 @@ exports.ServiceCapturedObjectRelocation = ServiceCapturedObjectRelocation;
 /** Captures the two valid relocation units: User Spot aggregate or one Actor. */
 class ServiceRelocationObjectCaptureOwner {
     maxConcurrentCallbacks;
-    constructor(maxConcurrentCallbacks = 8) {
+    constructor(maxConcurrentCallbacks = DEFAULT_RELOCATION_CALLBACK_CONCURRENCY) {
         this.maxConcurrentCallbacks = maxConcurrentCallbacks;
         requireCallbackConcurrency(maxConcurrentCallbacks);
     }
@@ -127,7 +128,7 @@ class ServiceRelocationObjectRestoreOwner {
     target;
     authorityKey;
     maxConcurrentCallbacks;
-    constructor(target, authorityKey, maxConcurrentCallbacks = 8) {
+    constructor(target, authorityKey, maxConcurrentCallbacks = DEFAULT_RELOCATION_CALLBACK_CONCURRENCY) {
         this.target = target;
         this.authorityKey = authorityKey;
         this.maxConcurrentCallbacks = maxConcurrentCallbacks;

package/dist/runtime/foundation/service-relocation-runtime.js

@@ -11,9 +11,18 @@ exports.encodeServiceRelocationEnvelope = encodeServiceRelocationEnvelope;
 exports.decodeServiceRelocationEnvelope = decodeServiceRelocationEnvelope;
 exports.inventoryDigest = inventoryDigest;
 exports.crc32c = crc32c;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
+const InternalDefaults_1 = require("../../contracts/Configuration/InternalDefaults");
 const authority_key_codec_1 = require("../locations/authority-key-codec");
+const service_wire_codec_generated_1 = require("../protocol/service_wire_codec.generated");
 const service_wire_pilot_codec_generated_1 = require("../protocol/service_wire_pilot_codec.generated");
+const actor_join_recovery_codec_1 = require("./actor-join-recovery-codec");
+const MAX_RELOCATION_GENERATION = 0x7fffffffffffffffn;
+const RELOCATION_PREPARING_PHASE = (0, service_wire_codec_generated_1.enumWireRelocationPhase)('preparing');
+const RELOCATION_ACTIVATING_PHASE = (0, service_wire_codec_generated_1.enumWireRelocationPhase)('activating');
+const RELOCATION_COMPLETED_PHASE = (0, service_wire_codec_generated_1.enumWireRelocationPhase)('completed');
+const RELOCATION_LAST_PHASE = (0, service_wire_codec_generated_1.enumWireRelocationPhase)('aborted');
 /** Deterministic Location authority wrapper for one immutable relocation root. */
 class ServiceRelocationAuthorityPayloadCodec {
     publish(currentPayload, publication) {
@@ -109,7 +118,7 @@ function projectServiceRelocationAuthorityTargetReady(payload, target) {
         coordinatorNodeRid: target.nodeRid,
         coordinatorNodeGeneration: target.nodeGeneration,
         coordinatorExpectedStoreVersion: target.coordinatorExpectedStoreVersion,
-        phase: 5,
+        phase: RELOCATION_ACTIVATING_PHASE,
         sourceCleanupState: 0
     });
     return replaceCanonicalRelocationSlot(layout, slot);
@@ -150,7 +159,7 @@ function decodeCanonicalAuthorityPublication(payload) {
 function decodeCanonicalAuthorityLayout(payload) {
     try {
         const bytes = Buffer.from(payload);
-        if (bytes.byteLength < 20 || bytes.byteLength > 1024 * 1024)
+        if (bytes.byteLength < 20 || bytes.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES)
             return undefined;
         const reader = new CanonicalReader(bytes);
         reader.expect(Buffer.from('ZLAU'));
@@ -223,21 +232,21 @@ function decodeCanonicalRelocationSlot(payload, rootAggregateGeneration) {
         const sourceCleanupState = reader.u8();
         if (!reader.done ||
             aggregateGeneration > 0x7ffffffffffffffen ||
-            (aggregateGeneration === 0n && phase !== 1) ||
+            (aggregateGeneration === 0n && phase !== RELOCATION_PREPARING_PHASE) ||
             (rootAggregateGeneration !== undefined && aggregateGeneration !== rootAggregateGeneration) ||
-            targetAttemptGeneration > 0x7fffffffffffffffn ||
+            targetAttemptGeneration > MAX_RELOCATION_GENERATION ||
             sourceNodeGeneration === 0n ||
-            sourceNodeGeneration > 0x7fffffffffffffffn ||
+            sourceNodeGeneration > MAX_RELOCATION_GENERATION ||
             sourceOwnerLeaseGeneration === 0n ||
-            sourceOwnerLeaseGeneration > 0x7fffffffffffffffn ||
-            targetNodeGeneration > 0x7fffffffffffffffn ||
-            targetOwnerLeaseGeneration > 0x7fffffffffffffffn ||
+            sourceOwnerLeaseGeneration > MAX_RELOCATION_GENERATION ||
+            targetNodeGeneration > MAX_RELOCATION_GENERATION ||
+            targetOwnerLeaseGeneration > MAX_RELOCATION_GENERATION ||
             coordinatorLeaseGeneration === 0n ||
-            coordinatorLeaseGeneration > 0x7fffffffffffffffn ||
+            coordinatorLeaseGeneration > MAX_RELOCATION_GENERATION ||
             coordinatorNodeGeneration === 0n ||
-            coordinatorNodeGeneration > 0x7fffffffffffffffn ||
-            phase < 1 ||
-            phase > 9 ||
+            coordinatorNodeGeneration > MAX_RELOCATION_GENERATION ||
+            phase < RELOCATION_PREPARING_PHASE ||
+            phase > RELOCATION_LAST_PHASE ||
             applicationVersion < 0n ||
             sourceCleanupState > 2)
             return undefined;
@@ -276,10 +285,10 @@ function encodeCanonicalRelocationSlot(value) {
     if (aggregateGeneration > 0x7ffffffffffffffen) {
         throw new TypeError('Aggregate generation exceeds the issued range.');
     }
-    if (aggregateGeneration === 0n && value.phase !== 1) {
+    if (aggregateGeneration === 0n && value.phase !== RELOCATION_PREPARING_PHASE) {
         throw new TypeError('Zero aggregate generation is only valid while preparing.');
     }
-    if (targetAttemptGeneration > 0x7fffffffffffffffn) {
+    if (targetAttemptGeneration > MAX_RELOCATION_GENERATION) {
         throw new TypeError('Target attempt generation exceeds the ordinal range.');
     }
     const sourceNodeGeneration = canonicalNonZeroOrdinal(value.sourceNodeGeneration, 'source node generation');
@@ -288,7 +297,9 @@ function encodeCanonicalRelocationSlot(value) {
     const targetOwnerLeaseGeneration = canonicalOrdinal(value.targetOwnerLeaseGeneration, 'target owner lease generation');
     const coordinatorLeaseGeneration = canonicalNonZeroOrdinal(value.coordinatorLeaseGeneration, 'coordinator lease generation');
     const coordinatorNodeGeneration = canonicalNonZeroOrdinal(value.coordinatorNodeGeneration, 'coordinator node generation');
-    if (!Number.isInteger(value.phase) || value.phase < 1 || value.phase > 9) {
+    if (!Number.isInteger(value.phase) ||
+        value.phase < RELOCATION_PREPARING_PHASE ||
+        value.phase > RELOCATION_LAST_PHASE) {
         throw new TypeError('Canonical relocation phase is invalid.');
     }
     if (!Number.isInteger(value.sourceCleanupState) ||
@@ -348,7 +359,7 @@ function encodeCanonicalRelocationPublicationSlot(layout, publication) {
         coordinatorNodeRid: publication.coordinatorNodeRid ?? nodeRid,
         coordinatorNodeGeneration: publication.coordinatorNodeGeneration ?? layout.nodeGeneration,
         coordinatorExpectedStoreVersion: publication.coordinatorExpectedStoreVersion ?? '',
-        phase: publication.canonicalPhase ?? 8,
+        phase: publication.canonicalPhase ?? RELOCATION_COMPLETED_PHASE,
         applicationVersion,
         sourceCleanupState: publication.canonicalSourceCleanupState ?? 0
     });
@@ -370,8 +381,8 @@ function replaceCanonicalRelocationSlot(layout, slot) {
         body
     ]);
     const result = Buffer.concat([envelope, canonicalU32(crc32c(envelope))]);
-    if (result.byteLength > 1024 * 1024) {
-        throw new TypeError('Canonical authority payload exceeds 1 MiB.');
+    if (result.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
+        throw new TypeError(`Canonical authority payload exceeds ${InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`);
     }
     return result;
 }
@@ -721,8 +732,8 @@ function encodeAuthorityEnvelope(base, publication) {
     }
     const aggregateGeneration = positiveBigInt(publication.aggregateGeneration, 'aggregate generation');
     const targetOwnerLeaseGeneration = positiveBigInt(publication.targetOwnerLeaseGeneration, 'target owner lease generation');
-    if (aggregateGeneration > 0x7fffffffffffffffn ||
-        targetOwnerLeaseGeneration > 0x7fffffffffffffffn) {
+    if (aggregateGeneration > MAX_RELOCATION_GENERATION ||
+        targetOwnerLeaseGeneration > MAX_RELOCATION_GENERATION) {
         throw new TypeError('Relocation publication generations must fit signed 64-bit storage.');
     }
     const payload = Buffer.concat([
@@ -738,8 +749,8 @@ function encodeAuthorityEnvelope(base, publication) {
         i64le(targetOwnerLeaseGeneration),
         bytes32le(base)
     ]);
-    if (payload.byteLength > 1024 * 1024) {
-        throw new TypeError('Location authority relocation payload exceeds 1 MiB.');
+    if (payload.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
+        throw new TypeError(`Location authority relocation payload exceeds ${InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`);
     }
     return payload;
 }
@@ -759,8 +770,8 @@ function decodeAuthorityEnvelope(payload) {
         const base = reader.bytes32();
         if (!reader.done ||
             aggregateGeneration === 0n ||
-            aggregateGeneration > 0x7fffffffffffffffn ||
-            inventoryDigestBytes.byteLength !== 32 ||
+            aggregateGeneration > MAX_RELOCATION_GENERATION ||
+            inventoryDigestBytes.byteLength !== actor_join_recovery_codec_1.SHA256_DIGEST_BYTES ||
             targetOwnerLeaseGeneration <= 0n) {
             return undefined;
         }
@@ -852,8 +863,8 @@ function text16le(value) {
 }
 function bytes32le(value) {
     const bytes = Buffer.from(value);
-    if (bytes.byteLength > 1024 * 1024) {
-        throw new TypeError('Relocation byte field exceeds 1 MiB.');
+    if (bytes.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
+        throw new TypeError(`Relocation byte field exceeds ${InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`);
     }
     const length = Buffer.alloc(4);
     length.writeInt32LE(bytes.byteLength);
@@ -1001,7 +1012,7 @@ function canonicalU32(value) {
     return result;
 }
 function canonicalU64(value) {
-    if (value < 0n || value > 0xffffffffffffffffn) {
+    if (value < 0n || value > stream_wire_1.UINT64_MAX) {
         throw new TypeError('Canonical authority u64 is invalid.');
     }
     const result = Buffer.alloc(8);
@@ -1010,7 +1021,7 @@ function canonicalU64(value) {
 }
 function canonicalOrdinal(value, name) {
     const ordinal = nonNegativeBigInt(value, name);
-    if (ordinal > 0x7fffffffffffffffn) {
+    if (ordinal > MAX_RELOCATION_GENERATION) {
         throw new TypeError(`${name} exceeds the ordinal range.`);
     }
     return ordinal;
@@ -1022,7 +1033,7 @@ function canonicalNonZeroOrdinal(value, name) {
     return ordinal;
 }
 function canonicalI64(value) {
-    if (value < 0n || value > 0x7fffffffffffffffn) {
+    if (value < 0n || value > MAX_RELOCATION_GENERATION) {
         throw new TypeError('Canonical authority i64 is invalid.');
     }
     const result = Buffer.alloc(8);
@@ -1034,8 +1045,8 @@ class DotnetBinaryReader {
     offset = 0;
     constructor(payload) {
         this.bytes = Buffer.from(payload);
-        if (this.bytes.byteLength > 1024 * 1024) {
-            throw new TypeError('Location authority relocation payload exceeds 1 MiB.');
+        if (this.bytes.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
+            throw new TypeError(`Location authority relocation payload exceeds ${InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`);
         }
     }
     get done() {
@@ -1066,7 +1077,7 @@ class DotnetBinaryReader {
     }
     bytes32() {
         const length = this.take(4).readInt32LE(0);
-        if (length < 0 || length > 1024 * 1024) {
+        if (length < 0 || length > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
             throw new TypeError('Location authority relocation byte field is invalid.');
         }
         return Buffer.from(this.take(length));

package/dist/runtime/foundation/service-runtime-contracts.d.ts

@@ -1,9 +1,30 @@
-import type { Message } from '../../contracts/Common/Message';
-import type { RequestResult, SubmitResult, ZLinkBackendMessageLike as MessageLike } from '../backend/runtime-values';
 import type { RoutingId } from '../../contracts';
+import type { Message } from '../../contracts/Common/Message';
 import type { ApplicationJobPermitPort } from '../application-jobs/contracts';
+import type { ZLinkBackendMessageLike as MessageLike, RequestResult, SubmitResult } from '../backend/runtime-values';
 import type { ServiceActorRef } from './service-stateful-registry';
 import type { ServiceDirectSpotRouteFence, ServiceRetiredBoundSessionRouteFence } from './service-stateful-wire-codec';
+export declare enum StreamSessionRuntimeState {
+    Created = 1,
+    Started = 2,
+    Closed = 5
+}
+export declare enum MeshNodeRuntimeState {
+    Preparing = 1,
+    Serving = 2,
+    Retiring = 3,
+    Draining = 4,
+    Stopped = 5,
+    Error = 6
+}
+export declare enum MeshPeerRuntimeState {
+    Connecting = 1,
+    Preparing = 2,
+    Serving = 3,
+    Draining = 4,
+    Closed = 5,
+    NotRequired = 6
+}
 export interface MeshOperationId {
     readonly high: bigint;
     readonly low: bigint;
@@ -142,6 +163,17 @@ export interface ActorTransferControlPayload {
     readonly resultCode: number;
     readonly failureErrno: number;
 }
+/** The Session owner's registry view of one Session binding (Session–Actor binding §5-2). */
+export interface ServiceStreamSessionBinding {
+    readonly sessionRid: RoutingId;
+    readonly actor: ServiceActorRef;
+    readonly sessionOwnerNodeRid: RoutingId;
+    readonly sessionOwnerNodeGeneration: bigint;
+    readonly sessionOwnerId: string;
+    readonly sessionOwnerLeaseGeneration: bigint;
+    readonly bindingGeneration: bigint;
+    readonly membershipEpoch: bigint;
+}
 export interface ActorBindingControlPayload {
     readonly kind: 'actorBinding';
     readonly transition: 'active' | 'tombstone';
@@ -199,8 +231,13 @@ export interface ReceiveRecord {
     readonly isPending?: () => boolean;
     /** Absolute deadline used by the local lifecycle dispatch fence. */
     readonly deadlineUnixMs?: bigint;
+    readonly activationRecord?: Extract<import('./service-stateful-wire-codec').ServiceStatefulWireRecord, {
+        readonly kind: 'instanceSpot';
+    }>;
     readonly messageFollowOrigin?: ZLinkMessageFollowOrigin;
     readonly onTerminalCompletion?: () => void | Promise<void>;
+    /** Marks the start of the first handler turn whose terminal record a Close waits for. */
+    readonly onHandlerTurnStarted?: () => void;
     readonly applicationJobPermit?: ApplicationJobPermitPort;
     readonly releaseRetainedIngress?: () => void;
     reply(parts: MessageLike | readonly MessageLike[], flags?: number): SubmitResult;
@@ -279,12 +316,7 @@ export interface StreamSessionService {
     lookupActor(targetNodeRid: RoutingId, actorId: string, timeoutMs?: number): MeshOperationId;
     bindActor(sessionRid: RoutingId, actor: ServiceActorRef, timeoutMs?: number, onBindingReplaced?: (actorId: string, retiredSession: ServiceRetiredBoundSessionRouteFence, actor: ServiceActorRef) => void, actorAuthority?: StreamSessionActorAuthorityFence): MeshOperationId;
     unbindActor(sessionRid: RoutingId, actor: ServiceActorRef, expectedBindingGeneration: bigint, timeoutMs?: number): MeshOperationId;
-    bindings(sessionRid: RoutingId): ReadonlyArray<{
-        readonly sessionRid: RoutingId;
-        readonly actor: ServiceActorRef;
-        readonly bindingGeneration: bigint;
-        readonly membershipEpoch: bigint;
-    }>;
+    bindings(sessionRid: RoutingId): ReadonlyArray<ServiceStreamSessionBinding>;
     sendToActor(sessionRid: RoutingId, actor: ServiceActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
     }): Promise<SubmitResult>;

package/dist/runtime/foundation/service-runtime-contracts.js

@@ -1,7 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActorTransferPhase = exports.ActorTransferRole = exports.ActorLifecycleKind = exports.OperationKind = exports.ReceiveKind = exports.ReadyOwnerKind = exports.ReadyDomain = void 0;
+exports.ActorTransferPhase = exports.ActorTransferRole = exports.ActorLifecycleKind = exports.OperationKind = exports.ReceiveKind = exports.ReadyOwnerKind = exports.ReadyDomain = exports.MeshPeerRuntimeState = exports.MeshNodeRuntimeState = exports.StreamSessionRuntimeState = void 0;
 exports.operationRequiresReply = operationRequiresReply;
+var StreamSessionRuntimeState;
+(function (StreamSessionRuntimeState) {
+    StreamSessionRuntimeState[StreamSessionRuntimeState["Created"] = 1] = "Created";
+    StreamSessionRuntimeState[StreamSessionRuntimeState["Started"] = 2] = "Started";
+    StreamSessionRuntimeState[StreamSessionRuntimeState["Closed"] = 5] = "Closed";
+})(StreamSessionRuntimeState || (exports.StreamSessionRuntimeState = StreamSessionRuntimeState = {}));
+var MeshNodeRuntimeState;
+(function (MeshNodeRuntimeState) {
+    MeshNodeRuntimeState[MeshNodeRuntimeState["Preparing"] = 1] = "Preparing";
+    MeshNodeRuntimeState[MeshNodeRuntimeState["Serving"] = 2] = "Serving";
+    MeshNodeRuntimeState[MeshNodeRuntimeState["Retiring"] = 3] = "Retiring";
+    MeshNodeRuntimeState[MeshNodeRuntimeState["Draining"] = 4] = "Draining";
+    MeshNodeRuntimeState[MeshNodeRuntimeState["Stopped"] = 5] = "Stopped";
+    MeshNodeRuntimeState[MeshNodeRuntimeState["Error"] = 6] = "Error";
+})(MeshNodeRuntimeState || (exports.MeshNodeRuntimeState = MeshNodeRuntimeState = {}));
+var MeshPeerRuntimeState;
+(function (MeshPeerRuntimeState) {
+    MeshPeerRuntimeState[MeshPeerRuntimeState["Connecting"] = 1] = "Connecting";
+    MeshPeerRuntimeState[MeshPeerRuntimeState["Preparing"] = 2] = "Preparing";
+    MeshPeerRuntimeState[MeshPeerRuntimeState["Serving"] = 3] = "Serving";
+    MeshPeerRuntimeState[MeshPeerRuntimeState["Draining"] = 4] = "Draining";
+    MeshPeerRuntimeState[MeshPeerRuntimeState["Closed"] = 5] = "Closed";
+    MeshPeerRuntimeState[MeshPeerRuntimeState["NotRequired"] = 6] = "NotRequired";
+})(MeshPeerRuntimeState || (exports.MeshPeerRuntimeState = MeshPeerRuntimeState = {}));
 exports.ReadyDomain = Object.freeze({
     None: 0,
     Application: 1,

package/dist/runtime/foundation/service-session-binding-ingress-port.d.ts

@@ -1,17 +1,5 @@
-export interface ServiceSessionBindingRetainedDelivery {
-    deliver(): Promise<boolean>;
-    fail(error: unknown): void;
-}
-export type ServiceSessionBindingAdmissionResult = 'passThrough' | 'retained' | 'rejected';
 export interface ServiceSessionBindingIngressPort {
     actorSlot(actorId: string, sessionRid: string): Promise<number | undefined>;
-    /**
-     * Holds a current-binding push while its relocation seal is open
-     * (Session–Actor binding §8.1). The caller has already decided that the push
-     * names the current binding.
-     */
-    retainOutbound(actorId: string, delivery: ServiceSessionBindingRetainedDelivery): Promise<ServiceSessionBindingAdmissionResult>;
-    clearOutbound(actorId: string, error: unknown): Promise<void>;
 }
 export declare function registerServiceSessionBindingIngressPort(service: object, port: ServiceSessionBindingIngressPort): void;
 export declare function serviceSessionBindingIngressPortIfRegistered(service: object): ServiceSessionBindingIngressPort | undefined;

package/dist/runtime/foundation/service-stateful-registry.d.ts

@@ -137,6 +137,8 @@ export declare class ServiceTerminalOperationRegistry<T> {
     fail(id: bigint, error: unknown): boolean;
     cancel(id: bigint): boolean;
     isPending(id: bigint): boolean;
+    get size(): number;
+    expire(nowMs: number, turnDeadlineMs: number): number;
     close(): void;
 }
 export {};