depa-actor 0.2.1 → 0.2.2

package/src/addressing.ts

@@ -125,8 +125,6 @@ export type TargetedActorProcessor<TRuntime, TSelector, TInvocation, TConfig, TO
   config: TConfig,
 ) => TOutput | Promise<TOutput>;
 
-type UnknownRecord = Record<string, unknown>;
-
 const ADDRESS_KEYS = [
   'schemaVersion',
   'namespace',
@@ -151,6 +149,9 @@ const REGISTRATION_RECEIPT_KEYS = [
 ] as const;
 const REGISTER_INPUT_KEYS = ['address', 'ownerSnapshot', 'endpoint'] as const;
 const ENDPOINT_KEYS = ['handlerIdentity', 'dispatch'] as const;
+const RUNTIME_CONFIG_KEYS = ['runtimeInstanceId', 'resolveAlias', 'registrationIdFactory'] as const;
+const EXPECTED_REGISTRATION_ID_KEYS = ['expectedRegistrationId'] as const;
+const DISPATCH_INVOCATION_REQUIRED_KEYS = ['input'] as const;
 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])?$/;
 
@@ -161,38 +162,126 @@ interface LocalRegistration<TInvocation, TOutput> {
 }
 
 interface LocalActorAddressingState<TInvocation, TOutput> {
-  readonly registrations: Map<string, LocalRegistration<TInvocation, TOutput>>;
-  readonly registrationIds: Set<string>;
+  registrations: Map<string, LocalRegistration<TInvocation, TOutput>>;
+  usedRegistrationIds: Set<string>;
+  readonly runtimeNonce: string;
   readonly resolveAlias?: (alias: string) => ActorAddress | undefined;
   readonly registrationIdFactory: NonNullable<
     LocalActorAddressingRuntimeConfig['registrationIdFactory']
   >;
   sequence: number;
+  mutationVersion: number;
+  mutationGuard: string | undefined;
 }
 
 const runtimeStates = new WeakMap<object, LocalActorAddressingState<unknown, unknown>>();
+let runtimeNonceSequence = 0;
+
+function closedRecordError(
+  code: ActorAddressingErrorCode,
+  label: string,
+  detail: string,
+): ActorAddressingError {
+  return new ActorAddressingError(code, `${label} ${detail}`);
+}
+
+function readClosedRecord(
+  value: unknown,
+  requiredKeys: readonly string[],
+  optionalKeys: readonly string[],
+  code: ActorAddressingErrorCode,
+  label: string,
+): ReadonlyMap<string, unknown> {
+  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<string, unknown>();
+  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);
+  }
 
-function isRecord(value: unknown): value is UnknownRecord {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
+  for (const key of requiredKeys) {
+    if (!values.has(key)) {
+      throw closedRecordError(code, label, `must contain required field: ${key}`);
+    }
+  }
+  return values;
 }
 
-function assertExactRecord(
+function readExactRecord(
   value: unknown,
   keys: readonly string[],
   code: ActorAddressingErrorCode,
   label: string,
-): asserts value is UnknownRecord {
-  if (!isRecord(value)) {
-    throw new ActorAddressingError(code, `${label} must be an object`);
+): ReadonlyMap<string, unknown> {
+  return readClosedRecord(value, keys, [], code, label);
+}
+
+function readClosedArray(
+  value: unknown,
+  code: ActorAddressingErrorCode,
+  label: string,
+): readonly unknown[] {
+  if (!Array.isArray(value) || Reflect.getPrototypeOf(value) !== Array.prototype) {
+    throw closedRecordError(code, label, 'must be a plain array');
   }
-  const actualKeys = Object.keys(value).sort();
-  const expectedKeys = [...keys].sort();
+
+  const lengthDescriptor = Reflect.getOwnPropertyDescriptor(value, 'length');
+  const lengthValue =
+    lengthDescriptor && 'value' in lengthDescriptor ? lengthDescriptor.value : undefined;
   if (
-    actualKeys.length !== expectedKeys.length ||
-    actualKeys.some((key, index) => key !== expectedKeys[index])
+    !lengthDescriptor ||
+    !('value' in lengthDescriptor) ||
+    lengthDescriptor.enumerable ||
+    typeof lengthValue !== 'number' ||
+    !Number.isSafeInteger(lengthValue) ||
+    lengthValue < 0
   ) {
-    throw new ActorAddressingError(code, `${label} must contain only: ${expectedKeys.join(', ')}`);
+    throw closedRecordError(code, label, 'must have the standard own data length property');
   }
+
+  const length = lengthValue;
+  const expectedKeys = new Set<string>(['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: unknown[] = [];
+  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(
@@ -229,16 +318,16 @@ function parseOpaqueToken(
 }
 
 export function parseActorAddress(value: unknown): ActorAddress {
-  assertExactRecord(value, ADDRESS_KEYS, 'invalid-address', 'ActorAddress');
-  if (value.schemaVersion !== ACTOR_ADDRESS_SCHEMA_VERSION) {
+  const record = readExactRecord(value, ADDRESS_KEYS, 'invalid-address', 'ActorAddress');
+  if (record.get('schemaVersion') !== ACTOR_ADDRESS_SCHEMA_VERSION) {
     throw new ActorAddressingError('invalid-address', 'Unsupported ActorAddress schemaVersion');
   }
   return Object.freeze({
     schemaVersion: 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'),
   });
 }
 
@@ -254,19 +343,22 @@ export function actorAddressKey(address: ActorAddress): string {
 }
 
 export function parseActorSelector(value: unknown): ActorSelector {
-  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) {
         throw new ActorAddressingError('invalid-selector', `Invalid byAddress: ${error.message}`);
@@ -275,23 +367,30 @@ export function parseActorSelector(value: unknown): ActorSelector {
     }
   }
   return Object.freeze({
-    byAlias: parseOpaqueToken(value.byAlias, 'byAlias', 'invalid-selector'),
+    byAlias: parseOpaqueToken(record.get('byAlias'), 'byAlias', 'invalid-selector'),
   });
 }
 
 export function parseActorOwnerSnapshot(value: unknown): ActorOwnerSnapshot {
-  assertExactRecord(value, OWNER_SNAPSHOT_KEYS, 'invalid-owner-snapshot', 'ActorOwnerSnapshot');
-  if (value.schemaVersion !== ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION) {
+  const record = readExactRecord(
+    value,
+    OWNER_SNAPSHOT_KEYS,
+    'invalid-owner-snapshot',
+    'ActorOwnerSnapshot',
+  );
+  if (record.get('schemaVersion') !== 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: ActorOwnerSnapshotRegistration[] = [];
   const seen = new Set<string>();
-  for (const registration of value.registrations) {
-    assertExactRecord(
+  for (const registration of sourceRegistrations) {
+    const registrationRecord = readExactRecord(
       registration,
       OWNER_REGISTRATION_KEYS,
       'invalid-owner-snapshot',
@@ -299,7 +398,7 @@ export function parseActorOwnerSnapshot(value: unknown): ActorOwnerSnapshot {
     );
     let address: ActorAddress;
     try {
-      address = parseActorAddress(registration.address);
+      address = parseActorAddress(registrationRecord.get('address'));
     } catch (error) {
       if (error instanceof ActorAddressingError) {
         throw new ActorAddressingError('invalid-owner-snapshot', error.message);
@@ -318,7 +417,7 @@ export function parseActorOwnerSnapshot(value: unknown): ActorOwnerSnapshot {
       Object.freeze({
         address,
         handlerIdentity: parseOpaqueToken(
-          registration.handlerIdentity,
+          registrationRecord.get('handlerIdentity'),
           'handlerIdentity',
           'invalid-owner-snapshot',
         ),
@@ -329,12 +428,12 @@ export function parseActorOwnerSnapshot(value: unknown): ActorOwnerSnapshot {
   return Object.freeze({
     schemaVersion: ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION,
     ownerRevision: parseOpaqueToken(
-      value.ownerRevision,
+      record.get('ownerRevision'),
       'ownerRevision',
       'invalid-owner-snapshot',
     ),
     snapshotReceipt: parseOpaqueToken(
-      value.snapshotReceipt,
+      record.get('snapshotReceipt'),
       'snapshotReceipt',
       'invalid-owner-snapshot',
     ),
@@ -343,35 +442,35 @@ export function parseActorOwnerSnapshot(value: unknown): ActorOwnerSnapshot {
 }
 
 export function parseActorRegistrationReceipt(value: unknown): ActorRegistrationReceipt {
-  assertExactRecord(
+  const record = readExactRecord(
     value,
     REGISTRATION_RECEIPT_KEYS,
     'registration-mismatch',
     'ActorRegistrationReceipt',
   );
-  if (value.schemaVersion !== ACTOR_REGISTRATION_SCHEMA_VERSION) {
+  if (record.get('schemaVersion') !== ACTOR_REGISTRATION_SCHEMA_VERSION) {
     throw new ActorAddressingError('registration-mismatch', 'Unsupported registration schemaVersion');
   }
   return Object.freeze({
     schemaVersion: ACTOR_REGISTRATION_SCHEMA_VERSION,
-    address: parseActorAddress(value.address),
+    address: parseActorAddress(record.get('address')),
     ownerRevision: parseOpaqueToken(
-      value.ownerRevision,
+      record.get('ownerRevision'),
       'ownerRevision',
       'registration-mismatch',
     ),
     snapshotReceipt: parseOpaqueToken(
-      value.snapshotReceipt,
+      record.get('snapshotReceipt'),
       'snapshotReceipt',
       'registration-mismatch',
     ),
     handlerIdentity: parseOpaqueToken(
-      value.handlerIdentity,
+      record.get('handlerIdentity'),
       'handlerIdentity',
       'registration-mismatch',
     ),
     registrationId: parseOpaqueToken(
-      value.registrationId,
+      record.get('registrationId'),
       'registrationId',
       'registration-mismatch',
     ),
@@ -379,9 +478,7 @@ export function parseActorRegistrationReceipt(value: unknown): ActorRegistration
 }
 
 function assertEmptyConfig(config: unknown): asserts config is ActorProcessorConfig {
-  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<TInvocation, TOutput>(
@@ -399,32 +496,60 @@ function runtimeState<TInvocation, TOutput>(
   return state;
 }
 
-export function createLocalActorAddressingRuntime<TInvocation, TOutput>(
-  config: LocalActorAddressingRuntimeConfig = {},
-): LocalActorAddressingRuntime<TInvocation, TOutput> {
-  if (!isRecord(config)) {
-    throw new ActorAddressingError('registration-mismatch', 'runtime config must be an object');
-  }
-  const allowedKeys = new Set(['runtimeInstanceId', 'resolveAlias', 'registrationIdFactory']);
-  if (Object.keys(config).some((key) => !allowedKeys.has(key))) {
+function createRuntimeNonce(): string {
+  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<TInvocation, TOutput>(
+  state: LocalActorAddressingState<TInvocation, TOutput>,
+  operation: string,
+): number {
+  if (state.mutationGuard !== undefined) {
     throw new ActorAddressingError(
       'registration-mismatch',
-      'runtime config contains an unsupported field',
+      `${operation} cannot mutate the runtime while ${state.mutationGuard} is in progress`,
     );
   }
-  if (config.resolveAlias !== undefined && typeof config.resolveAlias !== 'function') {
+  state.mutationGuard = operation;
+  return state.mutationVersion;
+}
+
+function endMutation<TInvocation, TOutput>(
+  state: LocalActorAddressingState<TInvocation, TOutput>,
+  operation: string,
+): void {
+  if (state.mutationGuard === operation) {
+    state.mutationGuard = undefined;
+  }
+}
+
+export function createLocalActorAddressingRuntime<TInvocation, TOutput>(
+  config: LocalActorAddressingRuntimeConfig = {},
+): LocalActorAddressingRuntime<TInvocation, TOutput> {
+  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}`,
+    record.get('runtimeInstanceId') ?? `local-runtime-${Date.now().toString(36)}-${randomPart}`,
     'runtimeInstanceId',
     'registration-mismatch',
   );
@@ -434,12 +559,15 @@ export function createLocalActorAddressingRuntime<TInvocation, TOutput>(
   >;
   runtimeStates.set(runtime, {
     registrations: new Map(),
-    registrationIds: new Set(),
-    resolveAlias: config.resolveAlias,
+    usedRegistrationIds: new Set(),
+    runtimeNonce: createRuntimeNonce(),
+    resolveAlias: resolveAlias as LocalActorAddressingRuntimeConfig['resolveAlias'],
     registrationIdFactory:
-      config.registrationIdFactory ??
+      (registrationIdFactory as LocalActorAddressingRuntimeConfig['registrationIdFactory']) ??
       ((input) => `${input.runtimeInstanceId}:registration-${input.sequence}`),
     sequence: 0,
+    mutationVersion: 0,
+    mutationGuard: undefined,
   } as LocalActorAddressingState<unknown, unknown>);
   return runtime;
 }
@@ -447,29 +575,40 @@ export function createLocalActorAddressingRuntime<TInvocation, TOutput>(
 function parseEndpoint<TInvocation, TOutput>(
   value: unknown,
 ): LocalActorEndpoint<TInvocation, TOutput> {
-  assertExactRecord(value, ENDPOINT_KEYS, 'registration-mismatch', 'LocalActorEndpoint');
+  const record = readExactRecord(
+    value,
+    ENDPOINT_KEYS,
+    'registration-mismatch',
+    'LocalActorEndpoint',
+  );
   const handlerIdentity = parseOpaqueToken(
-    value.handlerIdentity,
+    record.get('handlerIdentity'),
     'handlerIdentity',
     'registration-mismatch',
   );
-  if (typeof value.dispatch !== 'function') {
+  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 as LocalActorEndpoint<TInvocation, TOutput>['dispatch'],
+    dispatch: dispatch as LocalActorEndpoint<TInvocation, TOutput>['dispatch'],
   });
 }
 
 function parseRegisterInput<TInvocation, TOutput>(
   input: unknown,
 ): RegisterActorInput<TInvocation, TOutput> {
-  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<TInvocation, TOutput>(input.endpoint),
+    address: parseActorAddress(record.get('address')),
+    ownerSnapshot: parseActorOwnerSnapshot(record.get('ownerSnapshot')),
+    endpoint: parseEndpoint<TInvocation, TOutput>(record.get('endpoint')),
   };
 }
 
@@ -513,16 +652,17 @@ function resolveRegistration<TInvocation, TOutput>(
 }
 
 function expectedRegistrationId(value: unknown, required: boolean): string | undefined {
-  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) return undefined;
+  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,
+    valueToParse,
     'expectedRegistrationId',
     'stale-registration',
   );
@@ -540,59 +680,105 @@ function assertCurrentRegistration(
   }
 }
 
-export function registerActor<TInvocation, TOutput>(
-  runtime: LocalActorAddressingRuntime<TInvocation, TOutput>,
-  input: RegisterActorInput<TInvocation, TOutput>,
-  config: ActorProcessorConfig,
-): ActorRegistrationReceipt {
-  assertEmptyConfig(config);
-  const parsed = parseRegisterInput<TInvocation, TOutput>(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',
-    );
+function hashRegistrationIdComponent(value: string): string {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = Math.imul(hash ^ value.charCodeAt(index), 0x01000193);
   }
-  const sequence = state.sequence + 1;
-  const registrationId = parseOpaqueToken(
+  return (hash >>> 0).toString(36);
+}
+
+function mintRegistrationId<TInvocation, TOutput>(
+  runtime: LocalActorAddressingRuntime<TInvocation, TOutput>,
+  state: LocalActorAddressingState<TInvocation, TOutput>,
+  sequence: number,
+  address: ActorAddress,
+  additionallyUsed: ReadonlySet<string> = new Set(),
+): string {
+  const factoryValue = parseOpaqueToken(
     state.registrationIdFactory({
       runtimeInstanceId: runtime.runtimeInstanceId,
       sequence,
-      address: parsed.address,
+      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.registrationIds.has(registrationId)) {
+  if (state.usedRegistrationIds.has(registrationId) || additionallyUsed.has(registrationId)) {
     throw new ActorAddressingError(
       'registration-mismatch',
-      `registrationIdFactory returned a duplicate id: ${registrationId}`,
+      `registrationIdFactory produced an already-used registration id: ${registrationId}`,
     );
   }
-  state.sequence = sequence;
-  const receipt = Object.freeze({
-    schemaVersion: 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;
+  return registrationId;
+}
+
+export function registerActor<TInvocation, TOutput>(
+  runtime: LocalActorAddressingRuntime<TInvocation, TOutput>,
+  input: RegisterActorInput<TInvocation, TOutput>,
+  config: ActorProcessorConfig,
+): ActorRegistrationReceipt {
+  assertEmptyConfig(config);
+  const state = runtimeState(runtime);
+  const operation = 'registerActor';
+  const startingVersion = beginMutation(state, operation);
+  try {
+    const parsed = parseRegisterInput<TInvocation, TOutput>(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: ActorRegistrationReceipt = Object.freeze({
+      schemaVersion: 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);
+  }
 }
 
 export function resolveActor<TInvocation, TOutput>(
@@ -618,27 +804,25 @@ export async function dispatchActor<TInvocation, TOutput>(
   config: ActorProcessorConfig,
 ): Promise<TOutput> {
   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 expectedRegistrationIdValue = invocationRecord.get('expectedRegistrationId');
   const expectedId =
-    invocation.expectedRegistrationId === undefined
+    expectedRegistrationIdValue === undefined
       ? undefined
       : parseOpaqueToken(
-          invocation.expectedRegistrationId,
+          expectedRegistrationIdValue,
           'expectedRegistrationId',
           'stale-registration',
         );
   assertCurrentRegistration(registration.receipt, expectedId);
-  return await registration.endpoint.dispatch(invocation.input);
+  return await registration.endpoint.dispatch(invocationRecord.get('input') as TInvocation);
 }
 
 export function unregisterActor<TInvocation, TOutput>(
@@ -649,11 +833,24 @@ export function unregisterActor<TInvocation, TOutput>(
 ): ActorRegistrationReceipt {
   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);
+  }
 }
 
 export function rebuildActorRegistrations<TInvocation, TOutput>(
@@ -662,78 +859,101 @@ export function rebuildActorRegistrations<TInvocation, TOutput>(
   config: RebuildActorRegistrationsConfig<TInvocation, TOutput>,
 ): readonly ActorRegistrationReceipt[] {
   const snapshot = parseActorOwnerSnapshot(input);
-  assertExactRecord(
+  const configRecord = readExactRecord(
     config,
     ['endpointFor'],
     'registration-mismatch',
     'RebuildActorRegistrationsConfig',
   );
-  if (typeof config.endpointFor !== 'function') {
+  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 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<TInvocation, TOutput>(
+        endpointFor(registration) as LocalActorEndpoint<TInvocation, TOutput>,
+      );
+      if (endpoint.handlerIdentity !== registration.handlerIdentity) {
+        throw new ActorAddressingError(
+          'registration-mismatch',
+          `Recovered endpoint identity does not match snapshot for ${actorAddressKey(registration.address)}`,
+        );
+      }
+      return endpoint;
+    });
 
-  const endpoints = snapshot.registrations.map((registration) => {
-    const endpoint = parseEndpoint<TInvocation, TOutput>(config.endpointFor(registration));
-    if (endpoint.handlerIdentity !== registration.handlerIdentity) {
+    if (state.mutationVersion !== startingVersion || state.registrations.size !== 0) {
       throw new ActorAddressingError(
         'registration-mismatch',
-        `Recovered endpoint identity does not match snapshot for ${actorAddressKey(registration.address)}`,
+        'Runtime changed while recovery endpoints were being constructed',
       );
     }
-    return endpoint;
-  });
 
-  let nextSequence = state.sequence;
-  const plannedIds = new Set<string>();
-  const planned = snapshot.registrations.map((registration, index) => {
-    nextSequence += 1;
-    const registrationId = parseOpaqueToken(
-      state.registrationIdFactory({
-        runtimeInstanceId: runtime.runtimeInstanceId,
-        sequence: nextSequence,
+    let nextSequence = state.sequence;
+    const plannedIds = new Set<string>();
+    const planned = snapshot.registrations.map((registration, index) => {
+      nextSequence += 1;
+      const registrationId = mintRegistrationId(
+        runtime,
+        state,
+        nextSequence,
+        registration.address,
+        plannedIds,
+      );
+      plannedIds.add(registrationId);
+      const receipt: ActorRegistrationReceipt = Object.freeze({
+        schemaVersion: ACTOR_REGISTRATION_SCHEMA_VERSION,
         address: registration.address,
-      }),
-      'registrationId',
-      'registration-mismatch',
-    );
-    if (state.registrationIds.has(registrationId) || plannedIds.has(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',
-        `registrationIdFactory returned a duplicate id: ${registrationId}`,
+        'Runtime changed while recovery was being planned',
       );
     }
-    plannedIds.add(registrationId);
-    const receipt: ActorRegistrationReceipt = Object.freeze({
-      schemaVersion: 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]!,
-      },
-    };
-  });
 
-  for (const item of planned) {
-    state.registrations.set(item.key, item.registration);
-    state.registrationIds.add(item.registration.receipt.registrationId);
+    const nextRegistrations = new Map(
+      planned.map((item) => [item.key, item.registration] as const),
+    );
+    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));
 }
 
 export function createActorRefEndpoint<