@astrale-os/sdk 0.5.0-beta.15 → 0.5.0-beta.151

package/dist/application/error/error.d.ts

@@ -0,0 +1,23 @@
+import type { z } from 'zod';
+import type { DeclaredErrorDefinition } from '../../platform/schema/error.js';
+import * as value from '../../platform/value/index.js';
+export type { DeclaredErrorDefinition, DeclaredErrorFamily } from '../../platform/schema/error.js';
+export type DeclaredErrors = Readonly<Record<string, DeclaredErrorDefinition>>;
+export type NoDeclaredErrors = Readonly<Record<never, never>>;
+export interface DeclaredErrorOptions<out Errors extends DeclaredErrors = DeclaredErrors> {
+    readonly errors: Errors;
+}
+export type DeclaredErrorFactory<Errors extends DeclaredErrors> = <Code extends Extract<keyof Errors, string>>(code: Code, details: z.input<Errors[Code]['details']>) => Error;
+interface DeclaredErrorRecord {
+    readonly definition: object;
+    readonly code: string;
+    readonly family: DeclaredErrorDefinition['family'];
+    readonly message: string;
+    readonly details: value.Object;
+}
+/** Retain one implementation-local expected-error contract without publishing it in the Schema. */
+export declare function rememberDeclaredErrors(definition: object, input: unknown): void;
+/** Create a receiver-free factory closed over one admitted Action or Workflow definition. */
+export declare function declaredErrorFactory<Errors extends DeclaredErrors>(definition: object): DeclaredErrorFactory<Errors>;
+/** Return admitted evidence only when the error belongs to the active implementation. */
+export declare function declaredErrorOf(input: unknown, definition: object): DeclaredErrorRecord | undefined;

package/dist/application/error/error.js

@@ -0,0 +1,87 @@
+import { acceptErrorDefinition } from '../../platform/schema/error.js';
+import * as value from '../../platform/value/index.js';
+const MAXIMUM_DECLARED_ERRORS = 32;
+const MAXIMUM_DETAILS_BYTES = 16 * 1024;
+const CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,127}$/u;
+const declarations = new WeakMap();
+const errors = new WeakMap();
+class BusinessError extends Error {
+    name = 'BusinessError';
+    constructor(code) {
+        super(`Declared business error ${code}.`);
+    }
+}
+/** Retain one implementation-local expected-error contract without publishing it in the Schema. */
+export function rememberDeclaredErrors(definition, input) {
+    if (!isRecord(input) || Reflect.ownKeys(input).some((key) => key !== 'errors'))
+        invalidOptions();
+    if (!isRecord(input.errors))
+        invalidOptions();
+    const entries = Object.entries(input.errors);
+    if (entries.length > MAXIMUM_DECLARED_ERRORS) {
+        throw new TypeError(`An implementation may declare at most ${MAXIMUM_DECLARED_ERRORS} errors.`);
+    }
+    const accepted = new Map();
+    for (const [code, candidate] of entries) {
+        if (!CODE_PATTERN.test(code))
+            throw new TypeError(`Declared error code ${JSON.stringify(code)} is invalid.`);
+        accepted.set(code, acceptErrorDefinition(candidate, `Declared error ${JSON.stringify(code)}`));
+    }
+    declarations.set(definition, accepted);
+}
+/** Create a receiver-free factory closed over one admitted Action or Workflow definition. */
+export function declaredErrorFactory(definition) {
+    return ((code, input) => {
+        const declaration = declarations.get(definition)?.get(code);
+        if (declaration === undefined) {
+            throw new TypeError(`Business error ${JSON.stringify(code)} is not declared by this implementation.`);
+        }
+        const parsed = declaration.details.safeParse(input);
+        if (!parsed.success) {
+            throw new TypeError(`Business error ${code} details are invalid.`, { cause: parsed.error });
+        }
+        let details;
+        try {
+            const accepted = value.accept(parsed.data, { limits: { maxBytes: MAXIMUM_DETAILS_BYTES } });
+            value.json.encode(accepted, { limits: { maxBytes: MAXIMUM_DETAILS_BYTES } });
+            if (!isRecord(accepted))
+                throw new TypeError('Details must be an object.');
+            details = freezeValue(accepted);
+        }
+        catch (cause) {
+            throw new TypeError(`Business error ${code} details must be a bounded portable object.`, {
+                cause,
+            });
+        }
+        const error = new BusinessError(code);
+        errors.set(error, Object.freeze({
+            definition,
+            code,
+            family: declaration.family,
+            message: declaration.message,
+            details,
+        }));
+        return error;
+    });
+}
+/** Return admitted evidence only when the error belongs to the active implementation. */
+export function declaredErrorOf(input, definition) {
+    if (!(input instanceof Error))
+        return undefined;
+    const record = errors.get(input);
+    return record?.definition === definition ? record : undefined;
+}
+function isRecord(input) {
+    return input !== null && typeof input === 'object' && !Array.isArray(input);
+}
+function freezeValue(input) {
+    return Object.freeze(Object.fromEntries(Object.entries(input).map(([key, nested]) => [key, freezeNestedValue(nested)])));
+}
+function freezeNestedValue(input) {
+    if (Array.isArray(input))
+        return Object.freeze(input.map(freezeNestedValue));
+    return isRecord(input) ? freezeValue(input) : input;
+}
+function invalidOptions() {
+    throw new TypeError('Action or Workflow options must contain exactly an errors object.');
+}

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

@@ -0,0 +1,2 @@
+export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, NoDeclaredErrors, } from './error.js';
+export { declaredErrorFactory, declaredErrorOf, rememberDeclaredErrors } from './error.js';

package/dist/application/error/index.js

@@ -0,0 +1 @@
+export { declaredErrorFactory, declaredErrorOf, rememberDeclaredErrors } from './error.js';

package/dist/application/index.d.ts

@@ -0,0 +1,9 @@
+export { defineApplication, isApplication } from './define.js';
+export type { ApplicationInput } from './define.js';
+export { requirements } from './requirements/index.js';
+export type { AuthorityRequirements, AuthorityRequirementsInput, ClassOperation, ClassRequirement, ClassRequirementInput, CoreRequirement, CoreRequirementInput, FunctionRequirementTarget, Requirements, RequirementsInput, } from './requirements/index.js';
+export { route, routes } from './routes/index.js';
+export type { Route, RouteInput, RouteTarget, Routes } from './routes/index.js';
+export { defineFrontend, external, vite } from './view/index.js';
+export type { Frontend, FrontendInput, FrontendSource, IframeRequirements, ViewHostRequirements, } from './view/index.js';
+export type { Application, ApplicationIdentity, RuntimeOfApplication, SchemaOfApplication, SchemaOfRuntime, } from './application.js';

package/dist/application/index.js

@@ -0,0 +1,4 @@
+export { defineApplication, isApplication } from './define.js';
+export { requirements } from './requirements/index.js';
+export { route, routes } from './routes/index.js';
+export { defineFrontend, external, vite } from './view/index.js';

package/dist/application/integration/admission.d.ts

@@ -0,0 +1,9 @@
+import type { ProviderBinding } from './define.js';
+import type { Integrations } from './integration.js';
+import type { Providers } from './provider.js';
+export interface AdmittedProvider {
+    readonly name: string;
+    readonly binding: ProviderBinding;
+}
+/** Admit exact Provider coverage and Integration identity before any invocation. */
+export declare function admitProviders<Definitions extends Integrations>(integrations: Definitions, providers: Providers<Definitions>): readonly AdmittedProvider[];

package/dist/application/integration/admission.js

@@ -0,0 +1,21 @@
+import { admitIntegrations, requireProvider } from './define.js';
+/** Admit exact Provider coverage and Integration identity before any invocation. */
+export function admitProviders(integrations, providers) {
+    const required = admitIntegrations(integrations);
+    if (providers === null || typeof providers !== 'object' || Array.isArray(providers)) {
+        throw new TypeError('Runtime providers must be an object.');
+    }
+    const expected = Object.keys(required);
+    const actual = Reflect.ownKeys(providers);
+    if (actual.length !== expected.length ||
+        actual.some((key) => typeof key !== 'string' || !expected.includes(key))) {
+        throw new TypeError(`Runtime providers must contain exactly: ${expected.join(', ') || '(none)'}.`);
+    }
+    return Object.freeze(expected.map((name) => {
+        const binding = requireProvider(providers[name]);
+        if (binding.integration !== required[name]) {
+            throw new TypeError(`Provider ${name} implements another Integration.`);
+        }
+        return Object.freeze({ name, binding });
+    }));
+}

package/dist/application/integration/authentication.d.ts

@@ -0,0 +1,10 @@
+import type { MintedCredential } from '../../platform/auth/index.js';
+export interface IntegrationMintInput {
+    readonly audience: string;
+    /** Maximum requested lifetime, in whole seconds, from 1 through 60. */
+    readonly ttlSeconds: number;
+}
+/** Invocation-bound authentication as the executing Domain, never the caller. */
+export interface IntegrationAuthentication {
+    mint(input: IntegrationMintInput): Promise<MintedCredential>;
+}

package/dist/application/integration/authentication.js

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

package/dist/application/integration/authentication.typecheck.d.ts

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

package/dist/application/integration/authentication.typecheck.js

@@ -0,0 +1,18 @@
+async function provider(execution) {
+    // @ts-expect-error An anonymous invocation has no auth capability.
+    await execution.auth.mint({ audience: 'admin', ttlSeconds: 60 });
+    if (execution.auth === undefined)
+        return;
+    await execution.auth.mint({ audience: 'admin', ttlSeconds: 60 });
+    // @ts-expect-error Providers cannot register identities.
+    execution.auth.register({});
+    // @ts-expect-error Providers cannot delegate authority.
+    execution.auth.delegate({});
+    // @ts-expect-error Providers cannot supply a Grant.
+    execution.auth.mint({ audience: 'admin', ttlSeconds: 60, grant: {} });
+    // @ts-expect-error The destination audience is mandatory.
+    const invalid = { ttlSeconds: 60 };
+    return invalid;
+}
+void provider;
+export {};

package/dist/application/integration/client.d.ts

@@ -0,0 +1,27 @@
+import type { BoundClientSession } from '../../platform/client/session/index.js';
+import type { IntegrationAuthentication } from './authentication.js';
+import type { IntegrationClients, Integrations } from './integration.js';
+import type { IntegrationReplayDecision } from './operation.js';
+import type { Providers } from './provider.js';
+export interface IntegrationCallCoordinates {
+    readonly callId: string;
+    readonly signal: AbortSignal;
+    readonly deadline: number;
+    readonly invoke?: BoundClientSession['invoke'];
+    readonly auth?: IntegrationAuthentication;
+}
+export interface IntegrationAttempt<Output> {
+    readonly integration: string;
+    readonly operation: string;
+    readonly replay: IntegrationReplayDecision;
+    attempt(coordinates: IntegrationCallCoordinates): Promise<Output>;
+}
+export interface IntegrationInvocationOwner {
+    invoke<Output>(call: IntegrationAttempt<Output>): Promise<Output>;
+}
+export interface IntegrationClientFactory<Definitions extends Integrations> {
+    (owner: IntegrationInvocationOwner): IntegrationClients<Definitions>;
+}
+/** Bind exact Providers once, then create invocation-scoped Integration clients. */
+export declare function bindProviders<Definitions extends Integrations>(integrations: Definitions, providers: Providers<Definitions>): IntegrationClientFactory<Definitions>;
+export declare function createIntegrationClients<Definitions extends Integrations>(integrations: Definitions, providers: Providers<Definitions>, owner: IntegrationInvocationOwner): IntegrationClients<Definitions>;

package/dist/application/integration/client.js

@@ -0,0 +1,117 @@
+import { admitProviders } from './admission.js';
+import { resolveReplay } from './replay.js';
+/** Bind exact Providers once, then create invocation-scoped Integration clients. */
+export function bindProviders(integrations, providers) {
+    const admitted = admitProviders(integrations, providers);
+    return (owner) => createClients(admitted, owner);
+}
+export function createIntegrationClients(integrations, providers, owner) {
+    return bindProviders(integrations, providers)(owner);
+}
+function createClients(providers, owner) {
+    if (owner === null || typeof owner !== 'object' || typeof owner.invoke !== 'function') {
+        throw new TypeError('Integration invocation owner is invalid.');
+    }
+    const invoke = owner.invoke.bind(owner);
+    const clients = Object.create(null);
+    for (const { name, binding } of providers) {
+        const operations = Object.create(null);
+        for (const operationName of Object.keys(binding.integration.operations)) {
+            const operation = binding.integration.operations[operationName];
+            const implementation = binding.implementation[operationName];
+            operations[operationName] = async (...input) => {
+                if (input.length > 1) {
+                    throw new TypeError('Integration operations accept at most one semantic input.');
+                }
+                const value = input[0];
+                const replay = resolveReplay(operation, value);
+                let attempts = 0;
+                let logicalCall;
+                let active = true;
+                try {
+                    return await invoke({
+                        integration: binding.integration.id,
+                        operation: operationName,
+                        replay,
+                        async attempt(coordinates) {
+                            if (!active) {
+                                throw new TypeError('Settled Integration operation cannot be attempted again.');
+                            }
+                            if (replay.kind === 'unsafe' && attempts > 0) {
+                                throw new TypeError('Unsafe Integration operation cannot be attempted again.');
+                            }
+                            const admitted = admitCoordinates(coordinates);
+                            attempts += 1;
+                            if (logicalCall === undefined)
+                                logicalCall = admitted.callId;
+                            else if (logicalCall !== admitted.callId) {
+                                throw new TypeError('Integration replay must retain the logical call id.');
+                            }
+                            const execution = executionFor(admitted, replay);
+                            return input.length === 0
+                                ? Reflect.apply(implementation, undefined, [execution])
+                                : Reflect.apply(implementation, undefined, [value, execution]);
+                        },
+                    });
+                }
+                finally {
+                    active = false;
+                }
+            };
+        }
+        clients[name] = Object.freeze(operations);
+    }
+    return Object.freeze(clients);
+}
+function executionFor(coordinates, replay) {
+    const idempotencyKey = replay.kind !== 'keyed'
+        ? undefined
+        : replay.source === 'execution'
+            ? coordinates.callId
+            : replay.key;
+    return Object.freeze({
+        ...coordinates,
+        ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
+    });
+}
+function admitCoordinates(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalidCoordinates();
+    const keys = Reflect.ownKeys(input);
+    if (!['callId', 'signal', 'deadline'].every((key) => Object.hasOwn(input, key)) ||
+        !keys.every((key) => key === 'callId' ||
+            key === 'signal' ||
+            key === 'deadline' ||
+            key === 'invoke' ||
+            key === 'auth') ||
+        typeof input.callId !== 'string' ||
+        input.callId.length === 0 ||
+        input.callId.trim() !== input.callId ||
+        !(input.signal instanceof AbortSignal) ||
+        !Number.isFinite(input.deadline) ||
+        (input.invoke !== undefined && typeof input.invoke !== 'function')) {
+        invalidCoordinates();
+    }
+    const auth = input.auth === undefined ? undefined : admitAuthentication(input.auth);
+    return Object.freeze({
+        callId: input.callId,
+        signal: input.signal,
+        deadline: input.deadline,
+        ...(input.invoke === undefined ? {} : { invoke: input.invoke }),
+        ...(auth === undefined ? {} : { auth }),
+    });
+}
+function admitAuthentication(input) {
+    if (input === null ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        Reflect.ownKeys(input).length !== 1 ||
+        !Object.hasOwn(input, 'mint') ||
+        typeof input.mint !== 'function') {
+        invalidCoordinates();
+    }
+    return Object.freeze({ mint: input.mint.bind(input) });
+}
+function invalidCoordinates() {
+    throw new TypeError('Integration call coordinates are invalid.');
+}

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

@@ -0,0 +1,24 @@
+import type { IntegrationDefinition, Integrations } from './integration.js';
+import type { IntegrationOperation, IntegrationOperations, IntegrationReplay } from './operation.js';
+import type { Provider, ProviderImplementation } from './provider.js';
+type RuntimeDefinition = IntegrationDefinition<string, IntegrationOperations>;
+type ProviderOperations = Readonly<Record<string, (...input: readonly unknown[]) => unknown>>;
+export interface ProviderBinding {
+    readonly integration: RuntimeDefinition;
+    readonly implementation: ProviderOperations;
+}
+export interface DefineIntegration {
+    <Id extends string, Operations extends IntegrationOperations>(input: {
+        readonly id: Id;
+        readonly operations: Operations;
+    }): IntegrationDefinition<Id, Operations>;
+    operation<Input = void, Output = void>(input: {
+        readonly replay: IntegrationReplay<Input>;
+    }): IntegrationOperation<Input, Output>;
+}
+export declare const defineIntegration: DefineIntegration;
+export declare function defineProvider<Definition extends IntegrationDefinition>(definition: Definition, implementation: ProviderImplementation<Definition>): Provider<Definition>;
+export declare function admitIntegrations<Definitions extends Integrations>(input: Definitions): Definitions;
+export declare function requireIntegration(input: unknown): RuntimeDefinition;
+export declare function requireProvider(input: unknown): ProviderBinding;
+export {};

package/dist/application/integration/define.js

@@ -0,0 +1,101 @@
+import { acceptReplay } from './replay.js';
+const operations = new WeakSet();
+const definitions = new WeakSet();
+const providers = new WeakMap();
+function integration(input) {
+    const source = record(input, 'Integration definition');
+    exactKeys(source, ['id', 'operations'], 'Integration definition');
+    if (typeof input.id !== 'string' || input.id.length === 0 || input.id.trim() !== input.id) {
+        throw new TypeError('Integration id must be non-empty stable text.');
+    }
+    const authored = record(input.operations, 'Integration operations');
+    const names = Object.keys(authored);
+    if (names.length === 0)
+        throw new TypeError('Integration must declare at least one operation.');
+    const retained = Object.create(null);
+    for (const name of names) {
+        if (name.length === 0 || name.trim() !== name) {
+            throw new TypeError('Integration operation name must be stable text.');
+        }
+        const operation = authored[name];
+        if (operation === null || typeof operation !== 'object' || !operations.has(operation)) {
+            throw new TypeError(`Integration operation ${name} is not admitted.`);
+        }
+        retained[name] = operation;
+    }
+    const definition = Object.freeze({
+        kind: 'integration',
+        id: input.id,
+        operations: Object.freeze(retained),
+    });
+    definitions.add(definition);
+    return definition;
+}
+function operation(input) {
+    const source = record(input, 'Integration operation');
+    exactKeys(source, ['replay'], 'Integration operation');
+    const replay = typeof input.replay === 'function'
+        ? input.replay
+        : acceptReplay(input.replay);
+    const value = Object.freeze({ replay });
+    operations.add(value);
+    return value;
+}
+export const defineIntegration = Object.assign(integration, { operation });
+export function defineProvider(definition, implementation) {
+    if (!definitions.has(definition)) {
+        throw new TypeError('Provider requires an admitted Integration.');
+    }
+    const source = record(implementation, 'Provider implementation');
+    const names = Object.keys(definition.operations);
+    exactKeys(source, names, 'Provider implementation');
+    const retained = Object.create(null);
+    for (const name of names) {
+        const candidate = source[name];
+        if (typeof candidate !== 'function') {
+            throw new TypeError(`Provider operation ${name} must be a function.`);
+        }
+        retained[name] = candidate;
+    }
+    const provider = Object.freeze({ integration: definition });
+    providers.set(provider, Object.freeze({
+        integration: definition,
+        implementation: Object.freeze(retained),
+    }));
+    return provider;
+}
+export function admitIntegrations(input) {
+    const source = record(input, 'Runtime integrations');
+    const captured = Object.create(null);
+    for (const name of Object.keys(source))
+        captured[name] = requireIntegration(source[name]);
+    return Object.freeze(captured);
+}
+export function requireIntegration(input) {
+    if (input === null || typeof input !== 'object' || !definitions.has(input)) {
+        throw new TypeError('Integration is not admitted.');
+    }
+    return input;
+}
+export function requireProvider(input) {
+    if (input === null || typeof input !== 'object')
+        throw new TypeError('Provider is not admitted.');
+    const binding = providers.get(input);
+    if (binding === undefined)
+        throw new TypeError('Provider is not admitted.');
+    return binding;
+}
+function record(input, label) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError(`${label} must be an object.`);
+    }
+    return input;
+}
+function exactKeys(input, expected, label) {
+    const keys = Reflect.ownKeys(input);
+    const accepted = new Set(expected);
+    if (keys.length !== expected.length ||
+        keys.some((key) => typeof key !== 'string' || !accepted.has(key))) {
+        throw new TypeError(`${label} must contain exactly: ${expected.join(', ') || '(none)'}.`);
+    }
+}

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

@@ -0,0 +1,8 @@
+export { createIntegrationClients, bindProviders } from './client.js';
+export type { IntegrationAttempt, IntegrationCallCoordinates, IntegrationClientFactory, IntegrationInvocationOwner, } from './client.js';
+export { admitIntegrations, defineIntegration, defineProvider, requireIntegration, requireProvider, } from './define.js';
+export type { DefineIntegration, ProviderBinding } from './define.js';
+export type { IntegrationClient, IntegrationClients, IntegrationDefinition, Integrations, } from './integration.js';
+export type { IntegrationExecution, IntegrationInput, IntegrationOperation, IntegrationOperations, IntegrationOutput, IntegrationReplay, IntegrationReplayDecision, } from './operation.js';
+export type { Provider, ProviderImplementation, Providers } from './provider.js';
+export type { IntegrationAuthentication, IntegrationMintInput } from './authentication.js';

package/dist/application/integration/index.js

@@ -0,0 +1,2 @@
+export { createIntegrationClients, bindProviders } from './client.js';
+export { admitIntegrations, defineIntegration, defineProvider, requireIntegration, requireProvider, } from './define.js';

package/dist/application/integration/integration.d.ts

@@ -0,0 +1,19 @@
+import type { IntegrationOperation, IntegrationOperations } from './operation.js';
+declare const INTEGRATION_DEFINITION: unique symbol;
+export interface IntegrationDefinition<Id extends string = string, Operations extends IntegrationOperations = IntegrationOperations> {
+    readonly kind: 'integration';
+    readonly id: Id;
+    readonly operations: Operations;
+    readonly [INTEGRATION_DEFINITION]: Readonly<{
+        id: Id;
+        operations: Operations;
+    }>;
+}
+export type Integrations = Readonly<Record<string, IntegrationDefinition<string, IntegrationOperations>>>;
+export type IntegrationClient<Definition extends IntegrationDefinition> = Readonly<{
+    [Name in keyof Definition['operations']]: Definition['operations'][Name] extends IntegrationOperation<infer Input, infer Output> ? [Input] extends [void] ? () => Promise<Output> : (input: Input) => Promise<Output> : never;
+}>;
+export type IntegrationClients<Definitions extends Integrations> = Readonly<{
+    [Name in keyof Definitions]: IntegrationClient<Definitions[Name]>;
+}>;
+export {};

package/dist/application/integration/integration.js

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

package/dist/application/integration/operation.d.ts

@@ -0,0 +1,38 @@
+import type { BoundClientSession } from '../../platform/client/session/index.js';
+import type { IntegrationAuthentication } from './authentication.js';
+declare const INTEGRATION_OPERATION: unique symbol;
+export type IntegrationReplayDecision = {
+    readonly kind: 'safe';
+} | {
+    readonly kind: 'keyed';
+    readonly source: 'execution';
+} | {
+    readonly kind: 'keyed';
+    readonly source: 'input';
+    readonly key: string;
+} | {
+    readonly kind: 'unsafe';
+};
+export type IntegrationReplay<Input> = IntegrationReplayDecision | ((input: Input) => IntegrationReplayDecision);
+export interface IntegrationExecution {
+    readonly callId: string;
+    readonly signal: AbortSignal;
+    readonly deadline: number;
+    readonly idempotencyKey?: string;
+    /** Exact caller-bound invocation capability; absent for an anonymous invocation. */
+    readonly invoke?: BoundClientSession['invoke'];
+    /** Domain-self transport authentication; absent for an anonymous invocation. */
+    readonly auth?: IntegrationAuthentication;
+}
+export interface IntegrationOperation<Input = unknown, Output = unknown> {
+    readonly replay: IntegrationReplay<Input>;
+    readonly [INTEGRATION_OPERATION]: (input: Input) => Output;
+}
+export type IntegrationOperations = Readonly<Record<string, IntegrationOperation<never, unknown>>>;
+export type IntegrationInput<Operation> = Operation extends {
+    readonly [INTEGRATION_OPERATION]: (input: infer Input) => unknown;
+} ? Input : never;
+export type IntegrationOutput<Operation> = Operation extends {
+    readonly [INTEGRATION_OPERATION]: (input: never) => infer Output;
+} ? Output : never;
+export {};

package/dist/application/integration/operation.js

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

package/dist/application/integration/provider.d.ts

@@ -0,0 +1,14 @@
+import type { IntegrationDefinition, Integrations } from './integration.js';
+import type { IntegrationExecution, IntegrationOperation } from './operation.js';
+declare const INTEGRATION_PROVIDER: unique symbol;
+export type ProviderImplementation<Definition extends IntegrationDefinition> = Readonly<{
+    [Name in keyof Definition['operations']]: Definition['operations'][Name] extends IntegrationOperation<infer Input, infer Output> ? [Input] extends [void] ? (execution: IntegrationExecution) => Promise<Output> : (input: Input, execution: IntegrationExecution) => Promise<Output> : never;
+}>;
+export interface Provider<Definition extends IntegrationDefinition = IntegrationDefinition> {
+    readonly integration: Definition;
+    readonly [INTEGRATION_PROVIDER]: Definition;
+}
+export type Providers<Definitions extends Integrations> = Readonly<{
+    [Name in keyof Definitions]: Provider<Definitions[Name]>;
+}>;
+export {};

package/dist/application/integration/provider.js

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

package/dist/application/integration/replay.d.ts

@@ -0,0 +1,3 @@
+import type { IntegrationOperation, IntegrationReplayDecision } from './operation.js';
+export declare function resolveReplay(operation: IntegrationOperation<never, unknown>, input: unknown): IntegrationReplayDecision;
+export declare function acceptReplay(input: unknown): IntegrationReplayDecision;

package/dist/application/integration/replay.js

@@ -0,0 +1,37 @@
+export function resolveReplay(operation, input) {
+    const authored = typeof operation.replay === 'function'
+        ? Reflect.apply(operation.replay, undefined, [input])
+        : operation.replay;
+    return acceptReplay(authored);
+}
+export function acceptReplay(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    const decision = input;
+    if (decision.kind === 'safe' || decision.kind === 'unsafe') {
+        exactKeys(decision, ['kind']);
+        return Object.freeze({ kind: decision.kind });
+    }
+    if (decision.kind !== 'keyed')
+        invalid();
+    if (decision.source === 'execution') {
+        exactKeys(decision, ['kind', 'source']);
+        return Object.freeze({ kind: 'keyed', source: 'execution' });
+    }
+    if (decision.source === 'input' &&
+        typeof decision.key === 'string' &&
+        decision.key.trim().length > 0) {
+        exactKeys(decision, ['kind', 'source', 'key']);
+        return Object.freeze({ kind: 'keyed', source: 'input', key: decision.key });
+    }
+    invalid();
+}
+function exactKeys(input, expected) {
+    const keys = Reflect.ownKeys(input);
+    const accepted = new Set(expected);
+    if (keys.length !== expected.length || keys.some((key) => !accepted.has(key)))
+        invalid();
+}
+function invalid() {
+    throw new TypeError('Integration replay decision is invalid.');
+}