@zlink-systems/framework 0.10.0

package/dist/runtime/foundation/actor-join-recovery-codec.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalActorJoinHandoffId = canonicalActorJoinHandoffId;
+exports.encodeCanonicalActorJoinRecoverySavedWork = encodeCanonicalActorJoinRecoverySavedWork;
+exports.decodeCanonicalActorJoinRecoverySavedWork = decodeCanonicalActorJoinRecoverySavedWork;
+exports.routingIdBytes = routingIdBytes;
+const node_crypto_1 = require("node:crypto");
+const routing_id_1 = require("../routing-id");
+const service_wire_pilot_codec_generated_1 = require("../protocol/service_wire_pilot_codec.generated");
+const service_stateful_wire_codec_1 = require("./service-stateful-wire-codec");
+const RECOVERY_PACKET_NAME = '__zlink.actor.routed_join.recovery';
+const RECOVERY_CONTENT_TYPE = 'application/x-zlink-actor-routed-join-recovery-v1';
+const MAXIMUM_METADATA_BYTES = 256 * 1024;
+const MAXIMUM_MESSAGE_BYTES = 1024 * 1024;
+const FRAMEWORK_METADATA_UPPER_BOUND_BYTES = 64 * 1024;
+const ACCEPTED_JOURNAL_UPPER_BOUND_BYTES = 16 * 1024 * 1024;
+const SNAPSHOT_APPLICATION_STATE_RESERVATION_BYTES = 64 * 1024 * 1024;
+const RECREATE_RELOCATION_CONTENT_TYPE = 'application/vnd.zlink.actor-relocation.recreate';
+const SNAPSHOT_RELOCATION_CONTENT_TYPE = 'application/vnd.zlink.actor-relocation.snapshot';
+function canonicalActorJoinHandoffId(input) {
+    const actor = textBytes(input.actorId, 'actorId');
+    if (actor.byteLength > 0xffff)
+        throw new RangeError('Actor id exceeds u16 bytes.');
+    const digest = (0, node_crypto_1.createHash)('sha256').update(Buffer.concat([
+        Buffer.from(input.sourceActorNodeRid),
+        u16(actor.byteLength),
+        actor,
+        u64(input.actorGeneration),
+        u64(input.sourceActorNodeGeneration),
+        u64(input.correlation)
+    ])).digest().subarray(0, 16);
+    return Buffer.from([
+        digest[3], digest[2], digest[1], digest[0],
+        digest[5], digest[4], digest[7], digest[6],
+        ...digest.subarray(8)
+    ]).toString('hex');
+}
+function encodeCanonicalActorJoinRecoverySavedWork(input) {
+    const sourceNodeRid = routingIdBytes(input.sourceNodeRid);
+    const targetNodeRid = routingIdBytes(input.targetNodeRid);
+    const coordinatorNodeRid = routingIdBytes(input.coordinator.nodeRid);
+    const operationId = input.operationId;
+    const reply = operationId === undefined ? Buffer.alloc(0) : Buffer.from(input.reply ?? []);
+    const request = Buffer.from(input.request);
+    if (request.byteLength > MAXIMUM_MESSAGE_BYTES || reply.byteLength > MAXIMUM_MESSAGE_BYTES) {
+        throw new RangeError('Actor Join recovery message exceeds 1 MiB.');
+    }
+    const replyContentType = operationId === undefined ? null : requireText(input.replyContentType, 'Actor Join reply content type');
+    const metadata = encodeMetadataJson({
+        Request: {
+            ActorId: requireText(input.actorId, 'Actor id'),
+            ActorType: requireText(input.actorType, 'Actor type'),
+            HandoffId: requireText(input.handoffId, 'Actor Join handoff id'),
+            BoundSessionNodeRid: null,
+            BoundSessionRid: null,
+            RelocationContentType: requireText(input.relocationContentType, 'relocation content type'),
+            RelocationReference: 'pending',
+            RelocationChecksumCrc32c: 0,
+            RelocationAggregateId: canonicalUuid(input.relocationId),
+            RelocationAggregateGeneration: 1n,
+            RelocationInventoryDigest: Buffer.alloc(32).toString('base64'),
+            RequestContentType: requireText(input.requestContentType, 'Actor Join request content type'),
+            Request: '',
+            HandoffFrames: [],
+            SourceSpotId: requireText(input.sourceSpotId, 'source Spot id'),
+            SourceNodeRid: sourceNodeRid.toString('base64'),
+            ActorGeneration: nonZeroU64(input.actorGeneration, 'Actor generation'),
+            ActorAuthorityOwnerGeneration: nonZeroU64(input.actorAuthorityOwnerGeneration, 'Actor authority owner generation'),
+            BoundSessionBindingToken: null,
+            BoundSessionBindingGeneration: 0,
+            BoundSessionObjectGeneration: 0,
+            BoundSessionAuthorityOwnerGeneration: 0,
+            BoundSessionMeshName: null,
+            BoundSessionTargetNodeGeneration: 0,
+            BoundSessionOwnerLeaseGeneration: 0,
+            BoundSessionOwnerNodeGeneration: 0,
+            BoundSessionAcceptedHighWater: 0,
+            BoundSessionSessionOwnerId: null,
+            BoundSessionSessionOwnerLeaseGeneration: 0,
+            ReservationToken: requireText(input.handoffId, 'Actor Join reservation token'),
+            ReservedPayloadBytes: predictedRelocationPayloadBytes(request.byteLength, input.relocationContentType),
+            TargetNodeRid: targetNodeRid.toString('base64'),
+            TargetNodeGeneration: nonZeroU64(input.targetNodeGeneration, 'target node generation'),
+            TargetSpotGeneration: nonZeroU64(input.targetSpotGeneration, 'target Spot generation'),
+            TargetAuthorityOwnerGeneration: nonZeroU64(input.targetAuthorityOwnerGeneration, 'target authority owner generation'),
+            TargetSpotAuthorityOwnerGeneration: nonZeroU64(input.targetSpotAuthorityOwnerGeneration, 'target Spot authority owner generation'),
+            RelocationCoordinatorOwnerId: requireText(input.coordinator.ownerId, 'relocation coordinator owner id'),
+            RelocationCoordinatorLeaseGeneration: nonZeroU64(input.coordinator.leaseGeneration, 'relocation coordinator lease generation'),
+            RelocationCoordinatorNodeRid: coordinatorNodeRid.toString('base64'),
+            RelocationCoordinatorNodeGeneration: nonZeroU64(input.coordinator.nodeGeneration, 'relocation coordinator node generation'),
+            RelocationCoordinatorExpectedAuthorityStoreVersion: requireText(input.coordinator.expectedAuthorityStoreVersion, 'relocation coordinator authority Store version'),
+            ActorNodeGeneration: nonZeroU64(input.actorNodeGeneration, 'Actor node generation'),
+            ExpectedOwnerLeaseGeneration: nonZeroU64(input.expectedOwnerLeaseGeneration, 'Actor owner lease generation')
+        },
+        TargetSpotId: requireText(input.targetSpotId, 'target Spot id'),
+        TargetNodeRid: targetNodeRid.toString('base64'),
+        TargetNodeGeneration: nonZeroU64(input.targetNodeGeneration, 'target node generation'),
+        TargetSpotGeneration: nonZeroU64(input.targetSpotGeneration, 'target Spot generation'),
+        TargetAuthorityOwnerGeneration: nonZeroU64(input.targetAuthorityOwnerGeneration, 'target authority owner generation'),
+        OperationIdHigh: operationId?.high ?? 0n,
+        OperationIdLow: operationId?.low ?? 0n,
+        ReplyContentType: replyContentType,
+        Reply: ''
+    });
+    if (metadata.byteLength > MAXIMUM_METADATA_BYTES) {
+        throw new RangeError('Actor Join recovery metadata exceeds 256 KiB.');
+    }
+    return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeZljrRecordV1)({
+        source: {
+            nodeRid: Buffer.from((0, routing_id_1.encodeRoutingIdStorageHex)(input.sourceNodeRid), 'utf8'),
+            nodeGeneration: nonZeroU64(input.actorNodeGeneration, 'source node generation'),
+            ownerId: input.coordinator.ownerId,
+            ownerLeaseGeneration: nonZeroU64(input.coordinator.leaseGeneration, 'source owner lease generation')
+        },
+        operation: { high: 0n, low: 0n },
+        metadata,
+        request,
+        reply
+    }));
+}
+function decodeCanonicalActorJoinRecoverySavedWork(encoded) {
+    let record;
+    try {
+        record = (0, service_wire_pilot_codec_generated_1.decodeZljrRecordV1)(encoded);
+    }
+    catch (error) {
+        let frozen;
+        try {
+            frozen = (0, service_stateful_wire_codec_1.decodeServiceWireFrozenRecord)(encoded);
+        }
+        catch {
+            return undefined;
+        }
+        const payload = frozen.applicationPayload;
+        if (frozen.recordKind !== 1
+            || frozen.sourceKind !== 1
+            || payload?.packetName !== RECOVERY_PACKET_NAME
+            || payload.contentType !== RECOVERY_CONTENT_TYPE) {
+            return undefined;
+        }
+        throw error;
+    }
+    const metadataBytes = Buffer.from(record.metadata);
+    const metadata = JSON.parse(quoteJsonIntegers(metadataBytes.toString('utf8')));
+    const requestValue = object(metadata.Request, 'Request');
+    const handoffId = text(requestValue.HandoffId, 'Request.HandoffId');
+    const relocationAggregateId = canonicalUuid(text(requestValue.RelocationAggregateId, 'Request.RelocationAggregateId'));
+    const reservationToken = text(requestValue.ReservationToken, 'Request.ReservationToken');
+    const reservedPayloadBytes = positiveInteger(requestValue.ReservedPayloadBytes, 'Request.ReservedPayloadBytes');
+    if (canonicalUuid(handoffId) !== relocationAggregateId
+        || reservationToken !== handoffId) {
+        throw new TypeError('Canonical Actor Join recovery reservation identity changed.');
+    }
+    const request = Buffer.from(record.request);
+    const reply = Buffer.from(record.reply);
+    const operationHigh = integer(metadata.OperationIdHigh, 'OperationIdHigh');
+    const operationLow = integer(metadata.OperationIdLow, 'OperationIdLow');
+    const hasOperation = operationHigh !== 0n || operationLow !== 0n;
+    const replyContentType = nullableText(metadata.ReplyContentType, 'ReplyContentType');
+    if (hasOperation !== (replyContentType !== undefined)) {
+        throw new TypeError('Canonical Actor Join recovery reply identity is invalid.');
+    }
+    const targetNodeRid = base64(metadata.TargetNodeRid, 'TargetNodeRid');
+    const requestTargetNodeRid = base64(requestValue.TargetNodeRid, 'Request.TargetNodeRid');
+    if (!targetNodeRid.equals(requestTargetNodeRid)) {
+        throw new TypeError('Canonical Actor Join recovery target routing id changed.');
+    }
+    return {
+        source: {
+            nodeRid: (0, routing_id_1.decodeRoutingId)(Buffer.from(record.source.nodeRid).toString('utf8'), Buffer.from(record.source.nodeRid).toString('hex')),
+            nodeGeneration: record.source.nodeGeneration,
+            ownerId: record.source.ownerId,
+            ownerLeaseGeneration: record.source.ownerLeaseGeneration
+        },
+        request: {
+            actorId: text(requestValue.ActorId, 'Request.ActorId'),
+            actorType: text(requestValue.ActorType, 'Request.ActorType'),
+            handoffId,
+            sourceSpotId: text(requestValue.SourceSpotId, 'Request.SourceSpotId'),
+            sourceNodeRid: base64(requestValue.SourceNodeRid, 'Request.SourceNodeRid'),
+            actorGeneration: positiveInteger(requestValue.ActorGeneration, 'Request.ActorGeneration'),
+            actorAuthorityOwnerGeneration: positiveInteger(requestValue.ActorAuthorityOwnerGeneration, 'Request.ActorAuthorityOwnerGeneration'),
+            relocationAggregateId,
+            requestContentType: text(requestValue.RequestContentType, 'Request.RequestContentType'),
+            request,
+            reservationToken,
+            reservedPayloadBytes
+        },
+        targetSpotId: text(metadata.TargetSpotId, 'TargetSpotId'),
+        targetNodeRid,
+        targetNodeGeneration: positiveInteger(metadata.TargetNodeGeneration, 'TargetNodeGeneration'),
+        targetSpotGeneration: positiveInteger(metadata.TargetSpotGeneration, 'TargetSpotGeneration'),
+        targetAuthorityOwnerGeneration: positiveInteger(metadata.TargetAuthorityOwnerGeneration, 'TargetAuthorityOwnerGeneration'),
+        ...(hasOperation ? { operationId: { high: operationHigh, low: operationLow } } : {}),
+        ...(replyContentType === undefined ? {} : { replyContentType }),
+        reply
+    };
+}
+function routingIdBytes(value) {
+    return Buffer.from((0, routing_id_1.encodeRoutingIdStorageHex)(value), 'hex');
+}
+function encodeMetadataJson(value) {
+    const marker = '__zlink_u64__:';
+    const encoded = JSON.stringify(value, (_key, item) => typeof item === 'bigint'
+        ? `${marker}${item.toString()}`
+        : item);
+    return Buffer.from(encoded.replace(new RegExp(`"${marker}(\\d+)"`, 'gu'), '$1'), 'utf8');
+}
+function quoteJsonIntegers(value) {
+    let result = '';
+    let quoted = false;
+    let escaped = false;
+    for (let index = 0; index < value.length;) {
+        const character = value[index];
+        if (quoted) {
+            result += character;
+            index += 1;
+            if (escaped)
+                escaped = false;
+            else if (character === '\\')
+                escaped = true;
+            else if (character === '"')
+                quoted = false;
+            continue;
+        }
+        if (character === '"') {
+            quoted = true;
+            result += character;
+            index += 1;
+            continue;
+        }
+        if (character === '-' || (character >= '0' && character <= '9')) {
+            let end = index + 1;
+            while (end < value.length && value[end] >= '0' && value[end] <= '9')
+                end += 1;
+            result += `"${value.slice(index, end)}"`;
+            index = end;
+            continue;
+        }
+        result += character;
+        index += 1;
+    }
+    return result;
+}
+function canonicalUuid(value) {
+    const hex = value.replaceAll('-', '').toLowerCase();
+    if (!/^[0-9a-f]{32}$/u.test(hex) || /^0+$/u.test(hex)) {
+        throw new TypeError('Actor Join relocation id is invalid.');
+    }
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}`
+        + `-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function predictedRelocationPayloadBytes(requestBytes, relocationContentType) {
+    if (!Number.isSafeInteger(requestBytes) || requestBytes < 0) {
+        throw new RangeError('Actor Join request size is invalid.');
+    }
+    if (relocationContentType !== RECREATE_RELOCATION_CONTENT_TYPE
+        && relocationContentType !== SNAPSHOT_RELOCATION_CONTENT_TYPE) {
+        throw new TypeError('Actor Join relocation content type is invalid.');
+    }
+    return FRAMEWORK_METADATA_UPPER_BOUND_BYTES
+        + ACCEPTED_JOURNAL_UPPER_BOUND_BYTES
+        + requestBytes
+        + (relocationContentType === SNAPSHOT_RELOCATION_CONTENT_TYPE
+            ? SNAPSHOT_APPLICATION_STATE_RESERVATION_BYTES
+            : 0);
+}
+function textBytes(value, name) {
+    const result = Buffer.from(requireText(value, name), 'utf8');
+    if (result.includes(0))
+        throw new TypeError(`${name} contains NUL.`);
+    return result;
+}
+function requireText(value, name) {
+    if (value === undefined || value.length === 0)
+        throw new TypeError(`${name} must not be empty.`);
+    return value;
+}
+function nonZeroU64(value, name) {
+    if (value < 1n || value > 0xffffffffffffffffn)
+        throw new RangeError(`${name} is invalid.`);
+    return value;
+}
+function u16(value) {
+    if (!Number.isInteger(value) || value < 0 || value > 0xffff)
+        throw new RangeError('u16');
+    const result = Buffer.alloc(2);
+    result.writeUInt16BE(value);
+    return result;
+}
+function u64(value) {
+    if (value < 0n || value > 0xffffffffffffffffn)
+        throw new RangeError('u64');
+    const result = Buffer.alloc(8);
+    result.writeBigUInt64BE(value);
+    return result;
+}
+function object(value, name) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new TypeError(`${name} must be an object.`);
+    }
+    return value;
+}
+function text(value, name) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new TypeError(`${name} is invalid.`);
+    return value;
+}
+function nullableText(value, name) {
+    return value === null ? undefined : text(value, name);
+}
+function integer(value, name) {
+    if (typeof value !== 'string' || !/^\d+$/u.test(value))
+        throw new TypeError(`${name} is invalid.`);
+    const parsed = BigInt(value);
+    if (parsed > 0xffffffffffffffffn)
+        throw new TypeError(`${name} exceeds u64.`);
+    return parsed;
+}
+function positiveInteger(value, name) {
+    const parsed = integer(value, name);
+    if (parsed === 0n)
+        throw new TypeError(`${name} must not be zero.`);
+    return parsed;
+}
+function base64(value, name) {
+    if (typeof value !== 'string')
+        throw new TypeError(`${name} is invalid.`);
+    const decoded = Buffer.from(value, 'base64');
+    if (decoded.toString('base64') !== value)
+        throw new TypeError(`${name} is not canonical base64.`);
+    return decoded;
+}

package/dist/runtime/foundation/event-loop-resources.d.ts

@@ -0,0 +1,37 @@
+export interface CloseableResource {
+    close(): void | Promise<void>;
+}
+/** Closes owned runtime resources once, in reverse acquisition order. */
+export declare class EventLoopResourceStack {
+    private readonly resources;
+    private closePromise?;
+    own<T extends CloseableResource>(resource: T): T;
+    close(): Promise<void>;
+}
+export type EventLoopTask = () => void | Promise<void>;
+/** Keeps infrastructure progress independent from awaiting application handlers. */
+export declare class EventLoopWorkQueues {
+    private readonly infrastructureLimit;
+    private readonly applicationLimit;
+    private readonly infrastructure;
+    private infrastructureHead;
+    private infrastructureCount;
+    private readonly application;
+    private applicationHead;
+    private applicationCount;
+    private infrastructureScheduled;
+    private applicationScheduled;
+    private accepting;
+    constructor(infrastructureLimit: number, applicationLimit: number);
+    submitInfrastructure(task: EventLoopTask): boolean;
+    submitApplication(task: EventLoopTask): boolean;
+    stopAdmission(): void;
+    private scheduleInfrastructure;
+    private drainInfrastructure;
+    private scheduleApplication;
+    private drainApplication;
+    private takeInfrastructure;
+    private takeApplication;
+    private compactInfrastructure;
+    private compactApplication;
+}

package/dist/runtime/foundation/event-loop-resources.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventLoopWorkQueues = exports.EventLoopResourceStack = void 0;
+const execution_1 = require("../execution");
+/** Closes owned runtime resources once, in reverse acquisition order. */
+class EventLoopResourceStack {
+    resources = [];
+    closePromise;
+    own(resource) {
+        if (this.closePromise !== undefined)
+            throw new Error('Resource stack is closing.');
+        this.resources.push(resource);
+        return resource;
+    }
+    close() {
+        if (this.closePromise !== undefined)
+            return this.closePromise;
+        const resources = this.resources.splice(0).reverse();
+        this.closePromise = closeResources(resources);
+        return this.closePromise;
+    }
+}
+exports.EventLoopResourceStack = EventLoopResourceStack;
+async function closeResources(resources) {
+    const failures = [];
+    for (const resource of resources) {
+        try {
+            await resource.close();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    if (failures.length > 0) {
+        throw new AggregateError(failures, 'Event-loop resource cleanup failed.');
+    }
+}
+/** Keeps infrastructure progress independent from awaiting application handlers. */
+class EventLoopWorkQueues {
+    infrastructureLimit;
+    applicationLimit;
+    infrastructure = [];
+    infrastructureHead = 0;
+    infrastructureCount = 0;
+    application = [];
+    applicationHead = 0;
+    applicationCount = 0;
+    infrastructureScheduled = false;
+    applicationScheduled = false;
+    accepting = true;
+    constructor(infrastructureLimit, applicationLimit) {
+        this.infrastructureLimit = infrastructureLimit;
+        this.applicationLimit = applicationLimit;
+        if (infrastructureLimit < 1 || applicationLimit < 1) {
+            throw new RangeError('Queue limits must be positive.');
+        }
+    }
+    submitInfrastructure(task) {
+        if (!this.accepting || this.infrastructureCount >= this.infrastructureLimit)
+            return false;
+        this.infrastructure.push(task);
+        this.infrastructureCount += 1;
+        this.scheduleInfrastructure();
+        return true;
+    }
+    submitApplication(task) {
+        if (!this.accepting || this.applicationCount >= this.applicationLimit)
+            return false;
+        this.application.push(task);
+        this.applicationCount += 1;
+        this.scheduleApplication();
+        return true;
+    }
+    stopAdmission() {
+        this.accepting = false;
+    }
+    scheduleInfrastructure() {
+        if (this.infrastructureScheduled)
+            return;
+        this.infrastructureScheduled = true;
+        queueMicrotask(() => this.drainInfrastructure());
+    }
+    drainInfrastructure() {
+        this.infrastructureScheduled = false;
+        const task = this.takeInfrastructure();
+        if (task === undefined)
+            return;
+        try {
+            const result = (0, execution_1.runZLinkExecutionArea)('infrastructure', task);
+            if (result instanceof Promise)
+                void result.catch(() => undefined);
+        }
+        finally {
+            if (this.infrastructureCount > 0)
+                this.scheduleInfrastructure();
+        }
+    }
+    scheduleApplication() {
+        if (this.applicationScheduled)
+            return;
+        this.applicationScheduled = true;
+        queueMicrotask(() => void this.drainApplication());
+    }
+    async drainApplication() {
+        try {
+            const task = this.takeApplication();
+            if (task !== undefined) {
+                await (0, execution_1.runZLinkExecutionArea)('application', task);
+            }
+        }
+        catch {
+            // Handler failure is reported by the dispatch owner; it does not stop this queue.
+        }
+        finally {
+            this.applicationScheduled = false;
+            if (this.applicationCount > 0)
+                this.scheduleApplication();
+        }
+    }
+    takeInfrastructure() {
+        const task = this.infrastructure[this.infrastructureHead];
+        if (task === undefined)
+            return undefined;
+        this.infrastructure[this.infrastructureHead] = undefined;
+        this.infrastructureHead += 1;
+        this.infrastructureCount -= 1;
+        this.compactInfrastructure();
+        return task;
+    }
+    takeApplication() {
+        const task = this.application[this.applicationHead];
+        if (task === undefined)
+            return undefined;
+        this.application[this.applicationHead] = undefined;
+        this.applicationHead += 1;
+        this.applicationCount -= 1;
+        this.compactApplication();
+        return task;
+    }
+    compactInfrastructure() {
+        if (this.infrastructureCount === 0) {
+            this.infrastructure.length = 0;
+            this.infrastructureHead = 0;
+        }
+        else if (this.infrastructureHead >= 1024
+            && this.infrastructureHead * 2 >= this.infrastructure.length) {
+            this.infrastructure.splice(0, this.infrastructureHead);
+            this.infrastructureHead = 0;
+        }
+    }
+    compactApplication() {
+        if (this.applicationCount === 0) {
+            this.application.length = 0;
+            this.applicationHead = 0;
+        }
+        else if (this.applicationHead >= 1024
+            && this.applicationHead * 2 >= this.application.length) {
+            this.application.splice(0, this.applicationHead);
+            this.applicationHead = 0;
+        }
+    }
+}
+exports.EventLoopWorkQueues = EventLoopWorkQueues;

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

@@ -0,0 +1,18 @@
+export * from './event-loop-resources';
+export * from './operation-registry';
+export * from './raw-service-mesh-runtime';
+export * from './service-discovery-registry';
+export * from './service-liveness-registry';
+export * from './service-mailbox';
+export * from './service-maintenance-runtime';
+export * from './service-relocation-coordinator';
+export * from './service-relocation-aggregate-committer';
+export * from './service-relocation-object-owner';
+export * from './service-runtime-contracts';
+export * from './service-relocation-runtime';
+export * from './service-topology-registry';
+export * from './service-wire-codec';
+export * from './service-wire-m6a-codec';
+export * from './service-stateful-registry';
+export * from './service-stateful-runtime';
+export * from './service-stateful-wire-codec';

package/dist/runtime/foundation/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./event-loop-resources"), exports);
+__exportStar(require("./operation-registry"), exports);
+__exportStar(require("./raw-service-mesh-runtime"), exports);
+__exportStar(require("./service-discovery-registry"), exports);
+__exportStar(require("./service-liveness-registry"), exports);
+__exportStar(require("./service-mailbox"), exports);
+__exportStar(require("./service-maintenance-runtime"), exports);
+__exportStar(require("./service-relocation-coordinator"), exports);
+__exportStar(require("./service-relocation-aggregate-committer"), exports);
+__exportStar(require("./service-relocation-object-owner"), exports);
+__exportStar(require("./service-runtime-contracts"), exports);
+__exportStar(require("./service-relocation-runtime"), exports);
+__exportStar(require("./service-topology-registry"), exports);
+__exportStar(require("./service-wire-codec"), exports);
+__exportStar(require("./service-wire-m6a-codec"), exports);
+__exportStar(require("./service-stateful-registry"), exports);
+__exportStar(require("./service-stateful-runtime"), exports);
+__exportStar(require("./service-stateful-wire-codec"), exports);

package/dist/runtime/foundation/message-follow-suppression-registry.d.ts

@@ -0,0 +1,38 @@
+export interface MessageFollowSuppressionFence {
+    readonly objectKind: string;
+    readonly logicalObjectId: string;
+    readonly objectGeneration: string;
+    readonly sourceNodeRid: string;
+    readonly sourceNodeRidHex?: string;
+    readonly sourceNodeGeneration: string;
+    readonly sourceAuthorityOwnerGeneration: string;
+    readonly sourceOwnerLeaseGeneration: string;
+    readonly targetNodeRid: string;
+    readonly targetNodeRidHex?: string;
+    readonly targetNodeGeneration: string;
+    readonly targetAuthorityOwnerGeneration: string;
+    readonly targetOwnerLeaseGeneration: string;
+}
+export type MessageFollowSuppressionState = 'idle' | 'inFlight' | 'sentUntilExpiry';
+export interface MessageFollowSuppressionClaim {
+    readonly routeKey: string;
+    readonly serial: bigint;
+}
+/**
+ * Owns one Message Follow send marker per retained route. Route-cache expiry
+ * drives marker expiry; this registry never creates an independent timer.
+ */
+export declare class MessageFollowSuppressionRegistry {
+    private readonly markers;
+    private nextClaimSerial;
+    retainRoute(fence: MessageFollowSuppressionFence): void;
+    replaceRoute(previous: MessageFollowSuppressionFence, replacement: MessageFollowSuppressionFence): void;
+    expireRoute(fence: MessageFollowSuppressionFence): boolean;
+    begin(fence: MessageFollowSuppressionFence): MessageFollowSuppressionClaim | undefined;
+    markSent(claim: MessageFollowSuppressionClaim): boolean;
+    abort(claim: MessageFollowSuppressionClaim): boolean;
+    state(fence: MessageFollowSuppressionFence): MessageFollowSuppressionState;
+    get retainedRouteCount(): number;
+    private currentClaim;
+}
+export declare function messageFollowSuppressionKey(fence: MessageFollowSuppressionFence): string;