@zlink-systems/framework 0.28.0 → 0.29.1

package/dist/runtime/locations/in-memory-location-store.js

@@ -27,19 +27,19 @@ class ZLinkInMemoryLocationStore {
     authority;
     constructor(now = () => new Date()) {
         this.now = now;
+        const isOwnerLive = (owner) => this.liveOwnerLease(owner.ownerId, this.now())?.token.leaseGeneration ===
+            owner.leaseGeneration;
         this.authority = new in_memory_authority_store_1.ZLinkInMemoryAuthorityStore({
+            isOwnerLive,
             isTargetLive: (key, lifecycleGeneration, owner) => {
                 const descriptor = this.meshNodes.rows.get(meshNodeKey(key.meshName, key.rid));
-                const lease = this.leases.get(owner.ownerId);
                 return (descriptor !== undefined &&
                     descriptor.lifecycleGeneration === lifecycleGeneration &&
                     descriptor.ownerId === owner.ownerId &&
                     descriptor.leaseGeneration === owner.leaseGeneration &&
                     descriptor.objectRole === internal_location_contracts_1.ZLinkObjectRole.Server &&
                     descriptor.state === internal_location_contracts_1.ZLinkFrameworkRuntimeState.Serving &&
-                    lease !== undefined &&
-                    lease.token.leaseGeneration === owner.leaseGeneration &&
-                    lease.leaseExpiresAt.getTime() > this.now().getTime());
+                    isOwnerLive(owner));
             },
             placementCapacityAvailable: (key, requested, reserved, active) => {
                 const descriptor = this.meshNodes.rows.get(meshNodeKey(key.meshName, key.rid));
@@ -86,6 +86,9 @@ class ZLinkInMemoryLocationStore {
     async readCreationTerminal(operation, signal) {
         return this.authority.readCreationTerminal(operation, signal);
     }
+    async releaseEndedReservation(key, expectedStoreVersion, signal) {
+        return this.authority.releaseEndedReservation(key, expectedStoreVersion, signal);
+    }
     async abort(request, signal) {
         return this.authority.abort(request, signal);
     }
@@ -313,7 +316,7 @@ class ZLinkInMemoryLocationStore {
     async listFanoutPublishers(channelName, page = {}, signal) {
         signal?.throwIfAborted();
         const storeNow = this.now();
-        return pageRows(this.fanoutPublishers, (row) => row.channelName === channelName && this.isOwnerLive(row.ownerId, storeNow), page);
+        return pageRows(this.fanoutPublishers, (row) => row.channelName === channelName && this.liveOwnerLease(row.ownerId, storeNow) !== undefined, page);
     }
     async updatePeer(peer, intent) {
         return this.write(this.peers, key_codec_1.ZLinkLocationKeyCodec.encodePeerKey({
@@ -339,7 +342,7 @@ class ZLinkInMemoryLocationStore {
         const current = this.spots.rows.get(key);
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim &&
             current !== undefined &&
-            this.isOwnerLive(current.ownerId, updatedAt)) {
+            this.liveOwnerLease(current.ownerId, updatedAt) !== undefined) {
             return rejectedConflict();
         }
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.Renew) {
@@ -388,7 +391,7 @@ class ZLinkInMemoryLocationStore {
         const current = this.actors.rows.get(key);
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim &&
             current !== undefined &&
-            this.isOwnerLive(current.ownerId, updatedAt)) {
+            this.liveOwnerLease(current.ownerId, updatedAt) !== undefined) {
             return rejectedConflict();
         }
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.Renew) {
@@ -648,7 +651,7 @@ class ZLinkInMemoryLocationStore {
         const current = table.rows.get(key);
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim &&
             current !== undefined &&
-            this.isOwnerLive(ownerOf(current), updatedAt)) {
+            this.liveOwnerLease(ownerOf(current), updatedAt) !== undefined) {
             return rejectedConflict();
         }
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim ||
@@ -711,9 +714,11 @@ class ZLinkInMemoryLocationStore {
         }
         return removed;
     }
-    isOwnerLive(ownerId, now) {
+    liveOwnerLease(ownerId, now) {
         const lease = this.leases.get(ownerId);
-        return lease !== undefined && lease.leaseExpiresAt.getTime() > now.getTime();
+        return lease !== undefined && lease.leaseExpiresAt.getTime() > now.getTime()
+            ? lease
+            : undefined;
     }
     bump(kind, meshName) {
         this.bumpScope({ kind, meshName });

package/dist/runtime/locations/internal-location-contracts.d.ts

@@ -1,4 +1,9 @@
 export * from '../../contracts/Locations';
+import type { ZLinkObjectReserveRequest as ReserveRequest } from '../../contracts/Locations/Authority';
+import type { ZLinkRelocationConfiguration } from '../../contracts/Configuration/RegistrationTypes';
+export interface ZLinkObjectReserveRequest extends ReserveRequest {
+    readonly actorRelocationPolicy?: ZLinkRelocationConfiguration<unknown>['kind'];
+}
 export type * from '../../contracts/Locations/Authority';
 export type { ZLinkActorLocation, ZLinkPeerLocation, ZLinkRouteLocation, ZLinkSpotLocation } from '../../contracts/Locations/Rows';
 export type { ZLinkActorLocationFilter, ZLinkActorLocationKey, ZLinkLocationKey, ZLinkPeerLocationFilter, ZLinkPeerLocationKey, ZLinkRouteLocationFilter, ZLinkRouteLocationKey, ZLinkSpotLocationFilter, ZLinkSpotLocationKey } from '../../contracts/Locations/Keys';

package/dist/runtime/locations/internal-store-contracts.d.ts

@@ -1,7 +1,7 @@
 import type { ZLinkActorLocation, ZLinkActorLocationFilter, ZLinkActorLocationKey, ZLinkLocationOwnerToken, ZLinkLocationPage, ZLinkLocationWriteIntent, ZLinkLocationWriteResult, ZLinkLocationWriteStatus, ZLinkPageRequest, ZLinkPeerLocation, ZLinkPeerLocationFilter, ZLinkPeerLocationKey, ZLinkRouteLocation, ZLinkRouteLocationFilter, ZLinkRouteLocationKey, ZLinkSpotLocation, ZLinkSpotLocationFilter, ZLinkSpotLocationKey } from './internal-location-contracts';
 import type { ZLinkDomainLocationStore } from './domain-store-contract';
 export type ZLinkAuthorityStore = Pick<ZLinkDomainLocationStore, 'readAuthority' | 'compareExchangeAuthority' | 'listAuthorities'>;
-export type ZLinkObjectCreationStore = Pick<ZLinkDomainLocationStore, 'readCreationTerminal' | 'reserve' | 'commit' | 'completeCreation' | 'abort' | 'prepareAggregate' | 'commitAggregate' | 'abortAggregate'>;
+export type ZLinkObjectCreationStore = Pick<ZLinkDomainLocationStore, 'readCreationTerminal' | 'reserve' | 'commit' | 'completeCreation' | 'abort' | 'releaseEndedReservation' | 'prepareAggregate' | 'commitAggregate' | 'abortAggregate'>;
 export type ZLinkOwnerLeaseStore = Pick<ZLinkDomainLocationStore, 'claimOwnerLease' | 'readOwnerLease' | 'renewOwnerLease' | 'releaseOwnerLease'>;
 export type ZLinkMeshNodeLocationStore = Pick<ZLinkDomainLocationStore, 'updateMeshNode' | 'removeMeshNode' | 'listMeshNodes'>;
 export type ZLinkClientServerLocationStore = Pick<ZLinkDomainLocationStore, 'updateClientServer' | 'removeClientServer' | 'listClientServers'>;

package/dist/runtime/locations/location-store-repository.d.ts

@@ -20,6 +20,8 @@ export declare class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationS
     commitAggregate(fence: ZLinkAggregateFence, signal?: AbortSignal): Promise<ZLinkAggregateCommitResult>;
     private commitAggregateCore;
     abortAggregate(fence: ZLinkAggregateFence, signal?: AbortSignal): Promise<ZLinkAggregateAbortResult>;
+    releaseEndedReservation(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal): Promise<boolean>;
+    private tryReleaseEndedReservation;
     reserve(request: ZLinkObjectReserveRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectReserveResult>;
     commit(request: ZLinkObjectCommitRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectCommitResult>;
     abort(request: ZLinkObjectAbortRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectAbortResult>;

package/dist/runtime/locations/location-store-repository.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkLocationStoreRepository = void 0;
+const service_relocation_runtime_1 = require("../foundation/service-relocation-runtime");
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
 const Options_1 = require("../../contracts/Locations/Options");
@@ -46,7 +47,33 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
     constructor(provider, nowProvider = () => new Date()) {
         super(nowProvider);
         this.nowProvider = nowProvider;
-        this.provider = provider;
+        // Classify only failures of the opaque SPI, before interpreting its records.
+        this.provider = {
+            async read(key, signal) {
+                try {
+                    return await provider.read(key, signal);
+                }
+                catch (error) {
+                    throw locationStoreProviderFailure(error, signal);
+                }
+            },
+            async write(request, signal) {
+                try {
+                    return await provider.write(request, signal);
+                }
+                catch (error) {
+                    throw locationStoreProviderFailure(error, signal);
+                }
+            },
+            async scan(request, signal) {
+                try {
+                    return await provider.scan(request, signal);
+                }
+                catch (error) {
+                    throw locationStoreProviderFailure(error, signal);
+                }
+            }
+        };
         this.aggregateInventory = new aggregate_inventory_store_1.ZLinkAggregateInventoryStore(this.provider);
     }
     async readAuthority(key, signal) {
@@ -787,9 +814,88 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             return { kind: 'aborted' };
         }
     }
+    async releaseEndedReservation(key, expectedStoreVersion, signal) {
+        return ((await this.tryReleaseEndedReservation(key, expectedStoreVersion, signal)) === 'reclaimed');
+    }
+    async tryReleaseEndedReservation(key, expectedStoreVersion, signal, request) {
+        const rowKey = authorityKey(key.value);
+        const current = await this.provider.read(rowKey, signal);
+        if (current.kind === 'missing' || current.value.version.value !== expectedStoreVersion)
+            return 'conflict';
+        const record = decodeAuthorityRecord(current.value.bytes);
+        const snapshot = record.snapshot;
+        if ((snapshot.allocation.state === 'active'
+            ? request?.key.kind !== 'actor'
+            : snapshot.pendingCreation === undefined) ||
+            record.aggregate !== undefined ||
+            hasRelocationAuthority(snapshot.payload))
+            return 'notReclaimable';
+        const leaseKey = ownerKey(snapshot.ownerId);
+        const descriptorKey = meshKey(snapshot.allocation.descriptor.meshName, snapshot.allocation.descriptor.rid);
+        const capacityRowKey = capacityKey(snapshot.allocation.descriptor.meshName, String(snapshot.allocation.descriptor.rid));
+        const [lease, descriptor, capacity] = await Promise.all([
+            this.provider.read(leaseKey, signal),
+            this.provider.read(descriptorKey, signal),
+            this.provider.read(capacityRowKey, signal)
+        ]);
+        if (lease.kind === 'found' && lease.value.expiresAt === undefined)
+            throw new Error('Location Store owner lease record is invalid.');
+        const ownerLive = sameLiveOwner(lease, snapshot);
+        if (snapshot.allocation.state === 'active') {
+            if (ownerLive)
+                return 'notReclaimable';
+            if (request?.actorRelocationPolicy !== 'disabled')
+                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'Actor owner lease is unavailable.');
+        }
+        else if (ownerLive &&
+            descriptor.kind === 'found' &&
+            reviveMeshDescriptor(decodeCanonicalDescriptorRecord(descriptor.value.bytes).descriptor).lifecycleGeneration === snapshot.allocation.descriptorLifecycleGeneration)
+            return 'notReclaimable';
+        const mutations = [
+            { kind: 'delete', key: rowKey }
+        ];
+        if (capacity.kind === 'found') {
+            const stored = decodeJson(capacity.value.bytes);
+            try {
+                mutations.push({
+                    kind: 'put',
+                    key: capacityRowKey,
+                    bytes: encodeJson({
+                        active: snapshot.allocation.state === 'active'
+                            ? subtractCapacity(stored.active, snapshot.allocation.capacity)
+                            : stored.active,
+                        pending: snapshot.allocation.state === 'reserved'
+                            ? subtractCapacity(stored.pending, snapshot.allocation.capacity)
+                            : stored.pending
+                    })
+                });
+            }
+            catch (error) {
+                if (!(error instanceof contracts_1.ZLinkFrameworkException) ||
+                    error.kind !== contracts_1.ZLinkFrameworkErrorKind.DataLost)
+                    throw error;
+                const observed = await this.provider.read(rowKey, signal);
+                if (observed.kind === 'missing' ||
+                    observed.value.version.value !== current.value.version.value)
+                    return 'conflict';
+                throw error;
+            }
+        }
+        const result = await this.provider.write({
+            conditions: [
+                { kind: 'version', key: rowKey, expected: current.value.version },
+                conditionFor(leaseKey, lease),
+                conditionFor(descriptorKey, descriptor),
+                conditionFor(capacityRowKey, capacity)
+            ],
+            mutations
+        }, signal);
+        return result.kind === 'applied' ? 'reclaimed' : 'conflict';
+    }
     async reserve(request, signal, deadlineUnixMs) {
         const encodedAuthorityKey = (0, authority_key_codec_1.encodeAuthorityKey)(request.key.kind, request.key.globalId);
         const reservationId = (0, node_crypto_1.randomUUID)();
+        let reclaimVersion;
         for (;;) {
             throwIfOperationExpired(signal, deadlineUnixMs);
             const rowKey = authorityKey(encodedAuthorityKey.value);
@@ -804,56 +910,18 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                     snapshot.allocation.stableType !== request.intent.stableType) {
                     return { kind: 'typeMismatch', current: snapshot };
                 }
-                if (snapshot.allocation.state === 'active') {
-                    return { kind: 'alreadyExists', current: snapshot };
-                }
-                if (record.aggregate !== undefined ||
-                    isCanonicalAuthorityPayload(record.snapshot.payload)) {
-                    // A relocation record carries its own recovery protocol. Reserve
-                    // may reclaim only an unfinished plain creation.
+                if (reclaimVersion !== undefined && snapshot.storeVersion.value !== reclaimVersion)
                     return { kind: 'conflict', current: snapshot };
-                }
-                // The row is Reserved by another owner. An unfinished creation
-                // whose owner lease ended is cancellable, so reclaim it and retry
-                // instead of blocking the key forever.
-                const staleOwnerKey = ownerKey(snapshot.ownerId);
-                const staleCapacityKey = capacityKey(snapshot.allocation.descriptor.meshName, String(snapshot.allocation.descriptor.rid));
-                const [staleOwnerRead, staleCapacityRead] = await Promise.all([
-                    this.provider.read(staleOwnerKey, signal),
-                    this.provider.read(staleCapacityKey, signal)
-                ]);
-                if (staleOwnerRead.kind === 'found' && staleOwnerRead.value.expiresAt === undefined) {
-                    // A lease is always written with a positive TTL, so a missing
-                    // expiry is a corrupt record. Reclaiming deletes authority state,
-                    // so refuse rather than read the absence as expiry.
-                    throw new Error('Location Store owner lease record is invalid.');
-                }
-                if (sameLiveOwner(staleOwnerRead, record.snapshot)) {
-                    return { kind: 'conflict', current: snapshot };
-                }
-                const staleCapacity = staleCapacityRead.kind === 'missing'
-                    ? emptyCapacityRecord()
-                    : decodeJson(staleCapacityRead.value.bytes);
-                await this.provider.write({
-                    conditions: [
-                        { kind: 'version', key: rowKey, expected: current.value.version },
-                        versionCondition(staleOwnerKey, staleOwnerRead),
-                        conditionFor(staleCapacityKey, staleCapacityRead)
-                    ],
-                    mutations: [
-                        { kind: 'delete', key: rowKey },
-                        {
-                            kind: 'put',
-                            key: staleCapacityKey,
-                            bytes: encodeJson({
-                                active: staleCapacity.active,
-                                pending: subtractCapacity(staleCapacity.pending, record.snapshot.allocation.capacity)
-                            })
-                        }
-                    ]
-                }, signal);
+                const reclaim = await this.tryReleaseEndedReservation(encodedAuthorityKey, current.value.version.value, signal, request);
+                if (reclaim === 'notReclaimable')
+                    return snapshot.allocation.state === 'active'
+                        ? { kind: 'alreadyExists', current: snapshot }
+                        : { kind: 'conflict', current: snapshot };
+                reclaimVersion = reclaim === 'conflict' ? snapshot.storeVersion.value : undefined;
                 continue;
             }
+            if (reclaimVersion !== undefined)
+                return { kind: 'conflict', current: { kind: 'missing', storeNow: current.storeNow } };
             const [descriptorRead, leaseRead] = await Promise.all([
                 this.provider.read(descriptorKey, signal),
                 this.provider.read(leaseKey, signal)
@@ -2906,7 +2974,7 @@ function adjustCapacity(usage, delta, direction) {
         const key = capacityTypeKey(delta.spotType);
         const next = (spotTypes[key] ?? 0) + direction * delta.spotType.count;
         if (next < 0)
-            throw new Error('Provider capacity counter underflow.');
+            throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.DataLost, 'Provider capacity counter underflow.');
         if (next === 0)
             delete spotTypes[key];
         else
@@ -2915,7 +2983,7 @@ function adjustCapacity(usage, delta, direction) {
     const actors = usage.actors + direction * delta.actors;
     const spots = usage.spots + direction * delta.spots;
     if (actors < 0 || spots < 0)
-        throw new Error('Provider capacity counter underflow.');
+        throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.DataLost, 'Provider capacity counter underflow.');
     return { actors, spots, spotTypes };
 }
 function capacityTypeKey(value) {
@@ -2942,10 +3010,9 @@ function sameCreationTarget(snapshot, target) {
         snapshot.ownerId === target.owner.ownerId &&
         snapshot.ownerLeaseGeneration === target.owner.leaseGeneration);
 }
-const CANONICAL_AUTHORITY_MAGIC = Buffer.from('ZLAU');
-function isCanonicalAuthorityPayload(payload) {
-    return (payload.byteLength >= CANONICAL_AUTHORITY_MAGIC.byteLength &&
-        Buffer.from(payload.buffer, payload.byteOffset, CANONICAL_AUTHORITY_MAGIC.byteLength).equals(CANONICAL_AUTHORITY_MAGIC));
+const relocationAuthorityCodec = new service_relocation_runtime_1.ServiceRelocationAuthorityPayloadCodec();
+function hasRelocationAuthority(payload) {
+    return relocationAuthorityCodec.read(payload) !== undefined;
 }
 function sameLiveOwner(lease, snapshot) {
     if (lease.kind === 'missing')
@@ -3239,3 +3306,12 @@ function throwIfOperationExpired(signal, deadlineUnixMs) {
         throw new DOMException('Operation deadline exceeded.', 'TimeoutError');
     }
 }
+// Store SPI §6: preserve caller failures and classify provider failures once.
+function locationStoreProviderFailure(error, signal) {
+    if (error instanceof contracts_1.ZLinkFrameworkException ||
+        error instanceof TypeError ||
+        error instanceof RangeError ||
+        signal?.aborted === true)
+        return error;
+    return new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'Location Store provider is unavailable.', error);
+}

package/dist/runtime/spots/spot-entry-activation.d.ts

@@ -89,6 +89,7 @@ export declare class ZLinkEntrySpotActivation {
      */
     commitServiceActorJoin(actor: ZLinkActor, handoffBacklog?: readonly ZLinkActorHandoffPacket[], signal?: AbortSignal): Promise<void>;
     executeActor<T>(actorId: string, operation: () => Promise<T>): Promise<T>;
+    terminateActor(actorId: string, terminal: () => Promise<void>): Promise<void>;
     /**
      * Entry Spot membership does not have an application admission callback.
      * The shared core round-trip therefore accepts a valid returning Actor and

package/dist/runtime/spots/spot-entry-activation.js

@@ -220,6 +220,9 @@ class ZLinkEntrySpotActivation {
     executeActor(actorId, operation) {
         return this.spotSerialExecutor.executeActor(actorId, operation);
     }
+    terminateActor(actorId, terminal) {
+        return this.spotSerialExecutor.terminateActor(actorId, terminal);
+    }
     /**
      * Entry Spot membership does not have an application admission callback.
      * The shared core round-trip therefore accepts a valid returning Actor and

package/dist/runtime/spots/spot-node-runtime-manager.d.ts

@@ -104,6 +104,7 @@ export declare class ZLinkSpotNodeRuntimeManager {
     get primaryMeshCompletions(): ZLinkMeshCompletionTable | undefined;
     notifyEntrySpotActorCreated(nodeRid: RoutingId, actor: ZLinkActor, createRequest: ZLinkMessage, signal?: AbortSignal): Promise<import('../../contracts').ZLinkActorCreateResponse | undefined>;
     notifyPrimaryEntrySpotActorJoined(actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
+    terminateActorActivation(actor: ZLinkActor, terminal: () => Promise<void>): Promise<void>;
     notifyPrimaryEntrySpotActorLeft(actor: ZLinkActor, signal?: AbortSignal, actorRef?: ActorRef, membershipEpoch?: bigint): Promise<void>;
     notifyPrimaryEntrySpotActorDisconnected(actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
     notifyEntrySpotActorDisconnected(meshName: string, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;

package/dist/runtime/spots/spot-node-runtime-manager.js

@@ -542,6 +542,12 @@ class ZLinkSpotNodeRuntimeManager {
         const activation = this.primaryEntryActivation();
         return activation?.notifyJoinActor(actor, signal) ?? Promise.resolve();
     }
+    terminateActorActivation(actor, terminal) {
+        const activation = this.entryActivations.get(actor.context.meshName);
+        return activation === undefined
+            ? terminal()
+            : activation.terminateActor(actor.context.actorId, terminal);
+    }
     notifyPrimaryEntrySpotActorLeft(actor, signal, actorRef, membershipEpoch) {
         const activation = this.primaryEntryActivation();
         return (activation?.notifyLeaveActor(actor, signal, actorRef, membershipEpoch) ?? Promise.resolve());

package/dist/runtime/spots/spot-serial-executor.d.ts

@@ -26,6 +26,7 @@ export declare class ZLinkSpotSerialExecutor {
     executeTimer<T>(timerName: string, operation: () => Promise<T> | T, workOptions?: ZLinkSerialWorkOptions): Promise<T>;
     isTimerExecuting(timerName: string): boolean;
     executeLifecycle<T>(operation: () => Promise<T> | T, workOptions?: ZLinkSerialWorkOptions): Promise<T>;
+    terminateActor(actorId: string, terminal: () => Promise<void>): Promise<void>;
     /**
      * Makes all child queues unreachable and completes them in one synchronous
      * ownership turn. Already accepted work remains drainable.

package/dist/runtime/spots/spot-serial-executor.js

@@ -42,7 +42,8 @@ class ZLinkSpotSerialExecutor {
         return this.spotSerial.execute(operation, workOptions);
     }
     executeActor(actorId, operation, workOptions) {
-        return this.actorExecutor(actorId).execute(() => operation(this.actorSerial(actorId)), workOptions);
+        const serial = this.actorSerial(actorId);
+        return this.actorExecutor(actorId).execute(() => operation(serial), workOptions);
     }
     /** @internal Restores a durable Actor FIFO prefix without starting it. */
     admitActorDurablePrefix(actorId, records) {
@@ -65,6 +66,14 @@ class ZLinkSpotSerialExecutor {
     executeLifecycle(operation, workOptions) {
         return this.spotSerial.execute(operation, { ...workOptions, lane: 'lifecycle' });
     }
+    async terminateActor(actorId, terminal) {
+        const executor = this.actorExecutor(actorId);
+        await executor.close();
+        await terminal();
+        if (this.actorExecutors.get(actorId) === executor)
+            this.actorExecutors.delete(actorId);
+        this.actorSerials.delete(actorId);
+    }
     /**
      * Makes all child queues unreachable and completes them in one synchronous
      * ownership turn. Already accepted work remains drainable.
@@ -96,7 +105,10 @@ class ZLinkSpotSerialExecutor {
         this.throwIfClosing();
         let executor = this.actorExecutors.get(actorId);
         if (executor === undefined) {
-            executor = new actors_1.ZLinkActorSerialExecutor(actorId, this.sourceSpotId, this.actorOptions);
+            executor =
+                this.executionMode === contracts_1.ZLinkUserSpotExecutionMode.SpotWide
+                    ? this.spotSerial.createActorExecutor(actorId, this.sourceSpotId, this.actorOptions)
+                    : new actors_1.ZLinkActorSerialExecutor(actorId, this.sourceSpotId, this.actorOptions);
             this.actorExecutors.set(actorId, executor);
         }
         return executor;

package/dist/runtime/spots/spot-serial-turn-executor.d.ts

@@ -3,6 +3,7 @@ import type { SpotId } from '../../contracts';
 import type { ZLinkFrameworkException } from '../../contracts/Errors/ZLinkFrameworkException';
 import { type ZLinkSerialSchedulerOptions, type ZLinkSerialWorkOptions, type ZLinkSerialWorkRecord } from '../execution/serial-execution-queue';
 import type { ZLinkSerialLifecycleContext } from '../execution/serial-execution-queue';
+import { ZLinkActorSerialExecutor } from '../actors/actor-mailbox';
 export type ZLinkSpotApplicationTurnContext = ZLinkExecutionBarrierClaim & {
     readonly replay?: (failure?: unknown) => Promise<unknown> | unknown;
 };
@@ -19,6 +20,8 @@ export declare class ZLinkSpotSerialTurnExecutor {
     activeTurnId: number;
     constructor(yieldAllowed?: boolean, sourceSpotId?: SpotId | undefined, schedulerOptions?: ZLinkSerialSchedulerOptions);
     get isExecuting(): boolean;
+    /** Creates a passive Actor mailbox consumed by this Spot's scheduler. */
+    createActorExecutor(actorId: string, sourceSpotId: unknown, options?: ZLinkSerialSchedulerOptions): ZLinkActorSerialExecutor;
     get isCurrentTurn(): boolean;
     get hasPendingWork(): boolean;
     get lastActivityAt(): number;

package/dist/runtime/spots/spot-serial-turn-executor.js

@@ -4,6 +4,7 @@ exports.ZLinkSpotSerialTurnExecutor = void 0;
 const execution_1 = require("../execution");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const serial_execution_queue_1 = require("../execution/serial-execution-queue");
+const actor_mailbox_1 = require("../actors/actor-mailbox");
 const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
 class ZLinkSpotSerialTurnExecutor {
     yieldAllowed;
@@ -24,6 +25,10 @@ class ZLinkSpotSerialTurnExecutor {
     get isExecuting() {
         return this.depth > 0;
     }
+    /** Creates a passive Actor mailbox consumed by this Spot's scheduler. */
+    createActorExecutor(actorId, sourceSpotId, options) {
+        return new actor_mailbox_1.ZLinkActorSerialExecutor(actorId, sourceSpotId, options, this.scheduler);
+    }
     get isCurrentTurn() {
         return this.depth > 0 && (0, execution_1.isCurrentZLinkSpotSerialTurn)(this);
     }

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

@@ -16,7 +16,6 @@ import { ZLinkStreamCodec, ZLinkStreamMessageKind, type ZLinkStreamFrameHeader,
 import { DefaultZLinkSessionActor, DefaultZLinkSessionContext } from './session-context';
 import type { ZLinkActorRouteCommitOptions, ZLinkSessionBindingConfirmationOptions, ZLinkSessionBindingIdentity } from './stream-binding-runtime-ports';
 import { ZLinkStreamSessionNodeRuntime as ZLinkStreamSessionNodeRuntimeCore, ZLinkStreamSessionRuntime as ZLinkStreamSessionRuntimeCore, type ZLinkStreamSessionNodeRuntimeOptions as ZLinkStreamSessionNodeRuntimeCoreOptions, type ZLinkStreamSessionRuntimeOptions as ZLinkStreamSessionRuntimeCoreOptions } from './stream-session-runtime';
-export { ZLinkPendingSessionRequest } from './session-requests';
 export { ZLinkActorSessionLifecycleCoordinator } from './actor-session-lifecycle-coordinator';
 export { ZLinkActorSessionBindingRegistry } from './actor-session-binding-registry';
 export { zlinkStreamLz4CompressionCodec } from './stream-frame-factory';

package/dist/runtime/streams/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkStreamBindingRuntime = exports.ZLinkStreamSessionNodeRuntime = exports.ZLinkStreamSessionRuntime = exports.ZLinkStreamRuntimeManager = exports.DefaultZLinkSessionContext = exports.DefaultZLinkSessionActor = exports.DefaultZLinkBoundSessionFactory = exports.DefaultZLinkBoundSession = exports.ZLinkManagedStream = exports.zlinkStreamLz4CompressionCodec = exports.ZLinkActorSessionBindingRegistry = exports.ZLinkActorSessionLifecycleCoordinator = exports.ZLinkPendingSessionRequest = void 0;
+exports.ZLinkStreamBindingRuntime = exports.ZLinkStreamSessionNodeRuntime = exports.ZLinkStreamSessionRuntime = exports.ZLinkStreamRuntimeManager = exports.DefaultZLinkSessionContext = exports.DefaultZLinkSessionActor = exports.DefaultZLinkBoundSessionFactory = exports.DefaultZLinkBoundSession = exports.ZLinkManagedStream = exports.zlinkStreamLz4CompressionCodec = exports.ZLinkActorSessionBindingRegistry = exports.ZLinkActorSessionLifecycleCoordinator = void 0;
 const InternalDefaults_1 = require("../../contracts/Configuration/InternalDefaults");
 const Options_1 = require("../../contracts/Locations/Options");
 const configuration_1 = require("../configuration");
@@ -20,8 +20,6 @@ const stream_frame_factory_1 = require("./stream-frame-factory");
 const stream_message_utils_1 = require("./stream-message-utils");
 const stream_session_runtime_1 = require("./stream-session-runtime");
 const DEFAULT_STREAM_SERVICE_SHUTDOWN_TIMEOUT_MS = 1000;
-var session_requests_1 = require("./session-requests");
-Object.defineProperty(exports, "ZLinkPendingSessionRequest", { enumerable: true, get: function () { return session_requests_1.ZLinkPendingSessionRequest; } });
 var actor_session_lifecycle_coordinator_2 = require("./actor-session-lifecycle-coordinator");
 Object.defineProperty(exports, "ZLinkActorSessionLifecycleCoordinator", { enumerable: true, get: function () { return actor_session_lifecycle_coordinator_2.ZLinkActorSessionLifecycleCoordinator; } });
 var actor_session_binding_registry_2 = require("./actor-session-binding-registry");
@@ -116,6 +114,9 @@ class ZLinkStreamRuntimeManager {
             const readablePoller = streamAdapter.createReadablePoller(socket);
             const runtime = new stream_session_runtime_1.ZLinkStreamSessionNodeRuntime({
                 nodeName,
+                heartbeatIntervalMs: streamNode.heartbeatIntervalMs,
+                heartbeatTimeoutMs: streamNode.heartbeatTimeoutMs,
+                idleTimeoutMs: streamNode.idleTimeoutMs,
                 socket,
                 createPacket: () => streamAdapter.createStreamPacket(),
                 readablePoller,

package/dist/runtime/streams/protocol.js

@@ -118,15 +118,6 @@ function decodeStreamHeader(header, flowEnabled = true) {
     const decoded = (0, stream_wire_1.decodeStreamWireHeader)(header, undefined, flowEnabled);
     const kind = decoded.kind;
     const flags = decoded.flags;
-    const hasRequestSeq = (flags & stream_wire_1.ZlinkStreamHeaderFlags.HasRequestSeq) !== 0;
-    const hasMetadata = (flags & stream_wire_1.ZlinkStreamHeaderFlags.HasMetadata) !== 0;
-    const hasCorrelation = (flags & stream_wire_1.ZlinkStreamHeaderFlags.HasCorrelationId) !== 0;
-    const hasFlow = (flags & stream_wire_1.ZlinkStreamHeaderFlags.HasFlowId) !== 0;
-    const hasActorSlot = (flags & stream_wire_1.ZlinkStreamHeaderFlags.HasActorSlot) !== 0;
-    if (kind === stream_wire_1.ZlinkStreamMessageKind.Control &&
-        (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow || hasActorSlot)) {
-        throw new Error('Control packet must not contain a request sequence, metadata, correlation id, or flow id.');
-    }
     const metadata = publicStreamMetadata(decoded.metadata);
     return {
         kind,

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

@@ -6,7 +6,6 @@ import type { ServiceRetiredBoundSessionRouteFence } from '../foundation/service
 import { type ZLinkSubmitResult } from '../messaging/submission-result';
 import { ZLinkStreamMessageKind, type ZLinkStreamFrameHeader, type ZLinkStreamReplyMessageKind } from './protocol';
 import { DefaultZLinkBoundSessionSendCall } from './session-calls';
-import { type ZLinkPendingSessionRequest } from './session-requests';
 export interface ZLinkSessionContextStream extends ZLinkStream {
     writeRaw(payload: Message, flags?: number): boolean;
     submitRaw(payload: Message): Promise<ZLinkSubmitResult>;
@@ -42,7 +41,6 @@ export declare class DefaultZLinkSessionContext implements ZLinkSessionContext {
     private readonly handlerRegistry;
     readonly handlers: ZLinkSessionHandlerRegistry;
     private readonly localActors;
-    private readonly requests;
     private currentDispatchHeader;
     private currentReplyClaimed;
     private actorBindingReplacementHandler?;
@@ -73,8 +71,6 @@ export declare class DefaultZLinkSessionContext implements ZLinkSessionContext {
     /** True while the current request dispatch has already submitted its reply. */
     get replyClaimed(): boolean;
     claimReply(requestHeader: ZLinkStreamFrameHeader): void;
-    startRequest(timeoutMs?: number): ZLinkPendingSessionRequest;
-    tryCompleteResponse(header: ZLinkStreamFrameHeader, payload: Message): boolean;
     payloadForHeader(header: ZLinkStreamFrameHeader, payload: Message): Message;
     get boundActors(): readonly DefaultZLinkSessionActor[];
     findBoundActor(actorId: string): DefaultZLinkSessionActor | undefined;

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

@@ -12,7 +12,6 @@ const submission_result_1 = require("../messaging/submission-result");
 const protocol_1 = require("./protocol");
 const session_calls_1 = require("./session-calls");
 const session_local_actors_1 = require("./session-local-actors");
-const session_requests_1 = require("./session-requests");
 class DefaultZLinkSessionContext {
     runtime;
     stream;
@@ -22,7 +21,6 @@ class DefaultZLinkSessionContext {
     handlerRegistry;
     handlers;
     localActors = new session_local_actors_1.ZLinkSessionLocalActorBindings();
-    requests = new session_requests_1.ZLinkSessionRequestTracker();
     currentDispatchHeader;
     currentReplyClaimed = false;
     actorBindingReplacementHandler;
@@ -137,21 +135,6 @@ class DefaultZLinkSessionContext {
         }
         this.currentReplyClaimed = true;
     }
-    startRequest(timeoutMs) {
-        return this.requests.start(timeoutMs);
-    }
-    tryCompleteResponse(header, payload) {
-        if (header.requestSeq === undefined) {
-            return false;
-        }
-        if (header.kind === protocol_1.ZLinkStreamMessageKind.Response) {
-            return this.requests.complete(header.requestSeq, payload);
-        }
-        if (header.kind === protocol_1.ZLinkStreamMessageKind.Error) {
-            return this.requests.fail(header.requestSeq, decodeStreamErrorPayload(payload));
-        }
-        return false;
-    }
     payloadForHeader(header, payload) {
         if ((header.flags & protocol_1.ZLinkStreamHeaderFlags.PayloadCompressed) === 0) {
             return payload;
@@ -374,15 +357,6 @@ class DefaultZLinkBoundSessionFactory {
     }
 }
 exports.DefaultZLinkBoundSessionFactory = DefaultZLinkBoundSessionFactory;
-function decodeStreamErrorPayload(payload) {
-    try {
-        const value = JSON.parse(Buffer.from((0, protocol_1.messageToBytes)(payload)).toString());
-        return new Error(typeof value.message === 'string' ? value.message : 'Stream request failed.');
-    }
-    catch {
-        return new Error('Stream request failed.');
-    }
-}
 function sameRetiredSession(left, right) {
     return (left.sessionOwnerNodeRid === right.sessionOwnerNodeRid &&
         left.sessionOwnerNodeGeneration === right.sessionOwnerNodeGeneration &&

package/dist/runtime/streams/session-serial-executor.d.ts

@@ -4,7 +4,6 @@ export declare class ZLinkSessionSerialExecutor {
     private closed;
     executeApplication(work: () => Promise<void>, options?: Omit<ZLinkSerialWorkOptions, 'lane'>, onRejected?: (error?: unknown) => void): boolean;
     executeControl(work: () => Promise<void>, options?: Omit<ZLinkSerialWorkOptions, 'lane'>, onRejected?: (error?: unknown) => void): boolean;
-    executeInfrastructure(work: () => Promise<void>, options?: Omit<ZLinkSerialWorkOptions, 'lane'>, onRejected?: (error?: unknown) => void): boolean;
     executeFinal(work: () => Promise<void>): Promise<void>;
     private submit;
     dispose(): Promise<void>;

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

@@ -13,9 +13,6 @@ class ZLinkSessionSerialExecutor {
     executeControl(work, options = {}, onRejected) {
         return this.submit(work, 'lifecycle', options, onRejected);
     }
-    executeInfrastructure(work, options = {}, onRejected) {
-        return this.submit(work, 'lifecycle', options, onRejected);
-    }
     executeFinal(work) {
         if (this.closed) {
             return Promise.reject((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RuntimeShutdown, 'Session execution queue is closed.'));