effect-actors 0.0.1

package/dist/gateway/http/events.js

@@ -0,0 +1,32 @@
+import { Effect, Queue, Stream } from "effect";
+import { Sse } from "effect/unstable/encoding";
+import { boundary, decode, readCursor } from "../../protocol/index.js";
+import { Event as EventSchema } from "../../protocol/schemas.js";
+import { fromServiceError, safeError, slowConsumer, unavailable } from "../fault.js";
+const checkedEvents = (client, address, after, eventSchema) => client.events(address, { after }).pipe(Stream.mapEffect((event) => decode(EventSchema, event).pipe(Effect.flatMap((checked) => boundary(() => readCursor(address, checked.cursor)).pipe(Effect.mapError(() => unavailable()), Effect.flatMap(() => decode(eventSchema, checked.value).pipe(Effect.as(checked))))), Effect.mapError(() => unavailable()))), Stream.mapError((error) => fromServiceError(error)));
+export const boundedEvents = (client, address, after, eventSchema, options, recheck) => Effect.gen(function* () {
+    const queue = yield* Queue.make({
+        capacity: options.maxBufferedEvents,
+        strategy: "dropping",
+    });
+    yield* Effect.addFinalizer(() => Queue.shutdown(queue).pipe(Effect.asVoid));
+    const producer = Stream.runForEach(checkedEvents(client, address, after, eventSchema), (event) => Queue.offer(queue, event).pipe(Effect.flatMap((accepted) => (accepted ? Effect.void : Effect.fail(slowConsumer()))))).pipe(Effect.matchEffect({
+        onFailure: (error) => Queue.fail(queue, error).pipe(Effect.asVoid),
+        onSuccess: () => Queue.end(queue).pipe(Effect.asVoid),
+    }));
+    const rechecker = Effect.forever(Effect.sleep(options.authenticationRecheckMillis).pipe(Effect.andThen(recheck))).pipe(Effect.catchIf((error) => true, (error) => Queue.fail(queue, error).pipe(Effect.andThen(Queue.shutdown(queue)), Effect.asVoid)));
+    yield* Effect.forkScoped(producer);
+    yield* Effect.forkScoped(rechecker);
+    return Stream.fromQueue(queue);
+});
+export const sseBody = (events) => events.pipe(Stream.map((event) => Sse.encoder.write({
+    _tag: "Event",
+    id: event.cursor,
+    event: "actor-event",
+    data: JSON.stringify(event),
+})), Stream.catchIf((error) => true, (error) => Stream.succeed(Sse.encoder.write({
+    _tag: "Event",
+    id: undefined,
+    event: "actor-error",
+    data: JSON.stringify(safeError(error)),
+}))), Stream.encodeText);

package/dist/gateway/http/response.d.ts

@@ -0,0 +1,11 @@
+import { HttpServerResponse } from "effect/unstable/http";
+import type { HttpServerRequest } from "effect/unstable/http";
+import type { Options } from "../options.js";
+import type { GatewayFault } from "../fault.js";
+export declare const allowedOrigin: (request: HttpServerRequest.HttpServerRequest, options: Options) => string | undefined;
+export declare const validateHttpOrigin: (request: HttpServerRequest.HttpServerRequest, options: Options) => GatewayFault | undefined;
+export declare const validateWebSocketOrigin: (request: HttpServerRequest.HttpServerRequest, options: Options) => GatewayFault | undefined;
+export declare const jsonResponse: (request: HttpServerRequest.HttpServerRequest, options: Options, body: unknown, status?: number, headers?: Record<string, string>) => HttpServerResponse.HttpServerResponse;
+export declare const errorResponse: (request: HttpServerRequest.HttpServerRequest, options: Options, fault: GatewayFault) => HttpServerResponse.HttpServerResponse;
+export declare const preflightResponse: (request: HttpServerRequest.HttpServerRequest, options: Options) => HttpServerResponse.HttpServerResponse | undefined;
+export declare const sseHeaders: (request: HttpServerRequest.HttpServerRequest, options: Options) => Record<string, string>;

package/dist/gateway/http/response.js

@@ -0,0 +1,57 @@
+import { HttpServerResponse } from "effect/unstable/http";
+import { safeError } from "../fault.js";
+const origin = (request) => request.headers.origin;
+export const allowedOrigin = (request, options) => {
+    const value = origin(request);
+    return value !== undefined && options.allowedOrigins.includes(value) ? value : undefined;
+};
+export const validateHttpOrigin = (request, options) => {
+    const value = origin(request);
+    return value === undefined || options.allowedOrigins.includes(value)
+        ? undefined
+        : { _tag: "GatewayFault", code: "Unauthorized", status: 403, message: "Origin is not allowed" };
+};
+export const validateWebSocketOrigin = (request, options) => allowedOrigin(request, options) === undefined
+    ? { _tag: "GatewayFault", code: "Unauthorized", status: 403, message: "Origin is not allowed" }
+    : undefined;
+const corsHeaders = (request, options) => {
+    const value = allowedOrigin(request, options);
+    return value === undefined
+        ? {}
+        : {
+            "access-control-allow-origin": value,
+            "access-control-allow-credentials": "true",
+            vary: "Origin",
+        };
+};
+export const jsonResponse = (request, options, body, status = 200, headers = {}) => HttpServerResponse.jsonUnsafe(body, {
+    status,
+    headers: { ...corsHeaders(request, options), ...headers, "cache-control": "no-store" },
+});
+export const errorResponse = (request, options, fault) => {
+    const retryAfter = fault.retryAfterMillis === undefined
+        ? {}
+        : { "retry-after": String(Math.max(1, Math.ceil(fault.retryAfterMillis / 1_000))) };
+    return jsonResponse(request, options, { error: safeError(fault) }, fault.status, retryAfter);
+};
+export const preflightResponse = (request, options) => {
+    const value = allowedOrigin(request, options);
+    if (value === undefined)
+        return undefined;
+    return HttpServerResponse.empty({
+        status: 204,
+        headers: {
+            "access-control-allow-origin": value,
+            "access-control-allow-credentials": "true",
+            "access-control-allow-methods": "GET, POST, OPTIONS",
+            "access-control-allow-headers": "content-type, authorization, last-event-id",
+            "access-control-max-age": "600",
+            vary: "Origin, Access-Control-Request-Headers",
+        },
+    });
+};
+export const sseHeaders = (request, options) => ({
+    ...corsHeaders(request, options),
+    "cache-control": "no-cache, no-transform",
+    "x-accel-buffering": "no",
+});

package/dist/gateway/http/routes.d.ts

@@ -0,0 +1,6 @@
+import { Layer } from "effect";
+import { HttpRouter } from "effect/unstable/http";
+import { Client } from "../../client/service.js";
+import type { Options } from "../options.js";
+import { Security } from "../security.js";
+export declare const layer: (options: Options) => Layer.Layer<never, never, HttpRouter.HttpRouter | Client | Security>;

package/dist/gateway/http/routes.js

@@ -0,0 +1,184 @@
+import { Effect, Layer, Option, Ref } from "effect";
+import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
+import { Client } from "../../client/service.js";
+import { boundary, decode, fingerprint, readCursor } from "../../protocol/index.js";
+import { Receipt as WireReceipt } from "../../protocol/schemas.js";
+import { boundedEvents, sseBody } from "./events.js";
+import { errorResponse, jsonResponse, preflightResponse, sseHeaders, validateHttpOrigin, } from "./response.js";
+import { addressFrom, readJson, readEventParameters, validateCommandId, validateCursor, validatePublicName, validateReceiptCommandId, validateRevision, validateRequestId, } from "./validation.js";
+import { admit, assertTenant, authenticate, authorize, leaseConnection, recheck, } from "../access.js";
+import { hostedProcedure, mapInputError, stateProcedure, validateOutcome, validatePayload, validateQueryResult, validateReceipt, } from "../dispatch.js";
+import { CommandRequest, HostedRequest, QueryRequest, ReceiptRequest } from "../wire.js";
+import { fromServiceError, isGatewayFault, notFound, unauthorized, unavailable } from "../fault.js";
+import { makeRegistry } from "../options.js";
+import { Security } from "../security.js";
+import { handler as webSocketHandler } from "../websocket.js";
+const path = (prefix, suffix) => `${prefix}${suffix}`;
+const params = () => HttpRouter.params.pipe(Effect.mapError(mapInputError));
+const safe = (request, options, effect) => effect.pipe(Effect.catchIf((fault) => true, (fault) => Effect.succeed(errorResponse(request, options, fault))));
+const originGate = (request, options) => {
+    const fault = validateHttpOrigin(request, options);
+    return fault === undefined ? Effect.void : Effect.fail(fault);
+};
+const commandRoute = (registry, client, security) => (request) => safe(request, registry.options, Effect.gen(function* () {
+    yield* originGate(request, registry.options);
+    const body = yield* readJson(request, registry.options.maxRequestBytes, CommandRequest);
+    const route = yield* params();
+    const tenant = yield* validateRequestId(route.tenant ?? "");
+    const actorType = yield* validatePublicName(route.actorType ?? "", registry.isPublicOperation);
+    const command = yield* validatePublicName(route.name ?? "", registry.isPublicOperation);
+    const commandId = yield* validateCommandId(body.commandId);
+    const expectedRevision = body.expectedRevision === undefined
+        ? undefined
+        : yield* validateRevision(body.expectedRevision);
+    const address = yield* addressFrom(registry.options.namespace, tenant, actorType, body.key);
+    const procedure = yield* stateProcedure(registry, address, body.protocolVersion, command, "command");
+    const principal = yield* authenticate(security, request);
+    yield* assertTenant(principal, address);
+    const access = { address, operation: "command", name: command };
+    yield* authorize(security, principal, access);
+    yield* admit(security, principal, access);
+    const payload = yield* validatePayload(procedure, body.payload);
+    const invocation = yield* boundary(() => ({
+        address,
+        command,
+        protocolVersion: body.protocolVersion,
+        payload,
+        commandId,
+        fingerprint: fingerprint({
+            command,
+            protocolVersion: body.protocolVersion,
+            payload,
+            ...(expectedRevision === undefined ? {} : { expectedRevision }),
+        }),
+        ...(expectedRevision === undefined ? {} : { expectedRevision }),
+    })).pipe(Effect.mapError(mapInputError));
+    const receipt = yield* client
+        .command(invocation)
+        .pipe(Effect.mapError((error) => fromServiceError(error, commandId)));
+    const checked = yield* validateReceipt(procedure, address, receipt);
+    return jsonResponse(request, registry.options, checked);
+}));
+const queryRoute = (registry, client, security) => (request) => safe(request, registry.options, Effect.gen(function* () {
+    yield* originGate(request, registry.options);
+    const body = yield* readJson(request, registry.options.maxRequestBytes, QueryRequest);
+    const route = yield* params();
+    const tenant = yield* validateRequestId(route.tenant ?? "");
+    const actorType = yield* validatePublicName(route.actorType ?? "", registry.isPublicOperation);
+    const query = yield* validatePublicName(route.name ?? "", registry.isPublicOperation);
+    const address = yield* addressFrom(registry.options.namespace, tenant, actorType, body.key);
+    const procedure = yield* stateProcedure(registry, address, body.protocolVersion, query, "query");
+    const principal = yield* authenticate(security, request);
+    yield* assertTenant(principal, address);
+    const access = { address, operation: "query", name: query };
+    yield* authorize(security, principal, access);
+    yield* admit(security, principal, access);
+    const payload = yield* validatePayload(procedure, body.payload);
+    const result = yield* client
+        .query({ address, query, protocolVersion: body.protocolVersion, payload })
+        .pipe(Effect.mapError(fromServiceError));
+    const checked = yield* validateQueryResult(procedure, address, result);
+    return jsonResponse(request, registry.options, checked);
+}));
+const receiptRoute = (registry, client, security) => (request) => safe(request, registry.options, Effect.gen(function* () {
+    yield* originGate(request, registry.options);
+    const body = yield* readJson(request, registry.options.maxRequestBytes, ReceiptRequest);
+    const route = yield* params();
+    const tenant = yield* validateRequestId(route.tenant ?? "");
+    const actorType = yield* validatePublicName(route.actorType ?? "", registry.isPublicOperation);
+    const commandId = yield* validateReceiptCommandId(route["*"] ?? "");
+    const address = yield* addressFrom(registry.options.namespace, tenant, actorType, body.key);
+    const protocol = registry.get(actorType);
+    if (!protocol || protocol.kind !== "state")
+        return yield* Effect.fail(notFound());
+    const principal = yield* authenticate(security, request);
+    yield* assertTenant(principal, address);
+    const access = { address, operation: "receipt" };
+    yield* authorize(security, principal, access);
+    yield* admit(security, principal, access);
+    const receipt = yield* client
+        .receipt(address, commandId)
+        .pipe(Effect.mapError(fromServiceError));
+    if (Option.isNone(receipt))
+        return jsonResponse(request, registry.options, { receipt: null }, 404);
+    const checked = yield* decode(WireReceipt, receipt.value).pipe(Effect.flatMap((value) => boundary(() => readCursor(address, value.cursor)).pipe(Effect.mapError(() => unavailable()), Effect.as(value))), Effect.mapError(() => unavailable()));
+    return jsonResponse(request, registry.options, { receipt: checked });
+}));
+const eventsRoute = (registry, connections, client, security) => (request) => safe(request, registry.options, Effect.gen(function* () {
+    yield* originGate(request, registry.options);
+    const route = yield* params();
+    const tenant = yield* validateRequestId(route.tenant ?? "");
+    const actorType = yield* validatePublicName(route.actorType ?? "", registry.isPublicOperation);
+    const parameters = yield* readEventParameters(request);
+    const address = yield* addressFrom(registry.options.namespace, tenant, actorType, parameters.key);
+    const protocol = registry.get(actorType);
+    if (!protocol || protocol.kind !== "state")
+        return yield* Effect.fail(notFound());
+    const after = parameters.after;
+    yield* validateCursor(address, 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);
+    yield* leaseConnection(connections, principal, registry.options.maxConnectionsPerPrincipal);
+    const events = yield* boundedEvents(client, address, after, protocol.eventSchema, registry.options, recheck(security, request, principal, access));
+    return HttpServerResponse.stream(sseBody(events), {
+        contentType: "text/event-stream",
+        headers: sseHeaders(request, registry.options),
+    });
+}));
+const hostedRoute = (registry, client, security) => (request) => safe(request, registry.options, Effect.gen(function* () {
+    yield* originGate(request, registry.options);
+    const body = yield* readJson(request, registry.options.maxRequestBytes, HostedRequest);
+    const route = yield* params();
+    const tenant = yield* validateRequestId(route.tenant ?? "");
+    const actorType = yield* validatePublicName(route.actorType ?? "", registry.isPublicOperation);
+    const action = yield* validatePublicName(route.name ?? "", registry.isPublicOperation);
+    const address = yield* addressFrom(registry.options.namespace, tenant, actorType, body.key);
+    const procedure = yield* hostedProcedure(registry, address, body.protocolVersion, action);
+    const principal = yield* authenticate(security, request);
+    yield* assertTenant(principal, address);
+    const access = { address, operation: "hosted", name: action };
+    yield* authorize(security, principal, access);
+    yield* admit(security, principal, access);
+    const payload = yield* validatePayload(procedure, body.payload);
+    const requestKey = body.requestKey === undefined ? undefined : yield* validateRequestId(body.requestKey);
+    const input = yield* boundary(() => ({
+        address,
+        action,
+        protocolVersion: body.protocolVersion,
+        payload,
+        ...(requestKey === undefined ? {} : { requestKey }),
+        fingerprint: fingerprint({
+            command: action,
+            protocolVersion: body.protocolVersion,
+            payload,
+        }),
+    })).pipe(Effect.mapError(mapInputError));
+    const result = yield* client.hosted(input).pipe(Effect.mapError(fromServiceError));
+    const checked = yield* validateOutcome(procedure, result);
+    return jsonResponse(request, registry.options, checked);
+}));
+export const layer = (options) => {
+    const registry = makeRegistry(options);
+    return Layer.effectDiscard(Effect.gen(function* () {
+        const router = yield* HttpRouter.HttpRouter;
+        const client = yield* Client;
+        const security = yield* Security;
+        const connections = yield* Ref.make(new Map());
+        yield* router.add("OPTIONS", path(registry.path, "/*"), (request) => {
+            const response = preflightResponse(request, registry.options);
+            return Effect.succeed(response ?? errorResponse(request, registry.options, unauthorized()));
+        });
+        yield* router.add("POST", path(registry.path, "/:tenant/:actorType/commands/:name"), commandRoute(registry, client, security));
+        yield* router.add("POST", path(registry.path, "/:tenant/:actorType/queries/:name"), queryRoute(registry, client, security));
+        yield* router.add("POST", path(registry.path, "/:tenant/:actorType/receipts/*"), receiptRoute(registry, client, security));
+        yield* router.add("GET", path(registry.path, "/:tenant/:actorType/events"), eventsRoute(registry, connections, client, security));
+        yield* router.add("POST", path(registry.path, "/:tenant/:actorType/actions/:name"), hostedRoute(registry, client, security));
+        if (registry.options.enableWebSocket) {
+            const socket = webSocketHandler(registry, client, security, connections);
+            yield* router.add("GET", path(registry.path, "/connect"), (request) => safe(request, registry.options, socket(request)));
+        }
+    }));
+};

package/dist/gateway/http/validation.d.ts

@@ -0,0 +1,19 @@
+import { Effect, Schema } from "effect";
+import type { HttpServerRequest } from "effect/unstable/http";
+import type { Address } from "../../protocol/index.js";
+import { slowConsumer } from "../fault.js";
+import type { GatewayFault } from "../fault.js";
+export declare const readJson: <S extends Schema.ConstraintDecoder<unknown>>(request: HttpServerRequest.HttpServerRequest, maximum: number, schema: S) => Effect.Effect<S["Type"], GatewayFault>;
+export declare const addressFrom: (namespace: string, tenant: string, actorType: string, key: ReadonlyArray<string>) => Effect.Effect<Address, GatewayFault>;
+export declare const validateCursor: (address: Address, cursor: string) => Effect.Effect<string, GatewayFault>;
+export declare const validateRequestId: (value: string) => Effect.Effect<string, GatewayFault>;
+export declare const validateCommandId: (value: string) => Effect.Effect<string, GatewayFault>;
+export declare const validateReceiptCommandId: (value: string) => Effect.Effect<string, GatewayFault>;
+export declare const validateRevision: (value: string) => Effect.Effect<string, GatewayFault>;
+export declare const validatePublicName: (value: string, isPublicOperation: (name: string) => boolean) => Effect.Effect<string, GatewayFault>;
+export interface EventParameters {
+    readonly after: string;
+    readonly key: ReadonlyArray<string>;
+}
+export declare const readEventParameters: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<EventParameters, GatewayFault>;
+export declare const slowConsumerFault: typeof slowConsumer;

package/dist/gateway/http/validation.js

@@ -0,0 +1,92 @@
+import { Effect, Encoding, Result, Schema, Stream } from "effect";
+import { addressId, boundary, decode, readCursor, validateId, validateKey, } from "../../protocol/index.js";
+import { isSequence } from "../../protocol/encoding.js";
+import { invalidInput, isGatewayFault, slowConsumer } from "../fault.js";
+const isBoundedText = (value, maximum) => value.length > 0 && value.length <= maximum && !/[\u0000-\u001f\u007f]/.test(value);
+const textDecoder = new TextDecoder("utf-8", { fatal: true });
+const bodyTooLarge = () => ({
+    _tag: "GatewayFault",
+    code: "InvalidInput",
+    status: 413,
+    message: "Request body is too large",
+});
+const mapInputError = (error) => isGatewayFault(error) ? error : invalidInput();
+const parseContentLength = (request, maximum) => {
+    const contentLength = request.headers["content-length"];
+    if (contentLength === undefined)
+        return Effect.void;
+    if (!/^(0|[1-9][0-9]*)$/.test(contentLength))
+        return Effect.fail(invalidInput());
+    const length = Number(contentLength);
+    return Number.isSafeInteger(length) && length <= maximum
+        ? Effect.void
+        : Effect.fail(bodyTooLarge());
+};
+const join = (chunks, length) => {
+    const body = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        body.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return body;
+};
+export const readJson = (request, maximum, schema) => Effect.gen(function* () {
+    yield* parseContentLength(request, maximum);
+    const collected = yield* Stream.runFoldEffect(request.stream, () => ({ chunks: [], length: 0 }), (state, chunk) => {
+        const length = state.length + chunk.length;
+        return length > maximum
+            ? Effect.fail(bodyTooLarge())
+            : Effect.succeed({ chunks: [...state.chunks, chunk], length });
+    }).pipe(Effect.mapError(mapInputError));
+    const text = yield* boundary(() => textDecoder.decode(join(collected.chunks, collected.length))).pipe(Effect.mapError(mapInputError));
+    const value = yield* boundary(() => JSON.parse(text)).pipe(Effect.mapError(mapInputError));
+    return yield* decode(schema, value).pipe(Effect.mapError(mapInputError));
+});
+export const addressFrom = (namespace, tenant, actorType, key) => boundary(() => {
+    const checkedKey = validateKey({ tenant, key });
+    const address = { namespace, tenant: checkedKey.tenant, actorType, key: checkedKey.key };
+    addressId(address);
+    return address;
+}).pipe(Effect.mapError(mapInputError));
+export const validateCursor = (address, cursor) => {
+    if (!isBoundedText(cursor, 16_384))
+        return Effect.fail(invalidInput());
+    return boundary(() => readCursor(address, cursor)).pipe(Effect.mapError(mapInputError));
+};
+export const validateRequestId = (value) => boundary(() => validateId(value)).pipe(Effect.mapError(mapInputError));
+export const validateCommandId = (value) => validateRequestId(value).pipe(Effect.flatMap((commandId) => commandId.startsWith("~effect-actors/")
+    ? Effect.fail(invalidInput())
+    : Effect.succeed(commandId)));
+export const validateReceiptCommandId = (value) => boundary(() => validateId(value, 1_024)).pipe(Effect.mapError(mapInputError));
+export const validateRevision = (value) => isSequence(value) ? Effect.succeed(value) : Effect.fail(invalidInput());
+export const validatePublicName = (value, isPublicOperation) => isPublicOperation(value) ? Effect.succeed(value) : Effect.fail(invalidInput());
+export const readEventParameters = (request) => boundary(() => {
+    const query = request.url.indexOf("?");
+    const values = new Map();
+    if (query !== -1) {
+        for (const pair of request.url.slice(query + 1).split("&")) {
+            if (pair.length === 0)
+                continue;
+            const separator = pair.indexOf("=");
+            const key = decodeURIComponent(separator === -1 ? pair : pair.slice(0, separator));
+            const value = decodeURIComponent(separator === -1 ? "" : pair.slice(separator + 1));
+            values.set(key, [...(values.get(key) ?? []), value]);
+        }
+    }
+    const afterValues = values.get("after") ?? [];
+    const keyValues = values.get("key") ?? [];
+    if (afterValues.length > 1 || keyValues.length !== 1)
+        throw new Error("invalid event parameters");
+    const header = request.headers["last-event-id"];
+    if (afterValues.length === 1 && header !== undefined && afterValues[0] !== header)
+        throw new Error("conflicting cursor");
+    const after = afterValues[0] ?? header;
+    if (after === undefined)
+        throw new Error("missing cursor");
+    const decoded = Encoding.decodeBase64UrlString(keyValues[0]);
+    if (Result.isFailure(decoded))
+        throw decoded.failure;
+    return { after, key: JSON.parse(decoded.success) };
+}).pipe(Effect.mapError(mapInputError), Effect.flatMap((input) => decode(Schema.Array(Schema.String), input.key).pipe(Effect.map((key) => ({ after: input.after, key })), Effect.mapError(mapInputError))));
+export const slowConsumerFault = slowConsumer;

package/dist/gateway/options.d.ts

@@ -0,0 +1,31 @@
+import type { Protocol as StateProtocol } from "../actor/definition.js";
+import type { Protocol as HostProtocol } from "../host/definition.js";
+import type { Procedure } from "../protocol/index.js";
+export declare const defaultMaxInFlightRequestsPerConnection = 32;
+export declare const defaultMaxSubscriptionsPerConnection = 8;
+export interface Options {
+    readonly protocols: ReadonlyArray<StateProtocol | HostProtocol>;
+    readonly path: `/${string}`;
+    readonly namespace: string;
+    readonly allowedOrigins: ReadonlyArray<string>;
+    readonly maxRequestBytes: number;
+    readonly maxConnectionsPerPrincipal: number;
+    readonly maxBufferedEvents: number;
+    readonly maxInFlightRequestsPerConnection?: number;
+    readonly maxSubscriptionsPerConnection?: number;
+    readonly authenticationRecheckMillis: number;
+    readonly enableWebSocket: boolean;
+}
+type RegisteredProtocol = StateProtocol | HostProtocol;
+export interface Registry {
+    readonly path: string;
+    readonly options: Options;
+    readonly maxInFlightRequestsPerConnection: number;
+    readonly maxSubscriptionsPerConnection: number;
+    readonly get: (actorType: string) => RegisteredProtocol | undefined;
+    readonly stateProcedure: (actorType: string, name: string, kind: "command" | "query") => Procedure | undefined;
+    readonly hostedProcedure: (actorType: string, name: string) => Procedure | undefined;
+    readonly isPublicOperation: (name: string) => boolean;
+}
+export declare const makeRegistry: (options: Options) => Registry;
+export {};

package/dist/gateway/options.js

@@ -0,0 +1,107 @@
+import { assertIdentifier } from "../actor/state/codec.js";
+export const defaultMaxInFlightRequestsPerConnection = 32;
+export const defaultMaxSubscriptionsPerConnection = 8;
+const isPublicOperation = (name) => {
+    try {
+        assertIdentifier(name);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const normalizePath = (path) => (path === "/" ? "" : path.replace(/\/+$/, ""));
+const validateOrigin = (origin) => {
+    let parsed;
+    try {
+        parsed = new URL(origin);
+    }
+    catch {
+        throw new TypeError("Gateway allowed origins must be normalized absolute origins");
+    }
+    if (parsed.origin !== origin ||
+        (parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
+        parsed.username !== "" ||
+        parsed.password !== "" ||
+        parsed.pathname !== "/" ||
+        parsed.search !== "" ||
+        parsed.hash !== "")
+        throw new TypeError("Gateway allowed origins must be normalized absolute origins");
+};
+const validateProtocol = (protocol) => {
+    if (!isPublicOperation(protocol.actorType)) {
+        throw new TypeError("Gateway actor types must use public operation names");
+    }
+    if (!Number.isSafeInteger(protocol.version) || protocol.version < 1) {
+        throw new TypeError("Gateway protocol versions must be positive integers");
+    }
+    const procedures = protocol.kind === "state"
+        ? [...Object.keys(protocol.commands), ...Object.keys(protocol.queries)]
+        : Object.keys(protocol.actions);
+    for (const procedure of procedures) {
+        if (!isPublicOperation(procedure)) {
+            throw new TypeError("Gateway protocols cannot expose private or reserved operations");
+        }
+    }
+};
+export const makeRegistry = (options) => {
+    if (!options.path.startsWith("/"))
+        throw new TypeError("Gateway paths must start with a slash");
+    if (options.namespace.length === 0 || options.namespace.length > 256) {
+        throw new TypeError("Gateway namespaces must be nonempty and bounded");
+    }
+    if (!Number.isSafeInteger(options.maxRequestBytes) || options.maxRequestBytes < 1) {
+        throw new TypeError("Gateway maxRequestBytes must be a positive integer");
+    }
+    if (!Number.isSafeInteger(options.maxConnectionsPerPrincipal) ||
+        options.maxConnectionsPerPrincipal < 1) {
+        throw new TypeError("Gateway maxConnectionsPerPrincipal must be a positive integer");
+    }
+    if (!Number.isSafeInteger(options.maxBufferedEvents) || options.maxBufferedEvents < 1) {
+        throw new TypeError("Gateway maxBufferedEvents must be a positive integer");
+    }
+    const maxInFlightRequestsPerConnection = options.maxInFlightRequestsPerConnection ?? defaultMaxInFlightRequestsPerConnection;
+    if (!Number.isSafeInteger(maxInFlightRequestsPerConnection) ||
+        maxInFlightRequestsPerConnection < 1) {
+        throw new TypeError("Gateway maxInFlightRequestsPerConnection must be a positive integer");
+    }
+    const maxSubscriptionsPerConnection = options.maxSubscriptionsPerConnection ?? defaultMaxSubscriptionsPerConnection;
+    if (!Number.isSafeInteger(maxSubscriptionsPerConnection) || maxSubscriptionsPerConnection < 1) {
+        throw new TypeError("Gateway maxSubscriptionsPerConnection must be a positive integer");
+    }
+    if (!Number.isSafeInteger(options.authenticationRecheckMillis) ||
+        options.authenticationRecheckMillis < 1) {
+        throw new TypeError("Gateway authenticationRecheckMillis must be a positive integer");
+    }
+    for (const origin of options.allowedOrigins)
+        validateOrigin(origin);
+    const protocols = new Map();
+    for (const protocol of options.protocols) {
+        validateProtocol(protocol);
+        if (protocols.has(protocol.actorType)) {
+            throw new TypeError(`Gateway protocol already registered for ${protocol.actorType}`);
+        }
+        protocols.set(protocol.actorType, protocol);
+    }
+    return {
+        path: normalizePath(options.path),
+        options,
+        maxInFlightRequestsPerConnection,
+        maxSubscriptionsPerConnection,
+        get: (actorType) => protocols.get(actorType),
+        stateProcedure: (actorType, name, kind) => {
+            const protocol = protocols.get(actorType);
+            if (!protocol || protocol.kind !== "state" || !isPublicOperation(name))
+                return undefined;
+            const procedures = kind === "command" ? protocol.commands : protocol.queries;
+            return Object.hasOwn(procedures, name) ? procedures[name] : undefined;
+        },
+        hostedProcedure: (actorType, name) => {
+            const protocol = protocols.get(actorType);
+            if (!protocol || protocol.kind !== "hosted" || !isPublicOperation(name))
+                return undefined;
+            return Object.hasOwn(protocol.actions, name) ? protocol.actions[name] : undefined;
+        },
+        isPublicOperation,
+    };
+};

package/dist/gateway/security.d.ts

@@ -0,0 +1,25 @@
+import { Context } from "effect";
+import type { Effect } from "effect";
+import type { HttpServerRequest } from "effect/unstable/http";
+import type { Overloaded, Unauthorized } from "../errors/index.js";
+import type { Address, Json } from "../protocol/index.js";
+export interface Principal {
+    readonly subject: string;
+    readonly tenant: string;
+    readonly claims: Readonly<Record<string, Json>>;
+}
+export declare const connectionKey: (principal: Principal) => string;
+export interface Access {
+    readonly address: Address;
+    readonly operation: "command" | "query" | "receipt" | "events" | "hosted";
+    readonly name?: string;
+}
+export interface SecurityService {
+    readonly authenticate: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<Principal, Unauthorized>;
+    readonly authorize: (principal: Principal, access: Access) => Effect.Effect<void, Unauthorized>;
+    readonly admit: (principal: Principal, access: Access) => Effect.Effect<void, Overloaded>;
+}
+declare const Security_base: Context.ServiceClass<Security, "effect-actors/Gateway/Security", SecurityService>;
+export declare class Security extends Security_base {
+}
+export {};

package/dist/gateway/security.js

@@ -0,0 +1,4 @@
+import { Context } from "effect";
+export const connectionKey = (principal) => JSON.stringify([principal.tenant, principal.subject]);
+export class Security extends Context.Service()("effect-actors/Gateway/Security") {
+}