effect-actors 0.0.1

package/dist/protocol/encoding.js

@@ -0,0 +1,165 @@
+import canonicalizeImport from "canonicalize";
+import { Effect, Encoding, Result, Schema } from "effect";
+import { InvalidInput } from "../errors/index.js";
+const canonicalize = canonicalizeImport;
+const Segment = Schema.String.check(Schema.isNonEmpty(), Schema.isMaxLength(256), Schema.makeFilter((value) => !/[\u0000-\u001f\u007f]/.test(value)));
+export const KeySchema = Schema.Struct({ tenant: Segment, key: Schema.Array(Segment) });
+export const AddressSchema = Schema.Struct({
+    namespace: Segment,
+    tenant: Segment,
+    actorType: Segment,
+    key: Schema.Array(Segment),
+});
+export const validateKey = (input) => {
+    let key;
+    try {
+        key = Schema.decodeUnknownSync(KeySchema)(input, { onExcessProperty: "error" });
+    }
+    catch {
+        throw new InvalidInput({ message: "Invalid actor identity" });
+    }
+    if (key.key.length === 0 || key.key.length > 32)
+        throw new InvalidInput({ message: "Actor keys require 1 to 32 segments" });
+    canonicalJson([key.tenant, key.key]);
+    return key;
+};
+export const addressId = (input) => {
+    let address;
+    try {
+        address = Schema.decodeUnknownSync(AddressSchema)(input, { onExcessProperty: "error" });
+    }
+    catch {
+        throw new InvalidInput({ message: "Invalid actor address" });
+    }
+    validateKey({ tenant: address.tenant, key: address.key });
+    const encoded = canonicalJson([address.namespace, address.tenant, address.actorType, address.key]);
+    if (new TextEncoder().encode(encoded).byteLength > 1024) {
+        throw new InvalidInput({
+            message: "Serialized actor identities cannot exceed 1024 UTF-8 bytes",
+        });
+    }
+    return encoded;
+};
+export const validateId = (value, maximumBytes = 256) => {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        /[\u0000-\u001f\u007f]/.test(value) ||
+        new TextEncoder().encode(value).byteLength > maximumBytes) {
+        throw new InvalidInput({
+            message: `Operation identities require 1 to ${maximumBytes} UTF-8 bytes without control characters`,
+        });
+    }
+    canonicalJson(value);
+    return value;
+};
+const invalidSurrogate = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+export const canonicalJson = (input) => {
+    const active = new Set();
+    const pending = [
+        { value: input, depth: 0 },
+    ];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        const value = current.value;
+        if (current.leave) {
+            active.delete(value);
+            continue;
+        }
+        if (current.depth > 64)
+            throw new InvalidInput({ message: "JSON exceeds the maximum nesting depth" });
+        if (value === null || typeof value === "boolean")
+            continue;
+        if (typeof value === "number") {
+            if (!Number.isFinite(value))
+                throw new InvalidInput({ message: "JSON numbers must be finite" });
+            continue;
+        }
+        if (typeof value === "string") {
+            if (invalidSurrogate.test(value))
+                throw new InvalidInput({ message: "JSON strings must contain valid Unicode" });
+            continue;
+        }
+        if (typeof value !== "object")
+            throw new InvalidInput({ message: "Value is not JSON" });
+        if (active.has(value))
+            throw new InvalidInput({ message: "JSON cannot contain cycles" });
+        const prototype = Object.getPrototypeOf(value);
+        if (Array.isArray(value) && (prototype !== Array.prototype || Object.hasOwn(value, "reduce"))) {
+            throw new InvalidInput({
+                message: "JSON arrays cannot override their serialization behavior",
+            });
+        }
+        if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+            throw new InvalidInput({ message: "JSON objects must be plain records" });
+        }
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        if (Object.values(descriptors).some((descriptor) => !("value" in descriptor)) ||
+            typeof descriptors.toJSON?.value === "function") {
+            throw new InvalidInput({ message: "JSON cannot contain accessors or custom serializers" });
+        }
+        active.add(value);
+        pending.push({ value, depth: current.depth, leave: true });
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index++) {
+                if (!Object.hasOwn(value, index))
+                    throw new InvalidInput({ message: "JSON arrays cannot contain holes" });
+                pending.push({ value: value[index], depth: current.depth + 1 });
+            }
+        }
+        else {
+            for (const [key, child] of Object.entries(value)) {
+                if (invalidSurrogate.test(key))
+                    throw new InvalidInput({ message: "JSON keys must contain valid Unicode" });
+                pending.push({ value: child, depth: current.depth + 1 });
+            }
+        }
+    }
+    const encoded = canonicalize(input);
+    if (encoded === undefined)
+        throw new InvalidInput({ message: "Value is not JSON" });
+    return encoded;
+};
+export const fingerprint = (input) => canonicalJson({
+    command: input.command,
+    protocolVersion: input.protocolVersion,
+    payload: input.payload,
+    ...(input.expectedRevision === undefined ? {} : { expectedRevision: input.expectedRevision }),
+});
+const sequencePattern = /^(0|[1-9][0-9]{0,31})$/;
+export const isSequence = (value) => value.trim() === value && sequencePattern.test(value);
+export const makeCursor = (address, sequence) => {
+    if (!isSequence(sequence))
+        throw new InvalidInput({ message: "Invalid event sequence" });
+    return Encoding.encodeBase64Url(JSON.stringify([1, addressId(address), sequence]));
+};
+export const readCursor = (address, cursor) => {
+    if (cursor.length > 16_384)
+        throw new InvalidInput({ message: "Invalid event cursor" });
+    const decoded = Encoding.decodeBase64UrlString(cursor);
+    if (Result.isFailure(decoded))
+        throw new InvalidInput({ message: "Invalid event cursor" });
+    let value;
+    try {
+        value = JSON.parse(decoded.success);
+    }
+    catch {
+        throw new InvalidInput({ message: "Invalid event cursor" });
+    }
+    if (!Array.isArray(value) ||
+        value.length !== 3 ||
+        value[0] !== 1 ||
+        value[1] !== addressId(address) ||
+        typeof value[2] !== "string" ||
+        !isSequence(value[2])) {
+        throw new InvalidInput({ message: "Cursor does not belong to this actor" });
+    }
+    return value[2];
+};
+export const decode = (schema, input) => Schema.decodeUnknownEffect(schema)(input, { onExcessProperty: "error" }).pipe(Effect.mapError(() => new InvalidInput({ message: "Input does not match its schema" })));
+export const encode = (schema, input) => Schema.encodeEffect(schema)(input).pipe(Effect.mapError(() => new InvalidInput({ message: "Output does not match its schema" })));
+export const boundary = (evaluate) => Effect.try({
+    try: evaluate,
+    catch: (cause) => cause instanceof InvalidInput
+        ? cause
+        : new InvalidInput({ message: "Invalid protocol value" }),
+});

package/dist/protocol/index.d.ts

@@ -0,0 +1,90 @@
+import type { Schema } from "effect";
+export { addressId, makeCursor, readCursor, fingerprint, canonicalJson, validateKey, validateId, decode, encode, boundary, } from "./encoding.js";
+export type Json = Schema.Json;
+export type JsonSchema = Schema.Codec<unknown, Json, never, never>;
+export type Decoded<S extends JsonSchema> = S["Type"];
+export interface Key {
+    readonly tenant: string;
+    readonly key: ReadonlyArray<string>;
+}
+export interface Address extends Key {
+    readonly namespace: string;
+    readonly actorType: string;
+}
+export interface CommandOptions {
+    readonly commandId: string;
+    readonly expectedRevision?: string;
+}
+export interface Receipt<A> {
+    readonly commandId: string;
+    readonly revision: string;
+    readonly cursor: string;
+    readonly committedAtMillis: number;
+    readonly value: A;
+}
+export interface QueryResult<A> {
+    readonly revision: string;
+    readonly cursor: string;
+    readonly value: A;
+}
+export interface Event<A> {
+    readonly cursor: string;
+    readonly commandId: string;
+    readonly committedAtMillis: number;
+    readonly value: A;
+}
+export interface SubscribeOptions {
+    readonly after: string;
+}
+export interface Procedure<P extends JsonSchema = JsonSchema, A extends JsonSchema = JsonSchema, E extends JsonSchema = JsonSchema> {
+    readonly payload: P;
+    readonly success: A;
+    readonly error: E;
+}
+export type Procedures = Readonly<Record<string, Procedure>>;
+export interface OutgoingCommand {
+    readonly kind: "command" | "hosted";
+    readonly target: Address;
+    readonly operation: string;
+    readonly protocolVersion: number;
+    readonly payload: Json;
+    readonly commandId: string;
+}
+export type TimerChange = {
+    readonly _tag: "Set";
+    readonly timerId: string;
+    readonly dueAtMillis: number;
+    readonly command: string;
+    readonly payload: Json;
+} | {
+    readonly _tag: "Cancel";
+    readonly timerId: string;
+};
+export type Outcome = {
+    readonly _tag: "Success";
+    readonly value: Json;
+} | {
+    readonly _tag: "Failure";
+    readonly error: Json;
+};
+export type WireReceipt = Receipt<Outcome>;
+export interface Invocation {
+    readonly address: Address;
+    readonly command: string;
+    readonly protocolVersion: number;
+    readonly payload: Json;
+    readonly commandId: string;
+    readonly fingerprint: string;
+    readonly expectedRevision?: string;
+}
+export interface Query {
+    readonly address: Address;
+    readonly query: string;
+    readonly protocolVersion: number;
+    readonly payload: Json;
+}
+export interface EventPage {
+    readonly events: ReadonlyArray<Event<Json>>;
+    readonly nextCursor: string;
+    readonly hasMore: boolean;
+}

package/dist/protocol/index.js

@@ -0,0 +1 @@
+export { addressId, makeCursor, readCursor, fingerprint, canonicalJson, validateKey, validateId, decode, encode, boundary, } from "./encoding.js";

package/dist/protocol/schemas.d.ts

@@ -0,0 +1,49 @@
+import { Schema } from "effect";
+export declare const Sequence: Schema.String;
+export declare const Outcome: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"Success">;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"Failure">;
+    readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>;
+export declare const Receipt: Schema.Struct<{
+    readonly commandId: Schema.String;
+    readonly revision: Schema.String;
+    readonly cursor: Schema.String;
+    readonly committedAtMillis: Schema.Number;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"Success">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"Failure">;
+        readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>]>;
+}>;
+export declare const QueryResult: Schema.Struct<{
+    readonly revision: Schema.String;
+    readonly cursor: Schema.String;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"Success">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"Failure">;
+        readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>]>;
+}>;
+export declare const Event: Schema.Struct<{
+    readonly cursor: Schema.String;
+    readonly commandId: Schema.String;
+    readonly committedAtMillis: Schema.Number;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export declare const EventPage: Schema.Struct<{
+    readonly events: Schema.$Array<Schema.Struct<{
+        readonly cursor: Schema.String;
+        readonly commandId: Schema.String;
+        readonly committedAtMillis: Schema.Number;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>>;
+    readonly nextCursor: Schema.String;
+    readonly hasMore: Schema.Boolean;
+}>;

package/dist/protocol/schemas.js

@@ -0,0 +1,30 @@
+import { Schema } from "effect";
+import { isSequence } from "./encoding.js";
+export const Sequence = Schema.String.check(Schema.makeFilter(isSequence));
+export const Outcome = Schema.Union([
+    Schema.Struct({ _tag: Schema.tag("Success"), value: Schema.Json }),
+    Schema.Struct({ _tag: Schema.tag("Failure"), error: Schema.Json }),
+]);
+export const Receipt = Schema.Struct({
+    commandId: Schema.String,
+    revision: Sequence,
+    cursor: Schema.String,
+    committedAtMillis: Schema.Number,
+    value: Outcome,
+});
+export const QueryResult = Schema.Struct({
+    revision: Sequence,
+    cursor: Schema.String,
+    value: Outcome,
+});
+export const Event = Schema.Struct({
+    cursor: Schema.String,
+    commandId: Schema.String,
+    committedAtMillis: Schema.Number,
+    value: Schema.Json,
+});
+export const EventPage = Schema.Struct({
+    events: Schema.Array(Event),
+    nextCursor: Schema.String,
+    hasMore: Schema.Boolean,
+});

package/dist/runtime/cluster/address.d.ts

@@ -0,0 +1,3 @@
+import type { Address } from "../../protocol/index.js";
+export declare const entityId: (address: Address) => string;
+export declare const decodeAddress: (namespace: string, actorType: string, id: string) => Address;

package/dist/runtime/cluster/address.js

@@ -0,0 +1,21 @@
+import { InvalidInput } from "../../errors/index.js";
+import { addressId, validateKey } from "../../protocol/encoding.js";
+export const entityId = (address) => {
+    addressId(address);
+    return JSON.stringify([address.tenant, address.key]);
+};
+export const decodeAddress = (namespace, actorType, id) => {
+    let value;
+    try {
+        value = JSON.parse(id);
+    }
+    catch {
+        throw new InvalidInput({ message: "Invalid entity identity" });
+    }
+    if (!Array.isArray(value) || value.length !== 2)
+        throw new InvalidInput({ message: "Invalid entity identity" });
+    const key = validateKey({ tenant: value[0], key: value[1] });
+    const address = { namespace, actorType, ...key };
+    addressId(address);
+    return address;
+};

package/dist/runtime/cluster/client.d.ts

@@ -0,0 +1,9 @@
+import { Sharding } from "effect/unstable/cluster";
+import type { Service } from "../../client/service.js";
+import type { Invocation } from "../../protocol/index.js";
+import type { Configuration, Runtime } from "../service.js";
+export declare const validateInvocation: (input: Invocation, configuration: Configuration) => void;
+export declare const make: (configuration: Configuration, sharding: Sharding.Sharding["Service"]) => {
+    readonly client: Service;
+    readonly wake: Runtime["Service"]["wake"];
+};

package/dist/runtime/cluster/client.js

@@ -0,0 +1,131 @@
+import { Effect, Option, Result, Schema, Stream } from "effect";
+import { Sharding } from "effect/unstable/cluster";
+import { CommandErrorSchema, EventErrorSchema, InvalidInput, OutcomeUnknown, Overloaded, ReadErrorSchema, StorageUnavailable, } from "../../errors/index.js";
+import { HostedErrorSchema } from "../../errors/index.js";
+import { addressId, boundary, canonicalJson, fingerprint, readCursor, validateId, isSequence, } from "../../protocol/encoding.js";
+import { entityId } from "./address.js";
+import { makeEntity } from "./protocol.js";
+const transportError = (error) => {
+    if (typeof error === "object" &&
+        error !== null &&
+        "_tag" in error &&
+        (error._tag === "MailboxFull" || error._tag === "AlreadyProcessingMessage")) {
+        return new Overloaded({ retryAfterMillis: 250 });
+    }
+    return new StorageUnavailable({ retryable: true });
+};
+const normalize = (schema, error) => {
+    const result = Schema.decodeUnknownResult(schema)(error);
+    return Result.isSuccess(result) ? result.success : transportError(error);
+};
+export const validateInvocation = (input, configuration) => {
+    addressId(input.address);
+    if (input.address.namespace !== configuration.namespace)
+        throw new InvalidInput({ message: "Actor namespace mismatch" });
+    validateId(input.commandId);
+    if (typeof input.commandId !== "string" ||
+        input.commandId.length === 0 ||
+        input.commandId.length > 256 ||
+        input.commandId.startsWith("~effect-actors/"))
+        throw new InvalidInput({ message: "Invalid or reserved command identity" });
+    if (!Number.isSafeInteger(input.protocolVersion) ||
+        input.protocolVersion < 1 ||
+        typeof input.command !== "string" ||
+        input.command.length < 1 ||
+        input.command.length > 128 ||
+        (input.expectedRevision !== undefined && !isSequence(input.expectedRevision))) {
+        throw new InvalidInput({ message: "Invalid command envelope" });
+    }
+    if (new TextEncoder().encode(canonicalJson(input.payload)).byteLength >
+        configuration.maxCommandBytes) {
+        throw new InvalidInput({ message: "Command payload exceeds the configured byte limit" });
+    }
+    if (fingerprint(input) !== input.fingerprint)
+        throw new InvalidInput({ message: "Command fingerprint mismatch" });
+};
+export const make = (configuration, sharding) => {
+    const clients = new Map();
+    const get = (address) => Effect.gen(function* () {
+        yield* boundary(() => {
+            addressId(address);
+            if (address.namespace !== configuration.namespace)
+                throw new InvalidInput({ message: "Actor namespace mismatch" });
+        });
+        let client = clients.get(address.actorType);
+        if (!client) {
+            client = yield* makeEntity(configuration.namespace, address.actorType).client.pipe(Effect.provideService(Sharding.Sharding, sharding));
+            clients.set(address.actorType, client);
+        }
+        return client(entityId(address));
+    });
+    const client = {
+        namespace: configuration.namespace,
+        command: (input) => Effect.gen(function* () {
+            yield* boundary(() => validateInvocation(input, configuration));
+            const client = yield* get(input.address);
+            return yield* client.Command(input).pipe(Effect.mapError((error) => normalize(CommandErrorSchema, error)), Effect.timeoutOrElse({
+                duration: configuration.maxTurnDuration,
+                orElse: () => Effect.fail(new OutcomeUnknown({ commandId: input.commandId })),
+            }));
+        }),
+        query: (input) => Effect.gen(function* () {
+            yield* boundary(() => {
+                if (new TextEncoder().encode(canonicalJson(input.payload)).byteLength >
+                    configuration.maxCommandBytes) {
+                    throw new InvalidInput({ message: "Query payload exceeds the configured byte limit" });
+                }
+            });
+            const client = yield* get(input.address);
+            return yield* client.Query(input).pipe(Effect.mapError((error) => normalize(ReadErrorSchema, error)), Effect.timeoutOrElse({
+                duration: configuration.maxTurnDuration,
+                orElse: () => Effect.fail(new StorageUnavailable({ retryable: true })),
+            }));
+        }),
+        receipt: (address, commandId) => Effect.gen(function* () {
+            yield* boundary(() => validateId(commandId, 1024));
+            const client = yield* get(address);
+            return yield* client.Receipt({ commandId }).pipe(Effect.map(Option.fromNullishOr), Effect.mapError((error) => normalize(ReadErrorSchema, error)), Effect.timeoutOrElse({
+                duration: configuration.maxTurnDuration,
+                orElse: () => Effect.fail(new StorageUnavailable({ retryable: true })),
+            }));
+        }),
+        events: (address, options) => Stream.unwrap(Effect.gen(function* () {
+            yield* boundary(() => readCursor(address, options.after));
+            const client = yield* get(address);
+            let after = options.after;
+            let waitBeforeNextPage = false;
+            const page = Effect.suspend(() => (waitBeforeNextPage ? Effect.sleep("250 millis") : Effect.void).pipe(Effect.andThen(client.Events({ after, limit: 128 })))).pipe(Effect.mapError((error) => normalize(EventErrorSchema, error)), Effect.timeoutOrElse({
+                duration: configuration.maxTurnDuration,
+                orElse: () => Effect.fail(new StorageUnavailable({ retryable: true })),
+            }), Effect.tap((page) => Effect.sync(() => {
+                after = page.nextCursor;
+                waitBeforeNextPage = !page.hasMore;
+            })));
+            return Stream.fromEffectRepeat(page).pipe(Stream.flatMap((page) => Stream.fromIterable(page.events)));
+        })),
+        hosted: (input) => Effect.gen(function* () {
+            yield* boundary(() => {
+                if (new TextEncoder().encode(canonicalJson(input.payload)).byteLength >
+                    configuration.maxCommandBytes) {
+                    throw new InvalidInput({ message: "Hosted payload exceeds the configured byte limit" });
+                }
+            });
+            const client = yield* get(input.address);
+            const request = input.requestKey === undefined ? client.Action(input) : client.DurableAction(input);
+            return yield* request.pipe(Effect.mapError((error) => normalize(HostedErrorSchema, error)), Effect.timeoutOrElse({
+                duration: configuration.maxTurnDuration,
+                orElse: () => Effect.fail(new OutcomeUnknown({ commandId: input.requestKey ?? "transient" })),
+            }));
+        }),
+    };
+    return {
+        client,
+        wake: (candidate) => Effect.gen(function* () {
+            const target = yield* get(candidate.address);
+            return yield* target.Wake(candidate).pipe(Effect.map(Option.fromNullishOr), Effect.mapError((error) => normalize(CommandErrorSchema, error)), Effect.timeoutOrElse({
+                duration: configuration.maxTurnDuration,
+                orElse: () => Effect.fail(new StorageUnavailable({ retryable: true })),
+            }));
+        }),
+    };
+};

package/dist/runtime/cluster/protocol.d.ts

@@ -0,0 +1,104 @@
+import { Schema } from "effect";
+import { Entity } from "effect/unstable/cluster";
+import { Rpc } from "effect/unstable/rpc";
+export declare const makeEntity: (namespace: string, actorType: string) => Entity.Entity<`effect-actors/${string}`, Rpc.Rpc<"Action", Schema.Struct<{
+    action: Schema.String;
+    protocolVersion: Schema.Int;
+    payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    requestKey: Schema.optionalKey<Schema.String>;
+    fingerprint: Schema.String;
+}>, Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"Success">;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"Failure">;
+    readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>, Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [typeof import("../../errors/index.js").InvalidInput, typeof import("../../errors/index.js").StorageUnavailable, typeof import("../../errors/index.js").OwnershipLost, typeof import("../../errors/index.js").Overloaded, typeof import("../../errors/index.js").Unauthorized, typeof import("../../errors/index.js").UnsupportedVersion, typeof import("../../errors/index.js").MigrationRejected]>, typeof import("../../errors/index.js").CommandConflict, typeof import("../../errors/index.js").RevisionConflict, typeof import("../../errors/index.js").OutcomeUnknown, typeof import("../../errors/index.js").MigrationRejected]>, typeof import("../../errors/index.js").HostUnavailable]>, never, never> | Rpc.Rpc<"Command", Schema.Struct<{
+    commandId: Schema.String;
+    fingerprint: Schema.String;
+    protocolVersion: Schema.Int;
+    command: Schema.String;
+    payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    expectedRevision: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly commandId: Schema.String;
+    readonly revision: Schema.String;
+    readonly cursor: Schema.String;
+    readonly committedAtMillis: Schema.Number;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"Success">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"Failure">;
+        readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>]>;
+}>, Schema.Union<readonly [Schema.Union<readonly [typeof import("../../errors/index.js").InvalidInput, typeof import("../../errors/index.js").StorageUnavailable, typeof import("../../errors/index.js").OwnershipLost, typeof import("../../errors/index.js").Overloaded, typeof import("../../errors/index.js").Unauthorized, typeof import("../../errors/index.js").UnsupportedVersion, typeof import("../../errors/index.js").MigrationRejected]>, typeof import("../../errors/index.js").CommandConflict, typeof import("../../errors/index.js").RevisionConflict, typeof import("../../errors/index.js").OutcomeUnknown, typeof import("../../errors/index.js").MigrationRejected]>, never, never> | Rpc.Rpc<"DurableAction", Schema.Struct<{
+    action: Schema.String;
+    protocolVersion: Schema.Int;
+    payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    requestKey: Schema.optionalKey<Schema.String>;
+    fingerprint: Schema.String;
+}>, Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"Success">;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"Failure">;
+    readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>, Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [typeof import("../../errors/index.js").InvalidInput, typeof import("../../errors/index.js").StorageUnavailable, typeof import("../../errors/index.js").OwnershipLost, typeof import("../../errors/index.js").Overloaded, typeof import("../../errors/index.js").Unauthorized, typeof import("../../errors/index.js").UnsupportedVersion, typeof import("../../errors/index.js").MigrationRejected]>, typeof import("../../errors/index.js").CommandConflict, typeof import("../../errors/index.js").RevisionConflict, typeof import("../../errors/index.js").OutcomeUnknown, typeof import("../../errors/index.js").MigrationRejected]>, typeof import("../../errors/index.js").HostUnavailable]>, never, never> | Rpc.Rpc<"Events", Schema.Struct<{
+    after: Schema.String;
+    limit: Schema.Int;
+}>, Schema.Struct<{
+    readonly events: Schema.$Array<Schema.Struct<{
+        readonly cursor: Schema.String;
+        readonly commandId: Schema.String;
+        readonly committedAtMillis: Schema.Number;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>>;
+    readonly nextCursor: Schema.String;
+    readonly hasMore: Schema.Boolean;
+}>, Schema.Union<readonly [Schema.Union<readonly [typeof import("../../errors/index.js").InvalidInput, typeof import("../../errors/index.js").StorageUnavailable, typeof import("../../errors/index.js").OwnershipLost, typeof import("../../errors/index.js").Overloaded, typeof import("../../errors/index.js").Unauthorized, typeof import("../../errors/index.js").UnsupportedVersion, typeof import("../../errors/index.js").MigrationRejected]>, typeof import("../../errors/index.js").CursorExpired]>, never, never> | Rpc.Rpc<"Query", Schema.Struct<{
+    query: Schema.String;
+    protocolVersion: Schema.Int;
+    payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly revision: Schema.String;
+    readonly cursor: Schema.String;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"Success">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"Failure">;
+        readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>]>;
+}>, Schema.Union<readonly [typeof import("../../errors/index.js").InvalidInput, typeof import("../../errors/index.js").StorageUnavailable, typeof import("../../errors/index.js").OwnershipLost, typeof import("../../errors/index.js").Overloaded, typeof import("../../errors/index.js").Unauthorized, typeof import("../../errors/index.js").UnsupportedVersion, typeof import("../../errors/index.js").MigrationRejected]>, never, never> | Rpc.Rpc<"Receipt", Schema.Struct<{
+    commandId: Schema.String;
+}>, Schema.NullOr<Schema.Struct<{
+    readonly commandId: Schema.String;
+    readonly revision: Schema.String;
+    readonly cursor: Schema.String;
+    readonly committedAtMillis: Schema.Number;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"Success">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"Failure">;
+        readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>]>;
+}>>, Schema.Union<readonly [typeof import("../../errors/index.js").InvalidInput, typeof import("../../errors/index.js").StorageUnavailable, typeof import("../../errors/index.js").OwnershipLost, typeof import("../../errors/index.js").Overloaded, typeof import("../../errors/index.js").Unauthorized, typeof import("../../errors/index.js").UnsupportedVersion, typeof import("../../errors/index.js").MigrationRejected]>, never, never> | Rpc.Rpc<"Wake", Schema.Struct<{
+    timerId: Schema.String;
+    generation: Schema.String;
+    dueAtMillis: Schema.Number;
+}>, Schema.NullOr<Schema.Struct<{
+    readonly commandId: Schema.String;
+    readonly revision: Schema.String;
+    readonly cursor: Schema.String;
+    readonly committedAtMillis: Schema.Number;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"Success">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"Failure">;
+        readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>]>;
+}>>, Schema.Union<readonly [Schema.Union<readonly [typeof import("../../errors/index.js").InvalidInput, typeof import("../../errors/index.js").StorageUnavailable, typeof import("../../errors/index.js").OwnershipLost, typeof import("../../errors/index.js").Overloaded, typeof import("../../errors/index.js").Unauthorized, typeof import("../../errors/index.js").UnsupportedVersion, typeof import("../../errors/index.js").MigrationRejected]>, typeof import("../../errors/index.js").CommandConflict, typeof import("../../errors/index.js").RevisionConflict, typeof import("../../errors/index.js").OutcomeUnknown, typeof import("../../errors/index.js").MigrationRejected]>, never, never>>;
+export type ActorEntity = ReturnType<typeof makeEntity>;