effect-actors 0.0.1

package/dist/client/http/layer.js

@@ -0,0 +1,133 @@
+import { Effect, Layer, Option, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { HostUnavailable, OutcomeUnknown } from "../../errors/index.js";
+import { addressId, boundary, canonicalJson, fingerprint, validateId, } from "../../protocol/index.js";
+import { isSequence } from "../../protocol/encoding.js";
+import { Outcome as OutcomeSchema, QueryResult as QueryResultSchema, Receipt, } from "../../protocol/schemas.js";
+import { ReceiptResponse } from "../../gateway/wire.js";
+import { Client } from "../service.js";
+import { isSuccess, invalid, parseCommandError, parseHostedError, parseReadError, parseReadOnlyError, responseJson, unavailable, } from "./errors.js";
+import { decodeEventStream, eventsUrl, validateCursor } from "./events.js";
+const normalizeBaseUrl = (baseUrl) => {
+    if (!/^https?:\/\//.test(baseUrl))
+        throw new TypeError("HTTP client baseUrl must be an absolute HTTP URL");
+    return baseUrl.replace(/\/+$/, "");
+};
+const segment = (value) => encodeURIComponent(value);
+const commandUrl = (baseUrl, address, command) => `${baseUrl}/${segment(address.tenant)}/${segment(address.actorType)}/commands/${segment(command)}`;
+const queryUrl = (baseUrl, address, query) => `${baseUrl}/${segment(address.tenant)}/${segment(address.actorType)}/queries/${segment(query)}`;
+const receiptUrl = (baseUrl, address, commandId) => `${baseUrl}/${segment(address.tenant)}/${segment(address.actorType)}/receipts/${segment(commandId)}`;
+const hostedUrl = (baseUrl, address, action) => `${baseUrl}/${segment(address.tenant)}/${segment(address.actorType)}/actions/${segment(action)}`;
+const validateAddress = (namespace, address) => boundary(() => {
+    addressId(address);
+    if (address.namespace !== namespace)
+        throw invalid();
+    return address;
+});
+const validateInvocation = (namespace, input) => boundary(() => {
+    addressId(input.address);
+    if (input.address.namespace !== namespace)
+        throw invalid();
+    validateId(input.commandId);
+    if (input.commandId.startsWith("~effect-actors/"))
+        throw invalid();
+    if (input.expectedRevision !== undefined && !isSequence(input.expectedRevision))
+        throw invalid();
+    const expectedFingerprint = fingerprint({
+        command: input.command,
+        protocolVersion: input.protocolVersion,
+        payload: input.payload,
+        ...(input.expectedRevision === undefined ? {} : { expectedRevision: input.expectedRevision }),
+    });
+    if (input.fingerprint !== expectedFingerprint)
+        throw invalid();
+    return input;
+});
+const validateReceiptCommandId = (commandId) => boundary(() => validateId(commandId, 1_024));
+const validateHosted = (namespace, input) => boundary(() => {
+    addressId(input.address);
+    if (input.address.namespace !== namespace)
+        throw invalid();
+    if (input.fingerprint !==
+        fingerprint({
+            command: input.action,
+            protocolVersion: input.protocolVersion,
+            payload: input.payload,
+        }))
+        throw invalid();
+    return input;
+});
+const validateQuery = (namespace, input) => boundary(() => {
+    addressId(input.address);
+    if (input.address.namespace !== namespace)
+        throw invalid();
+    canonicalJson(input.payload);
+    return input;
+});
+const requestJson = (http, url, body) => HttpClientRequest.bodyJson(HttpClientRequest.post(url), body).pipe(Effect.mapError(unavailable), Effect.flatMap((request) => http.execute(request).pipe(Effect.mapError(unavailable))));
+const requestEvents = (http, url) => http
+    .execute(HttpClientRequest.get(url, { headers: { accept: "text/event-stream" } }))
+    .pipe(Effect.mapError(unavailable));
+export const layerHttp = (options) => {
+    const baseUrl = normalizeBaseUrl(options.baseUrl);
+    return Layer.effect(Client, Effect.gen(function* () {
+        const http = yield* HttpClient.HttpClient;
+        const service = {
+            namespace: options.namespace,
+            command: (input) => validateInvocation(options.namespace, input).pipe(Effect.flatMap((checked) => requestJson(http, commandUrl(baseUrl, checked.address, checked.command), {
+                key: checked.address.key,
+                protocolVersion: checked.protocolVersion,
+                commandId: checked.commandId,
+                ...(checked.expectedRevision === undefined
+                    ? {}
+                    : { expectedRevision: checked.expectedRevision }),
+                payload: checked.payload,
+            }).pipe(Effect.mapError(() => new OutcomeUnknown({ commandId: checked.commandId })), Effect.flatMap((response) => isSuccess(response.status)
+                ? responseJson(response, Receipt, new OutcomeUnknown({ commandId: checked.commandId })).pipe(Effect.flatMap((receipt) => validateCursor(checked.address, receipt.cursor).pipe(Effect.mapError(() => new OutcomeUnknown({ commandId: checked.commandId })), Effect.as(receipt))))
+                : parseCommandError(response, {
+                    actorType: checked.address.actorType,
+                    protocolVersion: checked.protocolVersion,
+                    commandId: checked.commandId,
+                }, new OutcomeUnknown({ commandId: checked.commandId })))))),
+            query: (input) => validateQuery(options.namespace, input).pipe(Effect.flatMap((checkedInput) => requestJson(http, queryUrl(baseUrl, checkedInput.address, checkedInput.query), {
+                key: checkedInput.address.key,
+                protocolVersion: checkedInput.protocolVersion,
+                payload: checkedInput.payload,
+            }).pipe(Effect.flatMap((response) => isSuccess(response.status)
+                ? responseJson(response, QueryResultSchema, unavailable()).pipe(Effect.flatMap((result) => validateCursor(checkedInput.address, result.cursor).pipe(Effect.mapError(unavailable), Effect.as(result))))
+                : parseReadOnlyError(response, {
+                    actorType: checkedInput.address.actorType,
+                    protocolVersion: checkedInput.protocolVersion,
+                }))))),
+            receipt: (address, commandId) => validateAddress(options.namespace, address).pipe(Effect.flatMap((checked) => validateReceiptCommandId(commandId).pipe(Effect.flatMap((checkedCommandId) => requestJson(http, receiptUrl(baseUrl, checked, checkedCommandId), {
+                key: checked.key,
+            }).pipe(Effect.flatMap((response) => {
+                if (response.status === 404)
+                    return Effect.succeed(Option.none());
+                return isSuccess(response.status)
+                    ? responseJson(response, ReceiptResponse, unavailable()).pipe(Effect.flatMap((body) => body.receipt === null
+                        ? Effect.succeed(Option.none())
+                        : validateCursor(checked, body.receipt.cursor).pipe(Effect.mapError(unavailable), Effect.as(Option.some(body.receipt)))))
+                    : parseReadOnlyError(response, { actorType: checked.actorType });
+            })))))),
+            events: (address, subscribeOptions) => Stream.unwrap(validateAddress(options.namespace, address).pipe(Effect.flatMap((checked) => validateCursor(checked, subscribeOptions.after).pipe(Effect.as(checked))), Effect.mapError((error) => error), Effect.flatMap((checked) => requestEvents(http, eventsUrl(baseUrl, checked, subscribeOptions.after)).pipe(Effect.flatMap((response) => {
+                const context = { actorType: checked.actorType, address: checked };
+                return isSuccess(response.status)
+                    ? Effect.succeed(decodeEventStream(response.stream, context))
+                    : parseReadError(response, context);
+            }))))),
+            hosted: (input) => validateHosted(options.namespace, input).pipe(Effect.flatMap((checked) => requestJson(http, hostedUrl(baseUrl, checked.address, checked.action), {
+                key: checked.address.key,
+                protocolVersion: checked.protocolVersion,
+                ...(checked.requestKey === undefined ? {} : { requestKey: checked.requestKey }),
+                payload: checked.payload,
+            }).pipe(Effect.flatMap((response) => isSuccess(response.status)
+                ? responseJson(response, OutcomeSchema, new HostUnavailable({ retryable: true }))
+                : parseHostedError(response, {
+                    actorType: checked.address.actorType,
+                    protocolVersion: checked.protocolVersion,
+                }))))),
+        };
+        return service;
+    }));
+};

package/dist/client/http.d.ts

@@ -0,0 +1 @@
+export { layerHttp } from "./http/layer.js";

package/dist/client/http.js

@@ -0,0 +1 @@
+export { layerHttp } from "./http/layer.js";

package/dist/client/outcome.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import type { Decoded, JsonSchema, Outcome } from "../protocol/index.js";
+import type { InvalidInput } from "../errors/index.js";
+export declare const unwrap: <A extends JsonSchema, E extends JsonSchema, F extends JsonSchema>(success: A, error: E, framework: F, outcome: Outcome) => Effect.Effect<Decoded<A>, Decoded<E> | Decoded<F> | InvalidInput>;

package/dist/client/outcome.js

@@ -0,0 +1,10 @@
+import { Effect, Result, Schema } from "effect";
+import { decode } from "../protocol/encoding.js";
+export const unwrap = (success, error, framework, outcome) => {
+    if (outcome._tag === "Success")
+        return decode(success, outcome.value);
+    const known = Schema.decodeUnknownResult(framework)(outcome.error);
+    if (Result.isSuccess(known))
+        return Effect.fail(known.success);
+    return Effect.flatMap(decode(error, outcome.error), Effect.fail);
+};

package/dist/client/service.d.ts

@@ -0,0 +1,28 @@
+import { Context } from "effect";
+import type { Effect, Option, Stream } from "effect";
+import type { CommandError, CursorExpired, HostUnavailable, ReadError } from "../errors/index.js";
+import type { Address, Event, Invocation, Json, Outcome, Query, QueryResult, SubscribeOptions, WireReceipt } from "../protocol/index.js";
+export interface HostedInvocation {
+    readonly address: Address;
+    readonly action: string;
+    readonly protocolVersion: number;
+    readonly payload: Json;
+    readonly requestKey?: string;
+    readonly fingerprint: string;
+}
+export interface Service {
+    readonly namespace: string;
+    readonly command: (input: Invocation) => Effect.Effect<WireReceipt, CommandError>;
+    readonly query: (input: Query) => Effect.Effect<QueryResult<Outcome>, ReadError>;
+    readonly receipt: (address: Address, commandId: string) => Effect.Effect<Option.Option<WireReceipt>, ReadError>;
+    readonly events: (address: Address, options: SubscribeOptions) => Stream.Stream<Event<Json>, ReadError | CursorExpired>;
+    readonly hosted: (input: HostedInvocation) => Effect.Effect<Outcome, CommandError | HostUnavailable>;
+}
+declare const Client_base: Context.ServiceClass<Client, "effect-actors/Client", Service>;
+export declare class Client extends Client_base {
+}
+export interface HttpOptions {
+    readonly namespace: string;
+    readonly baseUrl: string;
+}
+export { layerHttp } from "./http.js";

package/dist/client/service.js

@@ -0,0 +1,4 @@
+import { Context } from "effect";
+export class Client extends Context.Service()("effect-actors/Client") {
+}
+export { layerHttp } from "./http.js";

package/dist/errors/index.d.ts

@@ -0,0 +1,93 @@
+import { Schema } from "effect";
+declare const InvalidInput_base: Schema.Class<InvalidInput, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/InvalidInput">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidInput extends InvalidInput_base {
+}
+declare const CommandConflict_base: Schema.Class<CommandConflict, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/CommandConflict">;
+    readonly commandId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class CommandConflict extends CommandConflict_base {
+}
+declare const RevisionConflict_base: Schema.Class<RevisionConflict, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/RevisionConflict">;
+    readonly expected: Schema.String;
+    readonly actual: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RevisionConflict extends RevisionConflict_base {
+}
+declare const CursorExpired_base: Schema.Class<CursorExpired, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/CursorExpired">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class CursorExpired extends CursorExpired_base {
+}
+declare const StorageUnavailable_base: Schema.Class<StorageUnavailable, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/StorageUnavailable">;
+    readonly retryable: Schema.Boolean;
+}>, import("effect/Cause").YieldableError>;
+export declare class StorageUnavailable extends StorageUnavailable_base {
+}
+declare const OwnershipLost_base: Schema.Class<OwnershipLost, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/OwnershipLost">;
+    readonly actorType: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class OwnershipLost extends OwnershipLost_base {
+}
+declare const Overloaded_base: Schema.Class<Overloaded, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/Overloaded">;
+    readonly retryAfterMillis: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+export declare class Overloaded extends Overloaded_base {
+}
+declare const Unauthorized_base: Schema.Class<Unauthorized, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/Unauthorized">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class Unauthorized extends Unauthorized_base {
+}
+declare const OutcomeUnknown_base: Schema.Class<OutcomeUnknown, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/OutcomeUnknown">;
+    readonly commandId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class OutcomeUnknown extends OutcomeUnknown_base {
+}
+declare const UnsupportedVersion_base: Schema.Class<UnsupportedVersion, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/UnsupportedVersion">;
+    readonly actorType: Schema.String;
+    readonly version: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+export declare class UnsupportedVersion extends UnsupportedVersion_base {
+}
+declare const MigrationRejected_base: Schema.Class<MigrationRejected, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/MigrationRejected">;
+    readonly fromVersion: Schema.Int;
+    readonly toVersion: Schema.Int;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class MigrationRejected extends MigrationRejected_base {
+}
+declare const RegistrationError_base: Schema.Class<RegistrationError, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/RegistrationError">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RegistrationError extends RegistrationError_base {
+}
+declare const HostUnavailable_base: Schema.Class<HostUnavailable, Schema.Struct<{
+    readonly _tag: Schema.tag<"effect-actors/HostUnavailable">;
+    readonly retryable: Schema.Boolean;
+}>, import("effect/Cause").YieldableError>;
+export declare class HostUnavailable extends HostUnavailable_base {
+}
+export type ReadError = InvalidInput | StorageUnavailable | OwnershipLost | Overloaded | Unauthorized | UnsupportedVersion | MigrationRejected;
+export type CommandError = ReadError | CommandConflict | RevisionConflict | OutcomeUnknown | MigrationRejected;
+export type StoreError = InvalidInput | StorageUnavailable | OwnershipLost | UnsupportedVersion | MigrationRejected;
+export declare const ReadErrorSchema: Schema.Union<readonly [typeof InvalidInput, typeof StorageUnavailable, typeof OwnershipLost, typeof Overloaded, typeof Unauthorized, typeof UnsupportedVersion, typeof MigrationRejected]>;
+export declare const CommandErrorSchema: Schema.Union<readonly [Schema.Union<readonly [typeof InvalidInput, typeof StorageUnavailable, typeof OwnershipLost, typeof Overloaded, typeof Unauthorized, typeof UnsupportedVersion, typeof MigrationRejected]>, typeof CommandConflict, typeof RevisionConflict, typeof OutcomeUnknown, typeof MigrationRejected]>;
+export declare const EventErrorSchema: Schema.Union<readonly [Schema.Union<readonly [typeof InvalidInput, typeof StorageUnavailable, typeof OwnershipLost, typeof Overloaded, typeof Unauthorized, typeof UnsupportedVersion, typeof MigrationRejected]>, typeof CursorExpired]>;
+export declare const HostedErrorSchema: Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [typeof InvalidInput, typeof StorageUnavailable, typeof OwnershipLost, typeof Overloaded, typeof Unauthorized, typeof UnsupportedVersion, typeof MigrationRejected]>, typeof CommandConflict, typeof RevisionConflict, typeof OutcomeUnknown, typeof MigrationRejected]>, typeof HostUnavailable]>;
+export declare const FrameworkErrorSchema: Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [typeof InvalidInput, typeof StorageUnavailable, typeof OwnershipLost, typeof Overloaded, typeof Unauthorized, typeof UnsupportedVersion, typeof MigrationRejected]>, typeof CommandConflict, typeof RevisionConflict, typeof OutcomeUnknown, typeof MigrationRejected]>, typeof HostUnavailable]>, typeof CursorExpired, typeof RegistrationError]>;
+export type FrameworkError = typeof FrameworkErrorSchema.Type;
+export {};

package/dist/errors/index.js

@@ -0,0 +1,93 @@
+import { Schema } from "effect";
+export class InvalidInput extends Schema.Error("effect-actors/InvalidInput")({
+    _tag: Schema.tag("effect-actors/InvalidInput"),
+    message: Schema.String,
+}) {
+}
+export class CommandConflict extends Schema.Error("effect-actors/CommandConflict")({
+    _tag: Schema.tag("effect-actors/CommandConflict"),
+    commandId: Schema.String,
+}) {
+}
+export class RevisionConflict extends Schema.Error("effect-actors/RevisionConflict")({
+    _tag: Schema.tag("effect-actors/RevisionConflict"),
+    expected: Schema.String,
+    actual: Schema.String,
+}) {
+}
+export class CursorExpired extends Schema.Error("effect-actors/CursorExpired")({
+    _tag: Schema.tag("effect-actors/CursorExpired"),
+    message: Schema.String,
+}) {
+}
+export class StorageUnavailable extends Schema.Error("effect-actors/StorageUnavailable")({
+    _tag: Schema.tag("effect-actors/StorageUnavailable"),
+    retryable: Schema.Boolean,
+}) {
+}
+export class OwnershipLost extends Schema.Error("effect-actors/OwnershipLost")({
+    _tag: Schema.tag("effect-actors/OwnershipLost"),
+    actorType: Schema.String,
+}) {
+}
+export class Overloaded extends Schema.Error("effect-actors/Overloaded")({
+    _tag: Schema.tag("effect-actors/Overloaded"),
+    retryAfterMillis: Schema.Number,
+}) {
+}
+export class Unauthorized extends Schema.Error("effect-actors/Unauthorized")({
+    _tag: Schema.tag("effect-actors/Unauthorized"),
+    message: Schema.String,
+}) {
+}
+export class OutcomeUnknown extends Schema.Error("effect-actors/OutcomeUnknown")({
+    _tag: Schema.tag("effect-actors/OutcomeUnknown"),
+    commandId: Schema.String,
+}) {
+}
+export class UnsupportedVersion extends Schema.Error("effect-actors/UnsupportedVersion")({
+    _tag: Schema.tag("effect-actors/UnsupportedVersion"),
+    actorType: Schema.String,
+    version: Schema.Int,
+}) {
+}
+export class MigrationRejected extends Schema.Error("effect-actors/MigrationRejected")({
+    _tag: Schema.tag("effect-actors/MigrationRejected"),
+    fromVersion: Schema.Int,
+    toVersion: Schema.Int,
+    message: Schema.String,
+}) {
+}
+export class RegistrationError extends Schema.Error("effect-actors/RegistrationError")({
+    _tag: Schema.tag("effect-actors/RegistrationError"),
+    message: Schema.String,
+}) {
+}
+export class HostUnavailable extends Schema.Error("effect-actors/HostUnavailable")({
+    _tag: Schema.tag("effect-actors/HostUnavailable"),
+    retryable: Schema.Boolean,
+}) {
+}
+export const ReadErrorSchema = Schema.Union([
+    InvalidInput,
+    StorageUnavailable,
+    OwnershipLost,
+    Overloaded,
+    Unauthorized,
+    UnsupportedVersion,
+    MigrationRejected,
+]);
+export const CommandErrorSchema = Schema.Union([
+    ReadErrorSchema,
+    CommandConflict,
+    RevisionConflict,
+    OutcomeUnknown,
+    MigrationRejected,
+]);
+export const EventErrorSchema = Schema.Union([ReadErrorSchema, CursorExpired]);
+export const HostedErrorSchema = Schema.Union([CommandErrorSchema, HostUnavailable]);
+export const FrameworkErrorSchema = Schema.Union([
+    HostedErrorSchema,
+    CursorExpired,
+    RegistrationError,
+]);

package/dist/gateway/access.d.ts

@@ -0,0 +1,11 @@
+import { Effect, Ref } from "effect";
+import type { Scope } from "effect";
+import type { Address } from "../protocol/index.js";
+import type { GatewayFault } from "./fault.js";
+import type { Access, Principal, SecurityService } from "./security.js";
+export declare const authenticate: (security: SecurityService, request: Parameters<SecurityService["authenticate"]>[0]) => Effect.Effect<Principal, GatewayFault>;
+export declare const authorize: (security: SecurityService, principal: Principal, access: Access) => Effect.Effect<void, GatewayFault>;
+export declare const admit: (security: SecurityService, principal: Principal, access: Access) => Effect.Effect<void, GatewayFault>;
+export declare const assertTenant: (principal: Principal, address: Address) => Effect.Effect<void, GatewayFault>;
+export declare const leaseConnection: (connections: Ref.Ref<ReadonlyMap<string, number>>, principal: Principal, maximum: number) => Effect.Effect<void, GatewayFault, Scope.Scope>;
+export declare const recheck: (security: SecurityService, request: Parameters<SecurityService["authenticate"]>[0], initial: Principal, access?: Access) => Effect.Effect<void, GatewayFault>;

package/dist/gateway/access.js

@@ -0,0 +1,38 @@
+import { Effect, Ref } from "effect";
+import { validateRequestId } from "./http/validation.js";
+import { overloaded, unauthenticated, unauthorized } from "./fault.js";
+import { connectionKey } from "./security.js";
+export const authenticate = (security, request) => security.authenticate(request).pipe(Effect.mapError(() => unauthenticated()), Effect.flatMap((principal) => Effect.all([
+    validateRequestId(principal.subject).pipe(Effect.mapError(() => unauthenticated())),
+    validateRequestId(principal.tenant).pipe(Effect.mapError(() => unauthenticated())),
+]).pipe(Effect.as(principal))));
+export const authorize = (security, principal, access) => security.authorize(principal, access).pipe(Effect.mapError(() => unauthorized()));
+export const admit = (security, principal, access) => security
+    .admit(principal, access)
+    .pipe(Effect.mapError((error) => overloaded(error.retryAfterMillis)));
+export const assertTenant = (principal, address) => principal.tenant === address.tenant ? Effect.void : Effect.fail(unauthorized());
+export const leaseConnection = (connections, principal, maximum) => Effect.acquireRelease(Ref.modify(connections, (current) => {
+    const key = connectionKey(principal);
+    const used = current.get(key) ?? 0;
+    if (used >= maximum)
+        return [false, current];
+    const next = new Map(current);
+    next.set(key, used + 1);
+    return [true, next];
+}), (leased) => leased
+    ? Ref.update(connections, (current) => {
+        const next = new Map(current);
+        const key = connectionKey(principal);
+        const used = next.get(key) ?? 0;
+        if (used <= 1)
+            next.delete(key);
+        else
+            next.set(key, used - 1);
+        return next;
+    })
+    : Effect.void).pipe(Effect.flatMap((leased) => (leased ? Effect.void : Effect.fail(overloaded(1_000)))));
+export const recheck = (security, request, initial, access) => authenticate(security, request).pipe(Effect.flatMap((current) => {
+    if (current.subject !== initial.subject || current.tenant !== initial.tenant)
+        return Effect.fail(unauthorized());
+    return access === undefined ? Effect.void : authorize(security, current, access);
+}));

package/dist/gateway/dispatch.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import type { Address, Json, Procedure, QueryResult as ActorQueryResult, WireReceipt as ActorWireReceipt } from "../protocol/index.js";
+import { QueryResult } from "../protocol/schemas.js";
+import type { GatewayFault } from "./fault.js";
+import type { Registry } from "./options.js";
+export declare const mapInputError: (error: unknown) => GatewayFault;
+export declare const validateAddress: (registry: Registry, address: Address) => Effect.Effect<Address, GatewayFault>;
+export declare const stateProcedure: (registry: Registry, address: Address, version: number, name: string, kind: "command" | "query") => Effect.Effect<Procedure, GatewayFault>;
+export declare const hostedProcedure: (registry: Registry, address: Address, version: number, name: string) => Effect.Effect<Procedure, GatewayFault>;
+export declare const validatePayload: (procedure: Procedure, payload: Json) => Effect.Effect<Json, GatewayFault>;
+export declare const validateReceipt: (procedure: Procedure, address: Address, receipt: ActorWireReceipt) => Effect.Effect<ActorWireReceipt, GatewayFault>;
+export declare const validateQueryResult: (procedure: Procedure, address: Address, result: ActorQueryResult<Json>) => Effect.Effect<(typeof QueryResult)["Type"], GatewayFault>;
+export declare const validateOutcome: (procedure: Procedure, value: Json) => Effect.Effect<Json, GatewayFault>;

package/dist/gateway/dispatch.js

@@ -0,0 +1,45 @@
+import { Effect } from "effect";
+import { CommandErrorSchema } from "../errors/index.js";
+import { addressId, boundary, decode, readCursor } from "../protocol/index.js";
+import { Outcome, QueryResult, Receipt as WireReceipt } from "../protocol/schemas.js";
+import { addressFrom, validatePublicName } from "./http/validation.js";
+import { invalidInput, isGatewayFault, notFound, unavailable, unsupportedVersion } from "./fault.js";
+export const mapInputError = (error) => isGatewayFault(error) ? error : invalidInput();
+export const validateAddress = (registry, address) => address.namespace === registry.options.namespace
+    ? boundary(() => addressId(address)).pipe(Effect.mapError(mapInputError), Effect.andThen(() => validatePublicName(address.actorType, registry.isPublicOperation).pipe(Effect.andThen(() => addressFrom(registry.options.namespace, address.tenant, address.actorType, address.key)))))
+    : Effect.fail(invalidInput());
+export const stateProcedure = (registry, address, version, name, kind) => {
+    const protocol = registry.get(address.actorType);
+    if (!protocol || protocol.kind !== "state")
+        return Effect.fail(notFound());
+    if (protocol.version !== version)
+        return Effect.fail(unsupportedVersion());
+    const procedure = registry.stateProcedure(address.actorType, name, kind);
+    return procedure === undefined ? Effect.fail(notFound()) : Effect.succeed(procedure);
+};
+export const hostedProcedure = (registry, address, version, name) => {
+    const protocol = registry.get(address.actorType);
+    if (!protocol || protocol.kind !== "hosted")
+        return Effect.fail(notFound());
+    if (protocol.version !== version)
+        return Effect.fail(unsupportedVersion());
+    const procedure = registry.hostedProcedure(address.actorType, name);
+    return procedure === undefined ? Effect.fail(notFound()) : Effect.succeed(procedure);
+};
+export const validatePayload = (procedure, payload) => decode(procedure.payload, payload).pipe(Effect.as(payload), Effect.mapError(mapInputError));
+export const validateReceipt = (procedure, address, receipt) => decode(WireReceipt, receipt).pipe(Effect.flatMap((checked) => boundary(() => readCursor(address, checked.cursor)).pipe(Effect.mapError(() => unavailable()), Effect.flatMap(() => {
+    if (checked.value._tag === "Success") {
+        return decode(procedure.success, checked.value.value).pipe(Effect.as(checked));
+    }
+    const failure = checked.value.error;
+    return decode(CommandErrorSchema, failure).pipe(Effect.as(checked), Effect.matchEffect({
+        onFailure: () => decode(procedure.error, failure).pipe(Effect.as(checked)),
+        onSuccess: Effect.succeed,
+    }));
+}))), Effect.mapError(() => unavailable()));
+export const validateQueryResult = (procedure, address, result) => decode(QueryResult, result).pipe(Effect.flatMap((checked) => boundary(() => readCursor(address, checked.cursor)).pipe(Effect.mapError(() => unavailable()), Effect.flatMap(() => checked.value._tag === "Success"
+    ? decode(procedure.success, checked.value.value).pipe(Effect.as(checked))
+    : decode(procedure.error, checked.value.error).pipe(Effect.as(checked))))), Effect.mapError(() => unavailable()));
+export const validateOutcome = (procedure, value) => decode(Outcome, value).pipe(Effect.flatMap((checked) => checked._tag === "Success"
+    ? decode(procedure.success, checked.value).pipe(Effect.as(value))
+    : decode(procedure.error, checked.error).pipe(Effect.as(value))), Effect.mapError(() => unavailable()));

package/dist/gateway/fault.d.ts

@@ -0,0 +1,32 @@
+export type FaultCode = "InvalidInput" | "Unauthenticated" | "Unauthorized" | "NotFound" | "UnsupportedVersion" | "CommandConflict" | "RevisionConflict" | "CursorExpired" | "Overloaded" | "OutcomeUnknown" | "HostUnavailable" | "Unavailable" | "SlowConsumer";
+export interface GatewayFault {
+    readonly _tag: "GatewayFault";
+    readonly code: FaultCode;
+    readonly status: number;
+    readonly message: string;
+    readonly commandId?: string;
+    readonly expected?: string;
+    readonly actual?: string;
+    readonly retryAfterMillis?: number;
+}
+export declare const invalidInput: () => GatewayFault;
+export declare const unauthenticated: () => GatewayFault;
+export declare const unauthorized: () => GatewayFault;
+export declare const notFound: () => GatewayFault;
+export declare const unsupportedVersion: () => GatewayFault;
+export declare const cursorExpired: () => GatewayFault;
+export declare const unavailable: () => GatewayFault;
+export declare const slowConsumer: () => GatewayFault;
+export declare const overloaded: (retryAfterMillis: number) => GatewayFault;
+export declare const outcomeUnknown: (commandId: string) => GatewayFault;
+export declare const isGatewayFault: (value: unknown) => value is GatewayFault;
+export declare const fromServiceError: (error: unknown, commandId?: string) => GatewayFault;
+export interface SafeGatewayError {
+    readonly code: FaultCode;
+    readonly message: string;
+    readonly commandId?: string;
+    readonly expected?: string;
+    readonly actual?: string;
+    readonly retryAfterMillis?: number;
+}
+export declare const safeError: (fault: GatewayFault) => SafeGatewayError;

package/dist/gateway/fault.js

@@ -0,0 +1,85 @@
+const make = (code, status, message, fields = {}) => ({ _tag: "GatewayFault", code, status, message, ...fields });
+export const invalidInput = () => make("InvalidInput", 400, "Invalid request");
+export const unauthenticated = () => make("Unauthenticated", 401, "Authentication required");
+export const unauthorized = () => make("Unauthorized", 403, "Access denied");
+export const notFound = () => make("NotFound", 404, "Actor or operation was not found");
+export const unsupportedVersion = () => make("UnsupportedVersion", 400, "Unsupported protocol version");
+export const cursorExpired = () => make("CursorExpired", 410, "Event cursor has expired");
+export const unavailable = () => make("Unavailable", 503, "Service temporarily unavailable");
+export const slowConsumer = () => make("SlowConsumer", 503, "Event consumer is too slow");
+export const overloaded = (retryAfterMillis) => make("Overloaded", 429, "Request overloaded", { retryAfterMillis });
+export const outcomeUnknown = (commandId) => make("OutcomeUnknown", 503, "Command outcome is unknown", { commandId });
+export const isGatewayFault = (value) => typeof value === "object" &&
+    value !== null &&
+    value._tag === "GatewayFault";
+const errorTag = (error) => typeof error === "object" &&
+    error !== null &&
+    typeof error._tag === "string"
+    ? error._tag
+    : undefined;
+const stringField = (error, key) => {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const value = error[key];
+    return typeof value === "string" ? value : undefined;
+};
+const numberField = (error, key) => {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const value = error[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+};
+export const fromServiceError = (error, commandId) => {
+    if (isGatewayFault(error))
+        return error;
+    switch (errorTag(error)) {
+        case "effect-actors/InvalidInput":
+            return invalidInput();
+        case "effect-actors/Unauthorized":
+            return unauthorized();
+        case "effect-actors/Overloaded":
+            return overloaded(numberField(error, "retryAfterMillis") ?? 1_000);
+        case "effect-actors/UnsupportedVersion":
+            return unsupportedVersion();
+        case "effect-actors/CommandConflict": {
+            const conflictedCommandId = stringField(error, "commandId") ?? commandId;
+            return conflictedCommandId === undefined
+                ? make("CommandConflict", 409, "Command identity conflicts with existing input")
+                : make("CommandConflict", 409, "Command identity conflicts with existing input", {
+                    commandId: conflictedCommandId,
+                });
+        }
+        case "effect-actors/RevisionConflict": {
+            const expected = stringField(error, "expected");
+            const actual = stringField(error, "actual");
+            if (expected !== undefined && actual !== undefined) {
+                return make("RevisionConflict", 409, "Revision conflict", { expected, actual });
+            }
+            if (expected !== undefined)
+                return make("RevisionConflict", 409, "Revision conflict", { expected });
+            return actual === undefined
+                ? make("RevisionConflict", 409, "Revision conflict")
+                : make("RevisionConflict", 409, "Revision conflict", { actual });
+        }
+        case "effect-actors/CursorExpired":
+            return cursorExpired();
+        case "effect-actors/OutcomeUnknown":
+            return outcomeUnknown(stringField(error, "commandId") ?? commandId ?? "");
+        case "effect-actors/HostUnavailable":
+            return make("HostUnavailable", 503, "Hosted actor is unavailable");
+        case "effect-actors/StorageUnavailable":
+        case "effect-actors/OwnershipLost":
+        case "effect-actors/MigrationRejected":
+            return unavailable();
+        default:
+            return unavailable();
+    }
+};
+export const safeError = (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 }),
+});

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

@@ -0,0 +1,8 @@
+import { Effect, Stream } from "effect";
+import type { Scope } from "effect";
+import type { Service as ClientService } from "../../client/service.js";
+import type { Event as ActorEvent, Json, JsonSchema } from "../../protocol/index.js";
+import type { GatewayFault } from "../fault.js";
+import type { Options } from "../options.js";
+export declare const boundedEvents: (client: ClientService, address: Parameters<ClientService["events"]>[0], after: string, eventSchema: JsonSchema, options: Options, recheck: Effect.Effect<void, GatewayFault>) => Effect.Effect<Stream.Stream<ActorEvent<Json>, GatewayFault>, never, Scope.Scope>;
+export declare const sseBody: (events: Stream.Stream<ActorEvent<Json>, GatewayFault>) => Stream.Stream<Uint8Array>;