@astrale-os/sdk 0.5.0-beta.124 → 0.5.0-beta.126

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.5.0-beta.126](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.125...sdk-v0.5.0-beta.126) (2026-09-07)
+
+
+### Bug Fixes
+
+* expose runtime-safe schema error declarations ([#457](https://github.com/astrale-os/sdk/issues/457)) ([67e2fd1](https://github.com/astrale-os/sdk/commit/67e2fd1a92fca1096a928510405d8a6c6f0fd7ef))
+* preserve safe installation failure diagnostics ([#456](https://github.com/astrale-os/sdk/issues/456)) ([5466a9e](https://github.com/astrale-os/sdk/commit/5466a9e7aa597d114fcd947be26df5ce823d6277))
+
+## [0.5.0-beta.125](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.124...sdk-v0.5.0-beta.125) (2026-09-07)
+
+
+### Bug Fixes
+
+* **runtime:** emit inferred recipe tuples without repeating schemas ([#451](https://github.com/astrale-os/sdk/issues/451)) ([e4e6fbc](https://github.com/astrale-os/sdk/commit/e4e6fbc72a9b5a80a876be9c9a9ba89a1f4d3ffd))
+* **runtime:** retain mixed recipe collection contracts ([#453](https://github.com/astrale-os/sdk/issues/453)) ([e7d18d0](https://github.com/astrale-os/sdk/commit/e7d18d0b669df90001d417c76c33f578b92b5039))
+* **schema:** retain inferred dependency graphs without repeated expansion ([#455](https://github.com/astrale-os/sdk/issues/455)) ([5c02a00](https://github.com/astrale-os/sdk/commit/5c02a00ffca51f9d5c3bfa6301fabd657c0cd65c))
+
 ## [0.5.0-beta.124](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.123...sdk-v0.5.0-beta.124) (2026-09-07)
 
 

package/README.md

@@ -65,7 +65,7 @@ Schema authoring.
 Declare reusable business errors in `schema/modules/<module>/errors/` through the Schema facade:
 
 ```typescript
-import { error } from '@astrale-os/sdk/schema'
+import { error } from '@astrale-os/sdk/schema/errors'
 import { z } from 'zod'
 
 export const resourceUnavailable = error({
@@ -79,6 +79,8 @@ 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

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

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

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

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

package/dist/application/runtime/declarations.js

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

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

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

package/dist/platform/schema/errors/index.d.ts

@@ -0,0 +1,3 @@
+/** Runtime-safe business-error declarations shared by Schema and handlers. */
+export { error } from '../error.js';
+export type { DeclaredErrorDefinition, DeclaredErrorFamily } from '../error.js';

package/dist/platform/schema/errors/index.js

@@ -0,0 +1,2 @@
+/** Runtime-safe business-error declarations shared by Schema and handlers. */
+export { error } from '../error.js';

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

@@ -1,5 +1,7 @@
 import { KernelSchema as CoreKernelSchema } from '@astrale-os/kernel-core/schema';
 export * from '@astrale-os/kernel-dsl/v1';
+export { defineSchema } from './schema-authoring.js';
+export type { AuthoredSchema, AuthoredDomain } from './schema-authoring.js';
 export { stateProperty } from './state-property.js';
 export type { StateProperty } from './state-property.js';
 export { patterns } from '@astrale-os/kernel-dsl/v1/addressing';

package/dist/platform/schema/index.js

@@ -2,6 +2,7 @@ import { KernelSchema as CoreKernelSchema } from '@astrale-os/kernel-core/schema
 /** Canonical Schema authoring, compilation, loading, and resolved Domain surface. */
 import { schema as language } from '@astrale-os/kernel-dsl/v1';
 export * from '@astrale-os/kernel-dsl/v1';
+export { defineSchema } from './schema-authoring.js';
 export { stateProperty } from './state-property.js';
 export { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 export { defineClass, nodeClass } from './class-authoring.js';

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

@@ -0,0 +1,48 @@
+import type { DefinedSchema, ResolvedDomainOfInput } from '@astrale-os/kernel-dsl/v1/builder';
+import type { DomainSchema } from '@astrale-os/kernel-dsl/v1/schema';
+import { defineSchema as kernelDefineSchema } from '@astrale-os/kernel-dsl/v1';
+type DomainSchemaInput = Parameters<typeof kernelDefineSchema>[1];
+declare const authoredGraph: unique symbol;
+/** Opaque legacy Schemas retain their witness; SDK Schemas retain authored input and edges. */
+type Entry = readonly [origin: string, schema: DomainSchema] | readonly [
+    origin: string,
+    input: DomainSchemaInput,
+    dependencies: Readonly<Record<string, string>>
+];
+type Dependencies<Input> = 'dependencies' extends keyof Input ? NonNullable<Input['dependencies']> : {};
+type GraphOf<Schema> = typeof authoredGraph extends keyof Schema ? Schema[typeof authoredGraph] extends infer Graph ? Graph extends Entry ? Graph : never : never : Schema extends DomainSchema<infer Origin> ? readonly [Origin, Schema] : never;
+type GraphOfInput<Origin extends string, Input extends DomainSchemaInput> = readonly [
+    Origin,
+    {
+        readonly [Key in keyof Input as Exclude<Key, 'dependencies'>]: Input[Key];
+    },
+    {
+        readonly [Alias in keyof Dependencies<Input>]: Dependencies<Input>[Alias] extends DomainSchema<infer DependencyOrigin> ? DependencyOrigin : never;
+    }
+] | {
+    [Alias in keyof Dependencies<Input>]: GraphOf<Dependencies<Input>[Alias]>;
+}[keyof Dependencies<Input>];
+type LastEntry<Graph> = (Graph extends unknown ? (entry: () => Graph) => void : never) extends (entry: infer Intersection) => void ? Intersection extends () => infer Last ? Last : never : never;
+type WithoutEquivalent<Graph, Selected> = Graph extends Selected ? Selected extends Graph ? never : Graph : Graph;
+type UniqueEntries<Graph, Selected = LastEntry<Graph>> = [Graph] extends [never] ? never : Selected | UniqueEntries<WithoutEquivalent<Graph, Selected>>;
+type InputOf<Origin extends string, Graph extends Entry> = Extract<Graph, readonly [Origin, DomainSchemaInput, Readonly<Record<string, string>>]> extends readonly [
+    string,
+    infer Input extends DomainSchemaInput,
+    infer Dependencies extends Readonly<Record<string, string>>
+] ? Input & {
+    readonly dependencies: {
+        readonly [Alias in keyof Dependencies]: SchemaOf<Dependencies[Alias], Graph>;
+    };
+} : never;
+type SchemaOf<Origin extends string, Graph extends Entry> = Extract<Graph, readonly [Origin, DomainSchema]> extends infer Legacy ? [Legacy] extends [never] ? AuthoredSchema<Origin, Graph> : Legacy extends readonly [string, infer Schema extends DomainSchema] ? Schema : never : never;
+/** Resolve a dependency graph without expanding a shared Schema at each dependency edge. */
+export interface AuthoredDomain<Origin extends string, Graph extends Entry> extends ResolvedDomainOfInput<Origin, InputOf<Origin, Graph>> {
+}
+/** A Schema retains each transitive author's input once, with dependency edges represented by origin. */
+export interface AuthoredSchema<Origin extends string, Graph extends Entry> extends DefinedSchema<Origin, AuthoredDomain<Origin, Graph>> {
+    readonly [authoredGraph]?: Graph;
+}
+type DefineSchema = <const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input) => string extends Origin | Extract<Dependencies<Input>[keyof Dependencies<Input>], DomainSchema>['origin'] ? DefinedSchema<Origin, ResolvedDomainOfInput<Origin, Input>> : AuthoredSchema<Origin, Extract<UniqueEntries<GraphOfInput<Origin, Input>>, Entry>>;
+/** The canonical implementation with a portable, automatically inferred declaration. */
+export declare const defineSchema: DefineSchema;
+export {};

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

@@ -0,0 +1,3 @@
+import { defineSchema as kernelDefineSchema } from '@astrale-os/kernel-dsl/v1';
+/** The canonical implementation with a portable, automatically inferred declaration. */
+export const defineSchema = kernelDefineSchema;

package/dist/tooling/cli/astrale/failure.d.ts

@@ -1,3 +1,6 @@
 import type { AstraleProcessResult } from './process.js';
+/** Only sanitized CLI diagnostics may be promoted through installation failures. */
+export declare class AstraleCliError extends Error {
+}
 export declare function astraleFailure(command: string, result: AstraleProcessResult): Error;
 export declare function isDomainNotInstalledFailure(stderr: string): boolean;

package/dist/tooling/cli/astrale/failure.js

@@ -1,3 +1,6 @@
+/** Only sanitized CLI diagnostics may be promoted through installation failures. */
+export class AstraleCliError extends Error {
+}
 export function astraleFailure(command, result) {
     let diagnostic;
     try {
@@ -11,7 +14,7 @@ export function astraleFailure(command, result) {
     catch {
         // Never forward raw stderr because a credential-bearing command owns it.
     }
-    return new Error(`Astrale CLI ${command} failed${diagnostic === undefined ? '' : ` (${diagnostic})`}.`);
+    return new AstraleCliError(`Astrale CLI ${command} failed${diagnostic === undefined ? '' : ` (${diagnostic})`}.`);
 }
 function admittedCode(input) {
     return typeof input === 'string' && /^[A-Z][A-Z0-9_]{0,63}$/u.test(input) ? input : undefined;

package/dist/tooling/cli/installation/reconcile.js

@@ -1,5 +1,5 @@
 import { astraleAuthorityArguments } from '../astrale/authority.js';
-import { isDomainNotInstalledFailure, astraleFailure } from '../astrale/failure.js';
+import { AstraleCliError, isDomainNotInstalledFailure, astraleFailure } from '../astrale/failure.js';
 import { runAstrale } from '../astrale/process.js';
 import { canonicalIssuer, decodeInstallationObservation } from './observation.js';
 /** Reconcile one observed Release without ever replacing a different issuer. */
@@ -57,10 +57,10 @@ export async function reconcileInstallation(input, dependencies = {
         after = await observe(input, origin, authority, executable, dependencies);
     }
     catch (cause) {
-        throw new AggregateError(installationFailure === undefined ? [cause] : [installationFailure, cause], 'Domain installation outcome is unknown because reconciliation failed.');
+        throw installationError(installationFailure === undefined ? [cause] : [installationFailure, cause], 'Domain installation outcome is unknown because reconciliation failed.');
     }
     if (installationFailure !== undefined && after === undefined) {
-        throw new AggregateError([installationFailure], 'Domain installation failed and no installed Release was observed.');
+        throw installationError([installationFailure], 'Domain installation failed and no installed Release was observed.');
     }
     if (after === undefined)
         throw new TypeError('Installed Domain was absent after installation.');
@@ -73,10 +73,16 @@ export async function reconcileInstallation(input, dependencies = {
     catch (cause) {
         if (installationFailure === undefined)
             throw cause;
-        throw new AggregateError([installationFailure, cause], 'Domain installation failed with a different observed Release.');
+        throw installationError([installationFailure, cause], 'Domain installation failed with a different observed Release.');
     }
     return evidence(before === undefined ? 'installed' : 'upgraded', input.target.instance, after);
 }
+function installationError(causes, message) {
+    const diagnostics = causes
+        .filter((cause) => cause instanceof AstraleCliError)
+        .map((cause) => cause.message);
+    return new AggregateError(causes, [message, ...diagnostics].join(' '));
+}
 async function observe(input, origin, authority, executable, dependencies) {
     const result = await dependencies.run({
         executable,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/sdk",
-  "version": "0.5.0-beta.124",
+  "version": "0.5.0-beta.126",
   "description": "Schema-first SDK for defining, composing, and deploying Astrale domains",
   "keywords": [
     "astrale",
@@ -47,6 +47,10 @@
       "types": "./dist/platform/schema/icons/index.d.ts",
       "import": "./dist/platform/schema/icons/index.js"
     },
+    "./schema/errors": {
+      "types": "./dist/platform/schema/errors/index.d.ts",
+      "import": "./dist/platform/schema/errors/index.js"
+    },
     "./schema/addressing": {
       "types": "./dist/platform/schema/addressing/index.d.ts",
       "import": "./dist/platform/schema/addressing/index.js"