depa-actor 0.2.0 → 0.2.2

package/dist-cjs/addressing.cjs

@@ -0,0 +1,532 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActorAddressingError = exports.ACTOR_REGISTRATION_SCHEMA_VERSION = exports.ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION = exports.ACTOR_ADDRESS_SCHEMA_VERSION = void 0;
+exports.parseActorAddress = parseActorAddress;
+exports.actorAddressKey = actorAddressKey;
+exports.parseActorSelector = parseActorSelector;
+exports.parseActorOwnerSnapshot = parseActorOwnerSnapshot;
+exports.parseActorRegistrationReceipt = parseActorRegistrationReceipt;
+exports.createLocalActorAddressingRuntime = createLocalActorAddressingRuntime;
+exports.registerActor = registerActor;
+exports.resolveActor = resolveActor;
+exports.dispatchActor = dispatchActor;
+exports.unregisterActor = unregisterActor;
+exports.rebuildActorRegistrations = rebuildActorRegistrations;
+exports.createActorRefEndpoint = createActorRefEndpoint;
+exports.ACTOR_ADDRESS_SCHEMA_VERSION = 'depa-actor-address/v1';
+exports.ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION = 'depa-actor-owner-snapshot/v1';
+exports.ACTOR_REGISTRATION_SCHEMA_VERSION = 'depa-actor-registration/v1';
+class ActorAddressingError extends Error {
+    code;
+    name = 'ActorAddressingError';
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.ActorAddressingError = ActorAddressingError;
+const ADDRESS_KEYS = [
+    'schemaVersion',
+    'namespace',
+    'deploymentId',
+    'actorKind',
+    'logicalKey',
+];
+const OWNER_SNAPSHOT_KEYS = [
+    'schemaVersion',
+    'ownerRevision',
+    'snapshotReceipt',
+    'registrations',
+];
+const OWNER_REGISTRATION_KEYS = ['address', 'handlerIdentity'];
+const REGISTRATION_RECEIPT_KEYS = [
+    'schemaVersion',
+    'address',
+    'ownerRevision',
+    'snapshotReceipt',
+    'handlerIdentity',
+    'registrationId',
+];
+const REGISTER_INPUT_KEYS = ['address', 'ownerSnapshot', 'endpoint'];
+const ENDPOINT_KEYS = ['handlerIdentity', 'dispatch'];
+const RUNTIME_CONFIG_KEYS = ['runtimeInstanceId', 'resolveAlias', 'registrationIdFactory'];
+const EXPECTED_REGISTRATION_ID_KEYS = ['expectedRegistrationId'];
+const DISPATCH_INVOCATION_REQUIRED_KEYS = ['input'];
+const ADDRESS_SEGMENT = /^[A-Za-z0-9](?:[A-Za-z0-9._~-]{0,126}[A-Za-z0-9])?$/;
+const OPAQUE_TOKEN = /^[A-Za-z0-9](?:[A-Za-z0-9._~:/-]{0,254}[A-Za-z0-9])?$/;
+const runtimeStates = new WeakMap();
+let runtimeNonceSequence = 0;
+function closedRecordError(code, label, detail) {
+    return new ActorAddressingError(code, `${label} ${detail}`);
+}
+function readClosedRecord(value, requiredKeys, optionalKeys, code, label) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw closedRecordError(code, label, 'must be an object');
+    }
+    const prototype = Reflect.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw closedRecordError(code, label, 'must use Object.prototype or a null prototype');
+    }
+    const allowedKeys = new Set([...requiredKeys, ...optionalKeys]);
+    const values = new Map();
+    for (const key of Reflect.ownKeys(value)) {
+        if (typeof key !== 'string' || !allowedKeys.has(key)) {
+            throw closedRecordError(code, label, `must contain only: ${[...allowedKeys].sort().join(', ')}`);
+        }
+        const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) {
+            throw closedRecordError(code, label, `${key} must be an own enumerable data property`);
+        }
+        values.set(key, descriptor.value);
+    }
+    for (const key of requiredKeys) {
+        if (!values.has(key)) {
+            throw closedRecordError(code, label, `must contain required field: ${key}`);
+        }
+    }
+    return values;
+}
+function readExactRecord(value, keys, code, label) {
+    return readClosedRecord(value, keys, [], code, label);
+}
+function readClosedArray(value, code, label) {
+    if (!Array.isArray(value) || Reflect.getPrototypeOf(value) !== Array.prototype) {
+        throw closedRecordError(code, label, 'must be a plain array');
+    }
+    const lengthDescriptor = Reflect.getOwnPropertyDescriptor(value, 'length');
+    const lengthValue = lengthDescriptor && 'value' in lengthDescriptor ? lengthDescriptor.value : undefined;
+    if (!lengthDescriptor ||
+        !('value' in lengthDescriptor) ||
+        lengthDescriptor.enumerable ||
+        typeof lengthValue !== 'number' ||
+        !Number.isSafeInteger(lengthValue) ||
+        lengthValue < 0) {
+        throw closedRecordError(code, label, 'must have the standard own data length property');
+    }
+    const length = lengthValue;
+    const expectedKeys = new Set(['length']);
+    for (let index = 0; index < length; index += 1) {
+        expectedKeys.add(String(index));
+    }
+    const ownKeys = Reflect.ownKeys(value);
+    if (ownKeys.length !== expectedKeys.size ||
+        ownKeys.some((key) => typeof key !== 'string' || !expectedKeys.has(key))) {
+        throw closedRecordError(code, label, 'must be dense and contain no extra own keys');
+    }
+    const elements = [];
+    for (let index = 0; index < length; index += 1) {
+        const key = String(index);
+        const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) {
+            throw closedRecordError(code, label, `${key} must be an own enumerable data property`);
+        }
+        elements.push(descriptor.value);
+    }
+    return elements;
+}
+function parseAddressSegment(value, field, code = 'invalid-address') {
+    if (typeof value !== 'string' ||
+        value !== value.normalize('NFC') ||
+        !ADDRESS_SEGMENT.test(value)) {
+        throw new ActorAddressingError(code, `${field} must be a canonical actor-address segment`);
+    }
+    return value;
+}
+function parseOpaqueToken(value, field, code) {
+    if (typeof value !== 'string' ||
+        value !== value.normalize('NFC') ||
+        !OPAQUE_TOKEN.test(value) ||
+        value.includes('..') ||
+        value.includes('//') ||
+        value.includes('%')) {
+        throw new ActorAddressingError(code, `${field} must be a canonical non-empty token`);
+    }
+    return value;
+}
+function parseActorAddress(value) {
+    const record = readExactRecord(value, ADDRESS_KEYS, 'invalid-address', 'ActorAddress');
+    if (record.get('schemaVersion') !== exports.ACTOR_ADDRESS_SCHEMA_VERSION) {
+        throw new ActorAddressingError('invalid-address', 'Unsupported ActorAddress schemaVersion');
+    }
+    return Object.freeze({
+        schemaVersion: exports.ACTOR_ADDRESS_SCHEMA_VERSION,
+        namespace: parseAddressSegment(record.get('namespace'), 'namespace'),
+        deploymentId: parseAddressSegment(record.get('deploymentId'), 'deploymentId'),
+        actorKind: parseAddressSegment(record.get('actorKind'), 'actorKind'),
+        logicalKey: parseAddressSegment(record.get('logicalKey'), 'logicalKey'),
+    });
+}
+function actorAddressKey(address) {
+    const parsed = parseActorAddress(address);
+    return [
+        parsed.schemaVersion,
+        parsed.namespace,
+        parsed.deploymentId,
+        parsed.actorKind,
+        parsed.logicalKey,
+    ].join(':');
+}
+function parseActorSelector(value) {
+    const record = readClosedRecord(value, [], ['byAddress', 'byAlias'], 'invalid-selector', 'ActorSelector');
+    if (record.size !== 1) {
+        throw new ActorAddressingError('invalid-selector', 'ActorSelector must contain exactly one of byAddress or byAlias');
+    }
+    if (record.has('byAddress')) {
+        try {
+            return Object.freeze({ byAddress: parseActorAddress(record.get('byAddress')) });
+        }
+        catch (error) {
+            if (error instanceof ActorAddressingError) {
+                throw new ActorAddressingError('invalid-selector', `Invalid byAddress: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    return Object.freeze({
+        byAlias: parseOpaqueToken(record.get('byAlias'), 'byAlias', 'invalid-selector'),
+    });
+}
+function parseActorOwnerSnapshot(value) {
+    const record = readExactRecord(value, OWNER_SNAPSHOT_KEYS, 'invalid-owner-snapshot', 'ActorOwnerSnapshot');
+    if (record.get('schemaVersion') !== exports.ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION) {
+        throw new ActorAddressingError('invalid-owner-snapshot', 'Unsupported owner snapshot schemaVersion');
+    }
+    const sourceRegistrations = readClosedArray(record.get('registrations'), 'invalid-owner-snapshot', 'registrations');
+    const registrations = [];
+    const seen = new Set();
+    for (const registration of sourceRegistrations) {
+        const registrationRecord = readExactRecord(registration, OWNER_REGISTRATION_KEYS, 'invalid-owner-snapshot', 'owner snapshot registration');
+        let address;
+        try {
+            address = parseActorAddress(registrationRecord.get('address'));
+        }
+        catch (error) {
+            if (error instanceof ActorAddressingError) {
+                throw new ActorAddressingError('invalid-owner-snapshot', error.message);
+            }
+            throw error;
+        }
+        const key = actorAddressKey(address);
+        if (seen.has(key)) {
+            throw new ActorAddressingError('duplicate-snapshot-address', `Owner snapshot contains duplicate address: ${key}`);
+        }
+        seen.add(key);
+        registrations.push(Object.freeze({
+            address,
+            handlerIdentity: parseOpaqueToken(registrationRecord.get('handlerIdentity'), 'handlerIdentity', 'invalid-owner-snapshot'),
+        }));
+    }
+    return Object.freeze({
+        schemaVersion: exports.ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION,
+        ownerRevision: parseOpaqueToken(record.get('ownerRevision'), 'ownerRevision', 'invalid-owner-snapshot'),
+        snapshotReceipt: parseOpaqueToken(record.get('snapshotReceipt'), 'snapshotReceipt', 'invalid-owner-snapshot'),
+        registrations: Object.freeze(registrations),
+    });
+}
+function parseActorRegistrationReceipt(value) {
+    const record = readExactRecord(value, REGISTRATION_RECEIPT_KEYS, 'registration-mismatch', 'ActorRegistrationReceipt');
+    if (record.get('schemaVersion') !== exports.ACTOR_REGISTRATION_SCHEMA_VERSION) {
+        throw new ActorAddressingError('registration-mismatch', 'Unsupported registration schemaVersion');
+    }
+    return Object.freeze({
+        schemaVersion: exports.ACTOR_REGISTRATION_SCHEMA_VERSION,
+        address: parseActorAddress(record.get('address')),
+        ownerRevision: parseOpaqueToken(record.get('ownerRevision'), 'ownerRevision', 'registration-mismatch'),
+        snapshotReceipt: parseOpaqueToken(record.get('snapshotReceipt'), 'snapshotReceipt', 'registration-mismatch'),
+        handlerIdentity: parseOpaqueToken(record.get('handlerIdentity'), 'handlerIdentity', 'registration-mismatch'),
+        registrationId: parseOpaqueToken(record.get('registrationId'), 'registrationId', 'registration-mismatch'),
+    });
+}
+function assertEmptyConfig(config) {
+    readExactRecord(config, [], 'registration-mismatch', 'Processor config');
+}
+function runtimeState(runtime) {
+    const state = runtimeStates.get(runtime);
+    if (!state) {
+        throw new ActorAddressingError('registration-mismatch', 'runtime must be created by createLocalActorAddressingRuntime');
+    }
+    return state;
+}
+function createRuntimeNonce() {
+    runtimeNonceSequence += 1;
+    const randomPart = typeof globalThis.crypto?.randomUUID === 'function'
+        ? globalThis.crypto.randomUUID().replaceAll('-', '')
+        : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2) || '0'}`;
+    return `runtime-${randomPart}-${runtimeNonceSequence.toString(36)}`;
+}
+function beginMutation(state, operation) {
+    if (state.mutationGuard !== undefined) {
+        throw new ActorAddressingError('registration-mismatch', `${operation} cannot mutate the runtime while ${state.mutationGuard} is in progress`);
+    }
+    state.mutationGuard = operation;
+    return state.mutationVersion;
+}
+function endMutation(state, operation) {
+    if (state.mutationGuard === operation) {
+        state.mutationGuard = undefined;
+    }
+}
+function createLocalActorAddressingRuntime(config = {}) {
+    const record = readClosedRecord(config, [], RUNTIME_CONFIG_KEYS, 'registration-mismatch', 'runtime config');
+    const resolveAlias = record.get('resolveAlias');
+    const registrationIdFactory = record.get('registrationIdFactory');
+    if (resolveAlias !== undefined && typeof resolveAlias !== 'function') {
+        throw new ActorAddressingError('registration-mismatch', 'resolveAlias must be a function');
+    }
+    if (registrationIdFactory !== undefined && typeof registrationIdFactory !== 'function') {
+        throw new ActorAddressingError('registration-mismatch', 'registrationIdFactory must be a function');
+    }
+    const randomPart = Math.random().toString(36).slice(2) || '0';
+    const runtimeInstanceId = parseOpaqueToken(record.get('runtimeInstanceId') ?? `local-runtime-${Date.now().toString(36)}-${randomPart}`, 'runtimeInstanceId', 'registration-mismatch');
+    const runtime = Object.freeze({ runtimeInstanceId });
+    runtimeStates.set(runtime, {
+        registrations: new Map(),
+        usedRegistrationIds: new Set(),
+        runtimeNonce: createRuntimeNonce(),
+        resolveAlias: resolveAlias,
+        registrationIdFactory: registrationIdFactory ??
+            ((input) => `${input.runtimeInstanceId}:registration-${input.sequence}`),
+        sequence: 0,
+        mutationVersion: 0,
+        mutationGuard: undefined,
+    });
+    return runtime;
+}
+function parseEndpoint(value) {
+    const record = readExactRecord(value, ENDPOINT_KEYS, 'registration-mismatch', 'LocalActorEndpoint');
+    const handlerIdentity = parseOpaqueToken(record.get('handlerIdentity'), 'handlerIdentity', 'registration-mismatch');
+    const dispatch = record.get('dispatch');
+    if (typeof dispatch !== 'function') {
+        throw new ActorAddressingError('registration-mismatch', 'endpoint.dispatch must be a function');
+    }
+    return Object.freeze({
+        handlerIdentity,
+        dispatch: dispatch,
+    });
+}
+function parseRegisterInput(input) {
+    const record = readExactRecord(input, REGISTER_INPUT_KEYS, 'registration-mismatch', 'RegisterActorInput');
+    return {
+        address: parseActorAddress(record.get('address')),
+        ownerSnapshot: parseActorOwnerSnapshot(record.get('ownerSnapshot')),
+        endpoint: parseEndpoint(record.get('endpoint')),
+    };
+}
+function resolveRegistration(runtime, selector) {
+    const state = runtimeState(runtime);
+    const parsedSelector = parseActorSelector(selector);
+    let address;
+    if ('byAddress' in parsedSelector) {
+        address = parsedSelector.byAddress;
+    }
+    else {
+        const resolved = state.resolveAlias?.(parsedSelector.byAlias);
+        if (resolved === undefined) {
+            throw new ActorAddressingError('unresolved-selector', `Actor alias is unresolved: ${parsedSelector.byAlias}`);
+        }
+        try {
+            address = parseActorAddress(resolved);
+        }
+        catch (error) {
+            if (error instanceof ActorAddressingError) {
+                throw new ActorAddressingError('unresolved-selector', `Actor alias resolved to an invalid address: ${parsedSelector.byAlias}`);
+            }
+            throw error;
+        }
+    }
+    const registration = state.registrations.get(actorAddressKey(address));
+    if (!registration) {
+        throw new ActorAddressingError('unresolved-selector', `Actor address is not registered: ${actorAddressKey(address)}`);
+    }
+    return registration;
+}
+function expectedRegistrationId(value, required) {
+    const record = readClosedRecord(value, required ? EXPECTED_REGISTRATION_ID_KEYS : [], required ? [] : EXPECTED_REGISTRATION_ID_KEYS, 'stale-registration', 'invocation');
+    const valueToParse = record.get('expectedRegistrationId');
+    if (valueToParse === undefined && !required)
+        return undefined;
+    return parseOpaqueToken(valueToParse, 'expectedRegistrationId', 'stale-registration');
+}
+function assertCurrentRegistration(registration, expectedId) {
+    if (expectedId !== undefined && expectedId !== registration.registrationId) {
+        throw new ActorAddressingError('stale-registration', `Expected registration ${expectedId} is not current`);
+    }
+}
+function hashRegistrationIdComponent(value) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = Math.imul(hash ^ value.charCodeAt(index), 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+}
+function mintRegistrationId(runtime, state, sequence, address, additionallyUsed = new Set()) {
+    const factoryValue = parseOpaqueToken(state.registrationIdFactory({
+        runtimeInstanceId: runtime.runtimeInstanceId,
+        sequence,
+        address,
+    }), 'registrationIdFactory result', 'registration-mismatch');
+    const factoryComponent = factoryValue.length <= 128
+        ? factoryValue
+        : `factory-${hashRegistrationIdComponent(factoryValue)}`;
+    const registrationId = parseOpaqueToken(`${factoryComponent}:${state.runtimeNonce}:${sequence.toString(36)}`, 'registrationId', 'registration-mismatch');
+    if (state.usedRegistrationIds.has(registrationId) || additionallyUsed.has(registrationId)) {
+        throw new ActorAddressingError('registration-mismatch', `registrationIdFactory produced an already-used registration id: ${registrationId}`);
+    }
+    return registrationId;
+}
+function registerActor(runtime, input, config) {
+    assertEmptyConfig(config);
+    const state = runtimeState(runtime);
+    const operation = 'registerActor';
+    const startingVersion = beginMutation(state, operation);
+    try {
+        const parsed = parseRegisterInput(input);
+        const key = actorAddressKey(parsed.address);
+        if (state.registrations.has(key)) {
+            throw new ActorAddressingError('already-registered', `Actor is already registered: ${key}`);
+        }
+        const ownerEntry = parsed.ownerSnapshot.registrations.find((entry) => actorAddressKey(entry.address) === key);
+        if (!ownerEntry || ownerEntry.handlerIdentity !== parsed.endpoint.handlerIdentity) {
+            throw new ActorAddressingError('registration-mismatch', 'Address and handler identity must be authorized by the owner snapshot');
+        }
+        const sequence = state.sequence + 1;
+        const registrationId = mintRegistrationId(runtime, state, sequence, parsed.address);
+        if (state.mutationVersion !== startingVersion) {
+            throw new ActorAddressingError('registration-mismatch', 'Runtime changed while registration was being constructed');
+        }
+        const receipt = Object.freeze({
+            schemaVersion: exports.ACTOR_REGISTRATION_SCHEMA_VERSION,
+            address: parsed.address,
+            ownerRevision: parsed.ownerSnapshot.ownerRevision,
+            snapshotReceipt: parsed.ownerSnapshot.snapshotReceipt,
+            handlerIdentity: parsed.endpoint.handlerIdentity,
+            registrationId,
+        });
+        state.sequence = sequence;
+        state.registrations.set(key, {
+            address: parsed.address,
+            receipt,
+            endpoint: parsed.endpoint,
+        });
+        state.usedRegistrationIds.add(registrationId);
+        state.mutationVersion = startingVersion + 1;
+        return receipt;
+    }
+    finally {
+        endMutation(state, operation);
+    }
+}
+function resolveActor(runtime, selector, invocation, config) {
+    assertEmptyConfig(config);
+    const expectedId = expectedRegistrationId(invocation, false);
+    const registration = resolveRegistration(runtime, selector);
+    assertCurrentRegistration(registration.receipt, expectedId);
+    return Object.freeze({
+        address: registration.address,
+        receipt: registration.receipt,
+    });
+}
+async function dispatchActor(runtime, selector, invocation, config) {
+    assertEmptyConfig(config);
+    const invocationRecord = readClosedRecord(invocation, DISPATCH_INVOCATION_REQUIRED_KEYS, EXPECTED_REGISTRATION_ID_KEYS, 'stale-registration', 'dispatch invocation');
+    const registration = resolveRegistration(runtime, selector);
+    const expectedRegistrationIdValue = invocationRecord.get('expectedRegistrationId');
+    const expectedId = expectedRegistrationIdValue === undefined
+        ? undefined
+        : parseOpaqueToken(expectedRegistrationIdValue, 'expectedRegistrationId', 'stale-registration');
+    assertCurrentRegistration(registration.receipt, expectedId);
+    return await registration.endpoint.dispatch(invocationRecord.get('input'));
+}
+function unregisterActor(runtime, selector, invocation, config) {
+    assertEmptyConfig(config);
+    const expectedId = expectedRegistrationId(invocation, true);
+    const state = runtimeState(runtime);
+    const operation = 'unregisterActor';
+    const startingVersion = beginMutation(state, operation);
+    try {
+        const registration = resolveRegistration(runtime, selector);
+        assertCurrentRegistration(registration.receipt, expectedId);
+        if (state.mutationVersion !== startingVersion) {
+            throw new ActorAddressingError('registration-mismatch', 'Runtime changed while unregister was being resolved');
+        }
+        state.registrations.delete(actorAddressKey(registration.address));
+        state.mutationVersion = startingVersion + 1;
+        return registration.receipt;
+    }
+    finally {
+        endMutation(state, operation);
+    }
+}
+function rebuildActorRegistrations(runtime, input, config) {
+    const snapshot = parseActorOwnerSnapshot(input);
+    const configRecord = readExactRecord(config, ['endpointFor'], 'registration-mismatch', 'RebuildActorRegistrationsConfig');
+    const endpointFor = configRecord.get('endpointFor');
+    if (typeof endpointFor !== 'function') {
+        throw new ActorAddressingError('registration-mismatch', 'endpointFor must be a function');
+    }
+    const state = runtimeState(runtime);
+    const operation = 'rebuildActorRegistrations';
+    const startingVersion = beginMutation(state, operation);
+    try {
+        if (state.registrations.size !== 0) {
+            throw new ActorAddressingError('already-registered', 'Registration recovery requires a fresh empty local runtime');
+        }
+        const endpoints = snapshot.registrations.map((registration) => {
+            const endpoint = parseEndpoint(endpointFor(registration));
+            if (endpoint.handlerIdentity !== registration.handlerIdentity) {
+                throw new ActorAddressingError('registration-mismatch', `Recovered endpoint identity does not match snapshot for ${actorAddressKey(registration.address)}`);
+            }
+            return endpoint;
+        });
+        if (state.mutationVersion !== startingVersion || state.registrations.size !== 0) {
+            throw new ActorAddressingError('registration-mismatch', 'Runtime changed while recovery endpoints were being constructed');
+        }
+        let nextSequence = state.sequence;
+        const plannedIds = new Set();
+        const planned = snapshot.registrations.map((registration, index) => {
+            nextSequence += 1;
+            const registrationId = mintRegistrationId(runtime, state, nextSequence, registration.address, plannedIds);
+            plannedIds.add(registrationId);
+            const receipt = Object.freeze({
+                schemaVersion: exports.ACTOR_REGISTRATION_SCHEMA_VERSION,
+                address: registration.address,
+                ownerRevision: snapshot.ownerRevision,
+                snapshotReceipt: snapshot.snapshotReceipt,
+                handlerIdentity: registration.handlerIdentity,
+                registrationId,
+            });
+            return {
+                key: actorAddressKey(registration.address),
+                registration: {
+                    address: registration.address,
+                    receipt,
+                    endpoint: endpoints[index],
+                },
+            };
+        });
+        if (state.mutationVersion !== startingVersion || state.registrations.size !== 0) {
+            throw new ActorAddressingError('registration-mismatch', 'Runtime changed while recovery was being planned');
+        }
+        const nextRegistrations = new Map(planned.map((item) => [item.key, item.registration]));
+        const nextUsedRegistrationIds = new Set(state.usedRegistrationIds);
+        for (const registrationId of plannedIds) {
+            nextUsedRegistrationIds.add(registrationId);
+        }
+        const receipts = Object.freeze(planned.map((item) => item.registration.receipt));
+        state.registrations = nextRegistrations;
+        state.usedRegistrationIds = nextUsedRegistrationIds;
+        state.sequence = nextSequence;
+        state.mutationVersion = startingVersion + 1;
+        return receipts;
+    }
+    finally {
+        endMutation(state, operation);
+    }
+}
+function createActorRefEndpoint(ref, tag, handlerIdentity) {
+    const parsedHandlerIdentity = parseOpaqueToken(handlerIdentity, 'handlerIdentity', 'registration-mismatch');
+    return Object.freeze({
+        handlerIdentity: parsedHandlerIdentity,
+        dispatch: (input) => ref.send(tag, input),
+    });
+}