effect-actors 0.0.1

package/dist/gateway/service.d.ts

@@ -0,0 +1,113 @@
+import type { ClientFrame as ClientFrameValue, ServerFrame as ServerFrameValue } from "./wire.js";
+export { layer } from "./http/routes.js";
+export { Security } from "./security.js";
+export type { Options } from "./options.js";
+export type { Access, Principal, SecurityService } from "./security.js";
+export declare const ClientFrame: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"command">;
+    readonly requestId: import("effect/Schema").String;
+    readonly address: import("effect/Schema").Struct<{
+        readonly namespace: import("effect/Schema").String;
+        readonly tenant: import("effect/Schema").String;
+        readonly actorType: import("effect/Schema").String;
+        readonly key: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }>;
+    readonly command: import("effect/Schema").String;
+    readonly protocolVersion: import("effect/Schema").Int;
+    readonly commandId: import("effect/Schema").String;
+    readonly expectedRevision: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+    readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+}>, import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"query">;
+    readonly requestId: import("effect/Schema").String;
+    readonly address: import("effect/Schema").Struct<{
+        readonly namespace: import("effect/Schema").String;
+        readonly tenant: import("effect/Schema").String;
+        readonly actorType: import("effect/Schema").String;
+        readonly key: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }>;
+    readonly query: import("effect/Schema").String;
+    readonly protocolVersion: import("effect/Schema").Int;
+    readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+}>, import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"subscribe">;
+    readonly subscriptionId: import("effect/Schema").String;
+    readonly address: import("effect/Schema").Struct<{
+        readonly namespace: import("effect/Schema").String;
+        readonly tenant: import("effect/Schema").String;
+        readonly actorType: import("effect/Schema").String;
+        readonly key: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }>;
+    readonly after: import("effect/Schema").String;
+}>, import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"unsubscribe">;
+    readonly subscriptionId: import("effect/Schema").String;
+}>]>;
+export type ClientFrame = ClientFrameValue;
+export declare const ServerFrame: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"command-result">;
+    readonly requestId: import("effect/Schema").String;
+    readonly receipt: import("effect/Schema").Struct<{
+        readonly commandId: import("effect/Schema").String;
+        readonly revision: import("effect/Schema").String;
+        readonly cursor: import("effect/Schema").String;
+        readonly committedAtMillis: import("effect/Schema").Number;
+        readonly value: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"Success">;
+            readonly value: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"Failure">;
+            readonly error: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+        }>]>;
+    }>;
+}>, import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"query-result">;
+    readonly requestId: import("effect/Schema").String;
+    readonly result: import("effect/Schema").Struct<{
+        readonly revision: import("effect/Schema").String;
+        readonly cursor: import("effect/Schema").String;
+        readonly value: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"Success">;
+            readonly value: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"Failure">;
+            readonly error: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+        }>]>;
+    }>;
+}>, import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"event">;
+    readonly subscriptionId: import("effect/Schema").String;
+    readonly event: import("effect/Schema").Struct<{
+        readonly cursor: import("effect/Schema").String;
+        readonly commandId: import("effect/Schema").String;
+        readonly committedAtMillis: import("effect/Schema").Number;
+        readonly value: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+    }>;
+}>, import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"subscribed">;
+    readonly subscriptionId: import("effect/Schema").String;
+    readonly after: import("effect/Schema").String;
+}>, import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"subscription-error">;
+    readonly subscriptionId: import("effect/Schema").String;
+    readonly error: import("effect/Schema").Struct<{
+        readonly code: import("effect/Schema").String;
+        readonly message: import("effect/Schema").String;
+        readonly commandId: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly expected: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly actual: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly retryAfterMillis: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+    }>;
+}>, import("effect/Schema").Struct<{
+    readonly type: import("effect/Schema").Literal<"request-error">;
+    readonly requestId: import("effect/Schema").String;
+    readonly error: import("effect/Schema").Struct<{
+        readonly code: import("effect/Schema").String;
+        readonly message: import("effect/Schema").String;
+        readonly commandId: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly expected: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly actual: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly retryAfterMillis: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+    }>;
+}>]>;
+export type ServerFrame = ServerFrameValue;

package/dist/gateway/service.js

@@ -0,0 +1,5 @@
+import { ClientFrame as ClientFrameSchema, ServerFrame as ServerFrameSchema } from "./wire.js";
+export { layer } from "./http/routes.js";
+export { Security } from "./security.js";
+export const ClientFrame = ClientFrameSchema;
+export const ServerFrame = ServerFrameSchema;

package/dist/gateway/websocket/operations.d.ts

@@ -0,0 +1,20 @@
+import { Effect, Fiber } from "effect";
+import type { Scope } from "effect";
+import type { Service as ClientService } from "../../client/service.js";
+import type { GatewayFault } from "../fault.js";
+import type { Registry } from "../options.js";
+import type { SecurityService } from "../security.js";
+import type { ClientFrame as IncomingFrame, ServerFrame as OutgoingFrame } from "../wire.js";
+export type Send = (frame: OutgoingFrame) => Effect.Effect<void, GatewayFault>;
+export type Close = (code: number, reason: string) => Effect.Effect<void>;
+export declare const sendRequestFailure: (send: Send, requestId: string, fault: GatewayFault) => Effect.Effect<void, GatewayFault>;
+export declare const sendSubscriptionFailure: (send: Send, subscriptionId: string, fault: GatewayFault) => Effect.Effect<void, GatewayFault>;
+export declare const command: (frame: Extract<IncomingFrame, {
+    readonly type: "command";
+}>, registry: Registry, client: ClientService, security: SecurityService, request: Parameters<SecurityService["authenticate"]>[0], send: Send) => Effect.Effect<void, GatewayFault>;
+export declare const query: (frame: Extract<IncomingFrame, {
+    readonly type: "query";
+}>, registry: Registry, client: ClientService, security: SecurityService, request: Parameters<SecurityService["authenticate"]>[0], send: Send) => Effect.Effect<void, GatewayFault>;
+export declare const subscribe: (frame: Extract<IncomingFrame, {
+    readonly type: "subscribe";
+}>, registry: Registry, client: ClientService, security: SecurityService, request: Parameters<SecurityService["authenticate"]>[0], send: Send, subscriptions: Map<string, Fiber.Fiber<void, never>>, release: Effect.Effect<void>, close: Close) => Effect.Effect<void, GatewayFault, Scope.Scope>;

package/dist/gateway/websocket/operations.js

@@ -0,0 +1,96 @@
+import { Effect, Fiber, Stream } from "effect";
+import { boundary, fingerprint } from "../../protocol/index.js";
+import { boundedEvents } from "../http/events.js";
+import { validateCommandId, validateCursor, validatePublicName, validateRevision, validateRequestId, } from "../http/validation.js";
+import { admit, assertTenant, authenticate, authorize, recheck } from "../access.js";
+import { mapInputError, stateProcedure, validateAddress, validatePayload, validateQueryResult, validateReceipt, } from "../dispatch.js";
+import { fromServiceError, invalidInput, notFound } from "../fault.js";
+const errorFrame = (fault) => ({
+    code: fault.code,
+    message: fault.message,
+    ...(fault.commandId === undefined ? {} : { commandId: fault.commandId }),
+    ...(fault.expected === undefined ? {} : { expected: fault.expected }),
+    ...(fault.actual === undefined ? {} : { actual: fault.actual }),
+    ...(fault.retryAfterMillis === undefined ? {} : { retryAfterMillis: fault.retryAfterMillis }),
+});
+export const sendRequestFailure = (send, requestId, fault) => fault.code === "SlowConsumer"
+    ? Effect.void
+    : send({ type: "request-error", requestId, error: errorFrame(fault) });
+export const sendSubscriptionFailure = (send, subscriptionId, fault) => fault.code === "SlowConsumer"
+    ? Effect.void
+    : send({ type: "subscription-error", subscriptionId, error: errorFrame(fault) });
+export const command = (frame, registry, client, security, request, send) => Effect.gen(function* () {
+    const requestId = yield* validateRequestId(frame.requestId);
+    const commandId = yield* validateCommandId(frame.commandId);
+    const expectedRevision = frame.expectedRevision === undefined
+        ? undefined
+        : yield* validateRevision(frame.expectedRevision);
+    const address = yield* validateAddress(registry, frame.address);
+    const commandName = yield* validatePublicName(frame.command, registry.isPublicOperation);
+    const procedure = yield* stateProcedure(registry, address, frame.protocolVersion, commandName, "command");
+    const principal = yield* authenticate(security, request);
+    yield* assertTenant(principal, address);
+    const access = { address, operation: "command", name: commandName };
+    yield* authorize(security, principal, access);
+    yield* admit(security, principal, access);
+    const payload = yield* validatePayload(procedure, frame.payload);
+    const input = yield* boundary(() => ({
+        address,
+        command: commandName,
+        protocolVersion: frame.protocolVersion,
+        payload,
+        commandId,
+        fingerprint: fingerprint({
+            command: commandName,
+            protocolVersion: frame.protocolVersion,
+            payload,
+            ...(expectedRevision === undefined ? {} : { expectedRevision }),
+        }),
+        ...(expectedRevision === undefined ? {} : { expectedRevision }),
+    })).pipe(Effect.mapError(mapInputError));
+    const receipt = yield* client
+        .command(input)
+        .pipe(Effect.mapError((error) => fromServiceError(error, commandId)));
+    const checked = yield* validateReceipt(procedure, address, receipt);
+    yield* send({ type: "command-result", requestId, receipt: checked });
+});
+export const query = (frame, registry, client, security, request, send) => Effect.gen(function* () {
+    const requestId = yield* validateRequestId(frame.requestId);
+    const address = yield* validateAddress(registry, frame.address);
+    const queryName = yield* validatePublicName(frame.query, registry.isPublicOperation);
+    const procedure = yield* stateProcedure(registry, address, frame.protocolVersion, queryName, "query");
+    const principal = yield* authenticate(security, request);
+    yield* assertTenant(principal, address);
+    const access = { address, operation: "query", name: queryName };
+    yield* authorize(security, principal, access);
+    yield* admit(security, principal, access);
+    const payload = yield* validatePayload(procedure, frame.payload);
+    const result = yield* client
+        .query({ address, query: queryName, protocolVersion: frame.protocolVersion, payload })
+        .pipe(Effect.mapError(fromServiceError));
+    const checked = yield* validateQueryResult(procedure, address, result);
+    yield* send({ type: "query-result", requestId, result: checked });
+});
+export const subscribe = (frame, registry, client, security, request, send, subscriptions, release, close) => Effect.gen(function* () {
+    const subscriptionId = yield* validateRequestId(frame.subscriptionId);
+    if (subscriptions.has(subscriptionId))
+        return yield* Effect.fail(invalidInput());
+    const address = yield* validateAddress(registry, frame.address);
+    const protocol = registry.get(address.actorType);
+    if (!protocol || protocol.kind !== "state")
+        return yield* Effect.fail(notFound());
+    const after = yield* validateCursor(address, frame.after);
+    const principal = yield* authenticate(security, request);
+    yield* assertTenant(principal, address);
+    const access = { address, operation: "events" };
+    yield* authorize(security, principal, access);
+    yield* admit(security, principal, access);
+    const events = yield* boundedEvents(client, address, after, protocol.eventSchema, registry.options, recheck(security, request, principal, access));
+    yield* send({ type: "subscribed", subscriptionId, after });
+    const fiber = yield* Stream.runForEach(events, (event) => send({ type: "event", subscriptionId, event })).pipe(Effect.catchIf((fault) => true, (fault) => {
+        if (fault.code === "SlowConsumer")
+            return close(1013, "slow consumer");
+        return sendSubscriptionFailure(send, subscriptionId, fault).pipe(Effect.catchIf((sendFault) => true, () => Effect.void));
+    }), Effect.ensuring(Effect.sync(() => subscriptions.delete(subscriptionId)).pipe(Effect.andThen(release))), Effect.forkScoped);
+    subscriptions.set(subscriptionId, fiber);
+});

package/dist/gateway/websocket.d.ts

@@ -0,0 +1,8 @@
+import { Effect, Ref } from "effect";
+import type { Scope } from "effect";
+import { HttpServerResponse } from "effect/unstable/http";
+import type { Service as ClientService } from "../client/service.js";
+import type { GatewayFault } from "./fault.js";
+import type { Registry } from "./options.js";
+import type { SecurityService } from "./security.js";
+export declare const handler: (registry: Registry, client: ClientService, security: SecurityService, connections: Ref.Ref<ReadonlyMap<string, number>>) => (request: Parameters<SecurityService["authenticate"]>[0]) => Effect.Effect<HttpServerResponse.HttpServerResponse, GatewayFault, Scope.Scope>;

package/dist/gateway/websocket.js

@@ -0,0 +1,96 @@
+import { Effect, Encoding, Fiber, Queue, Ref, Schema, Semaphore, Stream } from "effect";
+import { HttpServerResponse } from "effect/unstable/http";
+import { Socket } from "effect/unstable/socket";
+import { boundary, decode } from "../protocol/index.js";
+import { validateRequestId } from "./http/validation.js";
+import { authenticate, leaseConnection, recheck } from "./access.js";
+import { mapInputError } from "./dispatch.js";
+import { overloaded, unauthorized, unavailable } from "./fault.js";
+import { command, query, sendRequestFailure, sendSubscriptionFailure, subscribe, } from "./websocket/operations.js";
+import { ClientFrame, ServerFrame } from "./wire.js";
+const frameSize = (frame) => Encoding.encodeBase64(frame).length;
+const decodeFrame = (frame, maximum) => {
+    if (frameSize(frame) > Math.ceil(maximum / 3) * 4 + 4) {
+        return Effect.fail({
+            _tag: "GatewayFault",
+            code: "InvalidInput",
+            status: 413,
+            message: "WebSocket frame is too large",
+        });
+    }
+    return boundary(() => JSON.parse(frame)).pipe(Effect.flatMap((parsed) => decode(ClientFrame, parsed)), Effect.mapError(mapInputError));
+};
+const encodeFrame = (frame) => boundary(() => JSON.stringify(Schema.encodeSync(ServerFrame)(frame))).pipe(Effect.mapError(() => unavailable()));
+const isExpectedSocketClose = (error) => Socket.SocketError.is(error) &&
+    error.reason._tag === "SocketCloseError" &&
+    [1000, 1001, 1003, 1007, 1008, 1009, 1013].includes(error.reason.code);
+export const handler = (registry, client, security, connections) => (request) => Effect.gen(function* () {
+    if (request.headers.origin === undefined ||
+        !registry.options.allowedOrigins.includes(request.headers.origin)) {
+        return yield* Effect.fail(unauthorized());
+    }
+    const principal = yield* authenticate(security, request);
+    yield* leaseConnection(connections, principal, registry.options.maxConnectionsPerPrincipal);
+    const socket = yield* request.upgrade.pipe(Effect.mapError(() => unavailable()));
+    const writer = yield* socket.writer;
+    const outgoing = yield* Queue.make({
+        capacity: registry.options.maxBufferedEvents,
+        strategy: "dropping",
+    });
+    yield* Effect.addFinalizer(() => Queue.shutdown(outgoing).pipe(Effect.asVoid));
+    const close = (code, reason) => writer(new Socket.CloseEvent(code, reason)).pipe(Effect.catchIf((error) => true, () => Effect.void));
+    const send = (frame) => Queue.offer(outgoing, frame).pipe(Effect.flatMap((accepted) => {
+        if (accepted)
+            return Effect.void;
+        const fault = {
+            _tag: "GatewayFault",
+            code: "SlowConsumer",
+            status: 503,
+            message: "Event consumer is too slow",
+        };
+        return close(1013, "slow consumer").pipe(Effect.andThen(Effect.fail(fault)));
+    }));
+    const output = Stream.runForEach(Stream.fromQueue(outgoing), (frame) => encodeFrame(frame).pipe(Effect.flatMap((encoded) => writer(encoded).pipe(Effect.mapError(() => unavailable())))));
+    yield* Effect.forkScoped(output);
+    const watchdog = Effect.forever(Effect.sleep(registry.options.authenticationRecheckMillis).pipe(Effect.andThen(recheck(security, request, principal)))).pipe(Effect.catchIf((fault) => true, () => close(1008, "authentication expired")));
+    yield* Effect.forkScoped(watchdog);
+    const subscriptions = new Map();
+    const requests = yield* Semaphore.make(registry.maxInFlightRequestsPerConnection);
+    const subscriptionSlots = yield* Semaphore.make(registry.maxSubscriptionsPerConnection);
+    const handle = (frame) => {
+        if (frame.type === "unsubscribe") {
+            return validateRequestId(frame.subscriptionId).pipe(Effect.flatMap((subscriptionId) => {
+                const subscription = subscriptions.get(subscriptionId);
+                return subscription === undefined
+                    ? Effect.void
+                    : Fiber.interrupt(subscription).pipe(Effect.asVoid);
+            }), Effect.catchIf((fault) => true, () => close(1007, "invalid frame")));
+        }
+        if (frame.type === "subscribe") {
+            return subscriptionSlots.takeIfAvailable(1).pipe(Effect.flatMap((acquired) => {
+                if (!acquired)
+                    return sendSubscriptionFailure(send, frame.subscriptionId, overloaded(1_000)).pipe(Effect.catchIf((fault) => true, () => Effect.void));
+                const release = subscriptionSlots.release(1).pipe(Effect.asVoid);
+                return subscribe(frame, registry, client, security, request, send, subscriptions, release, close).pipe(Effect.catchIf((fault) => true, (fault) => release.pipe(Effect.andThen(sendSubscriptionFailure(send, frame.subscriptionId, fault)))), Effect.catchIf((fault) => true, () => Effect.void));
+            }));
+        }
+        const work = frame.type === "command"
+            ? command(frame, registry, client, security, request, send)
+            : query(frame, registry, client, security, request, send);
+        return requests.takeIfAvailable(1).pipe(Effect.flatMap((acquired) => {
+            if (!acquired)
+                return sendRequestFailure(send, frame.requestId, overloaded(1_000)).pipe(Effect.catchIf((fault) => true, () => Effect.void));
+            return work.pipe(Effect.catchIf((fault) => true, (fault) => sendRequestFailure(send, frame.requestId, fault)), Effect.catchIf((fault) => true, () => Effect.void), Effect.ensuring(requests.release(1).pipe(Effect.asVoid)), Effect.forkScoped, Effect.asVoid);
+        }));
+    };
+    yield* socket
+        .runRaw((raw) => {
+        if (typeof raw !== "string")
+            return close(1003, "text frames required").pipe(Effect.asVoid);
+        return decodeFrame(raw, registry.options.maxRequestBytes)
+            .pipe(Effect.flatMap(handle))
+            .pipe(Effect.catchIf((fault) => true, (fault) => close(fault.status === 413 ? 1009 : 1007, "invalid frame")));
+    })
+        .pipe(Effect.catchIf(isExpectedSocketClose, () => Effect.void), Effect.mapError(() => unavailable()));
+    return HttpServerResponse.empty();
+});

package/dist/gateway/wire.d.ts

@@ -0,0 +1,172 @@
+import { Schema } from "effect";
+import { Event, Outcome, QueryResult, Receipt as WireReceipt } from "../protocol/schemas.js";
+export { Event, Outcome, QueryResult, WireReceipt };
+export declare const Address: Schema.Struct<{
+    readonly namespace: Schema.String;
+    readonly tenant: Schema.String;
+    readonly actorType: Schema.String;
+    readonly key: Schema.$Array<Schema.String>;
+}>;
+export declare const CommandRequest: Schema.Struct<{
+    readonly key: Schema.$Array<Schema.String>;
+    readonly protocolVersion: Schema.Int;
+    readonly commandId: Schema.String;
+    readonly expectedRevision: Schema.optionalKey<Schema.String>;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export declare const QueryRequest: Schema.Struct<{
+    readonly key: Schema.$Array<Schema.String>;
+    readonly protocolVersion: Schema.Int;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export declare const ReceiptRequest: Schema.Struct<{
+    readonly key: Schema.$Array<Schema.String>;
+}>;
+export declare const HostedRequest: Schema.Struct<{
+    readonly key: Schema.$Array<Schema.String>;
+    readonly protocolVersion: Schema.Int;
+    readonly requestKey: Schema.optionalKey<Schema.String>;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export declare const GatewayError: Schema.Struct<{
+    readonly code: Schema.String;
+    readonly message: Schema.String;
+    readonly commandId: Schema.optionalKey<Schema.String>;
+    readonly expected: Schema.optionalKey<Schema.String>;
+    readonly actual: Schema.optionalKey<Schema.String>;
+    readonly retryAfterMillis: Schema.optionalKey<Schema.Number>;
+}>;
+export type GatewayError = (typeof GatewayError)["Type"];
+export declare const GatewayErrorResponse: Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+        readonly commandId: Schema.optionalKey<Schema.String>;
+        readonly expected: Schema.optionalKey<Schema.String>;
+        readonly actual: Schema.optionalKey<Schema.String>;
+        readonly retryAfterMillis: Schema.optionalKey<Schema.Number>;
+    }>;
+}>;
+export declare const ReceiptResponse: Schema.Struct<{
+    readonly receipt: 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>;
+        }>]>;
+    }>>;
+}>;
+export declare const ClientFrame: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"command">;
+    readonly requestId: Schema.String;
+    readonly address: Schema.Struct<{
+        readonly namespace: Schema.String;
+        readonly tenant: Schema.String;
+        readonly actorType: Schema.String;
+        readonly key: Schema.$Array<Schema.String>;
+    }>;
+    readonly command: Schema.String;
+    readonly protocolVersion: Schema.Int;
+    readonly commandId: Schema.String;
+    readonly expectedRevision: Schema.optionalKey<Schema.String>;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"query">;
+    readonly requestId: Schema.String;
+    readonly address: Schema.Struct<{
+        readonly namespace: Schema.String;
+        readonly tenant: Schema.String;
+        readonly actorType: Schema.String;
+        readonly key: Schema.$Array<Schema.String>;
+    }>;
+    readonly query: Schema.String;
+    readonly protocolVersion: Schema.Int;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"subscribe">;
+    readonly subscriptionId: Schema.String;
+    readonly address: Schema.Struct<{
+        readonly namespace: Schema.String;
+        readonly tenant: Schema.String;
+        readonly actorType: Schema.String;
+        readonly key: Schema.$Array<Schema.String>;
+    }>;
+    readonly after: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"unsubscribe">;
+    readonly subscriptionId: Schema.String;
+}>]>;
+export type ClientFrame = (typeof ClientFrame)["Type"];
+export declare const ServerFrame: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"command-result">;
+    readonly requestId: Schema.String;
+    readonly 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>;
+        }>]>;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"query-result">;
+    readonly requestId: Schema.String;
+    readonly result: 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.Struct<{
+    readonly type: Schema.Literal<"event">;
+    readonly subscriptionId: Schema.String;
+    readonly 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>;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"subscribed">;
+    readonly subscriptionId: Schema.String;
+    readonly after: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"subscription-error">;
+    readonly subscriptionId: Schema.String;
+    readonly error: Schema.Struct<{
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+        readonly commandId: Schema.optionalKey<Schema.String>;
+        readonly expected: Schema.optionalKey<Schema.String>;
+        readonly actual: Schema.optionalKey<Schema.String>;
+        readonly retryAfterMillis: Schema.optionalKey<Schema.Number>;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"request-error">;
+    readonly requestId: Schema.String;
+    readonly error: Schema.Struct<{
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+        readonly commandId: Schema.optionalKey<Schema.String>;
+        readonly expected: Schema.optionalKey<Schema.String>;
+        readonly actual: Schema.optionalKey<Schema.String>;
+        readonly retryAfterMillis: Schema.optionalKey<Schema.Number>;
+    }>;
+}>]>;
+export type ServerFrame = (typeof ServerFrame)["Type"];

package/dist/gateway/wire.js

@@ -0,0 +1,102 @@
+import { Schema } from "effect";
+import { Event, Outcome, QueryResult, Receipt as WireReceipt } from "../protocol/schemas.js";
+export { Event, Outcome, QueryResult, WireReceipt };
+export const Address = Schema.Struct({
+    namespace: Schema.String,
+    tenant: Schema.String,
+    actorType: Schema.String,
+    key: Schema.Array(Schema.String),
+});
+export const CommandRequest = Schema.Struct({
+    key: Schema.Array(Schema.String),
+    protocolVersion: Schema.Int,
+    commandId: Schema.String,
+    expectedRevision: Schema.optionalKey(Schema.String),
+    payload: Schema.Json,
+});
+export const QueryRequest = Schema.Struct({
+    key: Schema.Array(Schema.String),
+    protocolVersion: Schema.Int,
+    payload: Schema.Json,
+});
+export const ReceiptRequest = Schema.Struct({
+    key: Schema.Array(Schema.String),
+});
+export const HostedRequest = Schema.Struct({
+    key: Schema.Array(Schema.String),
+    protocolVersion: Schema.Int,
+    requestKey: Schema.optionalKey(Schema.String),
+    payload: Schema.Json,
+});
+export const GatewayError = Schema.Struct({
+    code: Schema.String,
+    message: Schema.String,
+    commandId: Schema.optionalKey(Schema.String),
+    expected: Schema.optionalKey(Schema.String),
+    actual: Schema.optionalKey(Schema.String),
+    retryAfterMillis: Schema.optionalKey(Schema.Number),
+});
+export const GatewayErrorResponse = Schema.Struct({ error: GatewayError });
+export const ReceiptResponse = Schema.Struct({ receipt: Schema.NullOr(WireReceipt) });
+export const ClientFrame = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("command"),
+        requestId: Schema.String,
+        address: Address,
+        command: Schema.String,
+        protocolVersion: Schema.Int,
+        commandId: Schema.String,
+        expectedRevision: Schema.optionalKey(Schema.String),
+        payload: Schema.Json,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("query"),
+        requestId: Schema.String,
+        address: Address,
+        query: Schema.String,
+        protocolVersion: Schema.Int,
+        payload: Schema.Json,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("subscribe"),
+        subscriptionId: Schema.String,
+        address: Address,
+        after: Schema.String,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("unsubscribe"),
+        subscriptionId: Schema.String,
+    }),
+]);
+export const ServerFrame = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("command-result"),
+        requestId: Schema.String,
+        receipt: WireReceipt,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("query-result"),
+        requestId: Schema.String,
+        result: QueryResult,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("event"),
+        subscriptionId: Schema.String,
+        event: Event,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("subscribed"),
+        subscriptionId: Schema.String,
+        after: Schema.String,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("subscription-error"),
+        subscriptionId: Schema.String,
+        error: GatewayError,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("request-error"),
+        requestId: Schema.String,
+        error: GatewayError,
+    }),
+]);

package/dist/host/client.d.ts

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+import { Client } from "../client/service.js";
+import type { Key } from "../protocol/index.js";
+import type { Actions, Reference } from "./definition.js";
+export declare const makeClient: <A extends Actions>(options: {
+    readonly name: string;
+    readonly protocolVersion: number;
+    readonly actions: A;
+}) => Effect.Effect<(key: Key) => Reference<A>, never, Client>;