@zlink-systems/framework 0.30.1 → 0.30.2

package/dist/runtime/protocol/service_wire_codec.generated.d.ts

@@ -212,6 +212,10 @@ export type SourceCleanupState = "pending" | "completed" | "sourceLeaseExpired";
 export declare function enumWireSourceCleanupState(value: SourceCleanupState): number;
 export declare function decodeSourceCleanupState(bytes: Uint8Array, context: ServiceWireDecoderContext): SourceCleanupState;
 export declare function encodeSourceCleanupState(value: SourceCleanupState, context: ServiceWireDecoderContext): Uint8Array;
+export type SessionSealResult = "sealed" | "bindingAbsent";
+export declare function enumWireSessionSealResult(value: SessionSealResult): number;
+export declare function decodeSessionSealResult(bytes: Uint8Array, context: ServiceWireDecoderContext): SessionSealResult;
+export declare function encodeSessionSealResult(value: SessionSealResult, context: ServiceWireDecoderContext): Uint8Array;
 export type ReplyRelayAckStatus = "terminalReceived" | "alreadyTerminal";
 export declare function enumWireReplyRelayAckStatus(value: ReplyRelayAckStatus): number;
 export declare function decodeReplyRelayAckStatus(bytes: Uint8Array, context: ServiceWireDecoderContext): ReplyRelayAckStatus;
@@ -1519,6 +1523,7 @@ export type RelocationPrepareCommand = {
     readonly payloadChunkCount: RelocationChunkCount;
     readonly payloadChecksumCrc32c: U32;
     readonly applicationVersion: ApplicationVersion;
+    readonly deadlineUnixMs: NonzeroU64;
 };
 export declare function decodeRelocationPrepareCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): RelocationPrepareCommand;
 export declare function encodeRelocationPrepareCommand(value: RelocationPrepareCommand, context: ServiceWireDecoderContext): readonly Uint8Array[];
@@ -1536,6 +1541,8 @@ export type SessionRelocationSealCommand = {
     readonly sessionOwnerLeaseGeneration: NonzeroU64;
     readonly sessionRid: Rid;
     readonly bindingGeneration: NonzeroU64;
+    readonly targetNodeRid: Rid;
+    readonly targetNodeGeneration: NonzeroU64;
 };
 export declare function decodeSessionRelocationSealCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): SessionRelocationSealCommand;
 export declare function encodeSessionRelocationSealCommand(value: SessionRelocationSealCommand, context: ServiceWireDecoderContext): readonly Uint8Array[];
@@ -1552,6 +1559,7 @@ export type SessionRelocationSealedCommand = {
     readonly sessionOwnerLeaseGeneration: NonzeroU64;
     readonly sessionRid: Rid;
     readonly bindingGeneration: NonzeroU64;
+    readonly sealResult: SessionSealResult;
 };
 export declare function decodeSessionRelocationSealedCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): SessionRelocationSealedCommand;
 export declare function encodeSessionRelocationSealedCommand(value: SessionRelocationSealedCommand, context: ServiceWireDecoderContext): readonly Uint8Array[];
@@ -1675,7 +1683,17 @@ export type RelocationFailedCommand = {
 export declare function decodeRelocationFailedCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): RelocationFailedCommand;
 export declare function encodeRelocationFailedCommand(value: RelocationFailedCommand, context: ServiceWireDecoderContext): readonly Uint8Array[];
 export declare function validateRelocationFailedCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void;
-export type ServiceWireCommand = HelloCommand | AdmitCommand | RejectCommand | UpdateCommand | LivenessProbeCommand | LivenessAckCommand | NodeSendCommand | NodeRequestCommand | ChannelSendCommand | ChannelRequestCommand | ReplyCommand | SpotSendCommand | SpotRequestCommand | LogicalMulticastCommand | ActorSendCommand | ActorRequestCommand | ActorLookupCommand | ActorDestroyCommand | ActorJoinCommand | ActorLeftCommand | RelocationReadyCommand | RelocationDataCommand | ReplyRelayCommand | RelocationCutoverCommand | BoundSessionSendCommand | ActorJoinedCommand | BoundSessionBindCommand | InstanceSpotCommand | RelocationPrepareCommand | SessionRelocationSealCommand | SessionRelocationSealedCommand | SessionRelocationRouteCommand | ReplyRelayAckCommand | UserSpotCreateCommand | UserSpotCloseCommand | ActorCreateCommand | MessageFollowCommand | BoundSessionReplacedCommand | RelocationStateCommand | RelocationFailedCommand;
+export type BoundSessionCloseCommand = {
+    readonly command: "boundSessionClose";
+    readonly flags: number;
+    readonly correlation: NonzeroU64;
+    readonly actor: ActorRef;
+    readonly session: RetiredBoundSessionRouteFence;
+};
+export declare function decodeBoundSessionCloseCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): BoundSessionCloseCommand;
+export declare function encodeBoundSessionCloseCommand(value: BoundSessionCloseCommand, context: ServiceWireDecoderContext): readonly Uint8Array[];
+export declare function validateBoundSessionCloseCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void;
+export type ServiceWireCommand = HelloCommand | AdmitCommand | RejectCommand | UpdateCommand | LivenessProbeCommand | LivenessAckCommand | NodeSendCommand | NodeRequestCommand | ChannelSendCommand | ChannelRequestCommand | ReplyCommand | SpotSendCommand | SpotRequestCommand | LogicalMulticastCommand | ActorSendCommand | ActorRequestCommand | ActorLookupCommand | ActorDestroyCommand | ActorJoinCommand | ActorLeftCommand | RelocationReadyCommand | RelocationDataCommand | ReplyRelayCommand | RelocationCutoverCommand | BoundSessionSendCommand | ActorJoinedCommand | BoundSessionBindCommand | InstanceSpotCommand | RelocationPrepareCommand | SessionRelocationSealCommand | SessionRelocationSealedCommand | SessionRelocationRouteCommand | ReplyRelayAckCommand | UserSpotCreateCommand | UserSpotCloseCommand | ActorCreateCommand | MessageFollowCommand | BoundSessionReplacedCommand | RelocationStateCommand | RelocationFailedCommand | BoundSessionCloseCommand;
 export declare function decodeAuthorityPayloadV1DurableFormat(bytes: Uint8Array, context: ServiceWireDecoderContext): AuthorityPayloadV1;
 export declare function encodeAuthorityPayloadV1DurableFormat(value: AuthorityPayloadV1, context: ServiceWireDecoderContext): Uint8Array;
 export declare function decodeInstanceActivationRecoveryV1DurableFormat(bytes: Uint8Array, context: ServiceWireDecoderContext): InstanceActivationRecoveryV1;

package/dist/runtime/protocol/service_wire_codec.generated.js

@@ -137,6 +137,9 @@ exports.encodeRelocationPhase = encodeRelocationPhase;
 exports.enumWireSourceCleanupState = enumWireSourceCleanupState;
 exports.decodeSourceCleanupState = decodeSourceCleanupState;
 exports.encodeSourceCleanupState = encodeSourceCleanupState;
+exports.enumWireSessionSealResult = enumWireSessionSealResult;
+exports.decodeSessionSealResult = decodeSessionSealResult;
+exports.encodeSessionSealResult = encodeSessionSealResult;
 exports.enumWireReplyRelayAckStatus = enumWireReplyRelayAckStatus;
 exports.decodeReplyRelayAckStatus = decodeReplyRelayAckStatus;
 exports.encodeReplyRelayAckStatus = encodeReplyRelayAckStatus;
@@ -477,6 +480,9 @@ exports.validateRelocationStateCommandRuntimePredicates = validateRelocationStat
 exports.decodeRelocationFailedCommand = decodeRelocationFailedCommand;
 exports.encodeRelocationFailedCommand = encodeRelocationFailedCommand;
 exports.validateRelocationFailedCommandRuntimePredicates = validateRelocationFailedCommandRuntimePredicates;
+exports.decodeBoundSessionCloseCommand = decodeBoundSessionCloseCommand;
+exports.encodeBoundSessionCloseCommand = encodeBoundSessionCloseCommand;
+exports.validateBoundSessionCloseCommandRuntimePredicates = validateBoundSessionCloseCommandRuntimePredicates;
 exports.decodeAuthorityPayloadV1DurableFormat = decodeAuthorityPayloadV1DurableFormat;
 exports.encodeAuthorityPayloadV1DurableFormat = encodeAuthorityPayloadV1DurableFormat;
 exports.decodeInstanceActivationRecoveryV1DurableFormat = decodeInstanceActivationRecoveryV1DurableFormat;
@@ -2721,6 +2727,32 @@ function writeSourceCleanupState(input, writer, context, enclosing, flags) {
 }
 function decodeSourceCleanupState(bytes, context) { const reader = new Reader(bytes); const value = readSourceCleanupState(reader, context, {}, 0); reader.done("source-cleanup-state"); return value; }
 function encodeSourceCleanupState(value, context) { const writer = new Writer(); writeSourceCleanupState(value, writer, context, {}, 0); return writer.result(); }
+function enumWireSessionSealResult(value) {
+    switch (value) {
+        case "sealed": return 1;
+        case "bindingAbsent": return 2;
+    }
+}
+function readSessionSealResult(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = reader.u(1);
+    switch (Number(raw)) {
+        case 1: return "sealed";
+        case 2: return "bindingAbsent";
+        default: fail("session-seal-result enum");
+    }
+}
+function writeSessionSealResult(input, writer, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = input;
+    writer.u(numeric(enumWireSessionSealResult(value)), 1);
+}
+function decodeSessionSealResult(bytes, context) { const reader = new Reader(bytes); const value = readSessionSealResult(reader, context, {}, 0); reader.done("session-seal-result"); return value; }
+function encodeSessionSealResult(value, context) { const writer = new Writer(); writeSessionSealResult(value, writer, context, {}, 0); return writer.result(); }
 function enumWireReplyRelayAckStatus(value) {
     switch (value) {
         case "terminalReceived": return 1;
@@ -10024,6 +10056,7 @@ function decodeRelocationPrepareCommand(frames, context) {
     value["payloadChunkCount"] = readRelocationChunkCount(reader, context, value, flags);
     value["payloadChecksumCrc32c"] = readU32(reader, context, value, flags);
     value["applicationVersion"] = readApplicationVersion(reader, context, value, flags);
+    value["deadlineUnixMs"] = readNonzeroU64(reader, context, value, flags);
     reader.done("relocationPrepare");
     let frameIndex = 1;
     if (frameIndex !== frames.length)
@@ -10071,6 +10104,9 @@ function encodeRelocationPrepareCommand(value, context) {
     if (value["applicationVersion"] === undefined)
         fail("applicationVersion required");
     writeApplicationVersion(numeric(value["applicationVersion"]), writer, context, value, value.flags);
+    if (value["deadlineUnixMs"] === undefined)
+        fail("deadlineUnixMs required");
+    writeNonzeroU64(numeric(value["deadlineUnixMs"]), writer, context, value, value.flags);
     const frames = [writer.result()];
     return frames;
 }
@@ -10095,6 +10131,8 @@ function decodeSessionRelocationSealCommand(frames, context) {
     value["sessionOwnerLeaseGeneration"] = readNonzeroU64(reader, context, value, flags);
     value["sessionRid"] = readRid(reader, context, value, flags);
     value["bindingGeneration"] = readNonzeroU64(reader, context, value, flags);
+    value["targetNodeRid"] = readRid(reader, context, value, flags);
+    value["targetNodeGeneration"] = readNonzeroU64(reader, context, value, flags);
     reader.done("sessionRelocationSeal");
     let frameIndex = 1;
     if (frameIndex !== frames.length)
@@ -10136,6 +10174,12 @@ function encodeSessionRelocationSealCommand(value, context) {
     if (value["bindingGeneration"] === undefined)
         fail("bindingGeneration required");
     writeNonzeroU64(numeric(value["bindingGeneration"]), writer, context, value, value.flags);
+    if (value["targetNodeRid"] === undefined)
+        fail("targetNodeRid required");
+    writeRid(value["targetNodeRid"], writer, context, value, value.flags);
+    if (value["targetNodeGeneration"] === undefined)
+        fail("targetNodeGeneration required");
+    writeNonzeroU64(numeric(value["targetNodeGeneration"]), writer, context, value, value.flags);
     const frames = [writer.result()];
     return frames;
 }
@@ -10159,6 +10203,7 @@ function decodeSessionRelocationSealedCommand(frames, context) {
     value["sessionOwnerLeaseGeneration"] = readNonzeroU64(reader, context, value, flags);
     value["sessionRid"] = readRid(reader, context, value, flags);
     value["bindingGeneration"] = readNonzeroU64(reader, context, value, flags);
+    value["sealResult"] = readSessionSealResult(reader, context, value, flags);
     reader.done("sessionRelocationSealed");
     let frameIndex = 1;
     if (frameIndex !== frames.length)
@@ -10197,6 +10242,9 @@ function encodeSessionRelocationSealedCommand(value, context) {
     if (value["bindingGeneration"] === undefined)
         fail("bindingGeneration required");
     writeNonzeroU64(numeric(value["bindingGeneration"]), writer, context, value, value.flags);
+    if (value["sealResult"] === undefined)
+        fail("sealResult required");
+    writeSessionSealResult(value["sealResult"], writer, context, value, value.flags);
     const frames = [writer.result()];
     return frames;
 }
@@ -10650,6 +10698,43 @@ function encodeRelocationFailedCommand(value, context) {
     return frames;
 }
 function validateRelocationFailedCommandRuntimePredicates(value, context) { void value; void context; }
+function decodeBoundSessionCloseCommand(frames, context) {
+    if (!frames.length)
+        fail("boundSessionClose frames");
+    const reader = new Reader(frames[0]);
+    if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 54)
+        fail("boundSessionClose header");
+    const flags = Number(reader.u(1));
+    if ((flags & ~0) !== 0 || (flags & 0) !== 0)
+        fail("boundSessionClose flags");
+    const value = { command: "boundSessionClose", flags };
+    value["correlation"] = readNonzeroU64(reader, context, value, flags);
+    value["actor"] = readActorRef(reader, context, value, flags);
+    value["session"] = readRetiredBoundSessionRouteFence(reader, context, value, flags);
+    reader.done("boundSessionClose");
+    let frameIndex = 1;
+    if (frameIndex !== frames.length)
+        fail("boundSessionClose frames");
+    return value;
+}
+function encodeBoundSessionCloseCommand(value, context) {
+    if ((value.flags & ~0) !== 0 || (value.flags & 0) !== 0)
+        fail("boundSessionClose flags");
+    const writer = new Writer();
+    writer.put([90, 77, 1, 54, value.flags]);
+    if (value["correlation"] === undefined)
+        fail("correlation required");
+    writeNonzeroU64(numeric(value["correlation"]), writer, context, value, value.flags);
+    if (value["actor"] === undefined)
+        fail("actor required");
+    writeActorRef(value["actor"], writer, context, value, value.flags);
+    if (value["session"] === undefined)
+        fail("session required");
+    writeRetiredBoundSessionRouteFence(value["session"], writer, context, value, value.flags);
+    const frames = [writer.result()];
+    return frames;
+}
+function validateBoundSessionCloseCommandRuntimePredicates(value, context) { void value; void context; }
 function decodeAuthorityPayloadV1DurableFormat(bytes, context) { if (bytes.length > 1048576)
     fail("authority-payload-v1 maximum"); const reader = new Reader(bytes); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 76 || Number(reader.u(1)) !== 65 || Number(reader.u(1)) !== 85 || Number(reader.u(1)) !== 1)
     fail("authority-payload-v1 header"); const flags = readU16(reader, context, {}, 0); if (!same(flags, 0))

package/dist/runtime/protocol/service_wire_pilot_codec.generated.d.ts

@@ -268,6 +268,7 @@ export interface RelocationPrepare40 {
     readonly payloadChunkCount: number;
     readonly payloadChecksumCrc32c: number;
     readonly applicationVersion: bigint;
+    readonly deadlineUnixMs: bigint;
 }
 export interface SessionRelocationSeal42 {
     readonly relocation: ServiceWireRelocationId;
@@ -280,8 +281,13 @@ export interface SessionRelocationSeal42 {
     readonly sessionOwnerLeaseGeneration: bigint;
     readonly sessionRid: Uint8Array;
     readonly bindingGeneration: bigint;
+    readonly targetNodeRid: Uint8Array;
+    readonly targetNodeGeneration: bigint;
 }
-export type SessionRelocationSealed43 = Omit<SessionRelocationSeal42, "senderRole">;
+export type ServiceWireSessionSealResult = "sealed" | "bindingAbsent";
+export type SessionRelocationSealed43 = Omit<SessionRelocationSeal42, "senderRole" | "targetNodeRid" | "targetNodeGeneration"> & {
+    readonly sealResult: ServiceWireSessionSealResult;
+};
 export interface SessionRelocationRoute44 {
     readonly relocation: ServiceWireRelocationId;
     readonly coordinator: ServiceWireCoordinatorFence;

package/dist/runtime/protocol/service_wire_pilot_codec.generated.js

@@ -472,6 +472,20 @@ function decodeActorDestroy27(bytes) { const at = { value: 0 }; if (bytes.length
     throw new RangeError("actorDestroy header"); const correlation = read64(bytes, at); if (correlation === 0n)
     throw new RangeError("correlation"); const actor = readFence(bytes, at); if (at.value !== bytes.length)
     throw new RangeError("actorDestroy trailing"); return { correlation, actor }; }
+function b3WriteSealResult(o, v) { switch (v) {
+    case "sealed":
+        o.push(1);
+        return;
+    case "bindingAbsent":
+        o.push(2);
+        return;
+    default: throw new RangeError("sealResult");
+} }
+function b3ReadSealResult(bytes, at) { switch (read8(bytes, at)) {
+    case 1: return "sealed";
+    case 2: return "bindingAbsent";
+    default: throw new RangeError("sealResult");
+} }
 function b3Header(id) { return [90, 77, 1, id, 0]; }
 function b3ReadHeader(bytes, id, name) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== id || bytes[at.value++] !== 0)
     throw new RangeError(name + " header"); return at; }
@@ -597,10 +611,11 @@ function decodeRelocationState52(bytes) { const at = b3ReadHeader(bytes, 52, "re
 function encodeRelocationPrepare40(v) { const o = b3Header(40); b3WriteId(o, v.relocation, "relocation"); if (v.targetAttemptGeneration === 0n || v.sourceNodeGeneration === 0n)
     throw new RangeError("prepare"); u64(o, v.targetAttemptGeneration); b3WriteCoordinator(o, v.coordinator); b3WriteTarget(o, v.target); b3WriteRole(o, v.initiatorRole); if (v.initiatorRole !== "source")
     throw new RangeError("initiator role"); writeRelocationObject(o, v.object); rid(o, v.sourceNodeRid); u64(o, v.sourceNodeGeneration); if (v.payloadTotalLength < 0n || v.payloadTotalLength > 274877906944n || v.payloadChunkCount > 4096 || v.applicationVersion < 0n || v.applicationVersion > 9223372036854775807n)
-    throw new RangeError("prepare bounds"); u64(o, v.payloadTotalLength); u32(o, v.payloadChunkCount); u32(o, v.payloadChecksumCrc32c); u64(o, v.applicationVersion); return Uint8Array.from(o); }
+    throw new RangeError("prepare bounds"); u64(o, v.payloadTotalLength); u32(o, v.payloadChunkCount); u32(o, v.payloadChecksumCrc32c); u64(o, v.applicationVersion); if (v.deadlineUnixMs === 0n)
+    throw new RangeError("deadline"); u64(o, v.deadlineUnixMs); return Uint8Array.from(o); }
 function decodeRelocationPrepare40(bytes) { const at = b3ReadHeader(bytes, 40, "relocationPrepare"), relocation = b3ReadId(bytes, at, "relocation"), targetAttemptGeneration = nonzero64(bytes, at, "target attempt"), coordinator = b3ReadCoordinator(bytes, at), target = b3ReadTarget(bytes, at), initiatorRole = b3ReadRole(bytes, at); if (initiatorRole !== "source")
-    throw new RangeError("initiator role"); const object = readRelocationObject(bytes, at), sourceNodeRid = readRid(bytes, at), sourceNodeGeneration = nonzero64(bytes, at, "source node"), payloadTotalLength = read64(bytes, at), payloadChunkCount = read32(bytes, at), payloadChecksumCrc32c = read32(bytes, at), applicationVersion = read64(bytes, at); if (payloadTotalLength > 274877906944n || payloadChunkCount > 4096 || applicationVersion > 9223372036854775807n)
-    throw new RangeError("prepare bounds"); b3Finish(at, bytes, "relocationPrepare"); return { relocation, targetAttemptGeneration, coordinator, target, initiatorRole, object, sourceNodeRid, sourceNodeGeneration, payloadTotalLength, payloadChunkCount, payloadChecksumCrc32c, applicationVersion }; }
+    throw new RangeError("initiator role"); const object = readRelocationObject(bytes, at), sourceNodeRid = readRid(bytes, at), sourceNodeGeneration = nonzero64(bytes, at, "source node"), payloadTotalLength = read64(bytes, at), payloadChunkCount = read32(bytes, at), payloadChecksumCrc32c = read32(bytes, at), applicationVersion = read64(bytes, at), deadlineUnixMs = nonzero64(bytes, at, "deadline"); if (payloadTotalLength > 274877906944n || payloadChunkCount > 4096 || applicationVersion > 9223372036854775807n)
+    throw new RangeError("prepare bounds"); b3Finish(at, bytes, "relocationPrepare"); return { relocation, targetAttemptGeneration, coordinator, target, initiatorRole, object, sourceNodeRid, sourceNodeGeneration, payloadTotalLength, payloadChunkCount, payloadChecksumCrc32c, applicationVersion, deadlineUnixMs }; }
 function b3WriteSealBase(o, v, includeRole) { b3WriteId(o, v.relocation, "relocation"); b3WriteCoordinator(o, v.coordinator); if (includeRole) {
     const role = v.senderRole;
     b3WriteRole(o, role);
@@ -612,10 +627,11 @@ function b3ReadSealBase(bytes, at, includeRole) { const relocation = b3ReadId(by
     if (senderRole !== "source")
         throw new RangeError("sender role");
 } const actor = readFence(bytes, at), session = b3ReadSession(bytes, at); return senderRole === undefined ? { relocation, coordinator, actor, ...session } : { relocation, coordinator, senderRole, actor, ...session }; }
-function encodeSessionRelocationSeal42(v) { const o = b3Header(42); b3WriteSealBase(o, v, true); return Uint8Array.from(o); }
-function decodeSessionRelocationSeal42(bytes) { const at = b3ReadHeader(bytes, 42, "sessionRelocationSeal"), v = b3ReadSealBase(bytes, at, true); b3Finish(at, bytes, "sessionRelocationSeal"); return v; }
-function encodeSessionRelocationSealed43(v) { const o = b3Header(43); b3WriteSealBase(o, v, false); return Uint8Array.from(o); }
-function decodeSessionRelocationSealed43(bytes) { const at = b3ReadHeader(bytes, 43, "sessionRelocationSealed"), v = b3ReadSealBase(bytes, at, false); b3Finish(at, bytes, "sessionRelocationSealed"); return v; }
+function encodeSessionRelocationSeal42(v) { const o = b3Header(42); b3WriteSealBase(o, v, true); rid(o, v.targetNodeRid); if (v.targetNodeGeneration === 0n)
+    throw new RangeError("target node"); u64(o, v.targetNodeGeneration); return Uint8Array.from(o); }
+function decodeSessionRelocationSeal42(bytes) { const at = b3ReadHeader(bytes, 42, "sessionRelocationSeal"), v = b3ReadSealBase(bytes, at, true); const targetNodeRid = readRid(bytes, at), targetNodeGeneration = nonzero64(bytes, at, "target node"); b3Finish(at, bytes, "sessionRelocationSeal"); return { ...v, targetNodeRid, targetNodeGeneration }; }
+function encodeSessionRelocationSealed43(v) { const o = b3Header(43); b3WriteSealBase(o, v, false); b3WriteSealResult(o, v.sealResult); return Uint8Array.from(o); }
+function decodeSessionRelocationSealed43(bytes) { const at = b3ReadHeader(bytes, 43, "sessionRelocationSealed"), v = { ...b3ReadSealBase(bytes, at, false), sealResult: b3ReadSealResult(bytes, at) }; b3Finish(at, bytes, "sessionRelocationSealed"); return v; }
 function encodeSessionRelocationRoute44(v) { const o = b3Header(44); b3WriteId(o, v.relocation, "relocation"); b3WriteCoordinator(o, v.coordinator); b3WriteRole(o, v.senderRole); if ((v.route.action === "commit" && v.senderRole !== "target") || (v.route.action === "abort" && v.senderRole !== "source"))
     throw new RangeError("route sender"); b3WriteActorRef(o, v.actor); b3WriteSession(o, v); b3WriteRoute(o, v.route); return Uint8Array.from(o); }
 function decodeSessionRelocationRoute44(bytes) { const at = b3ReadHeader(bytes, 44, "sessionRelocationRoute"), relocation = b3ReadId(bytes, at, "relocation"), coordinator = b3ReadCoordinator(bytes, at), senderRole = b3ReadRole(bytes, at), actor = b3ReadActorRef(bytes, at), session = b3ReadSession(bytes, at), route = b3ReadRoute(bytes, at); if ((route.action === "commit" && senderRole !== "target") || (route.action === "abort" && senderRole !== "source"))

package/dist/runtime/spots/formal-remote-actor-admission-registry.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkFormalRemoteActorAdmissionRegistry = void 0;
+const routing_id_1 = require("../routing-id");
 const ADMISSION_RETENTION_MS = 30_000;
 /** Identifies the object one admission attempt belongs to. */
 function objectKey(actorId, objectGeneration) {
@@ -275,9 +276,9 @@ function sameProvisionalAdmission(left, right) {
         left.requestFingerprint === right.requestFingerprint &&
         sameOperationId(left.completionOperationId, right.completionOperationId) &&
         String(left.sourceSpotId ?? '') === String(right.sourceSpotId ?? '') &&
-        String(left.sourceActorNodeRid ?? '') === String(right.sourceActorNodeRid ?? '') &&
+        (0, routing_id_1.routingIdsEqual)(left.sourceActorNodeRid, right.sourceActorNodeRid) &&
         left.actorRef.actorId === right.actorRef.actorId &&
-        String(left.actorRef.nodeRid) === String(right.actorRef.nodeRid) &&
+        (0, routing_id_1.routingIdsEqual)(left.actorRef.nodeRid, right.actorRef.nodeRid) &&
         left.actorRef.objectGeneration === right.actorRef.objectGeneration);
 }
 function sameOperationId(left, right) {

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

@@ -15,7 +15,7 @@ import { type ReadyRecord, type ReceiveRecord } from '../foundation/service-runt
 import type { ZLinkBackendSpot, ZLinkBackendSpotNode } from '../backend/contracts';
 import { ZLinkDispatchErrorReporter } from '../channels';
 import { ZLinkWorkerRuntime } from '../workers';
-import { type ZLinkRemoteBoundSessionTarget } from '../actors';
+import { type ZLinkActorHandoffPrefixAdmission, type ZLinkActorHandoffPrefixRecord, type ZLinkRemoteBoundSessionTarget } from '../actors';
 import type { ZLinkLocationLifecycle } from '../locations';
 import { type ZLinkActorHandoffPacket } from '../actors/actor-handoff';
 import type { CanonicalActorJoinRecovery } from '../foundation/actor-join-recovery-codec';
@@ -27,16 +27,17 @@ import { type ZLinkSpotRoutedTransport } from './spot-outbound';
 export { DefaultZLinkSpotHandlerRegistry, type ZLinkSpotHandlerRegistration } from './spot-handler-registry';
 export { ZLinkRuntimeSpotPublisherTransport } from './spot-publisher-transport';
 import type { ZLinkSpotActivation } from './spot-activation-state';
+import type { ZLinkSpotPreparationCompletion } from './spot-serial-executor';
 import { type ZLinkNativeSpotAuthority } from './spot-activation';
 import type { ZLinkSpotActorHandoffRuntime, ZLinkSpotActorTransferRuntime, ZLinkSpotBoundSessionRuntime } from './spot-runtime-ports';
-import type { ZLinkRuntimeAdmissionGate } from '../admission';
+import type { ZLinkRuntimeAdmissionGate, ZLinkMeshDispatchAdmission } from '../admission';
 import type { ZLinkActivationAdmission } from '../activation-admission';
 import type { ZLinkDetachedTaskRunner } from './spot-actor-join-dispatch';
 import type { ZLinkLocalSpotCreateResult } from './spot-manager-internal-contracts';
 export type { ZLinkLocalSpotCreateResult } from './spot-manager-internal-contracts';
 export type { ZLinkDetachedTaskRunner } from './spot-actor-join-dispatch';
 export { ZLinkEntrySpotActivation } from './spot-entry-activation';
-export { createFrameworkEntrySpotId, ZLinkSpotNodeRuntimeManager, type ZLinkSpotNodeRuntimeManagerOptions } from './spot-node-runtime-manager';
+export { createFrameworkEntrySpotId, registrationAcceptsNewActor, ZLinkSpotNodeRuntimeManager, type ZLinkSpotNodeRuntimeManagerOptions } from './spot-node-runtime-manager';
 export { ZLinkPublicSpotManager, type ZLinkPublicSpotManagerOptions } from './spot-manager-public';
 export interface ZLinkSpotManagerOptions {
     readonly spotFactories: readonly Type<ZLinkSpot>[];
@@ -62,6 +63,7 @@ export interface ZLinkSpotManagerOptions {
      * stateful reply has committed Core membership.
      */
     readonly dispatchEntryActorJoin?: (meshName: string, actor: ZLinkActor, handoffBacklog?: readonly ZLinkActorHandoffPacket[]) => Promise<void>;
+    readonly admitEntryActorPacketPrefix?: (meshName: string, actorId: string, records: readonly ZLinkActorHandoffPrefixRecord[]) => ZLinkActorHandoffPrefixAdmission;
     readonly executeEntryActor?: <T>(meshName: string, actorId: string, operation: () => Promise<T>) => Promise<T>;
     readonly actorCountProvider?: (spotId: RoutingId) => number;
     readonly releaseActorMembers?: (meshName: string, spotId: RoutingId) => Promise<void>;
@@ -146,11 +148,11 @@ export declare class DefaultZLinkSpotManager {
     relocationActivations(meshName: string): readonly ZLinkSpotActivation[];
     activeSpotCount(meshName: string): number;
     resolveRelocationActivation(meshName: string, spotId: RoutingId): ZLinkSpotActivation | undefined;
-    prepareRelocationSpot(meshName: string, objectKind: 'user_spot' | 'instance_spot', stableType: string, implementation: Type<ZLinkSpot | ZLinkInstanceSpot>, spotId: RoutingId, objectGeneration: bigint, authorityOwnerGeneration: bigint, signal?: AbortSignal): Promise<ZLinkSpotActivation>;
+    prepareRelocationSpot(meshName: string, objectKind: 'user_spot' | 'instance_spot', stableType: string, implementation: Type<ZLinkSpot | ZLinkInstanceSpot>, spotId: RoutingId, objectGeneration: bigint, authorityOwnerGeneration: bigint, restoredTimers: readonly import('./spot-timer').ZLinkTimerRelocationState[], signal?: AbortSignal): Promise<ZLinkSpotActivation>;
     publishRelocationSpot(activation: ZLinkSpotActivation, beforeAdmission?: () => Promise<void>): Promise<void>;
     abortRelocationSpot(activation: ZLinkSpotActivation): Promise<void>;
     completeRelocationSource(activation: ZLinkSpotActivation): Promise<void>;
-    materializeInstance(meshName: string, instanceType: string, spotId: RoutingId, objectGeneration: bigint, signal?: AbortSignal): Promise<void>;
+    materializeInstance(meshName: string, instanceType: string, spotId: RoutingId, objectGeneration: bigint, signal?: AbortSignal, completion?: ZLinkSpotPreparationCompletion): Promise<void>;
     private materializeInstanceCore;
     isInstanceMaterialized(meshName: string, instanceType: string, spotId: RoutingId): boolean;
     private resolveApplicationActivation;
@@ -162,6 +164,10 @@ export declare class DefaultZLinkSpotManager {
     beginInstanceSpotIdleEviction(meshName: string, spotId: RoutingId): boolean;
     completeInstanceTerminal(meshName: string, spotId: RoutingId, objectGeneration: bigint): Promise<boolean>;
     beginInstanceTerminal(meshName: string, spotId: RoutingId, objectGeneration: bigint): void;
+    publishInstance(target: {
+        readonly targetSpotId: string;
+        readonly objectGeneration: bigint;
+    }, meshName: string): void;
     private deferInstanceAuthorityRelease;
     private removeDeferredInstanceAuthorityRelease;
     private removePendingInstanceTerminalGeneration;
@@ -189,8 +195,8 @@ export declare class DefaultZLinkSpotManager {
     executeOnSpot<TSpot extends ZLinkSpot, TResult>(spotType: Type<TSpot>, spotId: RoutingId, operation: (spot: TSpot) => Promise<TResult> | TResult, signal?: AbortSignal): Promise<TResult>;
     hasActiveSpot(spotId: RoutingId): boolean;
     beginUserSpotPublication(meshName: string, spotId: RoutingId): void;
-    publishUserSpot(meshName: string, spotId: RoutingId): void;
-    abortUserSpotPublication(meshName: string, spotId: RoutingId): void;
+    publishUserSpot(meshName: string, spotId: RoutingId): Promise<void>;
+    abortUserSpotPublication(meshName: string, spotId: RoutingId): Promise<void>;
     resolveLocalSpotRoute(spotId: RoutingId): ZLinkSpotRouteTarget | undefined;
     admitActorJoin(spotId: RoutingId, actor: ZLinkActor, request: Message, commit: (spot: ZLinkSpot) => Promise<void> | void, signal?: AbortSignal, leaveSource?: () => Promise<void>, contentType?: string): Promise<ZLinkSpotActorJoinResult>;
     leaveActor(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
@@ -198,11 +204,12 @@ export declare class DefaultZLinkSpotManager {
     notifyActorLeftAfterTransfer(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
     prepareActorLeaveForTransfer(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
     commitActorLeaveAfterTransfer(spotId: RoutingId, actorId: string): Promise<void>;
-    restoreActorAfterFailedTransfer(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
     beginActorTransfer(spotId: RoutingId, actorId: string): Promise<void>;
     cancelActorTransfer(spotId: RoutingId, actorId: string): Promise<void>;
     notifyJoinedSpotActorDisconnected(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<boolean>;
     dispatchRoutedActorPacket(origin: ApplicationJobOrigin, spotId: RoutingId, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef): Promise<unknown>;
+    /** Resolves the current Actor FIFO owner for both Entry and User membership. */
+    admitSourceActorPacketPrefix(actorId: string, records: readonly ZLinkActorHandoffPrefixRecord[]): ZLinkActorHandoffPrefixAdmission;
     dispatchRoutedSpotSend(spotId: RoutingId, packetName: string | undefined, message: unknown, context: {
         readonly channelName: string;
         readonly contentType?: string;
@@ -218,12 +225,12 @@ export declare class DefaultZLinkSpotManager {
         readonly signal?: AbortSignal;
         readonly onAdmitted?: () => void;
     }): Promise<TReply>;
-    dispatchMeshSpot(meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;
+    dispatchMeshSpot(meshName: string, owner: ReadyRecord, record: ReceiveRecord, admit?: ZLinkMeshDispatchAdmission): Promise<void>;
     private ensureInstanceApplicationActivation;
-    dispatchMeshInstance(meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;
+    dispatchMeshInstance(meshName: string, owner: ReadyRecord, record: ReceiveRecord, admit?: ZLinkMeshDispatchAdmission): Promise<void>;
     private reportInstanceDispatchFailure;
     private traceInstanceMessage;
-    dispatchMeshActor(origin: ApplicationJobOrigin, meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;
+    dispatchMeshActor(origin: ApplicationJobOrigin, meshName: string, owner: ReadyRecord, record: ReceiveRecord, admit?: ZLinkMeshDispatchAdmission): Promise<void>;
     dispatchMeshActorJoin(meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;
     private dispatchMeshActorJoinCore;
     dispatchMeshSpotControl(meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;