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

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/sdk",
-  "version": "0.5.0-beta.124",
+  "version": "0.5.0-beta.125",
   "description": "Schema-first SDK for defining, composing, and deploying Astrale domains",
   "keywords": [
     "astrale",