@astrale-os/kernel-core 0.9.0-beta.52 → 0.9.0-beta.54

package/dist/schema/callables/function.js

@@ -1,10 +1,11 @@
 import { nodeClass, property } from '@astrale-os/kernel-dsl/v1';
+import { Identity } from '../identity/index.js';
 import { FunctionMethods } from '../kernel/syscalls/declarations/index.js';
 import { Descriptable } from '../meta/index.js';
 export const Function = nodeClass({
     abstract: false,
-    description: 'The installed projection of a standalone Function or Node Method declaration; it is not a principal.',
-    extends: [Descriptable],
+    description: 'An invocable resource that can carry its own Identity authority.',
+    extends: [Descriptable, Identity],
     properties: {
         kind: { enum: ['function', 'method'] },
         input: {},

package/dist/schema/identity/identity.d.ts

@@ -174,21 +174,6 @@ export declare const Identity: builder.NodeClass<{
             })[];
         };
     }, "authenticated", true, false>>, "whoami", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-        audience?: string | undefined;
-        ttlSeconds: number;
-        grant?: unknown;
-        identity: string;
-    }, {
-        readonly mode: 'value';
-        readonly value: string;
-    }, "authorized", true, false>>, "impersonate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-        audience?: string | undefined;
-        ttlSeconds: number;
-        grant?: unknown;
-    }, {
-        readonly mode: 'value';
-        readonly value: string;
-    }, "authenticated", true, false>>, "mint", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
         principal: string;
         audience: string;
         ttlSeconds: number;
@@ -220,6 +205,21 @@ export declare const Identity: builder.NodeClass<{
             })[];
         } | null;
     }, "authorized", true, false>>, "whois", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
         policy: string;
         object: string;
     } | {

package/dist/schema/kernel/projection/project.js

@@ -95,8 +95,9 @@ function walk(domain, payload) {
             [K.classes.of_domain.self.properties.member.key]: `core.${slug}`,
         })));
     }
-    for (const declaration of domainSchema.core.edges) {
-        addEdge(coreEdges, coreEndpoint(declaration.source, domain, persistedDomainEndpoint, coreLocations), coreEndpoint(declaration.target, domain, persistedDomainEndpoint, coreLocations), declaration.class, payload(() => declaration.properties));
+    // Resolved edges carry each endpoint's own identity; the source IR only names it.
+    for (const edge of domain.core.edges) {
+        addEdge(coreEdges, coreEndpoint(edge.source, domain, persistedDomainEndpoint, coreLocations), coreEndpoint(edge.target, domain, persistedDomainEndpoint, coreLocations), edge.class.ref, payload(() => edge.properties));
     }
     return Object.freeze({
         origin: domain.origin,
@@ -133,10 +134,16 @@ function projectionLocations(paths) {
 function invert(locations) {
     return new Map([...locations].map(([path, binding]) => [binding, path]));
 }
+/**
+ * A Core Node binds inside the Core part; every other local Definition is already projected as a
+ * managed declaration, so it is addressed by its canonical Path exactly like the owning Domain.
+ */
 function coreEndpoint(value, domain, domainEndpoint, locations) {
-    if (value.kind === 'domain')
-        return domainEndpoint;
-    return endpoint(PathValue.project({ origin: domain.origin, kind: 'core', name: value.name }).raw, locations);
+    if ('ref' in value)
+        return endpoint(PathValue.project(value.ref).raw, locations);
+    if ('owner' in value)
+        return endpoint(projectedMethodPath(domain, value), locations);
+    return domainEndpoint;
 }
 function projectDefinitionRelations(domain, definition, definitionEndpoint, locations, edges, payload) {
     if (isResolvedClass(definition)) {