@astrale-os/sdk 0.5.0-beta.119 → 0.5.0-beta.120

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.5.0-beta.120](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.119...sdk-v0.5.0-beta.120) (2026-09-07)
+
+
+### ⚠ BREAKING CHANGES
+
+* **app:** name Core Identity requirements core ([#441](https://github.com/astrale-os/sdk/issues/441))
+
+### Features
+
+* **app:** name Core Identity requirements core ([#441](https://github.com/astrale-os/sdk/issues/441)) ([a91fb67](https://github.com/astrale-os/sdk/commit/a91fb67a7da0741c2466d9cbaf905d6dfda16be4))
+
 ## [0.5.0-beta.119](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.118...sdk-v0.5.0-beta.119) (2026-09-06)
 
 

package/README.md

@@ -83,6 +83,19 @@ 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+

package/dist/application/index.d.ts

@@ -1,7 +1,7 @@
 export { defineApplication, isApplication } from './define.js';
 export type { ApplicationInput } from './define.js';
 export { requirements } from './requirements/index.js';
-export type { AuthorityRequirements, AuthorityRequirementsInput, ClassOperation, ClassRequirement, ClassRequirementInput, FunctionRequirementTarget, Requirements, RequirementsInput, } from './requirements/index.js';
+export type { AuthorityRequirements, AuthorityRequirementsInput, ClassOperation, ClassRequirement, ClassRequirementInput, CoreRequirement, CoreRequirementInput, FunctionRequirementTarget, Requirements, RequirementsInput, } from './requirements/index.js';
 export { route, routes } from './routes/index.js';
 export type { Route, RouteInput, RouteTarget, Routes } from './routes/index.js';
 export { defineFrontend, external, vite } from './view/index.js';

package/dist/application/requirements/{profiles.d.ts → core.d.ts}

@@ -2,11 +2,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 {
+import type { CoreRequirement } from './requirement.js';
+/** Capabilities assigned to one installation-owned local Core Identity. */
+export interface CoreRequirementInput {
     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[];
+export declare function captureCore(input: readonly CoreRequirementInput[] | undefined): readonly CoreRequirement[];

package/dist/application/requirements/{profiles.js → core.js}

@@ -2,12 +2,12 @@ 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) {
+export function captureCore(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) => {
+        throw new TypeError('Core requirements must be an array.');
+    const core = 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')) {
@@ -29,12 +29,12 @@ export function captureProfiles(input) {
             ...(authority === undefined ? {} : { authority }),
         });
     });
-    if (new Set(profiles.map(({ subject }) => Key.of(subject))).size !== profiles.length)
+    if (new Set(core.map(({ subject }) => Key.of(subject))).size !== core.length)
         invalid();
-    return Object.freeze([...profiles].sort((left, right) => compare(Key.of(left.subject), Key.of(right.subject))));
+    return Object.freeze([...core].sort((left, right) => compare(Key.of(left.subject), Key.of(right.subject))));
 }
 function invalid() {
-    throw new TypeError('Capability profile requirement is invalid.');
+    throw new TypeError('Core capability requirement is invalid.');
 }
 function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;

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

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

package/dist/application/requirements/index.js

@@ -1,24 +1,24 @@
 import { captureAuthority } from './authority.js';
 import { captureClasses } from './classes.js';
+import { captureCore } from './core.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' && key !== 'profiles')) {
+    if (Reflect.ownKeys(input).some((key) => key !== 'functions' && key !== 'classes' && key !== 'authority' && key !== 'core')) {
         invalid();
     }
     const functions = captureFunctions(input.functions);
     const classes = captureClasses(input.classes);
     const authority = captureAuthority(input.authority);
-    const profiles = captureProfiles(input.profiles);
+    const core = captureCore(input.core);
     const value = Object.freeze({
         functions,
         classes,
-        profiles,
+        core,
         ...(authority === undefined ? {} : { authority }),
     });
     admittedRequirements.add(value);
@@ -28,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, authority, and profiles.');
+    throw new TypeError('Requirements definition may contain only functions, classes, authority, and core.');
 }

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

@@ -14,9 +14,10 @@ export interface Requirements {
     readonly functions: readonly Key.Callable[];
     readonly classes: readonly ClassRequirement[];
     readonly authority?: AuthorityRequirements;
-    readonly profiles: readonly CapabilityProfileRequirement[];
+    readonly core: readonly CoreRequirement[];
 }
-export interface CapabilityProfileRequirement {
+/** Capabilities assigned at installation to one Identity declared in the local Core. */
+export interface CoreRequirement {
     readonly subject: CoreRef;
     readonly functions: readonly Key.Callable[];
     readonly classes: readonly ClassRequirement[];

package/dist/deployment/build/compile.js

@@ -54,24 +54,24 @@ 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 requirement of input?.core ?? []) {
+        const subject = domain.core.nodes[requirement.subject.name];
+        if (requirement.subject.origin !== domain.origin || subject === undefined) {
+            throw new TypeError('Core capability subject must name one local Core Node.');
         }
-        for (const key of profile.functions) {
-            requireDirectDependency(domain, key, 'Capability profile Function');
+        for (const key of requirement.functions) {
+            requireDirectDependency(domain, key, 'Core capability Function');
             if (domain.callable(key) === undefined) {
-                throw new TypeError(`Capability profile Function ${key} is absent from the dependency closure.`);
+                throw new TypeError(`Core capability 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');
+        for (const classRequirement of requirement.classes) {
+            const key = Key.of(classRequirement.class);
+            if (classRequirement.class.origin !== domain.origin) {
+                requireDirectDependency(domain, key, 'Core capability Class');
             }
-            if (domain.definition(requirement.class) === undefined) {
-                throw new TypeError('Capability profile Class is absent from the dependency closure.');
+            if (domain.definition(classRequirement.class) === undefined) {
+                throw new TypeError('Core capability Class is absent from the dependency closure.');
             }
         }
     }
@@ -82,14 +82,14 @@ 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
+            ...(input === undefined || input.core.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 }),
+                    core: input.core.map((requirement) => ({
+                        subject: requirement.subject,
+                        ...(requirement.functions.length === 0 ? {} : { functions: requirement.functions }),
+                        ...(requirement.classes.length === 0 ? {} : { classes: requirement.classes }),
+                        ...(requirement.authority === undefined ? {} : { authority: requirement.authority }),
                     })),
                 }),
         },

package/dist/deployment/release/publication/seal.js

@@ -13,7 +13,7 @@ export function seal(build, addressing) {
     const selectedManifest = manifest(build);
     const sealed = publication.seal({
         format: 'astrale.domain.publication',
-        version: 2,
+        version: 3,
         origin: root.origin,
         identity: { issuer: addressing.issuer, subject: root.origin },
         schema: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/sdk",
-  "version": "0.5.0-beta.119",
+  "version": "0.5.0-beta.120",
   "description": "Schema-first SDK for defining, composing, and deploying Astrale domains",
   "keywords": [
     "astrale",
@@ -233,11 +233,11 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@astrale-os/kernel-client": "0.6.0-beta.52",
-    "@astrale-os/kernel-core": "0.9.0-beta.40",
+    "@astrale-os/kernel-client": "0.6.0-beta.55",
+    "@astrale-os/kernel-core": "0.9.0-beta.42",
     "@astrale-os/kernel-dsl": "0.2.0-beta.30",
-    "@astrale-os/kernel-protocol": "0.5.0-beta.43",
-    "@astrale-os/kernel-server": "0.5.0-beta.45",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.46",
+    "@astrale-os/kernel-server": "0.5.0-beta.48",
     "@lucide/icons": "1.34.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "hono": "^4.13.2",