@akterjs/effect 0.0.0-stage → 0.1.0

package/dist/contract/history/history-entry.pure.mjs

@@ -0,0 +1,95 @@
+import { ActorAlreadyExistsError } from "../actor/actor-already-exists.errors.mjs";
+import { Caller } from "../caller/caller.schema.mjs";
+import { jobResult } from "../command/command.contract.mjs";
+import { HandlerFailedError } from "../hosted/handler-failed.errors.mjs";
+import { exitCodec, jsonCodec } from "../json-codec.pure.mjs";
+import { Effect, Exit, HashMap, Option, Record, Schema, String } from "effect";
+// src/contract/history/history-entry.pure.ts
+const creationModes = HashMap.make(["akter.create", "create"], ["akter.ensure", "ensure"]);
+const resultPrefix = "akter.result.";
+const handlerFailure = Schema.decodeOption(Schema.fromJsonString(HandlerFailedError));
+const creationFailure = Schema.decodeOption(Schema.fromJsonString(Schema.Union([ActorAlreadyExistsError, HandlerFailedError])));
+const VoidExit = Schema.Exit(Schema.Void, Schema.Never, Schema.Defect());
+const voidExit = Schema.decodeEffect(jsonCodec(VoidExit));
+const callerOf = Schema.decodeEffect(jsonCodec(Caller));
+const placeOf = (entry) => ({
+	at: entry.at,
+	command: entry.command,
+	commandId: entry.commandId,
+	seq: entry.seq
+});
+const unreadable = (entry, reason) => ({
+	...placeOf(entry),
+	kind: "unreadable",
+	reason
+});
+const decodersOf = ({ definition, name }) => ({
+	commands: Record.map(definition.commands, (declaration) => ({
+		exit: Schema.decodeEffect(exitCodec(declaration)),
+		payload: Schema.decodeEffect(jsonCodec(declaration.payload))
+	})),
+	create: Schema.decodeEffect(jsonCodec(definition.create)),
+	jobs: Record.map(definition.jobs, (job) => Schema.decodeEffect(jsonCodec(jobResult(job)))),
+	name,
+	principals: Record.map(definition.callers, (schema) => Schema.decodeUnknownEffect(Schema.toCodecJson(schema)))
+});
+const exitOf = (failure, decode, text) => Option.match(failure(text), {
+	onNone: () => decode(text),
+	onSome: (failed) => Effect.succeed(Exit.fail(failed))
+});
+const principalOf = Effect.fnUntraced(function* principalOf({ principals }, entry) {
+	const caller = yield* callerOf(entry.principal);
+	const decode = Record.get(principals, caller.kind);
+	return {
+		kind: caller.kind,
+		principal: yield* Effect.transposeOption(Option.map(decode, (decoding) => decoding(caller.principal)))
+	};
+});
+const commandOf = Effect.fnUntraced(function* commandOf(decoders, entry) {
+	const command = Record.get(decoders.commands, entry.command);
+	if (Option.isNone(command)) return unreadable(entry, `${entry.command} is not a command of ${decoders.name}`);
+	const { kind, principal } = yield* principalOf(decoders, entry);
+	if (Option.isNone(principal)) return unreadable(entry, `${kind} is not a caller of ${decoders.name}`);
+	return {
+		...placeOf(entry),
+		exit: yield* exitOf(handlerFailure, command.value.exit, entry.exit),
+		kind: "recorded",
+		payload: yield* command.value.payload(entry.payload),
+		principal: principal.value
+	};
+});
+const createdOf = Effect.fnUntraced(function* createdOf(decoders, entry, mode) {
+	const { kind, principal } = yield* principalOf(decoders, entry);
+	if (Option.isNone(principal)) return unreadable(entry, `${kind} is not a caller of ${decoders.name}`);
+	return {
+		...placeOf(entry),
+		exit: yield* exitOf(creationFailure, voidExit, entry.exit),
+		kind: "created",
+		mode,
+		payload: yield* decoders.create(entry.payload),
+		principal: principal.value
+	};
+});
+const resultOf = Effect.fnUntraced(function* resultOf({ jobs, name }, entry, job) {
+	const result = Record.get(jobs, job);
+	if (Option.isNone(result)) return unreadable(entry, `${job} is not a job of ${name}`);
+	return {
+		...placeOf(entry),
+		exit: yield* exitOf(handlerFailure, voidExit, entry.exit),
+		job,
+		kind: "result",
+		result: yield* result.value(entry.payload)
+	};
+});
+const decodedOf = (decoders, entry) => {
+	const mode = HashMap.get(creationModes, entry.command);
+	if (Option.isSome(mode)) return createdOf(decoders, entry, mode.value);
+	if (String.startsWith(resultPrefix)(entry.command)) return resultOf(decoders, entry, String.slice(13)(entry.command));
+	return commandOf(decoders, entry);
+};
+const entryOf = (decoders) => (entry) => Effect.catchTag(decodedOf(decoders, entry), "SchemaError", (failure) => Effect.succeed(unreadable(entry, failure.message)));
+const decodeEntries = (source) => {
+	const decode = entryOf(decodersOf(source));
+	return (entries) => Effect.forEach(entries, decode);
+};
+export { decodeEntries };

package/dist/contract/hosted/handler-failed.errors.d.mts

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+declare const HandlerFailedError_base: Schema.Class<HandlerFailedError, Schema.TaggedStruct<"HandlerFailedError", {
+  readonly actor: Schema.String;
+  readonly member: Schema.String;
+  readonly message: Schema.String;
+  readonly platform: Schema.optionalKey<Schema.Literal<true>>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * A handler failed outside its declared error contract. `platform` is true when the failure was Akter's, not the
+ * handler's: a platform error such as `FilesUnavailableError` escaped it. Akter Cloud doesn't bill a call that ends
+ * with one. A handler's own failure, such as a statement its SQL got wrong, carries no `platform`.
+ */
+export declare class HandlerFailedError extends HandlerFailedError_base {}
+export {};

package/dist/contract/hosted/handler-failed.errors.mjs

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+// src/contract/hosted/handler-failed.errors.ts
+/**
+* A handler failed outside its declared error contract. `platform` is true when the failure was Akter's, not the
+* handler's: a platform error such as `FilesUnavailableError` escaped it. Akter Cloud doesn't bill a call that ends
+* with one. A handler's own failure, such as a statement its SQL got wrong, carries no `platform`.
+*/
+var HandlerFailedError = class extends Schema.TaggedError()("HandlerFailedError", {
+	actor: Schema.String,
+	member: Schema.String,
+	message: Schema.String,
+	platform: Schema.optionalKey(Schema.Literal(true))
+}) {};
+export { HandlerFailedError };

package/dist/contract/hosted/handler-failure.pure.d.mts

@@ -0,0 +1,21 @@
+import { HandlerFailedError } from "./handler-failed.errors.mjs";
+import { Context, Effect, Exit } from "effect";
+interface Failing {
+  readonly actor: string;
+  readonly member: string;
+  /** A query runs on a read-only connection, so a write in it fails as the plain SQLITE_READONLY: the handler's own. */
+  readonly query?: true;
+}
+/**
+ * Whether a failed SQL statement's own message reaches the caller. akter dev shows it. Akter Cloud's hosted runtime sets
+ * `logged`: the message names the app's tables, columns and constraints, so the host logs it under the command's id and
+ * the caller gets a generic message.
+ */
+declare const StatementDetail: Context.Reference<"logged" | "shown">;
+/** The message every engine gives a handler that writes an engine-owned `akter_*` table. */
+declare const engineOwnedRefusal: (table: string) => string;
+declare const rejectFailedStatement: {
+  (failing: Failing): <Success, Failure>(exit: Exit.Exit<Success, Failure>) => Effect.Effect<Exit.Exit<Success, Failure>, HandlerFailedError>;
+  <Success, Failure>(exit: Exit.Exit<Success, Failure>, failing: Failing): Effect.Effect<Exit.Exit<Success, Failure>, HandlerFailedError>;
+};
+export { StatementDetail, engineOwnedRefusal, rejectFailedStatement };

package/dist/contract/hosted/handler-failure.pure.mjs

@@ -0,0 +1,86 @@
+import { FilesUnavailableError } from "../file/files-unavailable.errors.mjs";
+import { HandlerFailedError } from "./handler-failed.errors.mjs";
+import { Array, Cause, Context, Effect, Exit, Option, Predicate, Record, Schema, String } from "effect";
+import { dual } from "effect/Function";
+import { SqlError } from "effect/sql";
+// src/contract/hosted/handler-failure.pure.ts
+const dataFirstArity = 2;
+const isHostFailure = Predicate.or(SqlError.isSqlError, Schema.is(FilesUnavailableError));
+/**
+* Whether a failed SQL statement's own message reaches the caller. akter dev shows it. Akter Cloud's hosted runtime sets
+* `logged`: the message names the app's tables, columns and constraints, so the host logs it under the command's id and
+* the caller gets a generic message.
+*/
+const StatementDetail = Context.Reference("@akterjs/effect/contract/hosted/handler-failure/StatementDetail", { defaultValue: () => "shown" });
+/** The message every engine gives a handler that writes an engine-owned `akter_*` table. */
+const engineOwnedRefusal = (table) => `${table} is engine-owned: a handler may read akter_* tables but never write them`;
+/** The engine's own refusal names only its own table, never the app's schema, so it reaches the caller as it is. */
+const isEngineRefusal = (failure) => String.includes(engineOwnedRefusal(""))(failure.message);
+const loggedStatement = "a SQL statement failed; its message is in the host's log under this command's id";
+/**
+* SQLite's primary result codes that mean the platform failed under the handler, not the handler's SQL: the disk or
+* the database file failed (IOERR, CORRUPT, NOTADB, CANTOPEN, READONLY, FULL; a store past its disk ceiling is refused
+* as StorageLimitError before this, so FULL here is the platform's sizing), the database was held elsewhere (BUSY,
+* LOCKED, PROTOCOL) or the host ran out of memory (NOMEM). Every other code, such as a constraint, a syntax error, a
+* mismatch or a misuse, is the handler's own failure. node:sqlite gives the extended code as `errcode`, whose low byte
+* is the primary code; Akter Cloud's native driver and Bun give its name as `code`, such as `SQLITE_IOERR_WRITE`. In a
+* query, the plain READONLY is the handler's: both engines run a query read-only, and SQLite refuses its write with
+* that code. An extended READONLY, such as READONLY_CANTLOCK or READONLY_DBMOVED, names the storage and stays the
+* platform's.
+*/
+const platformCodes = {
+	SQLITE_BUSY: 5,
+	SQLITE_CANTOPEN: 14,
+	SQLITE_CORRUPT: 11,
+	SQLITE_FULL: 13,
+	SQLITE_IOERR: 10,
+	SQLITE_LOCKED: 6,
+	SQLITE_NOMEM: 7,
+	SQLITE_NOTADB: 26,
+	SQLITE_PROTOCOL: 15,
+	SQLITE_READONLY: 8
+};
+/** An extended result code's primary code is its low byte. */
+const primaryCodes = 256;
+const NumberedCause = Schema.Struct({ errcode: Schema.Int });
+const NamedCause = Schema.Struct({ code: Schema.String });
+const platformNumbered = (cause) => Option.exists(Schema.decodeUnknownOption(NumberedCause)(cause), ({ errcode }) => Array.contains(Record.values(platformCodes), errcode % primaryCodes));
+const platformNamed = (cause) => Option.exists(Schema.decodeUnknownOption(NamedCause)(cause), ({ code }) => Array.some(Record.keys(platformCodes), (name) => code === name || String.startsWith(`${name}_`)(code)));
+/** The plain SQLITE_READONLY, with no extended code: what SQLite answers a write on a read-only connection. */
+const isPlainReadOnly = (cause) => Option.exists(Schema.decodeUnknownOption(NumberedCause)(cause), ({ errcode }) => errcode === platformCodes.SQLITE_READONLY) || Option.exists(Schema.decodeUnknownOption(NamedCause)(cause), ({ code }) => code === "SQLITE_READONLY");
+const isPlatformStatement = (failure, { query }) => {
+	const { cause } = failure.reason;
+	if (query === true && isPlainReadOnly(cause)) return false;
+	return platformNumbered(cause) || platformNamed(cause);
+};
+/** `platform: true` when the platform failed under the handler: its files were unavailable, or SQLite's storage failed. */
+const platformMark = (failure, failing) => {
+	if (Schema.is(FilesUnavailableError)(failure) || SqlError.isSqlError(failure) && isPlatformStatement(failure, failing)) return { platform: true };
+	return {};
+};
+const failedWith = Effect.fnUntraced(function* failedWith(failure, failing) {
+	const { actor, member } = failing;
+	const detail = yield* StatementDetail;
+	const mark = platformMark(failure, failing);
+	if (detail === "shown" || !SqlError.isSqlError(failure) || isEngineRefusal(failure)) return yield* HandlerFailedError.make({
+		actor,
+		member,
+		message: failure.message,
+		...mark
+	});
+	yield* Effect.logError(`${actor}.${member}: ${failure.message}`).pipe(Effect.annotateLogs({ member }));
+	return yield* HandlerFailedError.make({
+		actor,
+		member,
+		message: loggedStatement,
+		...mark
+	});
+});
+const rejectFailedStatement = dual(dataFirstArity, (exit, failing) => Exit.match(exit, {
+	onFailure: (cause) => Option.match(Option.filter(Cause.findErrorOption(cause), isHostFailure), {
+		onNone: () => Effect.succeed(exit),
+		onSome: (error) => failedWith(error, failing)
+	}),
+	onSuccess: () => Effect.succeed(exit)
+}));
+export { StatementDetail, engineOwnedRefusal, rejectFailedStatement };

package/dist/contract/hosted/hosted-actor.service.d.mts

@@ -0,0 +1,23 @@
+import { ActorDefinition, HostedActor, Implementation, StateOf } from "../actor/actor.contract.mjs";
+import { HostedCommand } from "./hosted-command.service.mjs";
+import { HostedCreate } from "./hosted-create.service.mjs";
+import { HostedQuery } from "./hosted-query.service.mjs";
+import { ProvideScope } from "./hosted-request.pure.mjs";
+import { Context, Effect, Layer, Option } from "effect";
+interface HostedSpec<Definition extends ActorDefinition> {
+  readonly definition: Definition;
+  readonly initial: Option.Option<() => StateOf<Definition>>;
+  readonly name: string;
+  readonly provide: ProvideScope;
+}
+declare const HostedActors_base: Context.ServiceClass<HostedActors, "@akterjs/effect/contract/hosted/hosted-actor.service/HostedActors", {
+  readonly register: <Definition extends ActorDefinition>(spec: HostedSpec<Definition>, implementation: Implementation<Definition>) => Effect.Effect<HostedActor>;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly register: <Definition extends ActorDefinition>(spec: HostedSpec<Definition>, implementation: Implementation<Definition>) => Effect.Effect<HostedActor>;
+  }, never, HostedCommand | HostedCreate | HostedQuery>;
+};
+export declare class HostedActors extends HostedActors_base {
+  static readonly layer: Layer.Layer<HostedActors, never, never>;
+}
+export {};

package/dist/contract/hosted/hosted-actor.service.mjs

@@ -0,0 +1,64 @@
+import { ActorRegistry } from "../actor/actor-registry.service.mjs";
+import { HostedCommand } from "./hosted-command.service.mjs";
+import { HostedCreate } from "./hosted-create.service.mjs";
+import { HostedQuery } from "./hosted-query.service.mjs";
+import "../actor/host-interface.pure.mjs";
+import { upgradeState } from "../state/state-migration.pure.mjs";
+import { stateReader } from "../state/state-read.pure.mjs";
+import { Context, Effect, Layer, Option } from "effect";
+// src/contract/hosted/hosted-actor.service.ts
+function hostedActor(runners, spec) {
+	return (implementation) => {
+		const parts = {
+			...spec,
+			implementation
+		};
+		return {
+			callers: spec.definition.callers,
+			fileAccess: spec.definition.fileAccess,
+			hostInterface: 1,
+			initial: spec.initial,
+			key: spec.definition.key,
+			migrations: implementation.migrations ?? {},
+			name: spec.name,
+			readState: stateReader({
+				callers: spec.definition.callers,
+				initial: spec.initial,
+				name: spec.name,
+				state: spec.definition.state
+			}),
+			runCommand: (request, environment) => runners.runCommand(parts, request, environment),
+			runCreate: (request, environment) => runners.runCreate(parts, request, environment),
+			runQuery: (request, environment) => runners.runQuery(parts, request, environment),
+			runResult: (request, environment) => runners.runResult(parts, request, environment),
+			secrets: spec.definition.secrets,
+			state: spec.definition.state,
+			upgradeState: (stored) => upgradeState(parts, stored)
+		};
+	};
+}
+var HostedActors = class extends Context.Service()("@akterjs/effect/contract/hosted/hosted-actor.service/HostedActors", { make: Effect.gen(function* makeHostedActors() {
+	const commands = yield* HostedCommand;
+	const runners = {
+		runCommand: commands.run,
+		runCreate: (yield* HostedCreate).run,
+		runQuery: (yield* HostedQuery).run,
+		runResult: commands.runResult
+	};
+	return { register: Effect.fnUntraced(function* register(spec, implementation) {
+		const hosted = hostedActor(runners, spec)(implementation);
+		const registry = yield* Effect.serviceOption(ActorRegistry);
+		yield* Option.match(registry, {
+			onNone: () => Effect.void,
+			onSome: (found) => found.register(hosted)
+		});
+		return hosted;
+	}) };
+}) }) {
+	static layer = Layer.effect(this, this.make).pipe(Layer.provide([
+		HostedCommand.layer,
+		HostedCreate.layer,
+		HostedQuery.layer
+	]));
+};
+export { HostedActors };

package/dist/contract/hosted/hosted-command.service.d.mts

@@ -0,0 +1,20 @@
+import { HostedOutcome } from "./hosted-outcome.contract.mjs";
+import { HostedError } from "./hosted-error.contract.mjs";
+import { CommandEnvironment, HostedRequest, HostedResult } from "../actor/actor.contract.mjs";
+import { ErasedParts } from "./hosted-request.pure.mjs";
+import { Context, Effect, Layer } from "effect";
+declare const runCommand: (parts: ErasedParts, request: HostedRequest, environment: CommandEnvironment) => Effect.Effect<HostedOutcome, HostedError, never>;
+declare const runResult: (parts: ErasedParts, request: HostedResult, environment: CommandEnvironment) => Effect.Effect<HostedOutcome, HostedError, never>;
+declare const HostedCommand_base: Context.ServiceClass<HostedCommand, "@akterjs/effect/contract/hosted/hosted-command.service/HostedCommand", {
+  readonly run: typeof runCommand;
+  readonly runResult: typeof runResult;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly run: typeof runCommand;
+    readonly runResult: typeof runResult;
+  }, never, never>;
+};
+export declare class HostedCommand extends HostedCommand_base {
+  static readonly layer: Layer.Layer<HostedCommand, never, never>;
+}
+export {};

package/dist/contract/hosted/hosted-command.service.mjs

@@ -0,0 +1,88 @@
+import { commandActorState, noJobs, noMessages, noSignals, noTimers, scopeOf } from "../state/actor-state.pure.mjs";
+import { rejectFailedStatement } from "./handler-failure.pure.mjs";
+import { prepare, prepareResult } from "./hosted-request.pure.mjs";
+import { exitCodec, jsonCodec } from "../json-codec.pure.mjs";
+import { Context, Effect, Exit, Layer, Option, Ref, Schema } from "effect";
+// src/contract/hosted/hosted-command.service.ts
+const nothingChanged = {
+	jobs: noJobs,
+	messages: noMessages,
+	signals: noSignals,
+	state: Option.none(),
+	timers: noTimers
+};
+const handle = Effect.fnUntraced(function* handle({ environment, member, parts, prepared }) {
+	const { changes, service } = yield* commandActorState({
+		actor: parts.name,
+		commands: parts.definition.commands,
+		environment,
+		jobs: parts.definition.jobs,
+		state: prepared.state
+	});
+	const execution = Effect.gen(function* execution() {
+		const value = yield* prepared.handler(prepared.state, prepared.payload);
+		const { cancelled, jobs, messages, scheduled, signals, state } = yield* Ref.get(changes);
+		return {
+			jobs,
+			messages,
+			signals,
+			text: yield* Effect.orDie(Schema.encodeEffect(jsonCodec(parts.definition.state))(state)),
+			timers: {
+				cancelled,
+				scheduled
+			},
+			value
+		};
+	});
+	const finished = yield* Effect.exit(parts.provide(execution, scopeOf({
+		environment,
+		principal: prepared.principal
+	}), service));
+	const exit = yield* rejectFailedStatement(finished, {
+		actor: parts.name,
+		member
+	});
+	const reply = yield* Effect.orDie(Schema.encodeEffect(exitCodec(prepared.declaration))(Exit.map(exit, (result) => result.value)));
+	return Exit.match(exit, {
+		onFailure: () => ({
+			...nothingChanged,
+			exit: reply
+		}),
+		onSuccess: (result) => ({
+			exit: reply,
+			jobs: result.jobs,
+			messages: result.messages,
+			signals: result.signals,
+			state: Option.some(result.text),
+			timers: result.timers
+		})
+	});
+});
+const runCommand = Effect.fn("HostedActor.runCommand")(function* runCommand(parts, request, environment) {
+	const prepared = yield* prepare(parts, {
+		declarations: parts.definition.commands,
+		handlers: parts.implementation.commands
+	}, request);
+	return yield* handle({
+		environment,
+		member: request.member,
+		parts,
+		prepared
+	});
+});
+const runResult = Effect.fn("HostedActor.runResult")(function* runResult(parts, request, environment) {
+	const prepared = yield* prepareResult(parts, request);
+	return yield* handle({
+		environment,
+		member: request.member,
+		parts,
+		prepared
+	});
+});
+var HostedCommand = class extends Context.Service()("@akterjs/effect/contract/hosted/hosted-command.service/HostedCommand", { make: Effect.succeed({
+	run: runCommand,
+	runResult
+}) }) {
+	static layer = Layer.effect(this, this.make);
+};
+export { HostedCommand };

package/dist/contract/hosted/hosted-create.service.d.mts

@@ -0,0 +1,17 @@
+import { HostedOutcome } from "./hosted-outcome.contract.mjs";
+import { HostedError } from "./hosted-error.contract.mjs";
+import { CommandEnvironment, HostedRequest } from "../actor/actor.contract.mjs";
+import { ErasedParts } from "./hosted-request.pure.mjs";
+import { Context, Effect, Layer } from "effect";
+declare const runCreate: (parts: ErasedParts, request: HostedRequest, environment: CommandEnvironment) => Effect.Effect<HostedOutcome, HostedError, never>;
+declare const HostedCreate_base: Context.ServiceClass<HostedCreate, "@akterjs/effect/contract/hosted/hosted-create.service/HostedCreate", {
+  readonly run: typeof runCreate;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly run: typeof runCreate;
+  }, never, never>;
+};
+export declare class HostedCreate extends HostedCreate_base {
+  static readonly layer: Layer.Layer<HostedCreate, never, never>;
+}
+export {};

package/dist/contract/hosted/hosted-create.service.mjs

@@ -0,0 +1,67 @@
+import { ActorAlreadyExistsError } from "../actor/actor-already-exists.errors.mjs";
+import { noJobs, noMessages, noSignals, noTimers, refusedActorState, scopeOf } from "../state/actor-state.pure.mjs";
+import { admit } from "../caller/caller-admission.pure.mjs";
+import { command } from "../command/command.contract.mjs";
+import { rejectFailedStatement } from "./handler-failure.pure.mjs";
+import { decodeRequest } from "./hosted-request.pure.mjs";
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { exitCodec, jsonCodec } from "../json-codec.pure.mjs";
+import { Context, Effect, Exit, Layer, Option, Schema } from "effect";
+// src/contract/hosted/hosted-create.service.ts
+const creation = command({ success: Schema.Void });
+const firstState = (parts, exit) => {
+	const encode = Schema.encodeEffect(jsonCodec(parts.definition.state));
+	return Effect.transposeOption(Option.map(Exit.getSuccess(exit), (state) => Effect.orDie(encode(state))));
+};
+const createdBy = Effect.fnUntraced(function* createdBy(parts, request, environment) {
+	const create = yield* Effect.mapError(Effect.fromOption(Option.fromNullishOr(parts.implementation.create)), () => InvalidRequestError.make({
+		actor: parts.name,
+		message: `${parts.name} has no create handler`
+	}));
+	const input = yield* decodeRequest({
+		actor: parts.name,
+		schema: parts.definition.create,
+		text: request.payload
+	});
+	const principal = yield* admit({
+		actor: parts.name,
+		allowed: Option.none(),
+		callers: parts.definition.callers,
+		member: request.member,
+		principal: request.principal
+	});
+	const finished = yield* Effect.exit(parts.provide(create(input), scopeOf({
+		environment,
+		principal
+	}), refusedActorState));
+	const exit = yield* rejectFailedStatement(finished, {
+		actor: parts.name,
+		member: request.member
+	});
+	const reply = yield* Effect.orDie(Schema.encodeEffect(exitCodec(creation))(Exit.asVoid(exit)));
+	const state = yield* firstState(parts, exit);
+	return {
+		exit: reply,
+		jobs: noJobs,
+		messages: noMessages,
+		signals: noSignals,
+		state,
+		timers: noTimers
+	};
+});
+const runCreate = Effect.fn("HostedActor.runCreate")(function* runCreate(parts, request, environment) {
+	if (Option.isNone(request.state)) return yield* createdBy(parts, request, environment);
+	if (request.member !== "ensure") return yield* ActorAlreadyExistsError.make({ actor: parts.name });
+	return {
+		exit: yield* Effect.orDie(Schema.encodeEffect(exitCodec(creation))(Exit.void)),
+		jobs: noJobs,
+		messages: noMessages,
+		signals: noSignals,
+		state: Option.none(),
+		timers: noTimers
+	};
+});
+var HostedCreate = class extends Context.Service()("@akterjs/effect/contract/hosted/hosted-create.service/HostedCreate", { make: Effect.succeed({ run: runCreate }) }) {
+	static layer = Layer.effect(this, this.make);
+};
+export { HostedCreate };

package/dist/contract/hosted/hosted-error.contract.d.mts

@@ -0,0 +1,11 @@
+import { ActorAlreadyExistsError } from "../actor/actor-already-exists.errors.mjs";
+import { ActorErasedError } from "../actor/actor-erased.errors.mjs";
+import { ActorNotCreatedError } from "../actor/actor-not-created.errors.mjs";
+import { CallerNotAllowedError } from "../caller/caller-not-allowed.errors.mjs";
+import { CommandIdExpiredError } from "../command/command-id-expired.errors.mjs";
+import { HandlerFailedError } from "./handler-failed.errors.mjs";
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { StateUnreadableError } from "../state/state-unreadable.errors.mjs";
+import { HostedOutcome } from "./hosted-outcome.contract.mjs";
+type HostedError = ActorAlreadyExistsError | ActorErasedError | ActorNotCreatedError | CallerNotAllowedError | CommandIdExpiredError | HandlerFailedError | InvalidRequestError;
+export type { HostedError, HostedOutcome, StateUnreadableError };

package/dist/contract/hosted/hosted-error.contract.mjs

@@ -0,0 +1 @@
+export {};

package/dist/contract/hosted/hosted-failure.schema.d.mts

@@ -0,0 +1,18 @@
+import { ActorErasedError } from "../actor/actor-erased.errors.mjs";
+import { ActorNotCreatedError } from "../actor/actor-not-created.errors.mjs";
+import { ActorUnavailableError } from "../client/actor-unavailable.errors.mjs";
+import { BillingUnavailableError } from "../spend/billing-unavailable.errors.mjs";
+import { CallerNotAllowedError } from "../caller/caller-not-allowed.errors.mjs";
+import { CommandIdExpiredError } from "../command/command-id-expired.errors.mjs";
+import { HandlerFailedError } from "./handler-failed.errors.mjs";
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { SpendCapReachedError } from "../spend/spend-cap-reached.errors.mjs";
+import { StorageLimitError } from "../client/storage-limit.errors.mjs";
+import "../client/client-failure.contract.mjs";
+import { Schema } from "effect";
+/**
+ * The failures any hosted member can answer besides its declared ones. Akter Cloud's gateway also answers
+ * `SpendCapReachedError` and `BillingUnavailableError` when it refuses new spend, and its hosts answer
+ * `StorageLimitError` when a write would grow storage past its ceiling, so clients decode those typed.
+ */
+export declare const HostedFailure: Schema.Union<readonly [typeof ActorErasedError, typeof ActorNotCreatedError, typeof ActorUnavailableError, typeof BillingUnavailableError, typeof CallerNotAllowedError, typeof CommandIdExpiredError, typeof HandlerFailedError, typeof InvalidRequestError, typeof SpendCapReachedError, typeof StorageLimitError]>;

package/dist/contract/hosted/hosted-failure.schema.mjs

@@ -0,0 +1,31 @@
+import { ActorErasedError } from "../actor/actor-erased.errors.mjs";
+import { ActorNotCreatedError } from "../actor/actor-not-created.errors.mjs";
+import { ActorUnavailableError } from "../client/actor-unavailable.errors.mjs";
+import { CallerNotAllowedError } from "../caller/caller-not-allowed.errors.mjs";
+import { CommandIdExpiredError } from "../command/command-id-expired.errors.mjs";
+import { HandlerFailedError } from "./handler-failed.errors.mjs";
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { BillingUnavailableError } from "../spend/billing-unavailable.errors.mjs";
+import { SpendCapReachedError } from "../spend/spend-cap-reached.errors.mjs";
+import { StorageLimitError } from "../client/storage-limit.errors.mjs";
+import "../client/client-failure.contract.mjs";
+import { Schema } from "effect";
+// src/contract/hosted/hosted-failure.schema.ts
+/**
+* The failures any hosted member can answer besides its declared ones. Akter Cloud's gateway also answers
+* `SpendCapReachedError` and `BillingUnavailableError` when it refuses new spend, and its hosts answer
+* `StorageLimitError` when a write would grow storage past its ceiling, so clients decode those typed.
+*/
+const HostedFailure = Schema.Union([
+	ActorErasedError,
+	ActorNotCreatedError,
+	ActorUnavailableError,
+	BillingUnavailableError,
+	CallerNotAllowedError,
+	CommandIdExpiredError,
+	HandlerFailedError,
+	InvalidRequestError,
+	SpendCapReachedError,
+	StorageLimitError
+]);
+export { HostedFailure };

package/dist/contract/hosted/hosted-outcome.contract.d.mts

@@ -0,0 +1,18 @@
+import { OutboxMessage } from "../command/outbox.schema.mjs";
+import { TimerChanges } from "../command/timer.schema.mjs";
+import { StartedJob } from "../job/started-job.schema.mjs";
+import { JobSignal } from "../job/job-signal.schema.mjs";
+import { Option } from "effect";
+interface HostedOutcome {
+  readonly exit: string;
+  readonly jobs: readonly StartedJob[];
+  readonly messages: readonly OutboxMessage[];
+  /**
+   * Signals to the actor's own jobs, stored with the command and woken once it commits. An app built with akter before
+   * Akter.signal leaves it out, and a host serves that build as signalling nothing.
+   */
+  readonly signals?: readonly JobSignal[] | undefined;
+  readonly state: Option.Option<string>;
+  readonly timers: TimerChanges;
+}
+export type { HostedOutcome };

package/dist/contract/hosted/hosted-outcome.contract.mjs

@@ -0,0 +1 @@
+export {};

package/dist/contract/hosted/hosted-query.service.d.mts

@@ -0,0 +1,16 @@
+import { HostedError } from "./hosted-error.contract.mjs";
+import { CommandEnvironment, HostedRequest } from "../actor/actor.contract.mjs";
+import { ErasedParts } from "./hosted-request.pure.mjs";
+import { Context, Effect, Layer } from "effect";
+declare const runQuery: (parts: ErasedParts, request: HostedRequest, environment: CommandEnvironment) => Effect.Effect<string, HostedError, never>;
+declare const HostedQuery_base: Context.ServiceClass<HostedQuery, "@akterjs/effect/contract/hosted/hosted-query.service/HostedQuery", {
+  readonly run: typeof runQuery;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly run: typeof runQuery;
+  }, never, never>;
+};
+export declare class HostedQuery extends HostedQuery_base {
+  static readonly layer: Layer.Layer<HostedQuery, never, never>;
+}
+export {};