effect-actors 0.0.1

package/dist/host/client.js

@@ -0,0 +1,46 @@
+import { Effect } from "effect";
+import { Client } from "../client/service.js";
+import { unwrap } from "../client/outcome.js";
+import { HostedErrorSchema } from "../errors/index.js";
+import { boundary, decode, encode, fingerprint, validateId, validateKey, } from "../protocol/encoding.js";
+const requestKeyFor = (action, payload) => {
+    if (action.delivery._tag === "Transient")
+        return undefined;
+    const requestKey = action.delivery.requestKey(payload);
+    return validateId(requestKey);
+};
+export const makeClient = (options) => Effect.map(Client, (client) => (key) => {
+    const identity = {
+        ...key,
+        key: Array.isArray(key?.key) ? Object.freeze([...key.key]) : key?.key,
+    };
+    const address = () => ({
+        ...validateKey(identity),
+        namespace: client.namespace,
+        actorType: options.name,
+    });
+    const actions = Object.fromEntries(Object.entries(options.actions).map(([name, action]) => [
+        name,
+        (payload) => Effect.gen(function* () {
+            const encoded = yield* encode(action.payload, payload);
+            const decoded = yield* decode(action.payload, encoded);
+            const target = yield* boundary(address);
+            const requestKey = yield* boundary(() => requestKeyFor(action, decoded));
+            const digest = yield* boundary(() => fingerprint({
+                command: name,
+                protocolVersion: options.protocolVersion,
+                payload: encoded,
+            }));
+            const outcome = yield* client.hosted({
+                address: target,
+                action: name,
+                protocolVersion: options.protocolVersion,
+                payload: encoded,
+                fingerprint: digest,
+                ...(requestKey === undefined ? {} : { requestKey }),
+            });
+            return yield* unwrap(action.success, action.error, HostedErrorSchema, outcome);
+        }),
+    ]));
+    return { actions };
+});

package/dist/host/definition.d.ts

@@ -0,0 +1,71 @@
+import { Effect } from "effect";
+import type { Duration, Fiber, Layer, Scope } from "effect";
+import type { Client } from "../client/service.js";
+import type { CommandError, HostUnavailable, RegistrationError } from "../errors/index.js";
+import type { Address, Decoded, JsonSchema, Key, Procedure } from "../protocol/index.js";
+import type { Runtime } from "../runtime/service.js";
+export interface Action<P extends JsonSchema = JsonSchema, A extends JsonSchema = JsonSchema, E extends JsonSchema = JsonSchema> extends Procedure<P, A, E> {
+    readonly delivery: {
+        readonly _tag: "Transient";
+    } | {
+        readonly _tag: "Persisted";
+        readonly requestKey: (payload: Decoded<P>) => string;
+    };
+}
+export type Actions = Readonly<Record<string, Procedure & {
+    readonly delivery: {
+        readonly _tag: "Transient";
+    } | {
+        readonly _tag: "Persisted";
+        readonly requestKey: (payload: never) => string;
+    };
+}>>;
+export interface HostContext {
+    readonly address: Address;
+    readonly scope: Scope.Scope;
+    /**
+     * Runs authority-owned background work for this activation. The effect itself is not
+     * serialized; `make` must reconstruct pending work from durable application authority
+     * whenever the hosted actor activates again.
+     */
+    readonly fork: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Fiber.Fiber<A, E>, never, Exclude<R, Scope.Scope>>;
+}
+export type Handlers<A extends Actions> = {
+    readonly [N in keyof A]: (payload: Decoded<A[N]["payload"]>) => Effect.Effect<Decoded<A[N]["success"]>, Decoded<A[N]["error"]>>;
+};
+export interface Implementation<A extends Actions> {
+    readonly handlers: Handlers<A>;
+    readonly failure: Effect.Effect<never, HostUnavailable>;
+}
+export interface Reference<A extends Actions> {
+    readonly actions: {
+        readonly [N in keyof A]: (payload: Decoded<A[N]["payload"]>) => Effect.Effect<Decoded<A[N]["success"]>, Decoded<A[N]["error"]> | CommandError | HostUnavailable>;
+    };
+}
+export interface Protocol<A extends Actions = Actions> {
+    readonly kind: "hosted";
+    readonly actorType: string;
+    readonly version: number;
+    readonly actions: A;
+}
+export interface Definition<A extends Actions> {
+    readonly name: string;
+    readonly protocolVersion: number;
+    readonly protocol: Protocol<A>;
+    readonly of: (handlers: Handlers<A>) => Handlers<A>;
+    readonly client: Effect.Effect<(key: Key) => Reference<A>, never, Client>;
+    /**
+     * Registers the hosted actor. `make` runs on every authority activation, including
+     * recovery driven by a persisted keep-alive without a new client request.
+     */
+    readonly toLayer: <R>(make: (context: HostContext) => Effect.Effect<Implementation<A>, HostUnavailable, R>, options: {
+        readonly maxIdleTime: Duration.Input;
+        readonly mailboxCapacity: number;
+        readonly concurrency: number;
+    }) => Layer.Layer<never, RegistrationError, Runtime | Exclude<R, Scope.Scope>>;
+}
+export declare const action: <P extends JsonSchema, A extends JsonSchema, E extends JsonSchema>(options: Action<P, A, E>) => Action<P, A, E>;
+export declare const make: <A extends Actions>(name: string, options: {
+    readonly protocolVersion: number;
+    readonly actions: A;
+}) => Definition<A>;

package/dist/host/definition.js

@@ -0,0 +1,68 @@
+import { Effect } from "effect";
+import { assertIdentifier } from "../actor/state/codec.js";
+import { makeClient } from "./client.js";
+import { layer } from "./entity.js";
+const validateVersion = (version) => {
+    if (!Number.isSafeInteger(version) || version < 1) {
+        throw new TypeError("Hosted actor protocol versions must be positive integers");
+    }
+};
+export const action = (options) => {
+    if (options === null || typeof options !== "object" || options.delivery === undefined) {
+        throw new TypeError("Hosted actions require a delivery policy");
+    }
+    if (options.payload === undefined ||
+        options.success === undefined ||
+        options.error === undefined) {
+        throw new TypeError("Hosted actions require payload, success, and error schemas");
+    }
+    if (options.delivery._tag !== "Transient" && options.delivery._tag !== "Persisted") {
+        throw new TypeError("Hosted action delivery must be transient or persisted");
+    }
+    if (options.delivery._tag === "Persisted" && typeof options.delivery.requestKey !== "function") {
+        throw new TypeError("Persisted hosted actions require a request key function");
+    }
+    return Object.freeze({
+        payload: options.payload,
+        success: options.success,
+        error: options.error,
+        delivery: Object.freeze({ ...options.delivery }),
+    });
+};
+export const make = (name, options) => {
+    if (options === null ||
+        typeof options !== "object" ||
+        options.actions === null ||
+        typeof options.actions !== "object") {
+        throw new TypeError("Hosted actors require an action definition");
+    }
+    assertIdentifier(name);
+    validateVersion(options.protocolVersion);
+    const entries = Object.entries(options.actions);
+    if (entries.length === 0)
+        throw new TypeError("Hosted actors require at least one action");
+    const actions = Object.freeze(Object.fromEntries(entries.map(([actionName, definition]) => {
+        assertIdentifier(actionName);
+        if (definition === null || typeof definition !== "object" || !("delivery" in definition)) {
+            throw new TypeError("Hosted actions must be created with HostActor.action");
+        }
+        return [actionName, action(definition)];
+    })));
+    const protocol = Object.freeze({
+        kind: "hosted",
+        actorType: name,
+        version: options.protocolVersion,
+        actions,
+    });
+    const of = (handlers) => Object.freeze({ ...handlers });
+    const client = makeClient({ name, protocolVersion: options.protocolVersion, actions });
+    const definition = {
+        name,
+        protocolVersion: options.protocolVersion,
+        protocol,
+        of,
+        client,
+        toLayer: (create, layerOptions) => layer(definition, create, layerOptions),
+    };
+    return Object.freeze(definition);
+};

package/dist/host/entity.d.ts

@@ -0,0 +1,9 @@
+import { Effect, Layer, Scope } from "effect";
+import { HostUnavailable, RegistrationError } from "../errors/index.js";
+import { Runtime } from "../runtime/service.js";
+import type { Actions, Definition, HostContext, Implementation } from "./definition.js";
+export declare const layer: <A extends Actions, R>(definition: Definition<A>, make: (context: HostContext) => Effect.Effect<Implementation<A>, HostUnavailable, R>, options: {
+    readonly maxIdleTime: import("effect").Duration.Input;
+    readonly mailboxCapacity: number;
+    readonly concurrency: number;
+}) => Layer.Layer<never, RegistrationError, Runtime | Exclude<R, Scope.Scope>>;

package/dist/host/entity.js

@@ -0,0 +1,302 @@
+import { Cause, Deferred, Duration, Effect, Exit, Layer, Option, Queue, Ref, Result, Schedule, Scope, Semaphore, } from "effect";
+import { Entity, Sharding } from "effect/unstable/cluster";
+import { HostUnavailable, InvalidInput, RegistrationError, UnsupportedVersion, } from "../errors/index.js";
+import { boundary, canonicalJson, decode, encode, fingerprint, validateId, } from "../protocol/encoding.js";
+import { decodeAddress } from "../runtime/cluster/address.js";
+import { makeEntity } from "../runtime/cluster/protocol.js";
+import { Runtime } from "../runtime/service.js";
+const unavailable = (retryable) => new HostUnavailable({ retryable });
+const reactivationPolicy = Schedule.min([
+    Schedule.exponential(500, 1.5),
+    Schedule.spaced("10 seconds"),
+]);
+const reject = () => Effect.fail(new InvalidInput({ message: "Operation is not available for this actor" }));
+const validateOptions = (options) => {
+    const maxIdleMillis = Duration.toMillis(options.maxIdleTime);
+    if (!Number.isFinite(maxIdleMillis) ||
+        maxIdleMillis <= 0 ||
+        !Number.isSafeInteger(options.mailboxCapacity) ||
+        options.mailboxCapacity < 1 ||
+        !Number.isSafeInteger(options.concurrency) ||
+        options.concurrency < 1) {
+        throw new RegistrationError({
+            message: "Hosted actor idle duration, capacity, and concurrency must be positive",
+        });
+    }
+};
+const requestKeyFor = (action, payload) => {
+    if (action.delivery._tag !== "Persisted")
+        throw new InvalidInput({ message: "Hosted action is not persisted" });
+    const requestKey = action.delivery.requestKey(payload);
+    return validateId(requestKey);
+};
+const retainForRecovery = (background) => Ref.modify(background, (state) => {
+    const reactivate = state.active > 0;
+    return [reactivate, reactivate ? { ...state, retain: true } : state];
+});
+const hostContext = (address, scope, unavailableSignal, currentAddress, sharding) => Effect.gen(function* () {
+    const background = yield* Ref.make({ active: 0, retain: false });
+    const keepAlive = (enabled) => Entity.keepAlive(enabled).pipe(Effect.provideService(Sharding.Sharding, sharding), Effect.provideService(Entity.CurrentAddress, currentAddress));
+    const release = Effect.gen(function* () {
+        const shouldRelease = yield* Ref.modify(background, (state) => [
+            state.active === 1 && !state.retain,
+            { ...state, active: Math.max(0, state.active - 1) },
+        ]);
+        if (shouldRelease)
+            yield* keepAlive(false);
+    });
+    const fork = (effect) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+        const shouldRetain = yield* Ref.modify(background, (state) => [state.active === 0, { ...state, active: state.active + 1 }]);
+        if (shouldRetain)
+            yield* keepAlive(true);
+        const work = restore(effect).pipe(Scope.provide(scope), Effect.onError((cause) => Cause.hasInterruptsOnly(cause)
+            ? Effect.void
+            : Effect.flatMap(retainForRecovery(background), (reactivate) => Deferred.fail(unavailableSignal, {
+                error: unavailable(true),
+                reactivate,
+            }).pipe(Effect.asVoid))), Effect.ensuring(release));
+        return yield* Effect.forkIn(work, scope);
+    }));
+    return { context: { address, scope, fork }, background, keepAlive };
+});
+const unavailableResult = (durable, error) => durable && error.retryable
+    ? Effect.die("Hosted actor is temporarily unavailable")
+    : Effect.fail(error);
+const validateHandlers = (actions, handlers) => {
+    if (typeof handlers !== "object" || handlers === null)
+        return unavailable(false);
+    const names = Object.keys(handlers);
+    const expected = Object.keys(actions);
+    if (names.length !== expected.length)
+        return unavailable(false);
+    for (const name of expected) {
+        if (!Object.hasOwn(handlers, name) || typeof handlers[name] !== "function")
+            return unavailable(false);
+    }
+    return undefined;
+};
+const activationFailure = (activation) => Effect.flatMap(Deferred.poll(activation.unavailableSignal), Option.match({
+    onNone: () => Effect.succeed(Option.none()),
+    onSome: (failure) => Effect.map(Effect.flip(failure), Option.some),
+}));
+const byteLength = (value) => new TextEncoder().encode(canonicalJson(value)).byteLength;
+const handlersForActivation = (entity, actorType, actions, protocolVersion, maxCommandBytes, maxStateBytes, activate) => {
+    const dispatch = (durable, input) => Effect.gen(function* () {
+        if (input.protocolVersion !== protocolVersion) {
+            return yield* Effect.fail(new UnsupportedVersion({ actorType, version: input.protocolVersion }));
+        }
+        if (!Object.hasOwn(actions, input.action)) {
+            return yield* Effect.fail(new InvalidInput({ message: "Unknown hosted action" }));
+        }
+        const action = actions[input.action];
+        if ((action.delivery._tag === "Persisted") !== durable) {
+            return yield* Effect.fail(new InvalidInput({ message: "Hosted action delivery does not match its definition" }));
+        }
+        yield* boundary(() => {
+            if (byteLength(input.payload) > maxCommandBytes) {
+                throw new InvalidInput({
+                    message: "Hosted action payload exceeds the configured byte limit",
+                });
+            }
+        });
+        const digest = yield* boundary(() => fingerprint({
+            command: input.action,
+            protocolVersion: input.protocolVersion,
+            payload: input.payload,
+        }));
+        if (digest !== input.fingerprint) {
+            return yield* Effect.fail(new InvalidInput({ message: "Hosted action fingerprint mismatch" }));
+        }
+        const payload = yield* decode(action.payload, input.payload);
+        const requestKey = durable ? yield* boundary(() => requestKeyFor(action, payload)) : undefined;
+        if (durable && input.requestKey !== requestKey) {
+            return yield* Effect.fail(new InvalidInput({ message: "Hosted action request key mismatch" }));
+        }
+        if (!durable && input.requestKey !== undefined) {
+            return yield* Effect.fail(new InvalidInput({ message: "Transient hosted actions cannot include a request key" }));
+        }
+        const activation = yield* activate.pipe(Effect.catch((error) => unavailableResult(durable, error)));
+        const knownFailure = yield* activationFailure(activation);
+        if (Option.isSome(knownFailure)) {
+            return yield* unavailableResult(durable, knownFailure.value.error);
+        }
+        const handler = activation.implementation.handlers[input.action];
+        const handle = Effect.gen(function* () {
+            const result = yield* Effect.result(Effect.suspend(() => handler(payload)));
+            if (Result.isSuccess(result)) {
+                const value = yield* encode(action.success, result.success);
+                yield* boundary(() => {
+                    if (byteLength(value) > maxStateBytes) {
+                        throw new InvalidInput({
+                            message: "Hosted action output exceeds the configured byte limit",
+                        });
+                    }
+                });
+                return { _tag: "Success", value };
+            }
+            const error = yield* encode(action.error, result.failure);
+            yield* boundary(() => {
+                if (byteLength(error) > maxStateBytes) {
+                    throw new InvalidInput({
+                        message: "Hosted action error exceeds the configured byte limit",
+                    });
+                }
+            });
+            return { _tag: "Failure", error };
+        });
+        return yield* Deferred.await(activation.unavailableSignal).pipe(Effect.catch((failure) => unavailableResult(durable, failure.error)), Effect.raceFirst(handle), Effect.catchDefect(() => Effect.die("Hosted actor handler failed")));
+    });
+    return entity.of({
+        Command: reject,
+        Query: reject,
+        Receipt: reject,
+        Events: reject,
+        Wake: reject,
+        Action: (request) => dispatch(false, request.payload),
+        DurableAction: (request) => dispatch(true, request.payload),
+    });
+};
+const makeActivation = (options) => Effect.gen(function* () {
+    const scope = yield* Scope.fork(options.transportScope);
+    const unavailableSignal = yield* Deferred.make();
+    const managed = yield* hostContext(options.address, scope, unavailableSignal, options.currentAddress, options.sharding);
+    const failed = (error) => Effect.map(retainForRecovery(managed.background), (active) => ({
+        _tag: "Unavailable",
+        failure: {
+            error,
+            reactivate: options.retainRecovery || active,
+        },
+    }));
+    const initialize = Effect.suspend(() => options.make(managed.context)).pipe(Effect.provideContext(options.dependencies), Scope.provide(scope), Effect.matchEffect({
+        onFailure: failed,
+        onSuccess: (implementation) => Effect.succeed({ _tag: "Ready", implementation }),
+    }), Effect.catchDefect(() => failed(unavailable(true))));
+    const initialized = yield* Deferred.await(unavailableSignal).pipe(Effect.catch((failure) => Effect.succeed({ _tag: "Unavailable", failure })), Effect.raceFirst(initialize));
+    if (initialized._tag === "Unavailable") {
+        if (!initialized.failure.error.retryable || !initialized.failure.reactivate) {
+            yield* managed.keepAlive(false);
+        }
+        yield* Scope.close(scope, Exit.fail(initialized.failure.error));
+        return yield* Effect.fail(initialized.failure);
+    }
+    const invalid = validateHandlers(options.actions, initialized.implementation.handlers);
+    if (invalid !== undefined) {
+        yield* managed.keepAlive(false);
+        yield* Scope.close(scope, Exit.fail(invalid));
+        return yield* Effect.fail({ error: invalid, reactivate: false });
+    }
+    if (options.retainRecovery) {
+        const state = yield* Ref.get(managed.background);
+        if (state.active === 0)
+            yield* managed.keepAlive(false);
+    }
+    return {
+        scope,
+        implementation: initialized.implementation,
+        unavailableSignal,
+        background: managed.background,
+        keepAlive: managed.keepAlive,
+    };
+});
+const watchActivation = (activation, transportScope, invalidate) => Effect.gen(function* () {
+    const closeOnFailure = Deferred.await(activation.unavailableSignal).pipe(Effect.catch((failure) => invalidate(activation, failure)));
+    const fail = (error) => Effect.flatMap(retainForRecovery(activation.background), (reactivate) => Deferred.fail(activation.unavailableSignal, { error, reactivate }).pipe(Effect.asVoid));
+    const watchAuthority = activation.implementation.failure.pipe(Effect.catch(fail), Effect.catchDefect(() => fail(unavailable(true))));
+    yield* Effect.forkIn(closeOnFailure, transportScope);
+    yield* Effect.forkIn(watchAuthority, activation.scope);
+});
+export const layer = (definition, make, options) => Layer.effectDiscard(Effect.gen(function* () {
+    yield* Effect.try({
+        try: () => validateOptions(options),
+        catch: () => new RegistrationError({ message: "Invalid hosted actor options" }),
+    });
+    const runtime = yield* Runtime;
+    const dependencies = yield* Effect.context();
+    const entity = makeEntity(runtime.configuration.namespace, definition.name);
+    const entityLayer = entity.toLayer(Effect.gen(function* () {
+        const currentAddress = yield* Entity.CurrentAddress;
+        const transportScope = yield* Effect.scope;
+        const address = yield* Effect.sync(() => decodeAddress(runtime.configuration.namespace, definition.name, currentAddress.entityId));
+        const sharding = yield* Sharding.Sharding;
+        const gate = yield* Semaphore.make(1);
+        const recoveries = yield* Queue.dropping(1);
+        let current;
+        let terminal;
+        let invalidate;
+        const attemptActivation = (retainRecovery) => gate.withPermit(Effect.gen(function* () {
+            if (terminal !== undefined) {
+                return {
+                    _tag: "Unavailable",
+                    failure: { error: terminal, reactivate: false },
+                };
+            }
+            if (current !== undefined) {
+                const failure = yield* activationFailure(current);
+                return Option.isNone(failure)
+                    ? { _tag: "Ready", activation: current }
+                    : { _tag: "Unavailable", failure: failure.value };
+            }
+            const result = yield* Effect.result(makeActivation({
+                actions: definition.protocol.actions,
+                address,
+                currentAddress,
+                dependencies,
+                make,
+                retainRecovery,
+                sharding,
+                transportScope,
+            }));
+            if (Result.isFailure(result)) {
+                if (!result.failure.error.retryable)
+                    terminal = result.failure.error;
+                return { _tag: "Unavailable", failure: result.failure };
+            }
+            current = result.success;
+            yield* watchActivation(result.success, transportScope, invalidate);
+            return { _tag: "Ready", activation: result.success };
+        }));
+        const activateManaged = (retainRecovery, superviseFailure) => Effect.flatMap(attemptActivation(retainRecovery), (result) => {
+            if (result._tag === "Ready")
+                return Effect.succeed(result.activation);
+            const supervise = superviseFailure && result.failure.error.retryable && result.failure.reactivate
+                ? Queue.offer(recoveries, undefined).pipe(Effect.asVoid)
+                : Effect.void;
+            return supervise.pipe(Effect.andThen(Effect.fail(result.failure)));
+        });
+        invalidate = (activation, failure) => Effect.flatMap(gate.withPermit(Effect.gen(function* () {
+            const active = current === activation;
+            if (active) {
+                current = undefined;
+                if (!failure.error.retryable)
+                    terminal = failure.error;
+            }
+            yield* Scope.close(activation.scope, Exit.fail(failure.error));
+            if (active && !failure.error.retryable)
+                yield* activation.keepAlive(false);
+            return active && failure.error.retryable && failure.reactivate;
+        })), (reactivate) => reactivate ? Queue.offer(recoveries, undefined).pipe(Effect.asVoid) : Effect.void);
+        const initial = yield* Effect.result(Effect.suspend(() => activateManaged(true, false)).pipe(Effect.retry({
+            while: (failure) => failure.error.retryable,
+            schedule: reactivationPolicy,
+        })));
+        if (Result.isFailure(initial) && initial.failure.error.retryable) {
+            return yield* Effect.die("Hosted actor activation retry policy terminated");
+        }
+        yield* Effect.forkIn(Queue.take(recoveries).pipe(Effect.andThen(Effect.suspend(() => activateManaged(true, false)).pipe(Effect.retry({
+            while: (failure) => failure.error.retryable,
+            schedule: reactivationPolicy,
+        }), Effect.catch(() => Effect.void))), Effect.forever), transportScope);
+        const activate = Effect.suspend(() => activateManaged(false, true).pipe(Effect.mapError((failure) => failure.error)));
+        return handlersForActivation(entity, definition.name, definition.protocol.actions, definition.protocolVersion, runtime.configuration.maxCommandBytes, runtime.configuration.maxStateBytes, activate);
+    }), {
+        maxIdleTime: options.maxIdleTime,
+        mailboxCapacity: options.mailboxCapacity,
+        concurrency: options.concurrency,
+    });
+    yield* runtime.register({
+        actorType: definition.name,
+        protocolVersion: definition.protocolVersion,
+        kind: "hosted",
+        entity: entityLayer,
+    });
+}));

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * as Actor from "./actor/definition.js";
+export * as ActorRuntime from "./runtime/service.js";
+export * as ActorStore from "./store/service.js";
+export * as ActorClient from "./client/service.js";
+export * as HostActor from "./host/definition.js";
+export * as Gateway from "./gateway/service.js";
+export * as Protocol from "./protocol/index.js";
+export * as Errors from "./errors/index.js";
+export * as Testing from "./testing/index.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export * as Actor from "./actor/definition.js";
+export * as ActorRuntime from "./runtime/service.js";
+export * as ActorStore from "./store/service.js";
+export * as ActorClient from "./client/service.js";
+export * as HostActor from "./host/definition.js";
+export * as Gateway from "./gateway/service.js";
+export * as Protocol from "./protocol/index.js";
+export * as Errors from "./errors/index.js";
+export * as Testing from "./testing/index.js";

package/dist/protocol/encoding.d.ts

@@ -0,0 +1,29 @@
+import { Effect, Schema } from "effect";
+import { InvalidInput } from "../errors/index.js";
+import type { Address, Json, Key } from "./index.js";
+export declare const KeySchema: Schema.Struct<{
+    readonly tenant: Schema.String;
+    readonly key: Schema.$Array<Schema.String>;
+}>;
+export declare const AddressSchema: Schema.Struct<{
+    readonly namespace: Schema.String;
+    readonly tenant: Schema.String;
+    readonly actorType: Schema.String;
+    readonly key: Schema.$Array<Schema.String>;
+}>;
+export declare const validateKey: (input: Key) => Key;
+export declare const addressId: (input: Address) => string;
+export declare const validateId: (value: string, maximumBytes?: number) => string;
+export declare const canonicalJson: (input: Json) => string;
+export declare const fingerprint: (input: {
+    readonly command: string;
+    readonly protocolVersion: number;
+    readonly payload: Json;
+    readonly expectedRevision?: string;
+}) => string;
+export declare const isSequence: (value: string) => boolean;
+export declare const makeCursor: (address: Address, sequence: string) => string;
+export declare const readCursor: (address: Address, cursor: string) => string;
+export declare const decode: <S extends Schema.ConstraintDecoder<unknown>>(schema: S, input: unknown) => Effect.Effect<S["Type"], InvalidInput, S["DecodingServices"]>;
+export declare const encode: <S extends Schema.ConstraintEncoder<unknown>>(schema: S, input: S["Type"]) => Effect.Effect<S["Encoded"], InvalidInput, S["EncodingServices"]>;
+export declare const boundary: <A>(evaluate: () => A) => Effect.Effect<A, InvalidInput>;