depa-actor 0.2.1 → 0.2.2

package/dist-cjs/addressing.cjs

@@ -49,22 +49,80 @@ const REGISTRATION_RECEIPT_KEYS = [
 ];
 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();
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+let runtimeNonceSequence = 0;
+function closedRecordError(code, label, detail) {
+    return new ActorAddressingError(code, `${label} ${detail}`);
 }
-function assertExactRecord(value, keys, code, label) {
-    if (!isRecord(value)) {
-        throw new ActorAddressingError(code, `${label} must be an object`);
+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}`);
+        }
     }
-    const actualKeys = Object.keys(value).sort();
-    const expectedKeys = [...keys].sort();
-    if (actualKeys.length !== expectedKeys.length ||
-        actualKeys.some((key, index) => key !== expectedKeys[index])) {
-        throw new ActorAddressingError(code, `${label} must contain only: ${expectedKeys.join(', ')}`);
+    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' ||
@@ -86,16 +144,16 @@ function parseOpaqueToken(value, field, code) {
     return value;
 }
 function parseActorAddress(value) {
-    assertExactRecord(value, ADDRESS_KEYS, 'invalid-address', 'ActorAddress');
-    if (value.schemaVersion !== exports.ACTOR_ADDRESS_SCHEMA_VERSION) {
+    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(value.namespace, 'namespace'),
-        deploymentId: parseAddressSegment(value.deploymentId, 'deploymentId'),
-        actorKind: parseAddressSegment(value.actorKind, 'actorKind'),
-        logicalKey: parseAddressSegment(value.logicalKey, 'logicalKey'),
+        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) {
@@ -109,16 +167,13 @@ function actorAddressKey(address) {
     ].join(':');
 }
 function parseActorSelector(value) {
-    if (!isRecord(value)) {
-        throw new ActorAddressingError('invalid-selector', 'ActorSelector must be an object');
-    }
-    const keys = Object.keys(value);
-    if (keys.length !== 1 || (keys[0] !== 'byAddress' && keys[0] !== 'byAlias')) {
+    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 (keys[0] === 'byAddress') {
+    if (record.has('byAddress')) {
         try {
-            return Object.freeze({ byAddress: parseActorAddress(value.byAddress) });
+            return Object.freeze({ byAddress: parseActorAddress(record.get('byAddress')) });
         }
         catch (error) {
             if (error instanceof ActorAddressingError) {
@@ -128,24 +183,22 @@ function parseActorSelector(value) {
         }
     }
     return Object.freeze({
-        byAlias: parseOpaqueToken(value.byAlias, 'byAlias', 'invalid-selector'),
+        byAlias: parseOpaqueToken(record.get('byAlias'), 'byAlias', 'invalid-selector'),
     });
 }
 function parseActorOwnerSnapshot(value) {
-    assertExactRecord(value, OWNER_SNAPSHOT_KEYS, 'invalid-owner-snapshot', 'ActorOwnerSnapshot');
-    if (value.schemaVersion !== exports.ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION) {
+    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');
     }
-    if (!Array.isArray(value.registrations)) {
-        throw new ActorAddressingError('invalid-owner-snapshot', 'registrations must be an array');
-    }
+    const sourceRegistrations = readClosedArray(record.get('registrations'), 'invalid-owner-snapshot', 'registrations');
     const registrations = [];
     const seen = new Set();
-    for (const registration of value.registrations) {
-        assertExactRecord(registration, OWNER_REGISTRATION_KEYS, 'invalid-owner-snapshot', 'owner snapshot registration');
+    for (const registration of sourceRegistrations) {
+        const registrationRecord = readExactRecord(registration, OWNER_REGISTRATION_KEYS, 'invalid-owner-snapshot', 'owner snapshot registration');
         let address;
         try {
-            address = parseActorAddress(registration.address);
+            address = parseActorAddress(registrationRecord.get('address'));
         }
         catch (error) {
             if (error instanceof ActorAddressingError) {
@@ -160,34 +213,32 @@ function parseActorOwnerSnapshot(value) {
         seen.add(key);
         registrations.push(Object.freeze({
             address,
-            handlerIdentity: parseOpaqueToken(registration.handlerIdentity, 'handlerIdentity', 'invalid-owner-snapshot'),
+            handlerIdentity: parseOpaqueToken(registrationRecord.get('handlerIdentity'), 'handlerIdentity', 'invalid-owner-snapshot'),
         }));
     }
     return Object.freeze({
         schemaVersion: exports.ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION,
-        ownerRevision: parseOpaqueToken(value.ownerRevision, 'ownerRevision', 'invalid-owner-snapshot'),
-        snapshotReceipt: parseOpaqueToken(value.snapshotReceipt, 'snapshotReceipt', 'invalid-owner-snapshot'),
+        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) {
-    assertExactRecord(value, REGISTRATION_RECEIPT_KEYS, 'registration-mismatch', 'ActorRegistrationReceipt');
-    if (value.schemaVersion !== exports.ACTOR_REGISTRATION_SCHEMA_VERSION) {
+    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(value.address),
-        ownerRevision: parseOpaqueToken(value.ownerRevision, 'ownerRevision', 'registration-mismatch'),
-        snapshotReceipt: parseOpaqueToken(value.snapshotReceipt, 'snapshotReceipt', 'registration-mismatch'),
-        handlerIdentity: parseOpaqueToken(value.handlerIdentity, 'handlerIdentity', 'registration-mismatch'),
-        registrationId: parseOpaqueToken(value.registrationId, 'registrationId', 'registration-mismatch'),
+        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) {
-    if (!isRecord(config) || Object.keys(config).length !== 0) {
-        throw new ActorAddressingError('registration-mismatch', 'Processor config must be an empty object');
-    }
+    readExactRecord(config, [], 'registration-mismatch', 'Processor config');
 }
 function runtimeState(runtime) {
     const state = runtimeStates.get(runtime);
@@ -196,51 +247,69 @@ function runtimeState(runtime) {
     }
     return state;
 }
-function createLocalActorAddressingRuntime(config = {}) {
-    if (!isRecord(config)) {
-        throw new ActorAddressingError('registration-mismatch', 'runtime config must be an object');
+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`);
     }
-    const allowedKeys = new Set(['runtimeInstanceId', 'resolveAlias', 'registrationIdFactory']);
-    if (Object.keys(config).some((key) => !allowedKeys.has(key))) {
-        throw new ActorAddressingError('registration-mismatch', 'runtime config contains an unsupported field');
+    state.mutationGuard = operation;
+    return state.mutationVersion;
+}
+function endMutation(state, operation) {
+    if (state.mutationGuard === operation) {
+        state.mutationGuard = undefined;
     }
-    if (config.resolveAlias !== undefined && typeof config.resolveAlias !== 'function') {
+}
+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 (config.registrationIdFactory !== undefined &&
-        typeof config.registrationIdFactory !== '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(config.runtimeInstanceId ?? `local-runtime-${Date.now().toString(36)}-${randomPart}`, 'runtimeInstanceId', 'registration-mismatch');
+    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(),
-        registrationIds: new Set(),
-        resolveAlias: config.resolveAlias,
-        registrationIdFactory: config.registrationIdFactory ??
+        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) {
-    assertExactRecord(value, ENDPOINT_KEYS, 'registration-mismatch', 'LocalActorEndpoint');
-    const handlerIdentity = parseOpaqueToken(value.handlerIdentity, 'handlerIdentity', 'registration-mismatch');
-    if (typeof value.dispatch !== 'function') {
+    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: value.dispatch,
+        dispatch: dispatch,
     });
 }
 function parseRegisterInput(input) {
-    assertExactRecord(input, REGISTER_INPUT_KEYS, 'registration-mismatch', 'RegisterActorInput');
+    const record = readExactRecord(input, REGISTER_INPUT_KEYS, 'registration-mismatch', 'RegisterActorInput');
     return {
-        address: parseActorAddress(input.address),
-        ownerSnapshot: parseActorOwnerSnapshot(input.ownerSnapshot),
-        endpoint: parseEndpoint(input.endpoint),
+        address: parseActorAddress(record.get('address')),
+        ownerSnapshot: parseActorOwnerSnapshot(record.get('ownerSnapshot')),
+        endpoint: parseEndpoint(record.get('endpoint')),
     };
 }
 function resolveRegistration(runtime, selector) {
@@ -272,59 +341,80 @@ function resolveRegistration(runtime, selector) {
     return registration;
 }
 function expectedRegistrationId(value, required) {
-    if (!isRecord(value)) {
-        throw new ActorAddressingError('stale-registration', 'invocation must be an object');
-    }
-    const allowedKeys = required ? ['expectedRegistrationId'] : ['expectedRegistrationId'];
-    if (Object.keys(value).some((key) => !allowedKeys.includes(key))) {
-        throw new ActorAddressingError('stale-registration', 'invocation contains an unsupported field');
-    }
-    if (value.expectedRegistrationId === undefined && !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(value.expectedRegistrationId, 'expectedRegistrationId', 'stale-registration');
+    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 parsed = parseRegisterInput(input);
     const state = runtimeState(runtime);
-    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 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;
     }
-    const sequence = state.sequence + 1;
-    const registrationId = parseOpaqueToken(state.registrationIdFactory({
-        runtimeInstanceId: runtime.runtimeInstanceId,
-        sequence,
-        address: parsed.address,
-    }), 'registrationId', 'registration-mismatch');
-    if (state.registrationIds.has(registrationId)) {
-        throw new ActorAddressingError('registration-mismatch', `registrationIdFactory returned a duplicate id: ${registrationId}`);
+    finally {
+        endMutation(state, operation);
     }
-    state.sequence = sequence;
-    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.registrations.set(key, {
-        address: parsed.address,
-        receipt,
-        endpoint: parsed.endpoint,
-    });
-    state.registrationIds.add(registrationId);
-    return receipt;
 }
 function resolveActor(runtime, selector, invocation, config) {
     assertEmptyConfig(config);
@@ -338,82 +428,100 @@ function resolveActor(runtime, selector, invocation, config) {
 }
 async function dispatchActor(runtime, selector, invocation, config) {
     assertEmptyConfig(config);
-    if (!isRecord(invocation)) {
-        throw new ActorAddressingError('stale-registration', 'dispatch invocation must be an object');
-    }
-    const keys = Object.keys(invocation);
-    if (!keys.includes('input') || keys.some((key) => key !== 'input' && key !== 'expectedRegistrationId')) {
-        throw new ActorAddressingError('stale-registration', 'dispatch invocation must contain input and optional expectedRegistrationId');
-    }
+    const invocationRecord = readClosedRecord(invocation, DISPATCH_INVOCATION_REQUIRED_KEYS, EXPECTED_REGISTRATION_ID_KEYS, 'stale-registration', 'dispatch invocation');
     const registration = resolveRegistration(runtime, selector);
-    const expectedId = invocation.expectedRegistrationId === undefined
+    const expectedRegistrationIdValue = invocationRecord.get('expectedRegistrationId');
+    const expectedId = expectedRegistrationIdValue === undefined
         ? undefined
-        : parseOpaqueToken(invocation.expectedRegistrationId, 'expectedRegistrationId', 'stale-registration');
+        : parseOpaqueToken(expectedRegistrationIdValue, 'expectedRegistrationId', 'stale-registration');
     assertCurrentRegistration(registration.receipt, expectedId);
-    return await registration.endpoint.dispatch(invocation.input);
+    return await registration.endpoint.dispatch(invocationRecord.get('input'));
 }
 function unregisterActor(runtime, selector, invocation, config) {
     assertEmptyConfig(config);
     const expectedId = expectedRegistrationId(invocation, true);
-    const registration = resolveRegistration(runtime, selector);
-    assertCurrentRegistration(registration.receipt, expectedId);
-    runtimeState(runtime).registrations.delete(actorAddressKey(registration.address));
-    runtimeState(runtime).registrationIds.delete(registration.receipt.registrationId);
-    return registration.receipt;
+    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);
-    assertExactRecord(config, ['endpointFor'], 'registration-mismatch', 'RebuildActorRegistrationsConfig');
-    if (typeof config.endpointFor !== 'function') {
+    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);
-    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(config.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;
-    });
-    let nextSequence = state.sequence;
-    const plannedIds = new Set();
-    const planned = snapshot.registrations.map((registration, index) => {
-        nextSequence += 1;
-        const registrationId = parseOpaqueToken(state.registrationIdFactory({
-            runtimeInstanceId: runtime.runtimeInstanceId,
-            sequence: nextSequence,
-            address: registration.address,
-        }), 'registrationId', 'registration-mismatch');
-        if (state.registrationIds.has(registrationId) || plannedIds.has(registrationId)) {
-            throw new ActorAddressingError('registration-mismatch', `registrationIdFactory returned a duplicate id: ${registrationId}`);
+    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');
         }
-        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,
+        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;
         });
-        return {
-            key: actorAddressKey(registration.address),
-            registration: {
+        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,
-                receipt,
-                endpoint: endpoints[index],
-            },
-        };
-    });
-    for (const item of planned) {
-        state.registrations.set(item.key, item.registration);
-        state.registrationIds.add(item.registration.receipt.registrationId);
+                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);
     }
-    state.sequence = nextSequence;
-    return Object.freeze(planned.map((item) => item.registration.receipt));
 }
 function createActorRefEndpoint(ref, tag, handlerIdentity) {
     const parsedHandlerIdentity = parseOpaqueToken(handlerIdentity, 'handlerIdentity', 'registration-mismatch');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "depa-actor",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "main": "./dist-cjs/index.cjs",
   "module": "./dist/index.js",