@astrale-os/sdk 0.5.0-beta.99 → 0.6.0-beta.1

package/dist/application/mutation/authoring/builder.js

@@ -1,5 +1,5 @@
-import { LocalBinding } from '@astrale-os/kernel-core/graph/graph';
 import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { LocalAlias } from '../../../platform/graph/alias.js';
 import { endpoint, existingEndpoint } from './endpoint.js';
 import { precondition } from './precondition.js';
 import { conditions, delta, properties } from './properties.js';
@@ -33,7 +33,7 @@ export function richMutationBuilder(core) {
         expect: expectation,
         createNode(input) {
             const created = core.createNode({
-                as: LocalBinding(input.as),
+                as: LocalAlias(input.as),
                 class: classKey(input.class),
                 ...(input.props === undefined ? {} : { props: properties(input.class, input.props) }),
             });

package/dist/application/mutation/authoring/endpoint.d.ts

@@ -1,9 +1,9 @@
-import type { LocalBinding } from '@astrale-os/kernel-core/graph/graph';
 import type { NodeId } from '@astrale-os/kernel-core/graph/node';
 import type { NodeTarget } from '@astrale-os/kernel-core/path';
 import type { ResolvedClass } from '@astrale-os/kernel-dsl/v1';
+import type { LocalAlias } from '../../../platform/graph/alias.js';
 export interface CreatedNode<Class extends ResolvedClass<'node'> = ResolvedClass<'node'>> {
-    readonly created: LocalBinding;
+    readonly created: LocalAlias;
     readonly class: Class;
 }
 export type ExistingEndpoint = NodeTarget | Readonly<{
@@ -11,6 +11,6 @@ export type ExistingEndpoint = NodeTarget | Readonly<{
 }>;
 export type MutationEndpoint = ExistingEndpoint | CreatedNode;
 export declare function endpoint(input: MutationEndpoint): NodeTarget | {
-    readonly created: LocalBinding;
+    readonly created: LocalAlias;
 };
 export declare function existingEndpoint(input: ExistingEndpoint): NodeTarget;

package/dist/application/mutation/authoring/endpoint.js

@@ -1,13 +1,22 @@
 export function endpoint(input) {
+    if (isDefinitionRefCandidate(input))
+        return input;
     if (isCreated(input))
         return Object.freeze({ created: input.created });
     return existingEndpoint(input);
 }
 export function existingEndpoint(input) {
+    if (isDefinitionRefCandidate(input))
+        return input;
     return typeof input === 'object' && input !== null && 'id' in input
         ? input.id
         : input;
 }
+// Keep DefinitionRef candidates intact for Kernel admission: an extra id/created
+// field must not silently redirect the operation to a different Node.
+function isDefinitionRefCandidate(input) {
+    return typeof input === 'object' && input !== null && 'kind' in input;
+}
 function isCreated(input) {
     return typeof input === 'object' && input !== null && 'created' in input;
 }

package/dist/application/mutation/failure.js

@@ -26,9 +26,9 @@ export function mutationFailure(input) {
         const event = Reflect.get(input, 'event');
         if (typeof from !== 'string' || typeof event !== 'string' || explicit === false)
             return undefined;
-        return Object.assign(input, { code, outcomeKnown: true, from, event });
+        return input;
     }
-    return Object.assign(input, {
+    return Object.assign(new Error(input.message, { cause: input }), {
         code,
         outcomeKnown: explicit !== false && !UNKNOWN_OUTCOME_CODES.has(code),
     });
@@ -37,15 +37,21 @@ function mutationCode(input) {
     const value = input;
     if (value.code === 'STATE_TRANSITION_ILLEGAL')
         return value.code;
-    for (const candidate of [value.code, nestedCode(value.reason), nestedCode(value.data)]) {
+    for (const candidate of [
+        value.code,
+        directOrNestedCode(value.reason),
+        directOrNestedCode(value.data),
+    ]) {
         if (typeof candidate === 'string' && candidate.startsWith('MUTATION_')) {
             return candidate;
         }
     }
     return undefined;
 }
-function nestedCode(input) {
-    return input !== null && typeof input === 'object' && !Array.isArray(input)
-        ? Reflect.get(input, 'code')
-        : undefined;
+function directOrNestedCode(input) {
+    return typeof input === 'string'
+        ? input
+        : input !== null && typeof input === 'object' && !Array.isArray(input)
+            ? Reflect.get(input, 'code')
+            : undefined;
 }

package/dist/application/mutation/index.d.ts

@@ -5,3 +5,4 @@ export type { Mutation, MutationDefinition, MutationInputOf, MutationOutputOf }
 export type { CreatedNode, EdgeSelector, ExistingEndpoint, MutationEndpoint, QueryPrecondition, RichMutationBuilder, RichPropertyConditions, RichPropertyDelta, RichPropertyInput, RichPropertyName, } from './authoring/index.js';
 /** Canonical low-level Mutation documents remain available as the explicit escape hatch. */
 export * from '@astrale-os/kernel-core/graph/mutate';
+export type { LocalAlias, LocalBinding } from '../../platform/graph/alias.js';

package/dist/application/requirements/{profiles.d.ts → core.d.ts}

@@ -2,11 +2,13 @@ import type { ResolvedCoreDefinition } from '../../platform/schema/index.js';
 import type { AuthorityRequirementsInput } from './authority.js';
 import type { ClassRequirementInput } from './classes.js';
 import type { FunctionRequirementTarget } from './functions.js';
-import type { CapabilityProfileRequirement } from './requirement.js';
-export interface CapabilityProfileRequirementInput {
+import type { CoreRequirement } from './requirement.js';
+/** Capabilities assigned to one installation-owned local Core Identity. */
+export interface CoreRequirementInput {
     readonly subject: Pick<ResolvedCoreDefinition, 'ref'>;
+    /** Exact executable local callables or direct dependency callables; does not bypass Policies. */
     readonly functions?: readonly FunctionRequirementTarget[];
     readonly classes?: readonly ClassRequirementInput[];
     readonly authority?: AuthorityRequirementsInput;
 }
-export declare function captureProfiles(input: readonly CapabilityProfileRequirementInput[] | undefined): readonly CapabilityProfileRequirement[];
+export declare function captureCore(input: readonly CoreRequirementInput[] | undefined): readonly CoreRequirement[];

package/dist/application/requirements/{profiles.js → core.js}

@@ -2,12 +2,12 @@ import { acceptDefinitionRef, Key } from '../../platform/schema/index.js';
 import { captureAuthority } from './authority.js';
 import { captureClasses } from './classes.js';
 import { captureFunctions } from './functions.js';
-export function captureProfiles(input) {
+export function captureCore(input) {
     if (input === undefined)
         return Object.freeze([]);
     if (!Array.isArray(input))
-        throw new TypeError('Requirement profiles must be an array.');
-    const profiles = input.map((entry) => {
+        throw new TypeError('Core requirements must be an array.');
+    const core = input.map((entry) => {
         if (entry === null || typeof entry !== 'object' || Array.isArray(entry))
             invalid();
         if (Reflect.ownKeys(entry).some((key) => key !== 'subject' && key !== 'functions' && key !== 'classes' && key !== 'authority')) {
@@ -29,12 +29,12 @@ export function captureProfiles(input) {
             ...(authority === undefined ? {} : { authority }),
         });
     });
-    if (new Set(profiles.map(({ subject }) => Key.of(subject))).size !== profiles.length)
+    if (new Set(core.map(({ subject }) => Key.of(subject))).size !== core.length)
         invalid();
-    return Object.freeze([...profiles].sort((left, right) => compare(Key.of(left.subject), Key.of(right.subject))));
+    return Object.freeze([...core].sort((left, right) => compare(Key.of(left.subject), Key.of(right.subject))));
 }
 function invalid() {
-    throw new TypeError('Capability profile requirement is invalid.');
+    throw new TypeError('Core capability requirement is invalid.');
 }
 function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;

package/dist/application/requirements/index.d.ts

@@ -1,18 +1,18 @@
 import type { AuthorityRequirementsInput } from './authority.js';
 import type { ClassRequirementInput } from './classes.js';
+import type { CoreRequirementInput } from './core.js';
 import type { FunctionRequirementTarget } from './functions.js';
-import type { CapabilityProfileRequirementInput } from './profiles.js';
 import type { Requirements } from './requirement.js';
-export type { AuthorityRequirements, CapabilityProfileRequirement, ClassRequirement, Requirements, } from './requirement.js';
+export type { AuthorityRequirements, CoreRequirement, ClassRequirement, Requirements, } from './requirement.js';
 export { ClassOperationOrder, type ClassOperation, type ClassRequirementInput } from './classes.js';
 export type { FunctionRequirementTarget } from './functions.js';
 export type { AuthorityRequirementsInput } from './authority.js';
-export type { CapabilityProfileRequirementInput } from './profiles.js';
+export type { CoreRequirementInput } from './core.js';
 export interface RequirementsInput {
     readonly functions?: readonly FunctionRequirementTarget[];
     readonly classes?: readonly ClassRequirementInput[];
     readonly authority?: AuthorityRequirementsInput;
-    readonly profiles?: readonly CapabilityProfileRequirementInput[];
+    readonly core?: readonly CoreRequirementInput[];
 }
 /** Capture canonical dependency requirements; Build proves the pinned dependency closure. */
 export declare function requirements(input?: RequirementsInput): Requirements;

package/dist/application/requirements/index.js

@@ -1,24 +1,24 @@
 import { captureAuthority } from './authority.js';
 import { captureClasses } from './classes.js';
+import { captureCore } from './core.js';
 import { captureFunctions } from './functions.js';
-import { captureProfiles } from './profiles.js';
 export { ClassOperationOrder } from './classes.js';
 const admittedRequirements = new WeakSet();
 /** Capture canonical dependency requirements; Build proves the pinned dependency closure. */
 export function requirements(input = {}) {
     if (input === null || typeof input !== 'object' || Array.isArray(input))
         invalid();
-    if (Reflect.ownKeys(input).some((key) => key !== 'functions' && key !== 'classes' && key !== 'authority' && key !== 'profiles')) {
+    if (Reflect.ownKeys(input).some((key) => key !== 'functions' && key !== 'classes' && key !== 'authority' && key !== 'core')) {
         invalid();
     }
     const functions = captureFunctions(input.functions);
     const classes = captureClasses(input.classes);
     const authority = captureAuthority(input.authority);
-    const profiles = captureProfiles(input.profiles);
+    const core = captureCore(input.core);
     const value = Object.freeze({
         functions,
         classes,
-        profiles,
+        core,
         ...(authority === undefined ? {} : { authority }),
     });
     admittedRequirements.add(value);
@@ -28,5 +28,5 @@ export function isRequirements(input) {
     return input !== null && typeof input === 'object' && admittedRequirements.has(input);
 }
 function invalid() {
-    throw new TypeError('Requirements definition may contain only functions, classes, authority, and profiles.');
+    throw new TypeError('Requirements definition may contain only functions, classes, authority, and core.');
 }

package/dist/application/requirements/requirement.d.ts

@@ -14,9 +14,10 @@ export interface Requirements {
     readonly functions: readonly Key.Callable[];
     readonly classes: readonly ClassRequirement[];
     readonly authority?: AuthorityRequirements;
-    readonly profiles: readonly CapabilityProfileRequirement[];
+    readonly core: readonly CoreRequirement[];
 }
-export interface CapabilityProfileRequirement {
+/** Capabilities assigned at installation to one Identity declared in the local Core. */
+export interface CoreRequirement {
     readonly subject: CoreRef;
     readonly functions: readonly Key.Callable[];
     readonly classes: readonly ClassRequirement[];

package/dist/application/runtime/authoring.d.ts

@@ -3,3 +3,4 @@ export type { RuntimeInput } from './define.js';
 export type { RuntimeInitialization, RuntimeInitializationContext, RuntimeInitializer, } from './initialize.js';
 export type { RuntimeIntegrations } from './integrations.js';
 export type { Runtime } from './runtime.js';
+export type { AuthoredRuntime } from './declarations.js';

package/dist/application/runtime/callables.js

@@ -12,11 +12,11 @@ export function runtimeCallables(domain) {
         if (selected.kind !== 'node')
             continue;
         for (const callable of selected.self.methods) {
-            if (callable.inheritance !== 'abstract')
+            if (callable.executable)
                 append(callable);
         }
         for (const callable of selected.self.static.methods) {
-            if (callable.inheritance !== 'abstract')
+            if (callable.executable)
                 append(callable);
         }
     }

package/dist/application/runtime/declarations.d.ts

@@ -0,0 +1,43 @@
+import type { schema } from '../../platform/schema/index.js';
+import type { ActionAddress, ActionDefinition } from '../action/index.js';
+import type { DeclaredErrors } from '../error/index.js';
+import type { Integrations } from '../integration/index.js';
+import type { WorkflowAddress, WorkflowDefinition } from '../workflow/index.js';
+import type { RuntimeInitialization, RuntimeInitializer } from './initialize.js';
+import type { RuntimeIntegrations } from './integrations.js';
+import type { Runtime } from './runtime.js';
+/** Retain each recipe's exact contract without repeating the owning Schema in every tuple slot. */
+type RuntimeFunctionSignature<Recipe> = Recipe extends ActionDefinition<infer Schema, infer Address, infer Definitions, infer Errors> ? readonly [
+    'action',
+    Address,
+    Definitions,
+    Errors,
+    {
+        [Key in keyof Recipe as Exclude<Key, keyof ActionDefinition<Schema, Address, Definitions, Errors>>]: Recipe[Key];
+    }
+] : Recipe extends WorkflowDefinition<infer Schema, infer Address, infer Definitions, infer Errors> ? readonly [
+    'workflow',
+    Address,
+    Definitions,
+    Errors,
+    {
+        [Key in keyof Recipe as Exclude<Key, keyof WorkflowDefinition<Schema, Address, Definitions, Errors>>]: Recipe[Key];
+    }
+] : never;
+export type RuntimeFunctionSignatures<Functions extends readonly unknown[]> = {
+    [Index in keyof Functions]: RuntimeFunctionSignature<Functions[Index]>;
+};
+type RuntimeFunction<Schema extends schema.DomainSchema, Signature> = Signature extends readonly [
+    infer Kind,
+    infer Address,
+    infer Definitions extends Integrations,
+    infer Errors extends DeclaredErrors,
+    infer Extra
+] ? Kind extends 'action' ? ActionDefinition<Schema, Extract<Address, ActionAddress<Schema>>, Definitions, Errors> & Extra : WorkflowDefinition<Schema, Extract<Address, WorkflowAddress<Schema>>, Definitions, Errors> & Extra : never;
+type RuntimeFunctions<Schema extends schema.DomainSchema, Signatures extends readonly unknown[]> = {
+    [Index in keyof Signatures]: RuntimeFunction<Schema, Signatures[Index]>;
+};
+/** A portable inferred Runtime keeps its Schema once while retaining the exact recipe tuple. */
+export interface AuthoredRuntime<Schema extends schema.DomainSchema, Integrations extends RuntimeIntegrations, Initialize extends RuntimeInitializer<never, RuntimeInitialization, Schema>, Signatures extends readonly unknown[]> extends Runtime<Schema, Integrations, Initialize, RuntimeFunctions<Schema, Signatures>> {
+}
+export {};

package/dist/application/runtime/define.d.ts

@@ -2,6 +2,7 @@ import type { schema } from '../../platform/schema/index.js';
 import type { ActionDefinition } from '../action/index.js';
 import type { Providers } from '../integration/index.js';
 import type { WorkflowDefinition } from '../workflow/index.js';
+import type { AuthoredRuntime, RuntimeFunctionSignatures } from './declarations.js';
 import type { RuntimeInitialization, RuntimeInitializer } from './initialize.js';
 import type { RuntimeIntegrations } from './integrations.js';
 import type { Runtime } from './runtime.js';
@@ -22,6 +23,6 @@ export interface RuntimeInput<Integrations extends RuntimeIntegrations, Initiali
     readonly functions: Functions;
 }
 /** Define one inert Runtime declaration; realization requires an exact loaded DSL Domain. */
-export declare function defineRuntime<Schema extends schema.DomainSchema>(): <const Integrations extends RuntimeIntegrations, Initialize extends AnyRuntimeInitializer<Schema>, const Functions extends readonly unknown[]>(input: RuntimeInput<Integrations, Initialize, Functions> & AdmitsRecipeSchema<Schema, Functions> & AdmitsIntegrations<Integrations, Functions> & AdmitsProviders<Integrations, Initialize>) => Runtime<Schema, Integrations, Initialize, Functions>;
+export declare function defineRuntime<Schema extends schema.DomainSchema>(): <const Integrations extends RuntimeIntegrations, Initialize extends AnyRuntimeInitializer<Schema>, const Functions extends readonly unknown[]>(input: RuntimeInput<Integrations, Initialize, Functions> & AdmitsRecipeSchema<Schema, Functions> & AdmitsIntegrations<Integrations, Functions> & AdmitsProviders<Integrations, Initialize>) => AuthoredRuntime<Schema, Integrations, Initialize, RuntimeFunctionSignatures<Functions>>;
 export declare function isRuntime(input: unknown): input is Runtime;
 export {};

package/dist/application/view/index.d.ts

@@ -1,6 +1,6 @@
 export { isFrontend } from './admission.js';
 export { defineFrontend } from './define.js';
 export type { Frontend, FrontendInput, FrontendRouteInputs, FrontendRoutes, ViewName, } from './frontend.js';
-export type { FrontendHandshake, FrontendRoute, FrontendRouteInput, IframeRequirements, } from './route.js';
+export type { FrontendHandshake, FrontendRoute, FrontendRouteInput, IframeRequirements, ViewHostRequirements, } from './route.js';
 export { external, isFrontendSource, vite } from './source.js';
 export type { ExternalSource, FrontendSource, ViteSource } from './source.js';

package/dist/application/view/route.d.ts

@@ -1,4 +1,10 @@
+import { type ViewHostRequirements } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
+export type { ViewHostRequirements } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
 export type FrontendHandshake = 'shell' | 'none';
+/**
+ * @deprecated Every trusted View receives the Shell's shared browser profile: requirements within
+ * it are redundant, and Astrale hosts refuse any beyond it. Declare none.
+ */
 export interface IframeRequirements {
     readonly sandbox?: readonly string[];
     readonly allow?: readonly string[];
@@ -7,13 +13,19 @@ export type FrontendRouteInput = string | {
     readonly path?: string;
     readonly document?: string;
     readonly handshake?: FrontendHandshake;
+    /**
+     * @deprecated Every trusted View receives the Shell's shared browser profile: requirements
+     * within it are redundant, and Astrale hosts refuse any beyond it. Remove this field.
+     */
     readonly iframe?: IframeRequirements;
+    readonly host?: ViewHostRequirements;
 };
 export interface FrontendRoute {
     readonly path: string;
     readonly document: string;
     readonly handshake: FrontendHandshake;
     readonly iframe?: IframeRequirements;
+    readonly host?: ViewHostRequirements;
 }
 export declare function normalizeRoute(input: FrontendRouteInput | undefined, fallback: string): FrontendRoute;
 export declare function defaultRoute(name: string): string;

package/dist/application/view/route.js

@@ -1,3 +1,4 @@
+import { acceptViewHostRequirements, } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
 const TOKEN = /^[a-z][a-z0-9-]*$/u;
 const BASELINES = Object.freeze({
     none: iframeRequirements(['allow-scripts'], []),
@@ -8,7 +9,8 @@ export function normalizeRoute(input, fallback) {
         return Object.freeze({ path: routePath(input), document: 'index.html', handshake: 'shell' });
     }
     const value = plainRecord(input ?? {});
-    if (Reflect.ownKeys(value).some((key) => typeof key !== 'string' || !['path', 'document', 'handshake', 'iframe'].includes(key))) {
+    if (Reflect.ownKeys(value).some((key) => typeof key !== 'string' ||
+        !['path', 'document', 'handshake', 'iframe', 'host'].includes(key))) {
         invalid();
     }
     const authoredHandshake = dataValue(value, 'handshake');
@@ -19,11 +21,13 @@ export function normalizeRoute(input, fallback) {
     }
     const handshake = authoredHandshake ?? 'shell';
     const iframe = normalizeIframeRequirements(dataValue(value, 'iframe'), handshake);
+    const host = acceptViewHostRequirements(dataValue(value, 'host'), handshake, true);
     return Object.freeze({
         path: routePath(dataValue(value, 'path') ?? fallback),
         document: filePath(dataValue(value, 'document') ?? 'index.html'),
         handshake,
         ...(iframe === undefined ? {} : { iframe }),
+        ...(host === undefined ? {} : { host }),
     });
 }
 function normalizeIframeRequirements(input, handshake) {

package/dist/application/workflow/authoring.d.ts

@@ -1,3 +1,4 @@
 export { defineWorkflow } from './define.js';
 export type { WorkflowContext } from './context.js';
 export type { Workflow, WorkflowAddress, WorkflowDefinition } from './workflow.js';
+export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, } from '../error/index.js';

package/dist/application/workflow/context.d.ts

@@ -1,8 +1,9 @@
 import type { Domain } from '../../platform/schema/index.js';
 import type { ActionContext, ResolvedCallable } from '../action/index.js';
+import type { DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
 import type { Integrations } from '../integration/index.js';
 import type { WorkflowStep } from './step/index.js';
 /** Exact multi-step Workflow context for one authenticated value-output callable. */
-export type WorkflowContext<Callable extends ResolvedCallable, DomainValue extends Domain = Domain, Definitions extends Integrations = Readonly<Record<never, never>>> = ActionContext<Callable, DomainValue, Definitions> & {
+export type WorkflowContext<Callable extends ResolvedCallable, DomainValue extends Domain = Domain, Definitions extends Integrations = Readonly<Record<never, never>>, Errors extends DeclaredErrors = NoDeclaredErrors> = ActionContext<Callable, DomainValue, Definitions, Errors> & {
     readonly step: WorkflowStep;
 };

package/dist/application/workflow/define.d.ts

@@ -1,7 +1,11 @@
 import type { schema } from '../../platform/schema/index.js';
 import type { ResolvedDomainOf } from '../action/index.js';
+import type { DeclaredErrorOptions, DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
 import type { Integrations } from '../integration/index.js';
 import type { CallableAtWorkflowAddress, Workflow, WorkflowAddress, WorkflowDefinition } from './workflow.js';
 /** Define one authenticated multi-step value-output implementation by its SDK Action address. */
-export declare function defineWorkflow<Schema extends schema.DomainSchema, Definitions extends Integrations = Readonly<Record<never, never>>>(): <const Address extends WorkflowAddress<Schema>>(address: Address, run: Workflow<CallableAtWorkflowAddress<Schema, Address>, Definitions, ResolvedDomainOf<Schema>>) => WorkflowDefinition<Schema, Address, Definitions>;
+export declare function defineWorkflow<Schema extends schema.DomainSchema, Definitions extends Integrations = Readonly<Record<never, never>>>(): {
+    <const Address extends WorkflowAddress<Schema>>(address: Address, run: Workflow<CallableAtWorkflowAddress<Schema, Address>, Definitions, ResolvedDomainOf<Schema>, NoDeclaredErrors>): WorkflowDefinition<Schema, Address, Definitions, NoDeclaredErrors>;
+    <const Address extends WorkflowAddress<Schema>, const Errors extends DeclaredErrors>(address: Address, options: DeclaredErrorOptions<Errors>, run: Workflow<CallableAtWorkflowAddress<Schema, Address>, Definitions, ResolvedDomainOf<Schema>, Errors>): WorkflowDefinition<Schema, Address, Definitions, Errors>;
+};
 export declare function isWorkflow(input: unknown): input is WorkflowDefinition;

package/dist/application/workflow/define.js

@@ -1,9 +1,12 @@
 import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { rememberDeclaredErrors } from '../error/index.js';
 const admittedWorkflows = new WeakSet();
 /** Define one authenticated multi-step value-output implementation by its SDK Action address. */
 export function defineWorkflow() {
-    return function define(address, run) {
+    return function define(address, optionsOrRun, possibleRun) {
         acceptWorkflowAddress(address);
+        const options = possibleRun === undefined ? undefined : optionsOrRun;
+        const run = possibleRun ?? optionsOrRun;
         if (typeof run !== 'function')
             throw new TypeError('Workflow run must be a function.');
         const workflow = Object.freeze({
@@ -11,6 +14,8 @@ export function defineWorkflow() {
             address,
             run,
         });
+        if (options !== undefined)
+            rememberDeclaredErrors(workflow, options);
         admittedWorkflows.add(workflow);
         return workflow;
     };

package/dist/application/workflow/index.d.ts

@@ -3,3 +3,4 @@ export type { WorkflowContext } from './context.js';
 export type { CallableAtWorkflowAddress, Workflow, WorkflowAddress, WorkflowCallable, WorkflowDefinition, } from './workflow.js';
 export * as step from './step/index.js';
 export * as runner from './runner/index.js';
+export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, } from '../error/index.js';

package/dist/application/workflow/runner/runner.d.ts

@@ -1,9 +1,10 @@
 import type { Domain, schema } from '../../../platform/schema/index.js';
 import type { ActionOutputOf, ResolvedCallable, ResolvedDomainOf } from '../../action/index.js';
+import type { DeclaredErrors, NoDeclaredErrors } from '../../error/index.js';
 import type { Integrations } from '../../integration/index.js';
 import type { WorkflowContext } from '../context.js';
 import type { CallableAtWorkflowAddress, WorkflowAddress, WorkflowDefinition } from '../workflow.js';
-export type WorkflowExecutionContext<Callable extends ResolvedCallable, Definitions extends Integrations, DomainValue extends Domain = Domain> = Omit<WorkflowContext<Callable, DomainValue, Definitions>, 'step'>;
+export type WorkflowExecutionContext<Callable extends ResolvedCallable, Definitions extends Integrations, DomainValue extends Domain = Domain, Errors extends DeclaredErrors = NoDeclaredErrors> = Omit<WorkflowContext<Callable, DomainValue, Definitions, Errors>, 'step'>;
 export interface WorkflowRunner {
-    run<Schema extends schema.DomainSchema, Address extends WorkflowAddress<Schema>, Definitions extends Integrations, Callable extends CallableAtWorkflowAddress<Schema, Address> = CallableAtWorkflowAddress<Schema, Address>>(workflow: WorkflowDefinition<Schema, Address, Definitions>, context: WorkflowExecutionContext<Callable, Definitions, ResolvedDomainOf<Schema>>): Promise<ActionOutputOf<Callable>>;
+    run<Schema extends schema.DomainSchema, Address extends WorkflowAddress<Schema>, Definitions extends Integrations, Errors extends DeclaredErrors, Callable extends CallableAtWorkflowAddress<Schema, Address> = CallableAtWorkflowAddress<Schema, Address>>(workflow: WorkflowDefinition<Schema, Address, Definitions, Errors>, context: WorkflowExecutionContext<Callable, Definitions, ResolvedDomainOf<Schema>, Errors>): Promise<ActionOutputOf<Callable>>;
 }

package/dist/application/workflow/workflow.d.ts

@@ -1,5 +1,6 @@
 import type { CallableOutputOf, Domain, schema } from '../../platform/schema/index.js';
 import type { ActionAddressOf, ActionOutputOf, CallableAtAddress, LocalCallable, ResolvedCallable, ResolvedDomainOf } from '../action/index.js';
+import type { DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
 import type { Integrations } from '../integration/index.js';
 import type { WorkflowContext } from './context.js';
 export type WorkflowCallable<Callable> = Callable extends ResolvedCallable ? Callable extends {
@@ -9,13 +10,13 @@ export type WorkflowCallable<Callable> = Callable extends ResolvedCallable ? Cal
 } ? Callable : never : never;
 export type WorkflowAddress<Schema extends schema.DomainSchema> = ActionAddressOf<WorkflowCallable<LocalCallable<ResolvedDomainOf<Schema>>>>;
 export type CallableAtWorkflowAddress<Schema extends schema.DomainSchema, Address extends WorkflowAddress<Schema>> = WorkflowCallable<Extract<CallableAtAddress<Schema, Address>, ResolvedCallable>>;
-export type Workflow<Callable extends ResolvedCallable, Definitions extends Integrations = Readonly<Record<never, never>>, DomainValue extends Domain = Domain> = (context: WorkflowContext<Callable, DomainValue, Definitions>) => Promise<ActionOutputOf<Callable>>;
+export type Workflow<Callable extends ResolvedCallable, Definitions extends Integrations = Readonly<Record<never, never>>, DomainValue extends Domain = Domain, Errors extends DeclaredErrors = NoDeclaredErrors> = (context: WorkflowContext<Callable, DomainValue, Definitions, Errors>) => Promise<ActionOutputOf<Callable>>;
 declare const WORKFLOW_SCHEMA: unique symbol;
 /** Sealed multi-step Workflow awaiting canonical callable association by Runtime admission. */
-export interface WorkflowDefinition<Schema extends schema.DomainSchema = schema.DomainSchema, Address extends WorkflowAddress<Schema> = WorkflowAddress<Schema>, Definitions extends Integrations = Readonly<Record<never, never>>> {
+export interface WorkflowDefinition<Schema extends schema.DomainSchema = schema.DomainSchema, Address extends WorkflowAddress<Schema> = WorkflowAddress<Schema>, Definitions extends Integrations = Readonly<Record<never, never>>, Errors extends DeclaredErrors = NoDeclaredErrors> {
     readonly kind: 'workflow';
     readonly address: Address;
-    readonly run: Workflow<CallableAtWorkflowAddress<Schema, Address>, Definitions, ResolvedDomainOf<Schema>>;
+    readonly run: Workflow<CallableAtWorkflowAddress<Schema, Address>, Definitions, ResolvedDomainOf<Schema>, Errors>;
     /** Invariant type-only Schema witness; absent from emitted JavaScript. */
     readonly [WORKFLOW_SCHEMA]: (schema: Schema) => Schema;
 }

package/dist/deployment/adapter/adapter.d.ts

@@ -1,22 +1,27 @@
 import type { DeployContext, DeployResult } from './deploy/index.js';
-import type { DevelopmentContext, DevelopmentSession } from './development/index.js';
 import type { ArtifactSource, PrepareContext } from './prepare/index.js';
-export interface Adapter<Parameters = unknown> {
+export interface InstallationTarget {
+    readonly instance: string;
+    readonly identity?: string;
+}
+export interface AdapterEnvironmentContext {
+    readonly environment: string;
+    readonly installation?: InstallationTarget;
+}
+export interface Adapter<Parameters extends object = object> {
     readonly kind: 'adapter';
     readonly name: string;
     readonly version: string;
-    parameters(environment: string): Parameters;
+    admit?(parameters: Parameters, context: AdapterEnvironmentContext): void;
     prepare(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
-    develop(parameters: Parameters, context: DevelopmentContext): Promise<DevelopmentSession>;
     deploy(parameters: Parameters, context: DeployContext): Promise<DeployResult>;
     readonly secretsFile?: (parameters: Parameters) => string | undefined;
 }
-export interface AdapterInput<Parameters> {
+export interface AdapterInput<Parameters extends object> {
     readonly name: string;
     readonly version: string;
-    readonly environments: Readonly<Record<string, Parameters>>;
+    admit?(parameters: Parameters, context: AdapterEnvironmentContext): void;
     prepare(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
-    develop(parameters: Parameters, context: DevelopmentContext): Promise<DevelopmentSession>;
     deploy(parameters: Parameters, context: DeployContext): Promise<DeployResult>;
     readonly secretsFile?: (parameters: Parameters) => string | undefined;
 }

package/dist/deployment/adapter/define.d.ts

@@ -1,4 +1,7 @@
+import type { Deployment } from '../deployment.js';
 import type { Adapter, AdapterInput } from './adapter.js';
-/** Capture one receiver-bound provider adapter and its environment parameters. */
-export declare function defineAdapter<Parameters>(input: AdapterInput<Parameters>): Adapter<Parameters>;
+/** Capture one receiver-bound provider adapter. */
+export declare function defineAdapter<Parameters extends object>(input: AdapterInput<Parameters>): Adapter<Parameters>;
+/** Bind one provider adapter to the parameters of one Project Environment. */
+export declare function defineDeployment<const Parameters extends object>(adapter: Adapter<Parameters>, parameters: Parameters): Deployment<Parameters>;
 export declare function isAdapter(input: unknown): input is Adapter;

package/dist/deployment/adapter/define.js

@@ -1,39 +1,37 @@
+import { captureDeployment } from '../deployment.js';
 const admittedAdapters = new WeakSet();
-/** Capture one receiver-bound provider adapter and its environment parameters. */
+/** Capture one receiver-bound provider adapter. */
 export function defineAdapter(input) {
     const value = record(input, 'Adapter definition');
-    exact(value, ['name', 'version', 'environments', 'prepare', 'develop', 'deploy'], ['secretsFile']);
+    exact(value, ['name', 'version', 'prepare', 'deploy'], ['admit', 'secretsFile']);
     const name = stableName(input.name);
     const version = stableName(input.version);
-    const environments = record(input.environments, 'Adapter environments');
-    if (Reflect.ownKeys(environments).some((key) => typeof key !== 'string')) {
-        throw new TypeError('Adapter environment names must be strings.');
-    }
-    const capturedEnvironments = Object.freeze({ ...environments });
-    const names = Object.keys(capturedEnvironments).sort();
-    const receiver = Object.freeze({ ...input, environments: capturedEnvironments });
+    const receiver = Object.freeze({ ...input });
+    const admit = optional(receiver, 'admit');
     const prepare = capture(receiver, 'prepare');
-    const develop = capture(receiver, 'develop');
     const deploy = capture(receiver, 'deploy');
     const secretsFile = optional(receiver, 'secretsFile');
     const adapter = Object.freeze({
         kind: 'adapter',
         name,
         version,
-        parameters(environment) {
-            if (Object.hasOwn(capturedEnvironments, environment)) {
-                return capturedEnvironments[environment];
-            }
-            throw new TypeError(`Adapter ${name} has no environment ${environment}; known environments: ${names.length === 0 ? '(none)' : names.join(', ')}.`);
-        },
+        ...(admit === undefined ? {} : { admit }),
         prepare,
-        develop,
         deploy,
         ...(secretsFile === undefined ? {} : { secretsFile }),
     });
     admittedAdapters.add(adapter);
     return adapter;
 }
+/** Bind one provider adapter to the parameters of one Project Environment. */
+export function defineDeployment(adapter, parameters) {
+    if (!isAdapter(adapter))
+        throw new TypeError('Deployment Adapter is not admitted.');
+    if (parameters === null || typeof parameters !== 'object' || Array.isArray(parameters)) {
+        throw new TypeError('Deployment parameters must be an object.');
+    }
+    return captureDeployment(adapter, Object.freeze({ ...parameters }));
+}
 export function isAdapter(input) {
     return input !== null && typeof input === 'object' && admittedAdapters.has(input);
 }

package/dist/deployment/adapter/deploy/context.d.ts

@@ -1,7 +1,13 @@
+import type { InstallationTarget } from '../adapter.js';
 import type { PreparedArtifact } from '../prepare/index.js';
 export interface DeployContext {
     readonly projectDir: string;
     readonly environment: string;
+    readonly installation?: InstallationTarget;
+    /** Optional command-scoped identity override (`--as`). */
+    readonly identity?: string;
+    /** Optional command-scoped credential; trusted adapters must neither retain nor disclose it. */
+    readonly credential?: string;
     readonly secrets: Readonly<Record<string, string>>;
     readonly artifact: PreparedArtifact;
     /** Parent-owned lifecycle cancellation shared by every provider process/effect. */

package/dist/deployment/adapter/deploy/result.d.ts

@@ -17,6 +17,8 @@ export interface ProviderDeploymentEvidence {
     readonly deployment: string;
     readonly artifact: Digest;
     readonly issuer?: Addressing['issuer'];
+    /** Optional provider-side check before promotion; distinct from public readiness. */
+    readonly preflight?: 'passed' | 'unavailable';
 }
 export type AppliedProviderDeployment = {
     readonly kind: 'applied';