@akterjs/sdk 0.0.0-stage → 0.1.1

package/dist/actor/plain-compile.contract.d.mts

@@ -0,0 +1,100 @@
+import { DeclaredError, ErrorCodec } from "./plain-error.schema.mjs";
+import { ActorContract, ActorOptions, CommandRef, JobRef, StateFields } from "./plain-types.contract.mjs";
+import { JsonCodec, KeyCodec, StateCodec } from "./standard-schema.schema.mjs";
+import { Option, Schema } from "effect";
+import { Actor, ActorHistory, Akter, Command, DefinitionOf, FileAccess, Implementation, Query } from "@akterjs/effect/contract";
+/** A payload or reply: a bridged validator, or nothing for a member declared without one. */
+type ValueCodec = JsonCodec | typeof Schema.Void;
+interface ErasedJobDeclaration {
+  readonly error: ErrorCodec;
+  readonly patches: readonly string[];
+  readonly payload: {
+    readonly input: ValueCodec;
+  };
+  readonly success: ValueCodec;
+}
+type ErasedCommand = Command<ValueCodec, ValueCodec, ErrorCodec, never>;
+type ErasedQuery = Query<ValueCodec, ValueCodec, ErrorCodec, never>;
+declare const erasedJob: (declaration: ErasedJobDeclaration) => ReturnType<typeof Akter.job<ErasedJobDeclaration>>;
+type ErasedJob = ReturnType<typeof erasedJob>;
+declare const PrincipalFields: Schema.StructWithRest<Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "PrincipalId">;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+type PrincipalCodec = Schema.Codec<typeof PrincipalFields.Type, Schema.Json>;
+interface ErasedMembers {
+  readonly callers: Readonly<Record<string, PrincipalCodec>>;
+  readonly commands: Readonly<Record<`command ${string}`, ErasedCommand>>;
+  readonly files: FileAccess;
+  readonly jobs: Readonly<Record<`job ${string}`, ErasedJob>>;
+  readonly key: KeyCodec;
+  readonly queries: Readonly<Record<`query ${string}`, ErasedQuery>>;
+  readonly state: StateCodec;
+}
+interface WithInitial extends ErasedMembers {
+  readonly initial: () => StateFields;
+}
+interface WithCreate extends ErasedMembers {
+  readonly create: JsonCodec;
+}
+type InitialDefinition = DefinitionOf<WithInitial>;
+type InitialActor = Actor<string, DefinitionOf<WithInitial>> & ActorHistory<DefinitionOf<WithInitial>>;
+type CreateActor = Actor<string, DefinitionOf<WithCreate>> & ActorHistory<DefinitionOf<WithCreate>>;
+/** The Effect handlers an implementation compiles to. Both creation modes take the same command, query and result handlers. */
+type ErasedImplementation = Implementation<DefinitionOf<WithInitial>>;
+type CreateHandler = NonNullable<Implementation<DefinitionOf<WithCreate>>["create"]>;
+type Compiled = {
+  readonly actor: CreateActor;
+  readonly mode: "create";
+} | {
+  readonly actor: InitialActor;
+  readonly mode: "initial";
+};
+/** One actor compiled to the Effect SDK, with what the handler bridge needs besides the Effect actor. */
+interface Compilation {
+  readonly compiled: Compiled;
+  readonly contract: ActorContract;
+  readonly errors: Readonly<Record<string, readonly DeclaredError[]>>;
+  readonly name: string;
+}
+/** What a client or app holds of an actor `Akter.make` defined. */
+interface DefinedActor {
+  readonly contract: ActorContract;
+  readonly name: string;
+}
+interface Naming {
+  readonly actor: string;
+  readonly member: string;
+}
+interface Target extends Naming {
+  readonly compilation: () => Compilation;
+}
+interface Membered {
+  readonly name: string;
+  readonly options: ActorOptions;
+}
+/** Compiles a plain actor declaration to `Akter.make`, refusing a declaration it cannot store as JSON. */
+declare const compile: (membered: Membered) => Compilation;
+interface Refs {
+  readonly commands: Readonly<Record<string, CommandRef>>;
+  readonly jobs: Readonly<Record<string, JobRef>>;
+}
+declare const refsOf: (compilation: () => Compilation, members: Membered) => Refs;
+declare const register: (actor: DefinedActor, compilation: Compilation) => void;
+type AddressedCommand = CreateActor["commands"][`command ${string}`] | InitialActor["commands"][`command ${string}`];
+type StartableJob = InitialActor["jobs"][`job ${string}`];
+declare const addressedOf: (compilation: Compilation, member: string) => Option.Option<AddressedCommand>;
+declare const startableOf: (compilation: Compilation, member: string) => Option.Option<StartableJob>;
+declare const compilationOf: (actor: DefinedActor) => Option.Option<Compilation>;
+declare const commandTargetOf: (ref: CommandRef) => Option.Option<Target>;
+declare const jobTargetOf: (ref: JobRef) => Option.Option<Target>;
+export declare const PlainCompiler: {
+  readonly addressedOf: typeof addressedOf;
+  readonly commandTargetOf: typeof commandTargetOf;
+  readonly compilationOf: typeof compilationOf;
+  readonly compile: typeof compile;
+  readonly jobTargetOf: typeof jobTargetOf;
+  readonly refsOf: typeof refsOf;
+  readonly register: typeof register;
+  readonly startableOf: typeof startableOf;
+};
+export type { AddressedCommand, Compilation, Compiled, CreateActor, CreateHandler, DefinedActor, ErasedImplementation, InitialActor, InitialDefinition, StartableJob, ValueCodec, WithCreate, WithInitial };

package/dist/actor/plain-compile.contract.mjs

@@ -0,0 +1,267 @@
+import { PlainErrors } from "./plain-error.schema.mjs";
+import { PlainFileAccesses } from "./resource/plain-file-access.contract.mjs";
+import { bridge, bridgeKey, bridgeState, refuse } from "./standard-schema.schema.mjs";
+import { Array, Option, Record, Schema, SchemaTransformation } from "effect";
+import { Akter } from "@akterjs/effect/contract";
+// src/actor/plain-compile.contract.ts
+const erasedJob = (declaration) => Akter.job(declaration);
+const PrincipalFields = Schema.StructWithRest(Schema.Struct({ id: Akter.PrincipalId }), [Schema.Record(Schema.String, Schema.Json)]);
+const nothing = {
+	codec: Schema.Void,
+	documents: Option.none()
+};
+const bridgedOrNothing = ({ declared, site }) => Option.match(Option.fromUndefinedOr(declared), {
+	onNone: () => nothing,
+	onSome: (validator) => {
+		const bridged = bridge({
+			site,
+			validator
+		});
+		return {
+			codec: bridged.codec,
+			documents: Option.some(bridged.documents)
+		};
+	}
+});
+const errorsOf = ({ actor, member }, classes) => Array.map(classes, (Class) => Option.getOrThrowWith(PlainErrors.declaredErrorOf(Class), () => refuse({
+	reasons: ["names an error class that Akter.error did not declare"],
+	site: {
+		actor,
+		member,
+		part: "errors"
+	}
+})));
+const errorContracts = (errors) => Record.fromEntries(Array.map(errors, (declared) => [declared.tag, declared.documents]));
+const memberContract = (payload, success, errors) => ({
+	errors: errorContracts(errors),
+	...Option.match(payload.documents, {
+		onNone: () => ({}),
+		onSome: (documents) => ({ payload: documents })
+	}),
+	...Option.match(success.documents, {
+		onNone: () => ({}),
+		onSome: (documents) => ({ success: documents })
+	})
+});
+const memberOf = (naming, options) => {
+	const payload = bridgedOrNothing({
+		declared: options.payload,
+		site: {
+			...naming,
+			part: "payload"
+		}
+	});
+	const success = bridgedOrNothing({
+		declared: options.success,
+		site: {
+			...naming,
+			part: "success"
+		}
+	});
+	const errors = errorsOf(naming, options.errors ?? []);
+	const callers = Option.match(Option.fromUndefinedOr(options.callers), {
+		onNone: () => ({}),
+		onSome: (kinds) => ({ callers: kinds })
+	});
+	return {
+		contract: {
+			...memberContract(payload, success, errors),
+			...callers
+		},
+		declaration: {
+			...callers,
+			error: PlainErrors.errorsCodec(errors),
+			payload: payload.codec,
+			success: success.codec
+		},
+		errors
+	};
+};
+const erasedCommand = (declaration) => Akter.command(declaration);
+const erasedQuery = (declaration) => Akter.query(declaration);
+const principalCodec = (validator, site) => bridge({
+	site,
+	validator
+}).codec.pipe(Schema.decodeTo(PrincipalFields, SchemaTransformation.passthrough({ strict: false })));
+const userPrincipal = Akter.Principal.pipe(Schema.decodeTo(PrincipalFields, SchemaTransformation.passthrough({ strict: false })));
+const commandTargets = /* @__PURE__ */ new WeakMap();
+const jobTargets = /* @__PURE__ */ new WeakMap();
+const callerSite = (actor, caller) => ({
+	actor,
+	member: caller,
+	part: "principal"
+});
+const contractOf = ({ name, options }, members) => ({
+	callers: Record.map(options.callers ?? {}, (validator, caller) => bridge({
+		site: callerSite(name, caller),
+		validator
+	}).documents),
+	commands: Record.map(members.commands, (member) => member.contract),
+	...Option.match(members.create, {
+		onNone: () => ({}),
+		onSome: (create) => ({ create: create.documents })
+	}),
+	jobs: Record.map(members.jobs, (member) => member.contract),
+	key: members.key.documents,
+	name,
+	queries: Record.map(members.queries, (member) => member.contract),
+	state: members.state.documents
+});
+const jobOf = (naming, options) => memberOf(naming, options);
+const membersOf = ({ name, options }) => ({
+	commands: Record.map(options.commands, (command, member) => memberOf({
+		actor: name,
+		member
+	}, command.options)),
+	create: Option.map(Option.fromUndefinedOr(options.create), (validator) => bridge({
+		site: {
+			actor: name,
+			member: "create",
+			part: "input"
+		},
+		validator
+	})),
+	jobs: Record.map(options.jobs ?? {}, (job, member) => jobOf({
+		actor: name,
+		member
+	}, job.options)),
+	key: bridgeKey({
+		site: {
+			actor: name,
+			member: "key",
+			part: "key"
+		},
+		validator: options.key
+	}),
+	queries: Record.map(options.queries ?? {}, (query, member) => memberOf({
+		actor: name,
+		member
+	}, query.options)),
+	state: bridgeState({
+		site: {
+			actor: name,
+			member: "state",
+			part: "state"
+		},
+		validator: options.state
+	})
+});
+const erasedMembers = ({ name, options }, members) => ({
+	callers: Option.match(Option.fromUndefinedOr(options.callers), {
+		onNone: () => ({ user: userPrincipal }),
+		onSome: (callers) => Record.map(callers, (validator, caller) => principalCodec(validator, callerSite(name, caller)))
+	}),
+	commands: Record.map(members.commands, (declared) => erasedCommand(declared.declaration)),
+	files: PlainFileAccesses.compiledFileAccess(options.files),
+	jobs: Record.map(members.jobs, (declared, member) => erasedJob({
+		error: declared.declaration.error,
+		patches: Option.match(Record.get(options.jobs ?? {}, member), {
+			onNone: () => [],
+			onSome: (job) => job.options.patches ?? []
+		}),
+		payload: { input: declared.declaration.payload },
+		success: declared.declaration.success
+	})),
+	key: members.key.codec,
+	queries: Record.map(members.queries, (declared) => erasedQuery(declared.declaration)),
+	state: members.state.codec
+});
+const makeInitial = (name, options) => Akter.make(name, options);
+const makeCreate = (name, options) => Akter.make(name, options);
+const compiledOf = (membered, members) => {
+	const erased = erasedMembers(membered, members);
+	const creation = {
+		actor: membered.name,
+		member: "create",
+		part: "options"
+	};
+	const initial = Option.fromUndefinedOr(membered.options.initial);
+	if (Option.isSome(initial) && Option.isSome(members.create)) throw refuse({
+		reasons: ["declare initial or create, not both"],
+		site: creation
+	});
+	if (Option.isSome(initial)) return {
+		actor: makeInitial(membered.name, {
+			...erased,
+			initial: initial.value
+		}),
+		mode: "initial"
+	};
+	if (Option.isSome(members.create)) return {
+		actor: makeCreate(membered.name, {
+			...erased,
+			create: members.create.value.codec
+		}),
+		mode: "create"
+	};
+	throw refuse({
+		reasons: ["declare initial or create"],
+		site: creation
+	});
+};
+/** Compiles a plain actor declaration to `Akter.make`, refusing a declaration it cannot store as JSON. */
+const compile = (membered) => {
+	const members = membersOf(membered);
+	return {
+		compiled: compiledOf(membered, members),
+		contract: contractOf(membered, members),
+		errors: Record.map({
+			...members.commands,
+			...members.queries,
+			...members.jobs
+		}, (member) => member.errors),
+		name: membered.name
+	};
+};
+const refsOf = (compilation, members) => ({
+	commands: Record.map(members.options.commands, (_command, member) => {
+		const ref = {
+			actor: members.name,
+			member
+		};
+		commandTargets.set(ref, {
+			actor: members.name,
+			compilation,
+			member
+		});
+		return ref;
+	}),
+	jobs: Record.map(members.options.jobs ?? {}, (_job, member) => {
+		const ref = {
+			actor: members.name,
+			member
+		};
+		jobTargets.set(ref, {
+			actor: members.name,
+			compilation,
+			member
+		});
+		return ref;
+	})
+});
+const compilations = /* @__PURE__ */ new WeakMap();
+const register = (actor, compilation) => {
+	compilations.set(actor, compilation);
+};
+const addressedOf = (compilation, member) => {
+	const commands = compilation.compiled.actor.commands;
+	return Record.get(commands, member);
+};
+const startableOf = (compilation, member) => {
+	const jobs = compilation.compiled.actor.jobs;
+	return Record.get(jobs, member);
+};
+const compilationOf = (actor) => Option.fromUndefinedOr(compilations.get(actor));
+const commandTargetOf = (ref) => Option.fromUndefinedOr(commandTargets.get(ref));
+const jobTargetOf = (ref) => Option.fromUndefinedOr(jobTargets.get(ref));
+const PlainCompiler = {
+	addressedOf,
+	commandTargetOf,
+	compilationOf,
+	compile,
+	jobTargetOf,
+	refsOf,
+	register,
+	startableOf
+};
+export { PlainCompiler };

package/dist/actor/plain-definition.errors.d.mts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+declare const PlainDefinitionError_base: Schema.Class<PlainDefinitionError, Schema.TaggedStruct<"PlainDefinitionError", {
+  readonly actor: Schema.String;
+  readonly member: Schema.String;
+  readonly message: Schema.String;
+  readonly part: Schema.String;
+  readonly reasons: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class PlainDefinitionError extends PlainDefinitionError_base {}
+export {};

package/dist/actor/plain-definition.errors.mjs

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+// src/actor/plain-definition.errors.ts
+var PlainDefinitionError = class extends Schema.TaggedError()("PlainDefinitionError", {
+	actor: Schema.String,
+	member: Schema.String,
+	message: Schema.String,
+	part: Schema.String,
+	reasons: Schema.Array(Schema.String)
+}) {};
+export { PlainDefinitionError };

package/dist/actor/plain-error.schema.d.mts

@@ -0,0 +1,25 @@
+import { JsonNode } from "./json-document.schema.mjs";
+import { Documents } from "./standard-schema.schema.mjs";
+import { AnyErrorClass, ErrorInput, ErrorOutput, PlainErrorClass, Validator } from "./plain-types.contract.mjs";
+import { Option, Schema } from "effect";
+/** An error a plain handler throws: its class's instance, tagged on the wire. */
+type PlainFailure = Error & {
+  readonly _tag: string;
+};
+type ErrorCodec = Schema.Codec<PlainFailure, Schema.Json>;
+type ErrorConstructor = new (fields: JsonNode) => PlainFailure;
+interface DeclaredError {
+  readonly Class: ErrorConstructor;
+  readonly codec: ErrorCodec;
+  readonly documents: Documents;
+  readonly tag: string;
+}
+declare function error<const Tag extends string, Fields extends Validator | undefined = undefined>(tag: Tag, fields?: Fields): PlainErrorClass<Tag, ErrorInput<Fields>, ErrorOutput<Fields>>;
+declare const declaredErrorOf: (Class: AnyErrorClass) => Option.Option<DeclaredError>;
+declare const errorsCodec: (declared: readonly DeclaredError[]) => ErrorCodec;
+export declare const PlainErrors: {
+  readonly declaredErrorOf: typeof declaredErrorOf;
+  readonly error: typeof error;
+  readonly errorsCodec: typeof errorsCodec;
+};
+export type { DeclaredError, ErrorCodec, PlainFailure };

package/dist/actor/plain-error.schema.mjs

@@ -0,0 +1,90 @@
+import { documentsOf, noFields, refuse, validating } from "./standard-schema.schema.mjs";
+import { Array, Data, Effect, Option, Record, Schema, SchemaIssue, SchemaTransformation, pipe } from "effect";
+// src/actor/plain-error.schema.ts
+const declaredErrors = /* @__PURE__ */ new WeakMap();
+const isStrings = Schema.is(Schema.Array(Schema.String));
+const isJsonObject = Schema.is(Schema.JsonObject);
+const objectOf = (node) => Option.liftPredicate(node, isJsonObject);
+const taggedDocument = (tag, document) => {
+	const properties = pipe(Record.get(document, "properties"), Option.flatMap(objectOf), Option.getOrElse(() => ({})));
+	const required = pipe(Record.get(document, "required"), Option.filter(isStrings), Option.getOrElse(() => []));
+	return {
+		...document,
+		properties: {
+			...properties,
+			_tag: {
+				const: tag,
+				type: "string"
+			}
+		},
+		required: Array.prepend(required, "_tag")
+	};
+};
+const issue = (message, input) => new SchemaIssue.InvalidValue({ message }, Option.some(input));
+const fieldsOf = (tag, json) => Effect.mapError(Effect.fromOption(objectOf(json)), () => issue(`${tag}'s fields must be a JSON object`, json));
+const taggedFields = (tag) => (json) => Effect.flatMap(fieldsOf(tag, json), (object) => {
+	if (Option.contains(Record.get(object, "_tag"), tag)) return Effect.succeed(Record.remove(object, "_tag"));
+	return Effect.fail(issue(`expected _tag ${tag}`, json));
+});
+const definedClass = (tag) => class extends Data.TaggedError(tag) {
+	constructor(fields) {
+		super(fields);
+		this.name = tag;
+	}
+};
+const declare = ({ fields, tag }) => {
+	const Class = definedClass(tag);
+	const site = {
+		actor: tag,
+		member: "error",
+		part: "fields"
+	};
+	const documents = documentsOf({
+		site,
+		validator: fields
+	});
+	const check = validating(fields);
+	if (!Option.contains(Record.get(documents.output, "type"), "object")) throw refuse({
+		reasons: ["an error's fields must be an object"],
+		site
+	});
+	const output = taggedDocument(tag, documents.output);
+	return {
+		Class,
+		codec: Schema.Json.check(Schema.makeFilter(() => true, { toJsonSchema: () => output })).pipe(Schema.decodeTo(Schema.instanceOf(Class), SchemaTransformation.transformEffect({
+			decode: (json) => taggedFields(tag)(json).pipe(Effect.flatMap(check), Effect.flatMap((checked) => fieldsOf(tag, checked)), Effect.map((value) => new Class(value))),
+			encode: (instance) => Effect.map(Effect.flatMap(check(instance), (checked) => fieldsOf(tag, checked)), (value) => ({
+				...value,
+				_tag: tag
+			}))
+		}))),
+		documents: {
+			input: taggedDocument(tag, documents.input),
+			output
+		},
+		tag
+	};
+};
+function error(tag, fields) {
+	const declared = declare({
+		fields: fields ?? noFields,
+		tag
+	});
+	const Class = Object.assign(declared.Class, { _tag: tag });
+	declaredErrors.set(Class, declared);
+	return Class;
+}
+const declaredErrorOf = (Class) => Option.fromUndefinedOr(declaredErrors.get(Class));
+const errorsCodec = (declared) => Array.match(declared, {
+	onEmpty: () => Schema.Never,
+	onNonEmpty: (all) => Array.match(Array.tailNonEmpty(all), {
+		onEmpty: () => Array.headNonEmpty(all).codec,
+		onNonEmpty: () => Schema.Union(Array.map(all, (each) => each.codec))
+	})
+});
+const PlainErrors = {
+	declaredErrorOf,
+	error,
+	errorsCodec
+};
+export { PlainErrors };

package/dist/actor/plain-handlers.contract.d.mts

@@ -0,0 +1,87 @@
+import { FileRequest } from "./resource/plain-file-access.contract.mjs";
+import { DefinedActor, ErasedImplementation, ValueCodec } from "./plain-compile.contract.mjs";
+import { Computers } from "./resource/plain-computers.contract.mjs";
+import { Delay, Sql } from "./plain-values.contract.mjs";
+import { Files, ReadingFiles } from "./resource/plain-files.contract.mjs";
+import { DeclaredError, PlainFailure } from "./plain-error.schema.mjs";
+import { CommandRef, FinishedJob, JobRef, JobResult, JobStep, Migrations as Migrations$1, StateFields, Validator } from "./plain-types.contract.mjs";
+import { Effect, Exit, Schema } from "effect";
+import { Akter, Migrations } from "@akterjs/effect/contract";
+import { DurableDeferred } from "effect/workflow";
+type CommandScope = Akter["Service"];
+type CommandServices = Effect.Services<ReturnType<ErasedImplementation["commands"][`command ${string}`]>>;
+type Run = <Success, Failure>(effect: Effect.Effect<Success, Failure, CommandServices>) => Success;
+type ReadRun = <Success, Failure>(effect: Effect.Effect<Success, Failure, Akter>) => Success;
+/** A payload or reply as the engine hands it over: a JSON value, or nothing for a member declared without one. */
+type Value = ValueCodec["Type"];
+/** The context every plain command, query, create and result handler is called with, before the facade types it per actor. */
+interface ErasedContext {
+  readonly cancel?: (timer: string) => void;
+  /** A command's and a result handler's `Files`; a query's `ReadingFiles`. */
+  readonly files?: Files | ReadingFiles;
+  readonly id?: () => string;
+  readonly key: CommandScope["key"];
+  readonly now?: () => number;
+  readonly principal: CommandScope["principal"];
+  readonly schedule?: (delay: Delay, command: CommandRef, ...payload: readonly Schema.Json[]) => string;
+  readonly send?: (command: CommandRef, key: string, ...payload: readonly Schema.Json[]) => void;
+  readonly signal?: (job: string, name: string, value: Schema.Json) => void;
+  readonly sql: Sql;
+  readonly start?: (job: JobRef, ...payload: readonly Schema.Json[]) => string;
+  readonly state?: StateFields;
+  readonly update?: (patch: StateFields) => void;
+}
+type Handler = (ctx: ErasedContext, payload: Value) => Value;
+type CreateHandler = (ctx: ErasedContext, input: Schema.Json) => StateFields;
+interface ErasedSteps {
+  readonly computer: (actor: DefinedActor, key: string) => Computers;
+  readonly patched: (name: string) => boolean;
+  readonly run: (name: string, execute: (step: JobStep) => Promise<Schema.Json>) => Promise<Schema.Json>;
+  readonly sleep: (name: string, delay: Delay) => Promise<void>;
+  readonly waitFor: (name: string) => Promise<Schema.Json>;
+}
+type JobHandler = (payload: Value, steps: ErasedSteps) => Promise<Value>;
+type ResultHandler = (ctx: ErasedContext, result: JobResult<Value, PlainFailure>, job: FinishedJob) => void;
+interface StateUpgrade {
+  readonly from: Validator<StateFields, StateFields>;
+  readonly upgrade: (stored: StateFields) => StateFields;
+}
+/** A plain implementation with its handlers' types erased; the actor's `implement` types it. */
+interface PlainHandlers {
+  readonly commands: Readonly<Record<string, Handler>>;
+  readonly create?: CreateHandler;
+  readonly files?: {
+    readonly authorize: (ctx: ErasedContext, request: FileRequest) => boolean;
+  };
+  readonly jobs?: Readonly<Record<string, JobHandler>>;
+  readonly migrations?: Migrations$1;
+  readonly queries?: Readonly<Record<string, Handler>>;
+  readonly results?: Readonly<Record<string, ResultHandler>>;
+  readonly state?: StateUpgrade;
+}
+declare const sqlOf: (scope: CommandScope, run: ReadRun) => Sql;
+/** What a handler threw: a declared error fails the call, anything else is a defect. */
+declare const failureOf: (errors: readonly DeclaredError[], cause: unknown) => Effect.Effect<never, PlainFailure>;
+/** Runs a handler: a declared error it throws fails the call; anything else it throws, or a Promise it returns, is a defect. */
+declare const settle: <Returned>(errors: readonly DeclaredError[], call: () => Returned) => Effect.Effect<Returned, PlainFailure>;
+/** The durable deferred a plain job waits on with `steps.waitFor(name)` and a command fills with `ctx.signal`. */
+declare const signalNamed: (name: string) => DurableDeferred.DurableDeferred<typeof Schema.Json>;
+interface Contexting {
+  readonly run: Run;
+  readonly scope: CommandScope;
+  readonly state: StateFields;
+  readonly update: (patch: StateFields) => void;
+}
+declare const commandContext: ({ run, scope, state, update }: Contexting) => ErasedContext;
+declare const migrationsOf: (migrations: Migrations$1) => Migrations;
+declare const jobResultOf: (exit: Exit.Exit<Value, PlainFailure>) => JobResult<Value, PlainFailure>;
+export declare const PlainHandlerBridge: {
+  readonly commandContext: typeof commandContext;
+  readonly failureOf: typeof failureOf;
+  readonly jobResultOf: typeof jobResultOf;
+  readonly migrationsOf: typeof migrationsOf;
+  readonly settle: typeof settle;
+  readonly signalNamed: typeof signalNamed;
+  readonly sqlOf: typeof sqlOf;
+};
+export type { CommandScope, ErasedContext, ErasedSteps, JobHandler, PlainHandlers, ReadRun, Run, Value };