@astrale-os/sdk 0.5.0-beta.95 → 0.5.0-beta.97

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.5.0-beta.97](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.96...sdk-v0.5.0-beta.97) (2026-08-31)
+
+
+### Bug Fixes
+
+* **tooling:** admit stable local state machines ([#374](https://github.com/astrale-os/sdk/issues/374)) ([7ebd1b5](https://github.com/astrale-os/sdk/commit/7ebd1b54e282e1b85587e8d33d3faa22b5421cc6))
+
+## [0.5.0-beta.96](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.95...sdk-v0.5.0-beta.96) (2026-08-31)
+
+
+### Bug Fixes
+
+* keep external token exchange caller-only ([#366](https://github.com/astrale-os/sdk/issues/366)) ([45d39de](https://github.com/astrale-os/sdk/commit/45d39debce782d1d4f76cf75e9ecf214ca57ddba))
+
 ## [0.5.0-beta.95](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.94...sdk-v0.5.0-beta.95) (2026-08-30)
 
 

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

@@ -34,25 +34,36 @@ export interface DomainGraphExecutor<DomainValue extends Domain = Domain> {
     readonly mutate: MutationExecutor<DomainValue>;
 }
 export type DomainGraphExecutors<DomainValue extends Domain = Domain> = Readonly<Record<'caller' | 'self' | 'union', DomainGraphExecutor<DomainValue>>>;
+/** Explicit full Kernel sessions. No authority mode is selected implicitly. */
+export type DomainKernelSessions = Readonly<Record<'caller' | 'self' | 'union', BoundClientSession>>;
 type AuthorityOf<Callable, DomainValue extends Domain> = Callable extends {
     readonly auth: 'anonymous';
 } ? {
     readonly caller: AnonymousCaller;
     readonly client: null;
+    readonly kernel: null;
     readonly graph: null;
     readonly query?: never;
     readonly mutate?: never;
 } | {
     readonly caller: AuthenticatedCaller;
+    /** Caller-only Kernel client. Privileged Domain work must select kernel.self explicitly. */
     readonly client: BoundClientSession;
+    readonly kernel: DomainKernelSessions;
     readonly graph: DomainGraphExecutors<DomainValue>;
+    /** Caller-only convenience executor. */
     readonly query: QueryExecutor<DomainValue>;
+    /** Caller-only convenience executor. */
     readonly mutate: MutationExecutor<DomainValue>;
 } : {
     readonly caller: AuthenticatedCaller;
+    /** Caller-only Kernel client. Privileged Domain work must select kernel.self explicitly. */
     readonly client: BoundClientSession;
+    readonly kernel: DomainKernelSessions;
     readonly graph: DomainGraphExecutors<DomainValue>;
+    /** Caller-only convenience executor. */
     readonly query: QueryExecutor<DomainValue>;
+    /** Caller-only convenience executor. */
     readonly mutate: MutationExecutor<DomainValue>;
 };
 type SelfOf<Callable> = Callable extends ResolvedMethod<unknown, unknown, false> ? {

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

@@ -1,15 +1,18 @@
 import type { AuthorityRequirementsInput } from './authority.js';
 import type { ClassRequirementInput } from './classes.js';
 import type { FunctionRequirementTarget } from './functions.js';
+import type { CapabilityProfileRequirementInput } from './profiles.js';
 import type { Requirements } from './requirement.js';
-export type { AuthorityRequirements, ClassRequirement, Requirements } from './requirement.js';
+export type { AuthorityRequirements, CapabilityProfileRequirement, ClassRequirement, Requirements, } from './requirement.js';
 export { ClassOperationOrder, type ClassOperation, type ClassRequirementInput } from './classes.js';
 export type { FunctionRequirementTarget } from './functions.js';
 export type { AuthorityRequirementsInput } from './authority.js';
+export type { CapabilityProfileRequirementInput } from './profiles.js';
 export interface RequirementsInput {
     readonly functions?: readonly FunctionRequirementTarget[];
     readonly classes?: readonly ClassRequirementInput[];
     readonly authority?: AuthorityRequirementsInput;
+    readonly profiles?: readonly CapabilityProfileRequirementInput[];
 }
 /** Capture canonical dependency requirements; Build proves the pinned dependency closure. */
 export declare function requirements(input?: RequirementsInput): Requirements;

package/dist/application/requirements/index.js

@@ -1,21 +1,24 @@
 import { captureAuthority } from './authority.js';
 import { captureClasses } from './classes.js';
 import { captureFunctions } from './functions.js';
+import { captureProfiles } from './profiles.js';
 export { ClassOperationOrder } from './classes.js';
 const admittedRequirements = new WeakSet();
 /** Capture canonical dependency requirements; Build proves the pinned dependency closure. */
 export function requirements(input = {}) {
     if (input === null || typeof input !== 'object' || Array.isArray(input))
         invalid();
-    if (Reflect.ownKeys(input).some((key) => key !== 'functions' && key !== 'classes' && key !== 'authority')) {
+    if (Reflect.ownKeys(input).some((key) => key !== 'functions' && key !== 'classes' && key !== 'authority' && key !== 'profiles')) {
         invalid();
     }
     const functions = captureFunctions(input.functions);
     const classes = captureClasses(input.classes);
     const authority = captureAuthority(input.authority);
+    const profiles = captureProfiles(input.profiles);
     const value = Object.freeze({
         functions,
         classes,
+        profiles,
         ...(authority === undefined ? {} : { authority }),
     });
     admittedRequirements.add(value);
@@ -25,5 +28,5 @@ export function isRequirements(input) {
     return input !== null && typeof input === 'object' && admittedRequirements.has(input);
 }
 function invalid() {
-    throw new TypeError('Requirements definition may contain only functions, classes, and authority.');
+    throw new TypeError('Requirements definition may contain only functions, classes, authority, and profiles.');
 }

package/dist/application/requirements/profiles.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedCoreDefinition } from '../../platform/schema/index.js';
+import type { AuthorityRequirementsInput } from './authority.js';
+import type { ClassRequirementInput } from './classes.js';
+import type { FunctionRequirementTarget } from './functions.js';
+import type { CapabilityProfileRequirement } from './requirement.js';
+export interface CapabilityProfileRequirementInput {
+    readonly subject: Pick<ResolvedCoreDefinition, 'ref'>;
+    readonly functions?: readonly FunctionRequirementTarget[];
+    readonly classes?: readonly ClassRequirementInput[];
+    readonly authority?: AuthorityRequirementsInput;
+}
+export declare function captureProfiles(input: readonly CapabilityProfileRequirementInput[] | undefined): readonly CapabilityProfileRequirement[];

package/dist/application/requirements/profiles.js

@@ -0,0 +1,41 @@
+import { acceptDefinitionRef, Key } from '../../platform/schema/index.js';
+import { captureAuthority } from './authority.js';
+import { captureClasses } from './classes.js';
+import { captureFunctions } from './functions.js';
+export function captureProfiles(input) {
+    if (input === undefined)
+        return Object.freeze([]);
+    if (!Array.isArray(input))
+        throw new TypeError('Requirement profiles must be an array.');
+    const profiles = input.map((entry) => {
+        if (entry === null || typeof entry !== 'object' || Array.isArray(entry))
+            invalid();
+        if (Reflect.ownKeys(entry).some((key) => key !== 'subject' && key !== 'functions' && key !== 'classes' && key !== 'authority')) {
+            invalid();
+        }
+        const admitted = acceptDefinitionRef(entry.subject?.ref);
+        if (admitted.kind !== 'core')
+            invalid();
+        const subject = admitted;
+        const functions = captureFunctions(entry.functions);
+        const classes = captureClasses(entry.classes);
+        const authority = captureAuthority(entry.authority);
+        if (functions.length === 0 && classes.length === 0 && authority === undefined)
+            invalid();
+        return Object.freeze({
+            subject,
+            functions,
+            classes,
+            ...(authority === undefined ? {} : { authority }),
+        });
+    });
+    if (new Set(profiles.map(({ subject }) => Key.of(subject))).size !== profiles.length)
+        invalid();
+    return Object.freeze([...profiles].sort((left, right) => compare(Key.of(left.subject), Key.of(right.subject))));
+}
+function invalid() {
+    throw new TypeError('Capability profile requirement is invalid.');
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/application/requirements/requirement.d.ts

@@ -1,5 +1,5 @@
 import type { AuthorityOperation } from '../../platform/schema/index.js';
-import type { ClassRef, Key } from '../../platform/schema/index.js';
+import type { ClassRef, CoreRef, Key } from '../../platform/schema/index.js';
 import type { ClassOperation } from './classes.js';
 export interface ClassRequirement {
     readonly class: ClassRef;
@@ -14,4 +14,11 @@ export interface Requirements {
     readonly functions: readonly Key.Callable[];
     readonly classes: readonly ClassRequirement[];
     readonly authority?: AuthorityRequirements;
+    readonly profiles: readonly CapabilityProfileRequirement[];
+}
+export interface CapabilityProfileRequirement {
+    readonly subject: CoreRef;
+    readonly functions: readonly Key.Callable[];
+    readonly classes: readonly ClassRequirement[];
+    readonly authority?: AuthorityRequirements;
 }

package/dist/deployment/build/compile.js

@@ -54,6 +54,27 @@ function compileRequirements(domain, input, sourceBundle) {
             throw new TypeError('Class requirement is absent from the dependency closure.');
         }
     }
+    for (const profile of input?.profiles ?? []) {
+        const subject = domain.core.nodes[profile.subject.name];
+        if (profile.subject.origin !== domain.origin || subject === undefined) {
+            throw new TypeError('Capability profile subject must name one local Core Node.');
+        }
+        for (const key of profile.functions) {
+            requireDirectDependency(domain, key, 'Capability profile Function');
+            if (domain.callable(key) === undefined) {
+                throw new TypeError(`Capability profile Function ${key} is absent from the dependency closure.`);
+            }
+        }
+        for (const requirement of profile.classes) {
+            const key = Key.of(requirement.class);
+            if (requirement.class.origin !== domain.origin) {
+                requireDirectDependency(domain, key, 'Capability profile Class');
+            }
+            if (domain.definition(requirement.class) === undefined) {
+                throw new TypeError('Capability profile Class is absent from the dependency closure.');
+            }
+        }
+    }
     const candidate = publication.admitRequirements({
         capabilities: {
             ...(input === undefined || input.functions.length === 0
@@ -61,6 +82,16 @@ function compileRequirements(domain, input, sourceBundle) {
                 : { functions: input.functions }),
             ...(input === undefined || input.classes.length === 0 ? {} : { classes: input.classes }),
             ...(input?.authority === undefined ? {} : { authority: input.authority }),
+            ...(input === undefined || input.profiles.length === 0
+                ? {}
+                : {
+                    profiles: input.profiles.map((profile) => ({
+                        subject: profile.subject,
+                        ...(profile.functions.length === 0 ? {} : { functions: profile.functions }),
+                        ...(profile.classes.length === 0 ? {} : { classes: profile.classes }),
+                        ...(profile.authority === undefined ? {} : { authority: profile.authority }),
+                    })),
+                }),
         },
     });
     publication.validateRequirements(sourceBundle.root, sourceBundle.closure, candidate);

package/dist/execution/identity/authentication.js

@@ -66,7 +66,7 @@ export async function authenticate(credentialInput, expectedKernel, execution, c
     let closed = false;
     return Object.freeze({
         caller: established.caller,
-        client: graph.union,
+        client: graph.caller,
         graph,
         close() {
             if (closed)

package/dist/execution/identity/exchange.d.ts

@@ -4,15 +4,6 @@ import type { IdentityNetworkPolicy, VerificationBasisResolver } from './jwks.js
 import type { SigningMaterial } from './signing.js';
 export interface ExchangeOptions {
     readonly maximumTtlSeconds?: number;
-    /** Authority carried by the exchanged Domain credential. Defaults to the authenticated caller. */
-    readonly grantMode?: ExchangeGrantMode;
-}
-export type ExchangeGrantMode = 'caller' | 'union';
-interface AcceptedExchangeOptions {
-    readonly maximumTtlSeconds: number;
-    readonly grantMode: ExchangeGrantMode;
 }
 export declare function maximumExchangeTtl(input: ExchangeOptions | undefined): number;
-export declare function tokenExchange(issuer: IssuerId, subject: string, signing: SigningMaterial, policy: IdentityNetworkPolicy, verification: VerificationBasisResolver, maximumTtlSeconds: number, grantMode?: ExchangeGrantMode): exchange.Provider;
-export declare function exchangeOptions(input: ExchangeOptions | undefined): AcceptedExchangeOptions;
-export {};
+export declare function tokenExchange(issuer: IssuerId, subject: string, signing: SigningMaterial, policy: IdentityNetworkPolicy, verification: VerificationBasisResolver, maximumTtlSeconds: number): exchange.Provider;

package/dist/execution/identity/exchange.js

@@ -8,27 +8,21 @@ import { CredentialRejected, IssuerUnavailable } from './errors.js';
 import { verifyCredential, verifyCredentialAgainst } from './jwks.js';
 const DEFAULT_MAXIMUM_TTL_SECONDS = 300;
 export function maximumExchangeTtl(input) {
-    return acceptExchangeOptions(input).maximumTtlSeconds;
-}
-function acceptExchangeOptions(input) {
-    if (input === undefined) {
-        return Object.freeze({ maximumTtlSeconds: DEFAULT_MAXIMUM_TTL_SECONDS, grantMode: 'caller' });
-    }
+    if (input === undefined)
+        return DEFAULT_MAXIMUM_TTL_SECONDS;
     if (input === null ||
         typeof input !== 'object' ||
         Array.isArray(input) ||
-        Reflect.ownKeys(input).some((key) => key !== 'maximumTtlSeconds' && key !== 'grantMode')) {
+        Reflect.ownKeys(input).some((key) => key !== 'maximumTtlSeconds')) {
         throw new TypeError('Execution identity tokenExchange options are invalid.');
     }
     const value = input.maximumTtlSeconds ?? DEFAULT_MAXIMUM_TTL_SECONDS;
     if (!Number.isSafeInteger(value) || value < 1) {
         throw new TypeError('tokenExchange.maximumTtlSeconds must be a positive safe integer.');
     }
-    const grantMode = input.grantMode ?? 'caller';
-    return Object.freeze({ maximumTtlSeconds: value, grantMode: acceptExchangeGrantMode(grantMode) });
+    return value;
 }
-export function tokenExchange(issuer, subject, signing, policy, verification, maximumTtlSeconds, grantMode = 'caller') {
-    const acceptedGrantMode = acceptExchangeGrantMode(grantMode);
+export function tokenExchange(issuer, subject, signing, policy, verification, maximumTtlSeconds) {
     return Object.freeze({
         async exchange(request, context) {
             try {
@@ -51,7 +45,7 @@ export function tokenExchange(issuer, subject, signing, policy, verification, ma
                 const token = await new SignJWT({
                     grant: {
                         v: 1,
-                        expr: exchangeGrant(acceptedGrantMode, carried.credential),
+                        expr: { kind: 'identity', credential: carried.credential },
                     },
                 })
                     .setProtectedHeader({
@@ -87,27 +81,6 @@ export function tokenExchange(issuer, subject, signing, policy, verification, ma
         },
     });
 }
-export function exchangeOptions(input) {
-    return acceptExchangeOptions(input);
-}
-function exchangeGrant(mode, credential) {
-    const caller = Object.freeze({ kind: 'identity', credential });
-    if (mode === 'caller')
-        return caller;
-    return Object.freeze({
-        kind: 'union',
-        operands: Object.freeze([
-            Object.freeze({ kind: 'identity', self: true }),
-            caller,
-        ]),
-    });
-}
-function acceptExchangeGrantMode(input) {
-    if (input !== 'caller' && input !== 'union') {
-        throw new TypeError('tokenExchange.grantMode must be caller or union.');
-    }
-    return input;
-}
 function requireProfile(input, profile) {
     const expected = ['aud', 'delegation', 'exp', 'iat', 'iss', 'sub'];
     const actual = Object.keys(input.claims).sort();

package/dist/execution/identity/identity.js

@@ -1,7 +1,7 @@
 import { admit, authenticate } from './authentication.js';
 import { publicationDelivery } from './delivery.js';
 import { httpIssuer } from './errors.js';
-import { exchangeOptions, tokenExchange } from './exchange.js';
+import { maximumExchangeTtl, tokenExchange } from './exchange.js';
 import { createVerificationBasisResolver } from './jwks.js';
 import { signing } from './signing.js';
 /** Create one stateless execution identity backed by an asymmetric private JWK. */
@@ -37,10 +37,7 @@ export function createIdentity(input) {
     });
     const exchangeProvider = input.tokenExchange === false
         ? undefined
-        : (() => {
-            const options = exchangeOptions(input.tokenExchange);
-            return tokenExchange(issuer, input.subject, material, policy, verification, options.maximumTtlSeconds, options.grantMode);
-        })();
+        : tokenExchange(issuer, input.subject, material, policy, verification, maximumExchangeTtl(input.tokenExchange));
     return identity({
         issuer,
         subject: input.subject,

package/dist/execution/identity/index.d.ts

@@ -1,2 +1,2 @@
 export { createIdentity, identity, type Identity, type IdentityInput } from './identity.js';
-export { maximumExchangeTtl, tokenExchange, type ExchangeGrantMode, type ExchangeOptions, } from './exchange.js';
+export { maximumExchangeTtl, tokenExchange, type ExchangeOptions } from './exchange.js';

package/dist/execution/identity/index.js

@@ -1,2 +1,2 @@
 export { createIdentity, identity } from './identity.js';
-export { maximumExchangeTtl, tokenExchange, } from './exchange.js';
+export { maximumExchangeTtl, tokenExchange } from './exchange.js';

package/dist/execution/index.d.ts

@@ -1,5 +1,5 @@
 export { serve } from './serve.js';
 export type { ExecutionContext, ServedApplication, ServeInput } from './serve.js';
-export { createIdentity, type ExchangeGrantMode, type ExchangeOptions, type Identity, type IdentityInput, } from './identity/index.js';
+export { createIdentity, type ExchangeOptions, type Identity, type IdentityInput, } from './identity/index.js';
 export { InvocationError } from './invocation/index.js';
 export type { InvocationErrorCode } from './invocation/index.js';

package/dist/execution/invocation/admission/authentication.d.ts

@@ -6,6 +6,7 @@ import type { AuthenticatedInvocation, InvocationAuthority } from './authority.j
 export interface AnonymousInvocation {
     readonly caller: AnonymousCaller;
     readonly client: null;
+    readonly kernel: null;
     readonly graph: null;
     close(): void;
 }

package/dist/execution/invocation/admission/authentication.js

@@ -6,6 +6,7 @@ import { requireVia } from './authority.js';
 const ANONYMOUS = Object.freeze({
     caller: Object.freeze({ kind: 'anonymous' }),
     client: null,
+    kernel: null,
     graph: null,
     close() { },
 });
@@ -37,14 +38,14 @@ export async function authentication(callable, request, release, domain, authori
         }
         const caller = admitCaller(authenticated.caller);
         const graphInput = admitGraph(authenticated.graph);
-        if (authenticated.client !== graphInput.union)
+        if (authenticated.client !== graphInput.caller)
             invalid();
         const graph = Object.freeze({
             caller: bindSession(graphInput.caller),
             self: bindSession(graphInput.self),
             union: bindSession(graphInput.union),
         });
-        return Object.freeze({ caller, client: graph.union, graph, close });
+        return Object.freeze({ caller, client: graph.caller, graph, close });
     }
     catch (cause) {
         if (close === undefined)

package/dist/execution/invocation/dispatch/context.d.ts

@@ -12,6 +12,7 @@ export interface DispatchContext {
     readonly input: unknown;
     readonly caller: Caller;
     readonly client: BoundClientSession | null;
+    readonly kernel: Readonly<Record<'caller' | 'self' | 'union', BoundClientSession>> | null;
     readonly graph: DomainGraphExecutors | null;
     readonly query?: QueryExecutor;
     readonly mutate?: MutationExecutor;

package/dist/execution/invocation/dispatch/context.js

@@ -18,6 +18,7 @@ export function context(request, runtime, authentication, self) {
         input: request.call.input,
         caller: authentication.caller,
         client,
+        kernel: authentication.graph,
         graph: authentication.graph === null ? null : bindGraph(authentication.graph, runtime.loaded.domain),
         ...(client === null
             ? {}

package/dist/tooling/linter/implementations/source/state-machine.d.ts

@@ -7,7 +7,7 @@ export type StateMachineResolution = Readonly<{
 }> | Readonly<{
     kind: 'ambiguous' | 'absent';
 }>;
-export type MachineExportStatus = 'exported' | 'private' | 'not-a-declaration';
+export type MachineExportStatus = 'exported' | 'private' | 'mutable' | 'not-a-declaration';
 /** Resolve a direct or static local alias of the SDK stateMachine constructor. */
 export declare function stateMachineConstructorOrigin(file: SourceFile, expression: ts.Expression, seen?: ReadonlySet<string>): StateMachineOrigin;
 /** Resolve one local binding to an exported SDK stateMachine authority. */

package/dist/tooling/linter/implementations/source/state-machine.js

@@ -42,6 +42,19 @@ export function stateMachineIdentity(project, file, expression, seen = new Set()
             const identity = `${file.path}\0${value.text}`;
             if (seen.has(identity))
                 return { kind: 'ambiguous' };
+            const initializer = unwrap(declaration.initializer);
+            if (ts.isCallExpression(initializer)) {
+                const origin = stateMachineConstructorOrigin(file, initializer.expression);
+                if (origin === 'ambiguous')
+                    return { kind: 'ambiguous' };
+                if (origin === 'resolved') {
+                    if (!declaration.constant)
+                        return { kind: 'ambiguous' };
+                    return machineExportStatus(file, initializer) === 'exported'
+                        ? { kind: 'resolved', identity: machineIdentity(file, value.text) }
+                        : { kind: 'absent' };
+                }
+            }
             const next = new Set(seen);
             next.add(identity);
             const resolution = stateMachineIdentity(project, file, declaration.initializer, next);
@@ -213,6 +226,8 @@ export function machineExportStatus(file, call) {
             const directlyExported = ts
                 .getModifiers(statement)
                 ?.some(({ kind }) => kind === ts.SyntaxKind.ExportKeyword);
+            if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0)
+                return 'mutable';
             if (directlyExported || locallyExported(file, declaration.name.text))
                 return 'exported';
             return 'private';
@@ -356,7 +371,9 @@ function localMachineOrigin(file, name) {
                 declaration.initializer !== undefined &&
                 ts.isCallExpression(unwrap(declaration.initializer))) {
                 const call = unwrap(declaration.initializer);
-                return stateMachineConstructorOrigin(file, call.expression);
+                const origin = stateMachineConstructorOrigin(file, call.expression);
+                const constant = (statement.declarationList.flags & ts.NodeFlags.Const) !== 0;
+                return constant || origin === 'absent' ? origin : 'ambiguous';
             }
         }
     }

package/dist/tooling/linter/implementations/source/states.js

@@ -40,7 +40,9 @@ export const stateRules = [
                     if (exportStatus !== 'exported') {
                         evidence.push(violation(machine.file, machine.call, exportStatus === 'private'
                             ? 'State machine relation must be exported as its Schema module StateMachine authority.'
-                            : 'State machine relation must be assigned to one exported top-level binding.'));
+                            : exportStatus === 'mutable'
+                                ? 'State machine relation must be declared const as its stable Schema module authority.'
+                                : 'State machine relation must be assigned to one exported top-level binding.'));
                     }
                     evidence.push(...admitStaticRelation(machine.file, machine.call));
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/sdk",
-  "version": "0.5.0-beta.95",
+  "version": "0.5.0-beta.97",
   "description": "Schema-first SDK for defining, composing, and deploying Astrale domains",
   "keywords": [
     "astrale",
@@ -217,11 +217,11 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@astrale-os/kernel-client": "0.6.0-beta.36",
-    "@astrale-os/kernel-core": "0.9.0-beta.28",
-    "@astrale-os/kernel-dsl": "0.2.0-beta.21",
-    "@astrale-os/kernel-protocol": "0.5.0-beta.29",
-    "@astrale-os/kernel-server": "0.5.0-beta.31",
+    "@astrale-os/kernel-client": "0.6.0-beta.39",
+    "@astrale-os/kernel-core": "0.9.0-beta.29",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.22",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.32",
+    "@astrale-os/kernel-server": "0.5.0-beta.34",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "hono": "^4.13.2",
     "jose": "^6.2.9",