depa-actor 0.2.0 → 0.2.2

package/dist/addressing.d.ts

@@ -0,0 +1,100 @@
+export declare const ACTOR_ADDRESS_SCHEMA_VERSION: "depa-actor-address/v1";
+export declare const ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION: "depa-actor-owner-snapshot/v1";
+export declare const ACTOR_REGISTRATION_SCHEMA_VERSION: "depa-actor-registration/v1";
+export type ActorAddressingErrorCode = 'invalid-address' | 'invalid-selector' | 'invalid-owner-snapshot' | 'duplicate-snapshot-address' | 'already-registered' | 'unresolved-selector' | 'registration-mismatch' | 'stale-registration';
+export declare class ActorAddressingError extends Error {
+    readonly code: ActorAddressingErrorCode;
+    readonly name = "ActorAddressingError";
+    constructor(code: ActorAddressingErrorCode, message: string);
+}
+export interface ActorAddress {
+    readonly schemaVersion: typeof ACTOR_ADDRESS_SCHEMA_VERSION;
+    readonly namespace: string;
+    readonly deploymentId: string;
+    readonly actorKind: string;
+    readonly logicalKey: string;
+}
+export type ActorSelector = {
+    readonly byAddress: ActorAddress;
+} | {
+    readonly byAlias: string;
+};
+export interface ActorOwnerSnapshotRegistration {
+    readonly address: ActorAddress;
+    readonly handlerIdentity: string;
+}
+export interface ActorOwnerSnapshot {
+    readonly schemaVersion: typeof ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION;
+    readonly ownerRevision: string;
+    readonly snapshotReceipt: string;
+    readonly registrations: readonly ActorOwnerSnapshotRegistration[];
+}
+export interface ActorRegistrationReceipt {
+    readonly schemaVersion: typeof ACTOR_REGISTRATION_SCHEMA_VERSION;
+    readonly address: ActorAddress;
+    readonly ownerRevision: string;
+    readonly snapshotReceipt: string;
+    readonly handlerIdentity: string;
+    readonly registrationId: string;
+}
+export interface LocalActorEndpoint<TInvocation, TOutput> {
+    readonly handlerIdentity: string;
+    readonly dispatch: (invocation: TInvocation) => TOutput | Promise<TOutput>;
+}
+declare const localActorAddressingRuntimeBrand: unique symbol;
+export interface LocalActorAddressingRuntime<TInvocation, TOutput> {
+    readonly runtimeInstanceId: string;
+    readonly [localActorAddressingRuntimeBrand]: {
+        readonly invocation: TInvocation;
+        readonly output: TOutput;
+    };
+}
+export interface LocalActorAddressingRuntimeConfig {
+    readonly runtimeInstanceId?: string;
+    readonly resolveAlias?: (alias: string) => ActorAddress | undefined;
+    readonly registrationIdFactory?: (input: {
+        readonly runtimeInstanceId: string;
+        readonly sequence: number;
+        readonly address: ActorAddress;
+    }) => string;
+}
+export interface RegisterActorInput<TInvocation, TOutput> {
+    readonly address: ActorAddress;
+    readonly ownerSnapshot: ActorOwnerSnapshot;
+    readonly endpoint: LocalActorEndpoint<TInvocation, TOutput>;
+}
+export type ActorProcessorConfig = Readonly<Record<string, never>>;
+export interface ResolveActorInvocation {
+    readonly expectedRegistrationId?: string;
+}
+export interface DispatchActorInvocation<TInvocation> extends ResolveActorInvocation {
+    readonly input: TInvocation;
+}
+export interface UnregisterActorInvocation {
+    readonly expectedRegistrationId: string;
+}
+export interface ResolvedActor {
+    readonly address: ActorAddress;
+    readonly receipt: ActorRegistrationReceipt;
+}
+export interface RebuildActorRegistrationsConfig<TInvocation, TOutput> {
+    readonly endpointFor: (registration: ActorOwnerSnapshotRegistration) => LocalActorEndpoint<TInvocation, TOutput>;
+}
+export type DirectActorProcessor<TRuntime, TInput, TConfig, TOutput> = (runtime: TRuntime, input: TInput, config: TConfig) => TOutput | Promise<TOutput>;
+export type TargetedActorProcessor<TRuntime, TSelector, TInvocation, TConfig, TOutput> = (runtime: TRuntime, selector: TSelector, invocation: TInvocation, config: TConfig) => TOutput | Promise<TOutput>;
+export declare function parseActorAddress(value: unknown): ActorAddress;
+export declare function actorAddressKey(address: ActorAddress): string;
+export declare function parseActorSelector(value: unknown): ActorSelector;
+export declare function parseActorOwnerSnapshot(value: unknown): ActorOwnerSnapshot;
+export declare function parseActorRegistrationReceipt(value: unknown): ActorRegistrationReceipt;
+export declare function createLocalActorAddressingRuntime<TInvocation, TOutput>(config?: LocalActorAddressingRuntimeConfig): LocalActorAddressingRuntime<TInvocation, TOutput>;
+export declare function registerActor<TInvocation, TOutput>(runtime: LocalActorAddressingRuntime<TInvocation, TOutput>, input: RegisterActorInput<TInvocation, TOutput>, config: ActorProcessorConfig): ActorRegistrationReceipt;
+export declare function resolveActor<TInvocation, TOutput>(runtime: LocalActorAddressingRuntime<TInvocation, TOutput>, selector: ActorSelector, invocation: ResolveActorInvocation, config: ActorProcessorConfig): ResolvedActor;
+export declare function dispatchActor<TInvocation, TOutput>(runtime: LocalActorAddressingRuntime<TInvocation, TOutput>, selector: ActorSelector, invocation: DispatchActorInvocation<TInvocation>, config: ActorProcessorConfig): Promise<TOutput>;
+export declare function unregisterActor<TInvocation, TOutput>(runtime: LocalActorAddressingRuntime<TInvocation, TOutput>, selector: ActorSelector, invocation: UnregisterActorInvocation, config: ActorProcessorConfig): ActorRegistrationReceipt;
+export declare function rebuildActorRegistrations<TInvocation, TOutput>(runtime: LocalActorAddressingRuntime<TInvocation, TOutput>, input: ActorOwnerSnapshot, config: RebuildActorRegistrationsConfig<TInvocation, TOutput>): readonly ActorRegistrationReceipt[];
+export declare function createActorRefEndpoint<TSchema extends Record<string, unknown>, TTag extends keyof TSchema & string>(ref: {
+    readonly send: (tag: TTag, payload: TSchema[TTag]) => void;
+}, tag: TTag, handlerIdentity: string): LocalActorEndpoint<TSchema[TTag], void>;
+export {};
+//# sourceMappingURL=addressing.d.ts.map

package/dist/addressing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addressing.d.ts","sourceRoot":"","sources":["../src/addressing.ts"],"names":[],"mappings":"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"}

package/dist/addressing.js

@@ -0,0 +1,517 @@
+export const ACTOR_ADDRESS_SCHEMA_VERSION = 'depa-actor-address/v1';
+export const ACTOR_OWNER_SNAPSHOT_SCHEMA_VERSION = 'depa-actor-owner-snapshot/v1';
+export const ACTOR_REGISTRATION_SCHEMA_VERSION = 'depa-actor-registration/v1';
+export class ActorAddressingError extends Error {
+    code;
+    name = 'ActorAddressingError';
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+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;
+}
+export function parseActorAddress(value) {
+    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(record.get('namespace'), 'namespace'),
+        deploymentId: parseAddressSegment(record.get('deploymentId'), 'deploymentId'),
+        actorKind: parseAddressSegment(record.get('actorKind'), 'actorKind'),
+        logicalKey: parseAddressSegment(record.get('logicalKey'), 'logicalKey'),
+    });
+}
+export function actorAddressKey(address) {
+    const parsed = parseActorAddress(address);
+    return [
+        parsed.schemaVersion,
+        parsed.namespace,
+        parsed.deploymentId,
+        parsed.actorKind,
+        parsed.logicalKey,
+    ].join(':');
+}
+export 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'),
+    });
+}
+export function parseActorOwnerSnapshot(value) {
+    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');
+    }
+    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: 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),
+    });
+}
+export function parseActorRegistrationReceipt(value) {
+    const record = readExactRecord(value, REGISTRATION_RECEIPT_KEYS, 'registration-mismatch', 'ActorRegistrationReceipt');
+    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(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;
+    }
+}
+export 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;
+}
+export 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: 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(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,
+    });
+}
+export 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'));
+}
+export 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);
+    }
+}
+export 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: 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);
+    }
+}
+export function createActorRefEndpoint(ref, tag, handlerIdentity) {
+    const parsedHandlerIdentity = parseOpaqueToken(handlerIdentity, 'handlerIdentity', 'registration-mismatch');
+    return Object.freeze({
+        handlerIdentity: parsedHandlerIdentity,
+        dispatch: (input) => ref.send(tag, input),
+    });
+}
+//# sourceMappingURL=addressing.js.map