@astrale-os/sdk 0.5.0-beta.14 → 0.5.0-beta.140

package/README.md

@@ -1,29 +1,26 @@
 # SDK
 
-Schema-first SDK for defining, composing, and deploying Astrale Domains. The public authoring
-surface covers Domain handlers, provider-neutral Capabilities, Workflows, Query, Mutation, State,
-and deployment adapters without coupling business code to one host runtime.
+Schema-first SDK for authoring and deploying Astrale Applications. The public surface separates
+single-step Actions, explicit multi-step Workflows, provider-neutral Integrations, concrete Providers, graph
+authoring, Application composition, Deployment, and Execution without exposing DSL callable
+topology in implementation files.
 
 [![CI](https://github.com/astrale-os/sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/astrale-os/sdk/actions/workflows/ci.yml)
 [![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
 
 ## Install
 
-Configure the Astrale scope for GitHub Packages and provide a token with `read:packages`; the SDK's
-Kernel dependencies are intentionally distributed there:
-
-```ini
-# ~/.npmrc
-registry=https://registry.npmjs.org/
-@astrale-os:registry=https://npm.pkg.github.com/
-//npm.pkg.github.com/:_authToken=${NODE_AUTH_TOKEN}
-```
+The SDK and its complete runtime dependency graph are public on npm and require no GitHub token:
 
 ```bash
-export NODE_AUTH_TOKEN="$(gh auth token)"
 npm install @astrale-os/sdk
 ```
 
+Zod schemas cross the SDK and Kernel compiler boundary by runtime identity. The SDK therefore
+declares one exact, non-optional Zod peer. If an Application declares Zod directly, it must use the
+same exact version rather than a range; a second physical Zod runtime is not an admitted authoring
+environment.
+
 During the beta program, opt in explicitly:
 
 ```bash
@@ -31,19 +28,109 @@ npm install @astrale-os/sdk@beta
 npx -y create-astrale-domain@beta my-domain --yes
 ```
 
-See [the release lifecycle](docs/release.md) for package-cohort versioning, verification, and stable
+See [the release lifecycle](docs/release.md) for package-set versioning, verification, and stable
 promotion.
 
+### Update a pnpm project
+
+```sh
+pnpm exec astrale-domain upgrade --check  # Preview; no project changes
+pnpm exec astrale-domain upgrade          # Update existing Astrale dependencies to beta
+```
+
+The command covers the workspace root and its packages, pins exact versions, and updates the
+lockfile through pnpm. Use `--channel latest` to select that tag instead. Missing tags and local,
+catalog, or aliased dependencies are left unchanged and reported; peers and overrides are not edited.
+For an older SDK without this command, start with `pnpm dlx @astrale-os/sdk@beta upgrade`.
+Stop development watchers first, then run the project's checks and validate on development.
+Nothing is committed or deployed. A Shell update also requires checking the installed Shell revision.
+Rerunning an upgrade synchronizes installation even when the manifest versions are already current.
+
+## Handler authority and dependencies
+
+Authenticated handlers use Domain self authority for `kernel`, `graph`, `query`, and `mutate`.
+`dependencies.directory.invoke(d => d.functions.lookup, input)` calls a direct declared dependency
+with the incoming caller Grant. Explicit authority remains on `kernel` and `graph`; the former
+handler `client` is removed. See [the API and migration guide](docs/handler-dependencies.md).
+
+## Node Class icons
+
+Every Node Class authored through the SDK must explicitly declare a self-contained SVG icon.
+Omission is rejected by TypeScript, at the runtime authoring boundary, and by the
+`SCH-ICON-REQUIRED` linter rule. Prefer framework-neutral Lucide data when an icon exists in that
+catalog:
+
+```typescript
+import { classIcon, nodeClass } from '@astrale-os/sdk/schema'
+import { FileText } from '@astrale-os/sdk/schema/icons'
+
+export const Article = nodeClass({
+  icon: classIcon.lucide(FileText),
+})
+```
+
+Use `classIcon.svg(source)` for a custom self-contained SVG. If no meaningful icon has been chosen,
+declare `icon: classIcon.neutral` explicitly. This stable empty SVG renders no glyph and remains
+valid; the linter emits a non-failing `SCH-ICON-NEUTRAL` warning. Bare names such as `"file-text"`,
+non-canonical empty SVGs, external references, and executable SVG content are rejected during
+Schema authoring.
+
+## Business-error declarations
+
+Declare reusable business errors in `schema/modules/<module>/errors/` through the Schema facade:
+
+```typescript
+import { error } from '@astrale-os/sdk/schema/errors'
+import { z } from 'zod'
+
+export const resourceUnavailable = error({
+  family: 'NOT_FOUND',
+  message: 'The selected resource is unavailable.',
+  details: z.strictObject({ resource: z.string() }),
+})
+```
+
+Register the declaration under a code in an Action or Workflow's options:
+`{ errors: { RESOURCE_UNAVAILABLE: resourceUnavailable } }`. Its handler can then
+`throw error('RESOURCE_UNAVAILABLE', { resource: id })` using the context factory.
+The builder validates and freezes declaration metadata while preserving exact details inference.
+Use `sdk/schema/errors` for declarations shared with handlers: this narrow entrypoint keeps the
+Schema compiler and Kernel Schema initialization out of the deployed Runtime.
+Error declarations are not yet published in the installed Kernel Schema.
+
 ## Development
 
+### Core Identity requirements
+
+Use `requirements({ core: [{ subject, functions, classes, authority }] })` to declare capabilities
+for an Identity in the Application's local Core. `subject` is the resolved Core Node; each entry
+must request at least one capability. The top-level `functions`, `classes`, and `authority` members
+describe capabilities for the Domain principal.
+
+This replaces `requirements.profiles`. Rename that property to `core` and imported
+`CapabilityProfileRequirement` / `CapabilityProfileRequirementInput` types to `CoreRequirement` /
+`CoreRequirementInput`. Builds emit `requirements.capabilities.core`; new releases use Publication
+v3 and require a Kernel that supports it. That Kernel can restore historical v2 Publications and
+installation ledgers without changing their existing authority or integrity evidence.
+
 ### Prerequisites
 
 - Node.js 26.7.0 (default) or Node.js 24; published packages remain compatible with Node.js 22+
-- pnpm 11.13.1
+- pnpm 12.1.0
 
 ### Setup
 
-The SDK is consumed as a submodule of the main Astrale workspace:
+The repository installs autonomously from its versioned npm-only lockfile:
+
+```bash
+git clone https://github.com/astrale-os/sdk.git
+cd sdk
+AGENT_HARNESSES=codex bash scripts/setup/setup.sh
+```
+
+See [agent setup](scripts/setup/README.md) for Claude Cloud and validation.
+
+It can also be consumed as a submodule of the main Astrale workspace:
 
 ```bash
 git clone --recursive https://github.com/astrale-os/workspace.git
@@ -65,7 +152,7 @@ pnpm check:issues    # Validate structured cross-repository issues
 The structured [Domain authoring knowledge](knowledge/README.md) is the source for contributor
 guidance and the generated linter policy.
 
-### Domain lint layout overrides
+### Domain lint configuration
 
 `astrale-domain lint` defaults to the canonical layer roots and aliases, including `functions/`,
 `#functions`, and `#functions/*`. A Domain that uses different physical vocabulary can remap a
@@ -75,19 +162,65 @@ semantic layer in `astrale.lint.json` without changing the rules attached to tha
 {
   "layers": {
     "functions": {
-      "sourcePath": "actions/",
-      "alias": "#actions"
+      "sourcePath": "operations/",
+      "alias": "#operations"
     }
   }
 }
 ```
 
-The linter then expects `actions/`, `#actions`, and `#actions/*` in the source tree,
+The linter then expects `operations/`, `#operations`, and `#operations/*` in the source tree,
 `compilerOptions.paths`, and `package.json#imports`. Omit the file to keep the canonical defaults.
 
+If a Domain rule has a known false positive or evaluator defect, disable that exact rule for the
+whole project with a committed reason:
+
+```json
+{
+  "disabledRules": {
+    "PRV-XDOM-REQ": "False positive for a generated Provider wrapper; reported upstream."
+  }
+}
+```
+
+Disabled rules are skipped before evaluation and remain visible in lint coverage and reports. Use
+`// astrale-disable-next-line RULE-ID -- reason` for an isolated conclusive violation instead. A
+project rule disable does not bypass generic Oxlint, project admission, type-universe checks, or
+linter tool failures.
+
 Structured review [issues](issues/README.md) retain observation-first evidence and later governance
 attachments without becoming current contract authority.
 
+## Dataset references
+
+A Dataset can materialize a projected Node explicitly with `ref`, using its resolved local or
+direct-dependency definition:
+
+```typescript
+const demo = defineDataset(Schema, {
+  id: 'demo',
+  graph({ domain, ref }) {
+    const member = ref(domain.core.nodes.member)
+    // Repeating ref returns the same Dataset Node. node() always creates a separate identity.
+    return { member }
+  },
+})
+```
+
+`ref` uses the canonical symbolic Schema projection for Class, Function, Policy, View and Core
+facts. The Dataset's `references` table retains the explicit association between each projected
+NodePath and its Dataset Node ID through encoding and decoding. Matching properties or slugs do
+not create that association. Studio uses it when simulating `sameNode` and reference endpoints;
+a missing association makes that simulation unavailable.
+
+## Kernel publication discovery
+
+Use `session.publication()` when a consumer needs the intrinsic Kernel's published identity or
+endpoints without its schema bundle or Views. It revalidates through the Client's existing issuer,
+URL, size, and ETag checks. Concurrent publication and snapshot observations share acquisition;
+cancelling one observer does not cancel another. `session.snapshot()` remains the complete,
+coherent Publication, bundle, and View catalog observation.
+
 ## License
 
 Apache License 2.0 — see [LICENSE](LICENSE) for details.

package/dist/application/action/action.d.ts

@@ -0,0 +1,43 @@
+import type { Domain, ResolvedMethod, schema } from '../../platform/schema/index.js';
+import type { DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
+import type { Integrations } from '../integration/index.js';
+import type { ActionContext, ResolvedCallable } from './context.js';
+import type { ActionOutputOf } from './output.js';
+export type Values<Value> = Value[keyof Value];
+type MethodValues<Class> = Class extends {
+    readonly self: {
+        readonly methods: {
+            readonly byKey: infer Instance extends Readonly<Record<string, unknown>>;
+        };
+        readonly static: {
+            readonly methods: {
+                readonly byKey: infer Static extends Readonly<Record<string, unknown>>;
+            };
+        };
+    };
+} ? Values<Instance> | Values<Static> : never;
+type Executable<Callable> = Callable extends ResolvedMethod ? Callable extends {
+    readonly executable: true;
+} ? Callable : never : Callable;
+/** Every root-owned callable implementation contract, independent of Function or Method topology. */
+export type LocalCallable<DomainValue extends Domain> = Extract<Values<DomainValue['functions']>, ResolvedCallable> | Extract<Executable<MethodValues<Values<DomainValue['classes']>>>, ResolvedCallable>;
+export type ActionAddressOf<Callable> = Callable extends {
+    readonly key: `${string}:function.${infer Name}`;
+} ? Name : Callable extends {
+    readonly key: `${string}:class.${infer Owner}.method.${infer Name}`;
+} ? `${Owner}.${Name}` : never;
+export type ResolvedDomainOf<Schema extends schema.DomainSchema> = Extract<schema.DomainOf<Schema>, Domain>;
+/** SDK Action address derived mechanically from the canonical local callable key. */
+export type ActionAddress<Schema extends schema.DomainSchema> = ActionAddressOf<LocalCallable<ResolvedDomainOf<Schema>>>;
+export type CallableAtAddress<Schema extends schema.DomainSchema, Address extends string> = LocalCallable<ResolvedDomainOf<Schema>> extends infer Callable ? Callable extends unknown ? ActionAddressOf<Callable> extends Address ? Callable : never : never : never;
+export type Action<Callable extends ResolvedCallable, Definitions extends Integrations = Readonly<Record<never, never>>, DomainValue extends Domain = Domain, Errors extends DeclaredErrors = NoDeclaredErrors> = (context: ActionContext<Callable, DomainValue, Definitions, Errors>) => Promise<ActionOutputOf<Callable>>;
+declare const ACTION_SCHEMA: unique symbol;
+/** Sealed standalone Action awaiting canonical callable association by Runtime admission. */
+export interface ActionDefinition<Schema extends schema.DomainSchema = schema.DomainSchema, Address extends ActionAddress<Schema> = ActionAddress<Schema>, Definitions extends Integrations = Readonly<Record<never, never>>, Errors extends DeclaredErrors = NoDeclaredErrors> {
+    readonly kind: 'action';
+    readonly address: Address;
+    readonly run: Action<Extract<CallableAtAddress<Schema, Address>, ResolvedCallable>, Definitions, ResolvedDomainOf<Schema>, Errors>;
+    /** Invariant type-only Schema witness; absent from emitted JavaScript. */
+    readonly [ACTION_SCHEMA]: (schema: Schema) => Schema;
+}
+export {};

package/dist/application/action/action.js

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

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

@@ -0,0 +1,5 @@
+export { defineAction } from './define.js';
+export type { Action, ActionDefinition } from './action.js';
+export type { ActionContext, ActionExecution, Caller, DomainGraphExecutor, DomainGraphExecutors, DomainKernelSessions, } from './context.js';
+export type { ActionBinary, ActionOutputOf } from './output.js';
+export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, } from '../error/index.js';

package/dist/application/action/authoring.js

@@ -0,0 +1 @@
+export { defineAction } from './define.js';

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

@@ -0,0 +1,87 @@
+import type { AuthenticationEvidence, Grant, IdentityId } from '../../platform/auth/index.js';
+import type { BoundClientSession } from '../../platform/client/session/index.js';
+import type { NodeId } from '../../platform/graph/node/index.js';
+import type { CallableInputOf, Domain, ResolvedFunction, ResolvedMethod } from '../../platform/schema/index.js';
+import type { HandlerDependencies } from '../dependency/index.js';
+import type { DeclaredErrorFactory, DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
+import type { IntegrationClients, Integrations } from '../integration/index.js';
+import type { MutationExecutor } from '../mutation/index.js';
+import type { QueryExecutor } from '../query/index.js';
+export type ResolvedCallable = ResolvedFunction | ResolvedMethod;
+/** Bearer-free caller evidence established before an Action or Workflow runs. */
+export interface AuthenticatedCaller {
+    readonly kind: 'authenticated';
+    /** Exact effective caller Identity. Access fails when authority is compound. */
+    readonly identity: IdentityId;
+    /** Identity whose credential directly authenticated this invocation. */
+    readonly principal: IdentityId;
+    readonly authority: Grant;
+    readonly authentication: AuthenticationEvidence;
+}
+export interface AnonymousCaller {
+    readonly kind: 'anonymous';
+}
+export type Caller = AuthenticatedCaller | AnonymousCaller;
+/** One invocation lifetime, retained without exposing Server implementation details. */
+export interface ActionExecution {
+    readonly signal: AbortSignal;
+    /** Absolute Unix time in milliseconds. */
+    readonly deadline: number;
+    readonly idempotencyKey?: string;
+    readonly background: (task: () => void | PromiseLike<unknown>) => void;
+    readonly sleep: (durationMs: number) => Promise<void>;
+    readonly request?: {
+        body(): Uint8Array;
+    };
+}
+export interface DomainGraphExecutor<DomainValue extends Domain = Domain> {
+    readonly query: QueryExecutor<DomainValue>;
+    readonly mutate: MutationExecutor<DomainValue>;
+}
+export type DomainGraphExecutors<DomainValue extends Domain = Domain> = Readonly<DomainGraphExecutor<DomainValue> & Record<'caller' | 'self' | 'union', DomainGraphExecutor<DomainValue>>>;
+/** Self-default Kernel session with one level of explicit authority selection. */
+export type DomainKernelSessions = Readonly<BoundClientSession & Record<'caller' | 'self' | 'union', BoundClientSession>>;
+type AuthorityOf<Callable, DomainValue extends Domain> = Callable extends {
+    readonly auth: 'anonymous';
+} ? {
+    readonly caller: AnonymousCaller;
+    readonly dependencies: null;
+    readonly kernel: null;
+    readonly graph: null;
+    readonly query?: never;
+    readonly mutate?: never;
+} | {
+    readonly caller: AuthenticatedCaller;
+    readonly dependencies: HandlerDependencies<DomainValue>;
+    readonly kernel: DomainKernelSessions;
+    readonly graph: DomainGraphExecutors<DomainValue>;
+    /** Convenience executor using the installed Domain authority (`graph.self`). */
+    readonly query: QueryExecutor<DomainValue>;
+    /** Convenience executor using the installed Domain authority (`graph.self`). */
+    readonly mutate: MutationExecutor<DomainValue>;
+} : {
+    readonly caller: AuthenticatedCaller;
+    readonly dependencies: HandlerDependencies<DomainValue>;
+    readonly kernel: DomainKernelSessions;
+    readonly graph: DomainGraphExecutors<DomainValue>;
+    /** Convenience executor using the installed Domain authority (`graph.self`). */
+    readonly query: QueryExecutor<DomainValue>;
+    /** Convenience executor using the installed Domain authority (`graph.self`). */
+    readonly mutate: MutationExecutor<DomainValue>;
+};
+type SelfOf<Callable> = Callable extends ResolvedMethod<unknown, unknown, false> ? {
+    readonly self: NodeId;
+} : {
+    readonly self?: never;
+};
+/** Exact single-step Action context derived from one resolved callable. */
+export type ActionContext<Callable extends ResolvedCallable, DomainValue extends Domain = Domain, Definitions extends Integrations = Readonly<Record<never, never>>, Errors extends DeclaredErrors = NoDeclaredErrors> = {
+    /** Exact admitted Domain retained by the Build being executed. */
+    readonly domain: DomainValue;
+    readonly input: CallableInputOf<Callable>;
+    readonly integrations: IntegrationClients<Definitions>;
+    readonly execution: ActionExecution;
+    /** Construct one implementation-declared safe business error for `throw error(...)`. */
+    readonly error: DeclaredErrorFactory<Errors>;
+} & AuthorityOf<Callable, DomainValue> & SelfOf<Callable>;
+export {};

package/dist/application/action/context.js

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

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

@@ -0,0 +1,12 @@
+import type { schema } from '../../platform/schema/index.js';
+import type { DeclaredErrorOptions, DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
+import type { Integrations } from '../integration/index.js';
+import type { Action, ActionAddress, ActionDefinition, CallableAtAddress, ResolvedDomainOf } from './action.js';
+import type { ResolvedCallable } from './context.js';
+/** Define one simple single-step implementation by its SDK Action address. */
+export declare function defineAction<Schema extends schema.DomainSchema, Definitions extends Integrations = Readonly<Record<never, never>>>(): {
+    <const Address extends ActionAddress<Schema>>(address: Address, run: Action<Extract<CallableAtAddress<Schema, Address>, ResolvedCallable>, Definitions, ResolvedDomainOf<Schema>, NoDeclaredErrors>): ActionDefinition<Schema, Address, Definitions, NoDeclaredErrors>;
+    <const Address extends ActionAddress<Schema>, const Errors extends DeclaredErrors>(address: Address, options: DeclaredErrorOptions<Errors>, run: Action<Extract<CallableAtAddress<Schema, Address>, ResolvedCallable>, Definitions, ResolvedDomainOf<Schema>, Errors>): ActionDefinition<Schema, Address, Definitions, Errors>;
+};
+/** True only for an Action produced by defineAction in this SDK package root. */
+export declare function isAction(input: unknown): input is ActionDefinition;

package/dist/application/action/define.js

@@ -0,0 +1,34 @@
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { rememberDeclaredErrors } from '../error/index.js';
+const admittedActions = new WeakSet();
+/** Define one simple single-step implementation by its SDK Action address. */
+export function defineAction() {
+    return function define(address, optionsOrRun, possibleRun) {
+        acceptActionAddress(address);
+        const options = possibleRun === undefined ? undefined : optionsOrRun;
+        const run = possibleRun ?? optionsOrRun;
+        if (typeof run !== 'function')
+            throw new TypeError('Action run must be a function.');
+        const action = Object.freeze({ kind: 'action', address, run });
+        if (options !== undefined)
+            rememberDeclaredErrors(action, options);
+        admittedActions.add(action);
+        return action;
+    };
+}
+/** True only for an Action produced by defineAction in this SDK package root. */
+export function isAction(input) {
+    return input !== null && typeof input === 'object' && admittedActions.has(input);
+}
+function acceptActionAddress(input) {
+    if (typeof input !== 'string')
+        invalidAddress(input);
+    const members = input.split('.');
+    if ((members.length !== 1 && members.length !== 2) ||
+        members.some((member) => !patterns.memberName.test(member))) {
+        invalidAddress(input);
+    }
+}
+function invalidAddress(input) {
+    throw new TypeError(`Invalid Action address: ${JSON.stringify(input)}.`);
+}

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

@@ -0,0 +1,5 @@
+export { defineAction, isAction } from './define.js';
+export type { Action, ActionAddress, ActionAddressOf, ActionDefinition, CallableAtAddress, LocalCallable, ResolvedDomainOf, } from './action.js';
+export type { ActionContext, ActionExecution, AnonymousCaller, AuthenticatedCaller, Caller, DomainGraphExecutor, DomainGraphExecutors, DomainKernelSessions, ResolvedCallable, } from './context.js';
+export type { ActionBinary, ActionOutputOf } from './output.js';
+export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, } from '../error/index.js';

package/dist/application/action/index.js

@@ -0,0 +1 @@
+export { defineAction, isAction } from './define.js';

package/dist/application/action/output.d.ts

@@ -0,0 +1,6 @@
+import type { BinaryOutput, BufferedBinaryResult, StreamingBinaryResult } from '@astrale-os/kernel-core/callable';
+import type { CallableResultOf } from '../../platform/schema/index.js';
+import type { ResolvedCallable } from './context.js';
+/** Logical output authored for the callable's exact value, stream, or binary mode. */
+export type ActionOutputOf<Callable extends ResolvedCallable> = CallableResultOf<Callable, BinaryOutput>;
+export type { BinaryOutput as ActionBinary, BufferedBinaryResult, StreamingBinaryResult };

package/dist/application/action/output.js

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

package/dist/application/application.d.ts

@@ -0,0 +1,28 @@
+import type { schema } from '../platform/schema/index.js';
+import type { Requirements } from './requirements/index.js';
+import type { Routes } from './routes/index.js';
+import type { Runtime, SchemaOfRuntime as RuntimeSchemaOf } from './runtime/index.js';
+import type { Frontend } from './view/index.js';
+declare const APPLICATION_IDENTITY: unique symbol;
+declare const APPLICATION_SCHEMA: unique symbol;
+/** Schema-independent type witness shared by every admitted Application declaration. */
+export interface ApplicationIdentity {
+    readonly [APPLICATION_IDENTITY]: true;
+}
+/** Inert source/build composition for one exact Schema and authored Runtime. */
+export interface Application<Schema extends schema.DomainSchema = schema.DomainSchema, RuntimeValue extends Runtime<Schema> = Runtime<Schema>, FrontendValue extends Frontend<Schema> | undefined = undefined, RoutesValue extends Routes | undefined = undefined, RequirementsValue extends Requirements | undefined = undefined> extends ApplicationIdentity {
+    readonly schema: Schema;
+    readonly runtime: RuntimeValue;
+    readonly frontend?: FrontendValue;
+    readonly routes?: RoutesValue;
+    readonly requirements?: RequirementsValue;
+    readonly [APPLICATION_SCHEMA]: (schema: Schema) => Schema;
+}
+export type SchemaOfApplication<Value> = Value extends {
+    readonly schema: infer Schema;
+} ? Extract<Schema, schema.DomainSchema> : never;
+export type RuntimeOfApplication<Value> = Value extends {
+    readonly runtime: infer RuntimeValue;
+} ? Extract<RuntimeValue, Runtime> : never;
+export type SchemaOfRuntime<Value> = RuntimeSchemaOf<Value>;
+export {};

package/dist/application/application.js

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

package/dist/application/define.d.ts

@@ -0,0 +1,16 @@
+import type { schema } from '../platform/schema/index.js';
+import type { Application } from './application.js';
+import type { Requirements } from './requirements/index.js';
+import type { Routes } from './routes/index.js';
+import type { Runtime } from './runtime/index.js';
+import type { Frontend } from './view/index.js';
+export interface ApplicationInput<Schema extends schema.DomainSchema, RuntimeValue extends Runtime<Schema>, FrontendValue extends Frontend<Schema> | undefined, RoutesValue extends Routes | undefined, RequirementsValue extends Requirements | undefined> {
+    readonly schema: Schema;
+    readonly runtime: RuntimeValue;
+    readonly frontend?: FrontendValue;
+    readonly routes?: RoutesValue;
+    readonly requirements?: RequirementsValue;
+}
+/** Capture one inert authored Application without resolving, compiling, loading, or deploying it. */
+export declare function defineApplication<const Schema extends schema.DomainSchema, const RuntimeValue extends Runtime<Schema>, const FrontendValue extends Frontend<Schema> | undefined = undefined, const RoutesValue extends Routes | undefined = undefined, const RequirementsValue extends Requirements | undefined = undefined>(input: ApplicationInput<Schema, RuntimeValue, FrontendValue, RoutesValue, RequirementsValue>): Application<Schema, RuntimeValue, FrontendValue, RoutesValue, RequirementsValue>;
+export declare function isApplication(input: unknown): input is Application;

package/dist/application/define.js

@@ -0,0 +1,40 @@
+import { isRequirements } from './requirements/index.js';
+import { isRoutes } from './routes/index.js';
+import { isRuntime } from './runtime/index.js';
+import { isFrontend } from './view/index.js';
+const admittedApplications = new WeakSet();
+/** Capture one inert authored Application without resolving, compiling, loading, or deploying it. */
+export function defineApplication(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    const allowed = new Set(['schema', 'runtime', 'frontend', 'routes', 'requirements']);
+    if (Reflect.ownKeys(input).some((key) => !allowed.has(key)))
+        invalid();
+    if (!isRuntime(input.runtime))
+        throw new TypeError('Application Runtime is not admitted.');
+    if (input.frontend !== undefined &&
+        (!isFrontend(input.frontend) || input.frontend.schema !== input.schema)) {
+        throw new TypeError('Application Frontend is not admitted for its exact Schema.');
+    }
+    if (input.routes !== undefined && !isRoutes(input.routes)) {
+        throw new TypeError('Application routes are not admitted.');
+    }
+    if (input.requirements !== undefined && !isRequirements(input.requirements)) {
+        throw new TypeError('Application requirements are not admitted.');
+    }
+    const application = Object.freeze({
+        schema: input.schema,
+        runtime: input.runtime,
+        ...(input.frontend === undefined ? {} : { frontend: input.frontend }),
+        ...(input.routes === undefined ? {} : { routes: input.routes }),
+        ...(input.requirements === undefined ? {} : { requirements: input.requirements }),
+    });
+    admittedApplications.add(application);
+    return application;
+}
+export function isApplication(input) {
+    return input !== null && typeof input === 'object' && admittedApplications.has(input);
+}
+function invalid() {
+    throw new TypeError('Application definition may contain only schema, runtime, frontend, routes, and requirements.');
+}

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

@@ -0,0 +1 @@
+export type { DependencyCallOptions, DependencyInvoker, HandlerDependencies } from './invoker.js';

package/dist/application/dependency/index.js

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

package/dist/application/dependency/invoker.d.ts

@@ -0,0 +1,26 @@
+import type { Binary, Input } from '../../platform/client/index.js';
+import type { SessionRequestOptions } from '../../platform/client/session/index.js';
+import type { NodeId } from '../../platform/graph/node/index.js';
+import type { CallableInputOf, CallableOutputOf, CallableResultOf, Domain, ResolvedMethod, KernelSchema, schema } from '../../platform/schema/index.js';
+import type { LocalCallable } from '../action/index.js';
+export type DependencyCallOptions = Pick<SessionRequestOptions, 'timeoutMs' | 'idempotencyKey'>;
+type InstanceMethodOf<D extends Domain> = Extract<LocalCallable<D>, ResolvedMethod<unknown, unknown, false>>;
+type FunctionOrStaticMethodOf<D extends Domain> = Exclude<LocalCallable<D>, ResolvedMethod<unknown, unknown, false>>;
+type DependencyInputOf<C> = C extends unknown ? unknown extends CallableInputOf<C> ? Input : [CallableInputOf<C>] extends [void] ? undefined : CallableInputOf<C> : never;
+type DependencyResultOf<C> = unknown extends CallableOutputOf<C> ? unknown : CallableResultOf<C, Binary>;
+/** One declared dependency, bound to one explicitly selected invocation authority. */
+export interface DependencyInvoker<D extends Domain> {
+    readonly invoke: {
+        <const C extends FunctionOrStaticMethodOf<D>>(select: (domain: D) => C, input: NoInfer<DependencyInputOf<C>>, options?: DependencyCallOptions): Promise<DependencyResultOf<C>>;
+        <const C extends InstanceMethodOf<D>>(select: (domain: D) => C, instance: NodeId, input: NoInfer<DependencyInputOf<C>>, options?: DependencyCallOptions): Promise<DependencyResultOf<C>>;
+    };
+}
+/**
+ * Direct Schema aliases with explicit authority selection and no default invoke.
+ * self is the executing Domain; caller forwards the incoming Grant; union combines both.
+ * The canonical Kernel is exposed through context.kernel.
+ */
+export type HandlerDependencies<D extends Domain> = Readonly<{
+    [Alias in keyof D['dependencies'] as D['dependencies'][Alias] extends schema.DomainOf<KernelSchema> ? never : Alias]: Readonly<Record<'caller' | 'self' | 'union', DependencyInvoker<Extract<D['dependencies'][Alias], Domain>>>>;
+}>;
+export {};

package/dist/application/dependency/invoker.js

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

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;