@astrale-os/sdk 0.6.0-beta.4 → 0.6.0-beta.41

package/dist/execution/workflows/run.js

@@ -0,0 +1,365 @@
+import { declaredErrorFactory } from '../../application/error/index.js';
+import { acceptStepId } from '../../application/workflow/step/index.js';
+import { acceptStepOutput } from '../../application/workflow/step/output.js';
+import { validateOutput } from '../invocation/result/index.js';
+import { BACKOFF, UNAVAILABLE, failedAttemptError, failedAttemptOf, nextAttempt, } from './attempts.js';
+import { decodeEnvelope } from './envelope.js';
+import { replayedFailure, StepExhausted, StepRetryAfter, terminalFailure } from './failure.js';
+import { stepServing } from './options.js';
+import { keySequence } from './steps.js';
+const MAXIMUM_SLEEP_MS = 365 * 24 * 60 * 60_000;
+const MAXIMUM_SIGNAL_NAME = 128;
+/** Engine handlers of one durable Workflow: the `run` and the shared `signal`. */
+export function durableHandlers(input) {
+    const { engine } = input.serving;
+    return Object.freeze({
+        run: (context, raw) => run(input, context, raw),
+        async signal(context, raw) {
+            const request = signalRequest(raw);
+            try {
+                await context.promise(request.name).resolve(request.value);
+                return { accepted: true };
+            }
+            catch (cause) {
+                // The engine refuses to resolve a promise twice with a terminal failure.
+                if (cause instanceof engine.TerminalError)
+                    return { accepted: false };
+                throw cause;
+            }
+        },
+    });
+}
+async function run(input, context, raw) {
+    const { workflow, serving } = input;
+    const { engine } = serving;
+    const definition = workflow.definition;
+    // A run replays the code of the release that started it, each release at its own URL. Code
+    // served in place of it replays the journal: the engine refuses a journal whose Steps no longer
+    // match, and code that cannot read what the Kernel recorded fails every attempt; both pause.
+    const envelope = admitted(workflow, raw, input.kernel);
+    const durable = durableContext(input, context, envelope);
+    let output;
+    try {
+        output = await definition.run(durable);
+    }
+    catch (cause) {
+        throw terminalFailure(engine, cause, definition) ?? cause;
+    }
+    return validateOutput(workflow.callable, output);
+}
+function admitted(workflow, raw, kernel) {
+    const envelope = decodeEnvelope(raw);
+    if (envelope.execution.kernel !== kernel) {
+        throw new TypeError('Durable envelope Kernel differs from its authenticated endpoint.');
+    }
+    const diagnostics = workflow.callable.validateInput(envelope.input);
+    if (diagnostics.length > 0) {
+        throw new TypeError(`Workflow ${workflow.address} cannot read the recorded input.`);
+    }
+    const instance = 'static' in workflow.callable && workflow.callable.static === false;
+    if (instance !== (envelope.execution.receiver !== undefined)) {
+        throw new TypeError(`Workflow ${workflow.address} cannot use the recorded receiver.`);
+    }
+    return envelope;
+}
+function durableContext(input, context, envelope) {
+    const { serving, domain, workflow } = input;
+    const { engine } = serving;
+    const definition = workflow.definition;
+    const execution = envelope.execution;
+    const signal = context.request().attemptCompletedSignal;
+    const steps = new Set();
+    let running;
+    /**
+     * Starts one durable operation, a Step or a wait, once the previous one has settled. The engine
+     * follows one awaited operation at a time: operations awaited together through `Promise` combinators
+     * make it lose track of the run, which then pauses.
+     */
+    const sequenced = (operation, start) => {
+        if (running !== undefined) {
+            return Promise.reject(new TypeError(`Workflow ${operation} started while ${running} runs: durable Steps and waits run one after another.`));
+        }
+        running = operation;
+        let started;
+        try {
+            started = start();
+        }
+        catch (cause) {
+            running = undefined;
+            return Promise.reject(cause);
+        }
+        return started.finally(() => {
+            running = undefined;
+        });
+    };
+    const now = input.now ?? Date.now;
+    /**
+     * One attempt of Step `id`, holding the capabilities of an Action as the Domain alone. Its
+     * Mutations, durable calls and Integration calls share one key sequence derived from the Step's
+     * name, which every attempt derives again. The engine journals its outcome: the Step's output, its
+     * declared error, or the failed attempt, as `failedAttemptError` records it. The Step decides from
+     * that journal alone whether to go on, so a replay decides alike.
+     *
+     * The engine promise is returned unawaited: awaiting it is what tells the engine the run waits on
+     * it, so parallel Steps hand theirs to the engine's own combinator instead.
+     */
+    const attempt = (id, held, execute) => {
+        const name = `step:${id}`;
+        const { timeoutMs } = held;
+        return context.run(name, async () => {
+            const startedAt = now();
+            const expiry = new AbortController();
+            const timer = setTimeout(() => expiry.abort(new Error(`Workflow Step ${id} exceeded its ${timeoutMs} ms timeout.`)), timeoutMs);
+            let step;
+            try {
+                const lifetime = {
+                    deadline: Date.now() + timeoutMs,
+                    signal: AbortSignal.any([signal, expiry.signal]),
+                };
+                const next = await keySequence(execution.id, name);
+                const { authority } = (step = input.steps({ name, execution, next, lifetime }));
+                const output = await Promise.race([
+                    Promise.resolve().then(() => execute(authority)),
+                    expired(expiry.signal),
+                ]);
+                try {
+                    return acceptStepOutput(output);
+                }
+                catch (cause) {
+                    throw new TypeError(`Workflow ${name} output must be portable.`, { cause });
+                }
+            }
+            catch (cause) {
+                throw (terminalFailure(engine, cause, definition) ??
+                    failedAttemptError(engine, cause, startedAt, now(), step?.repeatsEffects() ?? false));
+            }
+            finally {
+                clearTimeout(timer);
+                step?.close();
+            }
+        });
+    };
+    /**
+     * How Step `id` goes on after an attempt that failed with the journaled `outcome`, given what its
+     * earlier attempts spent. A declared error, an exhaustion the Step threw again, and the engine's
+     * cancellation are final: they throw, as the Workflow sees them.
+     */
+    const afterFailure = (id, held, spent, outcome) => {
+        const failed = failedAttemptOf(engine, outcome);
+        if (failed === undefined)
+            throw replayedFailure(engine, outcome, definition, id) ?? outcome;
+        return nextAttempt(spent, failed, held.retry);
+    };
+    /**
+     * One Step, awaited alone: attempted until it succeeds, fails for good or spends its budget, each
+     * attempt after a durable wait the failure of the previous one prescribes.
+     */
+    const attempts = async (id, held, execute) => {
+        let spent;
+        for (;;) {
+            let next;
+            try {
+                return await attempt(id, held, execute);
+            }
+            catch (outcome) {
+                next = afterFailure(id, held, spent, outcome);
+            }
+            if (next.kind === 'exhausted')
+                throw new StepExhausted(id, next.refusal);
+            spent = next.spending;
+            await context.sleep(next.delayMs, `${next.wait}:step:${id}`);
+        }
+    };
+    const step = (declared, execute) => {
+        let accepted;
+        try {
+            accepted = stepDeclaration(declared, serving.step);
+            if (steps.has(accepted.id))
+                throw new TypeError(`Workflow Step ${accepted.id} occurs more than once.`);
+        }
+        catch (cause) {
+            return Promise.reject(cause);
+        }
+        steps.add(accepted.id);
+        return sequenced(`Step ${accepted.id}`, () => attempts(accepted.id, accepted.held, execute));
+    };
+    /**
+     * The Steps `declare` declares, attempted together in rounds, each round awaited through the
+     * engine's combinator as one operation. A Step whose attempt failed and that goes on is attempted
+     * again in the next round, after one durable wait, the longest any of them prescribes; each Step
+     * spends its own budget. Once all have settled, their outputs in declaration order, or the failure
+     * of the first failed one in that order, as that Step alone fails. A cancellation ends the round
+     * it reaches.
+     */
+    const parallel = (declare) => {
+        const declared = new Map();
+        const declaration = (id, execute) => {
+            const accepted = stepDeclaration(id, serving.step);
+            const token = Object.freeze({});
+            declared.set(token, { ...accepted, execute });
+            return token;
+        };
+        let group;
+        try {
+            if (typeof declare !== 'function') {
+                throw new TypeError('step.parallel takes a function declaring its Steps.');
+            }
+            const returned = declare(Object.freeze({
+                run: (id, execute) => declaration(id, execute),
+                query: (id, query, value) => declaration(id, (authority) => authority.query(query, value)),
+                mutate: (id, mutation, value) => declaration(id, (authority) => authority.mutate(mutation, value)),
+            }));
+            if (!Array.isArray(returned) ||
+                returned.length !== declared.size ||
+                new Set(returned).size !== returned.length ||
+                returned.some((entry) => !declared.has(entry))) {
+                throw new TypeError('step.parallel takes exactly the Steps its function declares, each once, as an array.');
+            }
+            group = returned.map((entry) => declared.get(entry));
+            const ids = new Set();
+            for (const { id } of group) {
+                if (steps.has(id) || ids.has(id)) {
+                    throw new TypeError(`Workflow Step ${id} occurs more than once.`);
+                }
+                ids.add(id);
+            }
+        }
+        catch (cause) {
+            return Promise.reject(cause);
+        }
+        if (group.length === 0)
+            return Promise.resolve([]);
+        for (const { id } of group)
+            steps.add(id);
+        return sequenced(`parallel Steps ${group.map(({ id }) => id).join(', ')}`, async () => {
+            const states = group.map((declared) => ({
+                ...declared,
+                spent: undefined,
+                result: undefined,
+            }));
+            for (;;) {
+                const pending = states.filter(({ result }) => result === undefined);
+                const settled = await engine.RestatePromise.allSettled(pending.map(({ id, held, execute }) => attempt(id, held, execute)));
+                const cancelled = settled.find((outcome) => outcome.status === 'rejected' && outcome.reason instanceof engine.CancelledError);
+                if (cancelled !== undefined)
+                    throw cancelled.reason;
+                let delayMs = 0;
+                let wait = BACKOFF;
+                settled.forEach((outcome, index) => {
+                    const state = pending[index];
+                    if (outcome.status === 'fulfilled') {
+                        state.result = outcome;
+                        return;
+                    }
+                    let next;
+                    try {
+                        next = afterFailure(state.id, state.held, state.spent, outcome.reason);
+                    }
+                    catch (failure) {
+                        state.result = { status: 'rejected', reason: failure };
+                        return;
+                    }
+                    if (next.kind === 'exhausted') {
+                        state.result = { status: 'rejected', reason: new StepExhausted(state.id, next.refusal) };
+                        return;
+                    }
+                    state.spent = next.spending;
+                    delayMs = Math.max(delayMs, next.delayMs);
+                    if (next.wait === UNAVAILABLE)
+                        wait = UNAVAILABLE;
+                });
+                if (states.every(({ result }) => result !== undefined))
+                    break;
+                await context.sleep(delayMs, `${wait}:parallel`);
+            }
+            const failed = states.find(({ result }) => result.status === 'rejected');
+            if (failed !== undefined)
+                throw failed.result.reason;
+            return states.map(({ result }) => result.value);
+        });
+    };
+    return Object.freeze({
+        domain,
+        input: envelope.input,
+        execution,
+        error: declaredErrorFactory(definition),
+        step: Object.freeze({
+            run: step,
+            query: (id, query, value) => step(id, (authority) => authority.query(query, value)),
+            mutate: (id, mutation, value) => step(id, (authority) => authority.mutate(mutation, value)),
+            parallel,
+        }),
+        async sleep(durationMs) {
+            if (!Number.isSafeInteger(durationMs) || durationMs < 0 || durationMs > MAXIMUM_SLEEP_MS) {
+                throw new TypeError(`Durable sleep must be an integer between 0 and ${MAXIMUM_SLEEP_MS} ms.`);
+            }
+            await sequenced('sleep', () => Promise.resolve(context.sleep(durationMs)));
+        },
+        async awaitSignal(name, options) {
+            if (typeof name !== 'string' || name.length === 0 || name.length > MAXIMUM_SIGNAL_NAME) {
+                throw new TypeError('Durable signal name must have 1 to 128 characters.');
+            }
+            if (options === undefined) {
+                return (await sequenced(`wait for signal ${name}`, () => Promise.resolve(context.promise(name).get())));
+            }
+            const timeoutMs = options?.timeoutMs;
+            if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > MAXIMUM_SLEEP_MS) {
+                throw new TypeError(`Durable signal timeout must be an integer between 0 and ${MAXIMUM_SLEEP_MS} ms.`);
+            }
+            // The engine journals the race between the signal and the timer: a replay settles it alike.
+            try {
+                const value = await sequenced(`wait for signal ${name}`, () => Promise.resolve(context.promise(name).get().orTimeout(timeoutMs)));
+                return Object.freeze({ kind: 'signal', value });
+            }
+            catch (cause) {
+                if (cause instanceof engine.TimeoutError)
+                    return Object.freeze({ kind: 'timeout' });
+                throw cause;
+            }
+        },
+        cancelled: (error) => error instanceof engine.CancelledError,
+        exhausted: (error) => error instanceof StepExhausted,
+        retryAfter: (delayMs, cause) => new StepRetryAfter(delayMs, cause),
+        ...(execution.receiver === undefined ? {} : { self: execution.receiver }),
+    });
+}
+/** Admit a Step's id, and its declared retry budget and timeout over the deployment's. */
+function stepDeclaration(declared, fallback) {
+    if (typeof declared === 'string')
+        return { id: acceptStepId(declared), held: fallback };
+    if (declared === null ||
+        typeof declared !== 'object' ||
+        Array.isArray(declared) ||
+        Reflect.ownKeys(declared).some((key) => key !== 'id' && key !== 'retry' && key !== 'timeoutMs')) {
+        throw new TypeError('A Workflow Step declaration takes only id, retry and timeoutMs.');
+    }
+    return {
+        id: acceptStepId(declared.id),
+        held: stepServing({ retry: declared.retry, timeoutMs: declared.timeoutMs }, fallback),
+    };
+}
+/**
+ * Rejects with the abort reason once `signal` aborts, at once if it already has: a timeout may fire
+ * while the attempt derives its keys. Never settles otherwise.
+ */
+function expired(signal) {
+    return new Promise((_, reject) => {
+        if (signal.aborted)
+            reject(signal.reason);
+        else
+            signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+    });
+}
+function signalRequest(input) {
+    if (input === null ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        typeof input.name !== 'string') {
+        throw new TypeError('Durable signal request is invalid.');
+    }
+    const { name, value } = input;
+    if (name.length === 0 || name.length > MAXIMUM_SIGNAL_NAME) {
+        throw new TypeError('Durable signal name must have 1 to 128 characters.');
+    }
+    return { name, value: value ?? null };
+}

package/dist/execution/workflows/steps.d.ts

@@ -0,0 +1,48 @@
+import type { IntegrationClientFactory, Integrations } from '../../application/integration/index.js';
+import type { DurableExecution, DurableStepAuthority } from '../../application/workflow/index.js';
+import type { BoundClientSession } from '../../platform/client/session/index.js';
+import type { Domain } from '../../platform/schema/index.js';
+import type { Identity } from '../identity/index.js';
+import type { Lifetime } from '../invocation/lifecycle/index.js';
+type Executor = NonNullable<Identity['executor']>;
+/** One attempt of one Step: its journal name, its Execution, its key sequence and its bounds. */
+export interface StepAttempt {
+    readonly name: string;
+    readonly execution: DurableExecution;
+    /** The next key of the Step's sequence; the sequence restarts with every attempt. */
+    readonly next: () => string;
+    readonly lifetime: Lifetime;
+}
+/** What one Step attempt holds, released once the attempt ends. */
+export interface StepAuthorityBinding {
+    readonly authority: DurableStepAuthority;
+    /** Whether the attempt ran an `invoke` without a key, which the next attempt runs again. */
+    repeatsEffects(): boolean;
+    close(): void;
+}
+/** Bind the capabilities one Step attempt holds. */
+export type StepAuthorities = (attempt: StepAttempt) => StepAuthorityBinding;
+/**
+ * Steps acting as the Domain through a Session of the Execution they belong to: the capabilities of
+ * an Action over the keyed Session, and the Runtime's Integration clients over the same keys.
+ */
+export declare function sessionSteps(input: {
+    readonly executor: Executor;
+    readonly domain: Domain;
+    readonly integrations: IntegrationClientFactory<Integrations>;
+}): StepAuthorities;
+/**
+ * Every Mutation and every `invoke` of a durable callable of one Step without its own key carries
+ * the next key of the Step's sequence. The sequence restarts with every attempt, so a retried Step
+ * replays the same keys: the Kernel answers a Mutation with its receipt and a durable call with the
+ * Execution it started, or refuses a request that changed under its key. Any other `invoke` carries
+ * no key, because the Kernel accepts one only for a durable Function, and runs again with the Step.
+ *
+ * A keyed call and a Query repeat no effect when sent again, so their failures are marked
+ * resendable: an unreachable Kernel then costs the Step no attempt. `unkeyed` hears each `invoke`
+ * without a key that may have run.
+ */
+export declare function keyed<Session extends Pick<BoundClientSession, 'invoke' | 'mutate'>>(session: Session, domain: Domain, next: () => string, unkeyed: () => void): Session;
+/** The key sequence of one Step of one Execution: `<execution>.<digest of the name>.<position>`. */
+export declare function keySequence(execution: DurableExecution['id'], name: string): Promise<() => string>;
+export {};

package/dist/execution/workflows/steps.js

@@ -0,0 +1,93 @@
+import { bindSession } from '../../platform/client/session/index.js';
+import { bindCapabilities } from '../invocation/capabilities/index.js';
+import { bindIntegrationAuthentication } from '../invocation/integration/index.js';
+import { resendableCall, unkeyedCall } from './attempts.js';
+import { stepCalls } from './integrations.js';
+/**
+ * Steps acting as the Domain through a Session of the Execution they belong to: the capabilities of
+ * an Action over the keyed Session, and the Runtime's Integration clients over the same keys.
+ */
+export function sessionSteps(input) {
+    const { executor, domain, integrations } = input;
+    return ({ execution, next, lifetime }) => {
+        const session = executor(execution.kernel, execution.id, lifetime);
+        try {
+            const bound = bindSession(session, lifetime);
+            let repeats = false;
+            const self = keyed(bound, domain, next, () => {
+                repeats = true;
+            });
+            const auth = bindIntegrationAuthentication(lifetime, bound);
+            const authority = Object.freeze({
+                ...bindCapabilities(domain, { self }),
+                integrations: integrations(stepCalls({ next, lifetime, auth })),
+            });
+            return Object.freeze({
+                authority,
+                repeatsEffects: () => repeats,
+                close: () => session.close(),
+            });
+        }
+        catch (cause) {
+            session.close();
+            throw cause;
+        }
+    };
+}
+/**
+ * Every Mutation and every `invoke` of a durable callable of one Step without its own key carries
+ * the next key of the Step's sequence. The sequence restarts with every attempt, so a retried Step
+ * replays the same keys: the Kernel answers a Mutation with its receipt and a durable call with the
+ * Execution it started, or refuses a request that changed under its key. Any other `invoke` carries
+ * no key, because the Kernel accepts one only for a durable Function, and runs again with the Step.
+ *
+ * A keyed call and a Query repeat no effect when sent again, so their failures are marked
+ * resendable: an unreachable Kernel then costs the Step no attempt. `unkeyed` hears each `invoke`
+ * without a key that may have run.
+ */
+export function keyed(session, domain, next, unkeyed) {
+    const invokeSource = session.invoke;
+    const mutateSource = session.mutate;
+    const querySource = session.query;
+    const invoke = ((reference, value, options) => {
+        const sent = declaredDurable(domain, reference) ? withKey(options, next) : options;
+        const send = () => invokeSource(reference, value, sent);
+        return sent?.idempotencyKey === undefined ? unkeyedCall(send, unkeyed) : resendableCall(send);
+    });
+    const mutate = ((author, options) => {
+        const sent = withKey(options, next);
+        return sentKeyed(sent, () => mutateSource(author, sent));
+    });
+    const query = querySource === undefined
+        ? {}
+        : { query: (...input) => resendableCall(() => querySource(...input)) };
+    return Object.freeze({ ...session, invoke, mutate, ...query });
+}
+function sentKeyed(options, send) {
+    return options?.idempotencyKey === undefined ? send() : resendableCall(send);
+}
+/**
+ * Whether the Domain's Schema closure declares the referenced callable durable. An untyped Path
+ * names no declaration and a callable outside the closure has none here: both need their own key.
+ */
+function declaredDurable(domain, reference) {
+    if (reference === null || typeof reference !== 'object')
+        return false;
+    const key = reference.callable;
+    return (typeof key === 'string' && domain.callable(key)?.execution?.durable === true);
+}
+function withKey(options, next) {
+    if (options?.idempotencyKey !== undefined || options?.body !== undefined)
+        return options;
+    return { ...options, idempotencyKey: next() };
+}
+/** The key sequence of one Step of one Execution: `<execution>.<digest of the name>.<position>`. */
+export async function keySequence(execution, name) {
+    const digest = new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(name)));
+    const prefix = `${execution}.${Array.from(digest.subarray(0, 12), hex).join('')}`;
+    let position = 0;
+    return () => `${prefix}.${++position}`;
+}
+function hex(byte) {
+    return byte.toString(16).padStart(2, '0');
+}

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 /** Curated SDK authoring journey. Semantic values remain available from focused subpaths. */
 export { defineAction } from './application/action/index.js';
 export type { Action, ActionContext, ActionOutputOf, Caller, DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, } from './application/action/index.js';
-export { defineApplication, defineFrontend, external, requirements, route, routes, vite, } from './application/index.js';
-export type { Application, Frontend, Requirements, Route, Routes } from './application/index.js';
+export { defineDomain, defineFrontend, external, requirements, route, routes, vite, } from './application/index.js';
+export type { DomainDefinition, Frontend, Requirements, Route, Routes, } from './application/index.js';
 export { defineIntegration, defineProvider } from './application/integration/index.js';
 export type { IntegrationClient, IntegrationDefinition, Provider, } from './application/integration/index.js';
 export { defineMutation, executeMutation } from './application/mutation/index.js';
@@ -13,9 +13,9 @@ export { defineRuntime } from './application/runtime/index.js';
 export type { Runtime } from './application/runtime/index.js';
 export { defineWorkflow } from './application/workflow/index.js';
 export type { Workflow, WorkflowContext } from './application/workflow/index.js';
-export { compile, deploy, runtime } from './deployment/index.js';
+export { compile, runtime } from './deployment/index.js';
 export type { Build, Deployment, Release } from './deployment/index.js';
 export { defineProject } from './project/index.js';
 export type { Project } from './project/index.js';
 export { serve } from './execution/index.js';
-export type { ServedApplication } from './execution/index.js';
+export type { ServedDomain } from './execution/index.js';

package/dist/index.js

@@ -1,11 +1,11 @@
 /** Curated SDK authoring journey. Semantic values remain available from focused subpaths. */
 export { defineAction } from './application/action/index.js';
-export { defineApplication, defineFrontend, external, requirements, route, routes, vite, } from './application/index.js';
+export { defineDomain, defineFrontend, external, requirements, route, routes, vite, } from './application/index.js';
 export { defineIntegration, defineProvider } from './application/integration/index.js';
 export { defineMutation, executeMutation } from './application/mutation/index.js';
 export { defineCollectionQuery, defineCompositeQuery, defineQuery, executeQuery, } from './application/query/index.js';
 export { defineRuntime } from './application/runtime/index.js';
 export { defineWorkflow } from './application/workflow/index.js';
-export { compile, deploy, runtime } from './deployment/index.js';
+export { compile, runtime } from './deployment/index.js';
 export { defineProject } from './project/index.js';
 export { serve } from './execution/index.js';

package/dist/platform/graph/alias.d.ts

@@ -1,6 +1,2 @@
 /** Graph-local names retain the canonical Kernel type and constructor identity. */
-export { LocalBinding as LocalAlias, isLocalBinding as isLocalAlias, } from '@astrale-os/kernel-core/graph/graph';
-/** @deprecated Use LocalAlias. */
-export { LocalBinding } from '@astrale-os/kernel-core/graph/graph';
-/** @deprecated Use isLocalAlias. */
-export { isLocalBinding } from '@astrale-os/kernel-core/graph/graph';
+export { LocalAlias, isLocalAlias } from '@astrale-os/kernel-core/graph/graph';

package/dist/platform/graph/alias.js

@@ -1,6 +1,2 @@
 /** Graph-local names retain the canonical Kernel type and constructor identity. */
-export { LocalBinding as LocalAlias, isLocalBinding as isLocalAlias, } from '@astrale-os/kernel-core/graph/graph';
-/** @deprecated Use LocalAlias. */
-export { LocalBinding } from '@astrale-os/kernel-core/graph/graph';
-/** @deprecated Use isLocalAlias. */
-export { isLocalBinding } from '@astrale-os/kernel-core/graph/graph';
+export { LocalAlias, isLocalAlias } from '@astrale-os/kernel-core/graph/graph';

package/dist/platform/graph/document/index.d.ts

@@ -1,3 +1,3 @@
 /** Canonical graph documents and local aliases. */
 export * from '@astrale-os/kernel-core/graph/graph';
-export { LocalAlias, isLocalAlias, LocalBinding, isLocalBinding } from '../alias.js';
+export { LocalAlias, isLocalAlias } from '../alias.js';

package/dist/platform/graph/document/index.js

@@ -1,3 +1,3 @@
 /** Canonical graph documents and local aliases. */
 export * from '@astrale-os/kernel-core/graph/graph';
-export { LocalAlias, isLocalAlias, LocalBinding, isLocalBinding } from '../alias.js';
+export { LocalAlias, isLocalAlias } from '../alias.js';

package/dist/platform/graph/index.d.ts

@@ -1,6 +1,6 @@
 /** Curated aggregate over canonical graph values. */
 export { GraphData, GraphDataDecodeError, GraphSpec, GraphSpecDecodeError, } from '@astrale-os/kernel-core/graph/graph';
-export { LocalAlias, isLocalAlias, LocalBinding, isLocalBinding } from './alias.js';
+export { LocalAlias, isLocalAlias } from './alias.js';
 export type { AnonymousNodeSpec, GraphDataJson, GraphSpecEdge, GraphSpecEndpoint, GraphSpecJson, GraphSpecNode, } from '@astrale-os/kernel-core/graph/graph';
 export * from './edge/index.js';
 export * from './node/index.js';

package/dist/platform/graph/index.js

@@ -1,6 +1,6 @@
 /** Curated aggregate over canonical graph values. */
 export { GraphData, GraphDataDecodeError, GraphSpec, GraphSpecDecodeError, } from '@astrale-os/kernel-core/graph/graph';
-export { LocalAlias, isLocalAlias, LocalBinding, isLocalBinding } from './alias.js';
+export { LocalAlias, isLocalAlias } from './alias.js';
 export * from './edge/index.js';
 export * from './node/index.js';
 export * from './path/index.js';

package/dist/platform/release/index.d.ts

@@ -0,0 +1,2 @@
+/** Canonical DomainRelease v4 and Delivery v2 wire contracts. */
+export * from '@astrale-os/kernel-protocol/release';

package/dist/platform/release/index.js

@@ -0,0 +1,2 @@
+/** Canonical DomainRelease v4 and Delivery v2 wire contracts. */
+export * from '@astrale-os/kernel-protocol/release';

package/dist/platform/schema/callable-authoring.d.ts

@@ -0,0 +1,21 @@
+import { func as kernelFunc, method as kernelMethod, type CallablePolicyBuilder, type FunctionInput, type Method, type MethodInput } from '@astrale-os/kernel-dsl/v1/builder';
+/** Who may call an authorized callable: Policy checks, or the constant `true` or `false`. */
+export type CallerRule = CallablePolicyBuilder | boolean;
+/**
+ * An executable `authorized` callable declares its caller rule. An abstract Method is a contract
+ * on an abstract Class and executable on a concrete one, so its rule is settled by the Class that
+ * declares it.
+ */
+export type DeclaredCallerRule<Config> = Config extends {
+    readonly auth: 'authorized';
+} ? Config extends {
+    readonly abstract: true;
+} ? unknown : {
+    readonly policy: CallerRule;
+} : unknown;
+/** Author a Function. An `authorized` Function declares its caller rule. */
+export declare function func<const Config extends FunctionInput>(config: Config & DeclaredCallerRule<Config>): ReturnType<typeof kernelFunc<Config>>;
+/** Author a Method. An executable `authorized` Method declares its caller rule. */
+export declare function method<const Config extends MethodInput>(config: Config & DeclaredCallerRule<Config>): ReturnType<typeof kernelMethod<Config>>;
+/** A concrete Class executes every Method it declares, abstract contracts included. */
+export declare function assertNoUndeclaredCallerRule(methods: Readonly<Record<string, Method>> | undefined): void;

package/dist/platform/schema/callable-authoring.js

@@ -0,0 +1,27 @@
+import { func as kernelFunc, method as kernelMethod, } from '@astrale-os/kernel-dsl/v1/builder';
+/** Authorized abstract Methods authored without a caller rule, until a Class declares them. */
+const undeclared = new WeakSet();
+export function func(config) {
+    if (config.auth === 'authorized' && config.policy === undefined)
+        undeclaredCallerRule('Function');
+    return kernelFunc(config);
+}
+export function method(config) {
+    const value = kernelMethod(config);
+    if (config.auth === 'authorized' && config.policy === undefined) {
+        if (config.abstract !== true)
+            undeclaredCallerRule('Method');
+        undeclared.add(value);
+    }
+    return value;
+}
+/** A concrete Class executes every Method it declares, abstract contracts included. */
+export function assertNoUndeclaredCallerRule(methods) {
+    for (const [name, value] of Object.entries(methods ?? {})) {
+        if (undeclared.has(value))
+            undeclaredCallerRule(`Method ${name}`);
+    }
+}
+function undeclaredCallerRule(subject) {
+    throw new TypeError(`${subject} is authorized and executable: declare its policy with Policy checks, true or false.`);
+}