@astrale-os/kernel-core 0.9.0-beta.51 → 0.9.0-beta.53

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

@@ -49,10 +49,19 @@ export declare const Identity: builder.NodeClass<{
         can: builder.Method<builder.CallableProjection<{
             policy: string;
             object: string;
+        } | {
+            checks: {
+                policy: string;
+                object: string;
+            }[];
         }, {
             readonly mode: 'value';
             readonly value: {
                 allowed: boolean;
+            } | {
+                decisions: {
+                    allowed: boolean;
+                }[];
             };
         }, "authenticated", true, false>>;
         whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -188,14 +197,6 @@ export declare const Identity: builder.NodeClass<{
         readonly mode: 'value';
         readonly value: string;
     }, "authenticated", true, false>>, "delegate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-        policy: string;
-        object: string;
-    }, {
-        readonly mode: 'value';
-        readonly value: {
-            allowed: boolean;
-        };
-    }, "authenticated", true, false>>, "can", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
         iss: string;
         sub: string;
     }, {
@@ -218,5 +219,22 @@ export declare const Identity: builder.NodeClass<{
                 op: "exists";
             })[];
         } | null;
-    }, "authorized", true, false>>, "whois", "self">;
+    }, "authorized", true, false>>, "whois", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", "self">;
 }>;

package/dist/schema/kernel/projection/index.d.ts

@@ -1,6 +1,6 @@
-export { project } from './project.js';
+export { project, projectTopology } from './project.js';
 export { compile } from './compile.js';
 export { projectedCallables, projectedMethodPath } from './callables.js';
 export { ProjectionError } from './diagnostics.js';
 export type { ProjectionErrorCode } from './diagnostics.js';
-export type { CoreProjection, Projection, ProjectionPart } from './types.js';
+export type { CoreProjection, CoreProjectionTopology, Projection, ProjectionPart, ProjectionTopology, ProjectionTopologyEdge, ProjectionTopologyNode, ProjectionTopologyPart, } from './types.js';

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

@@ -1,4 +1,4 @@
-export { project } from './project.js';
+export { project, projectTopology } from './project.js';
 export { compile } from './compile.js';
 export { projectedCallables, projectedMethodPath } from './callables.js';
 export { ProjectionError } from './diagnostics.js';

package/dist/schema/kernel/projection/project.d.ts

@@ -1,4 +1,6 @@
 import { type SourceDomain, type schema } from '@astrale-os/kernel-dsl/v1';
-import type { Projection } from './types.js';
+import type { Projection, ProjectionTopology } from './types.js';
 /** Project a Domain into an installation-independent symbolic graph. */
 export declare function project(domain: SourceDomain<schema.DomainSchema>): Projection;
+/** Project only symbolic ownership, retaining every declaration and structural check. */
+export declare function projectTopology(domain: SourceDomain<schema.DomainSchema>): ProjectionTopology;

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

@@ -8,8 +8,31 @@ import { projectedMethodPath } from './callables.js';
 import { ProjectionError } from './diagnostics.js';
 import { coreKeys, managedKeys } from './keys.js';
 const EMPTY_PROPERTIES = normalizeProperties({});
+const NO_PAYLOAD = Object.freeze({});
 /** Project a Domain into an installation-independent symbolic graph. */
 export function project(domain) {
+    const projected = walk(domain, (properties) => ({ props: properties() }));
+    return Object.freeze({
+        origin: projected.origin,
+        revision: projected.revision,
+        managed: Object.freeze({
+            graph: Object.freeze({ nodes: projected.managed.nodes, edges: projected.managed.edges }),
+            paths: projected.managed.paths,
+        }),
+        core: Object.freeze({
+            graph: Object.freeze({ nodes: projected.core.nodes, edges: projected.core.edges }),
+            paths: projected.core.paths,
+            locators: projected.core.locators,
+        }),
+    });
+}
+/** Project only symbolic ownership, retaining every declaration and structural check. */
+export function projectTopology(domain) {
+    return walk(domain, () => NO_PAYLOAD);
+}
+function walk(domain, payload) {
+    // Consume payloads in argument position, before addNode's duplicate/binding checks and
+    // addEdge's Class conversion, preserving the full projection's original error order.
     const domainSchema = domain.source;
     const managedLocations = projectionLocations(managedKeys(domain));
     const coreLocations = projectionLocations(coreKeys(domain));
@@ -21,7 +44,7 @@ export function project(domain) {
     const domainPath = PathValue.domain(domain.origin).raw;
     const domainEndpoint = endpoint(domainPath, managedLocations);
     const persistedDomainEndpoint = Object.freeze({ path: NodePathValue(domainPath) });
-    addNode(managedNodes, domainPath, ClassKeyValue.of(K.classes.Domain.ref), domainPropertiesFor(domain), managedLocations);
+    addNode(managedNodes, domainPath, ClassKeyValue.of(K.classes.Domain.ref), payload(() => domainPropertiesFor(domain)), managedLocations);
     for (const definition of domain.definitions()) {
         if (definition.ref.origin !== domain.origin)
             continue;
@@ -29,10 +52,10 @@ export function project(domain) {
         if (projectedClass === undefined)
             continue;
         const definitionPath = PathValue.project(definition.ref).raw;
-        const definitionEndpoint = addNode(managedNodes, definitionPath, projectedClass, definitionPropertiesFor(definition), managedLocations);
-        addEdge(managedEdges, definitionEndpoint, domainEndpoint, K.classes.of_domain.ref, normalizeProperties({
+        const definitionEndpoint = addNode(managedNodes, definitionPath, projectedClass, payload(() => definitionPropertiesFor(definition)), managedLocations);
+        addEdge(managedEdges, definitionEndpoint, domainEndpoint, K.classes.of_domain.ref, payload(() => normalizeProperties({
             [K.classes.of_domain.self.properties.member.key]: memberKey(definition),
-        }));
+        })));
     }
     for (const definition of domain.definitions()) {
         if (definition.ref.origin !== domain.origin)
@@ -40,7 +63,7 @@ export function project(domain) {
         const projectedClass = projectionClassFor(definition);
         if (projectedClass === undefined)
             continue;
-        projectDefinitionRelations(domain, definition, endpoint(PathValue.project(definition.ref).raw, managedLocations), managedLocations, managedEdges);
+        projectDefinitionRelations(domain, definition, endpoint(PathValue.project(definition.ref).raw, managedLocations), managedLocations, managedEdges, payload);
     }
     const methods = new Map();
     for (const definition of Object.values(domain.classes)) {
@@ -52,42 +75,41 @@ export function project(domain) {
     }
     for (const method of methods.values()) {
         const methodPath = projectedMethodPath(domain, method);
-        const methodEndpoint = addNode(managedNodes, methodPath, ClassKeyValue.of(K.classes.Function.ref), callablePropertiesFor(method.definition), managedLocations);
+        const methodEndpoint = addNode(managedNodes, methodPath, ClassKeyValue.of(K.classes.Function.ref), payload(() => callablePropertiesFor(method.definition)), managedLocations);
         const ownerPath = PathValue.project(method.owner.ref);
-        addEdge(managedEdges, methodEndpoint, endpoint(ownerPath.raw, managedLocations), K.classes.method_of.ref, normalizeProperties({
+        addEdge(managedEdges, methodEndpoint, endpoint(ownerPath.raw, managedLocations), K.classes.method_of.ref, payload(() => normalizeProperties({
             [K.classes.method_of.self.properties.name.key]: method.name,
             [K.classes.method_of.self.properties.static.key]: method.definition.static,
-        }));
-        addEdge(managedEdges, methodEndpoint, domainEndpoint, K.classes.of_domain.ref, normalizeProperties({
-            [K.classes.of_domain.self.properties.member.key]: callableMemberKey(domain, method),
-        }));
+        })));
+        // This structural check must also execute when no Property payload is requested.
+        const member = callableMemberKey(domain, method);
+        addEdge(managedEdges, methodEndpoint, domainEndpoint, K.classes.of_domain.ref, payload(() => normalizeProperties({
+            [K.classes.of_domain.self.properties.member.key]: member,
+        })));
     }
     for (const [slug, declaration] of Object.entries(domainSchema.core.nodes)) {
         assertIdentityAuthenticationUnowned(domain, declaration.class, declaration.properties, slug);
         const path = PathValue.project({ origin: domain.origin, kind: 'core', name: slug }).raw;
-        const created = addNode(coreNodes, path, ClassKeyValue.of(declaration.class), declaration.properties, coreLocations);
-        addEdge(locators, created, persistedDomainEndpoint, K.classes.of_domain.ref, normalizeProperties({
+        const created = addNode(coreNodes, path, ClassKeyValue.of(declaration.class), payload(() => declaration.properties), coreLocations);
+        addEdge(locators, created, persistedDomainEndpoint, K.classes.of_domain.ref, payload(() => normalizeProperties({
             [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, 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,
         revision: domain.revision,
         managed: Object.freeze({
-            graph: Object.freeze({
-                nodes: Object.freeze([...managedNodes.values()]),
-                edges: Object.freeze(managedEdges),
-            }),
+            nodes: Object.freeze([...managedNodes.values()]),
+            edges: Object.freeze(managedEdges),
             paths: invert(managedLocations),
         }),
         core: Object.freeze({
-            graph: Object.freeze({
-                nodes: Object.freeze([...coreNodes.values()]),
-                edges: Object.freeze(coreEdges),
-            }),
+            nodes: Object.freeze([...coreNodes.values()]),
+            edges: Object.freeze(coreEdges),
             paths: invert(coreLocations),
             locators: Object.freeze(locators),
         }),
@@ -112,16 +134,22 @@ 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) {
+function projectDefinitionRelations(domain, definition, definitionEndpoint, locations, edges, payload) {
     if (isResolvedClass(definition)) {
         for (const parent of definition.definition.extends) {
             const path = PathValue.project(parent);
-            addEdge(edges, definitionEndpoint, endpoint(path.raw, locations), K.classes.extends.ref, EMPTY_PROPERTIES);
+            addEdge(edges, definitionEndpoint, endpoint(path.raw, locations), K.classes.extends.ref, payload(() => EMPTY_PROPERTIES));
         }
     }
     if (isResolvedClass(definition)) {
@@ -144,9 +172,9 @@ function projectDefinitionRelations(domain, definition, definitionEndpoint, loca
             }
         }
         for (const { policy, operations } of policies.values()) {
-            addEdge(edges, definitionEndpoint, endpoint(PathValue.project(policy).raw, locations), K.classes.governed_by.ref, normalizeProperties({
+            addEdge(edges, definitionEndpoint, endpoint(PathValue.project(policy).raw, locations), K.classes.governed_by.ref, payload(() => normalizeProperties({
                 [K.classes.governed_by.self.properties.operations.key]: Object.freeze(['read', 'traverse'].filter((operation) => operations.has(operation))),
-            }));
+            })));
         }
     }
     if (isResolvedView(definition)) {
@@ -164,7 +192,7 @@ function projectDefinitionRelations(domain, definition, definitionEndpoint, loca
                 });
             });
         for (const path of paths) {
-            addEdge(edges, definitionEndpoint, endpoint(path.raw, locations), K.classes.view_for.ref, EMPTY_PROPERTIES);
+            addEdge(edges, definitionEndpoint, endpoint(path.raw, locations), K.classes.view_for.ref, payload(() => EMPTY_PROPERTIES));
         }
     }
 }
@@ -269,7 +297,7 @@ function endpoint(path, locations) {
     const created = locations.get(path);
     return created === undefined ? Object.freeze({ path }) : Object.freeze({ created });
 }
-function addNode(nodes, path, classKey, props, locations) {
+function addNode(nodes, path, classKey, payload, locations) {
     const existing = nodes.get(path);
     if (existing !== undefined)
         return Object.freeze({ created: existing.as });
@@ -277,14 +305,14 @@ function addNode(nodes, path, classKey, props, locations) {
     if (as === undefined) {
         throw new ProjectionError('PROJECTION_INVALID', `Projection has no binding for ${path}.`);
     }
-    nodes.set(path, Object.freeze({ as, class: classKey, props }));
+    nodes.set(path, Object.freeze({ as, class: classKey, ...payload }));
     return Object.freeze({ created: as });
 }
-function addEdge(edges, source, target, classRef, props) {
+function addEdge(edges, source, target, classRef, payload) {
     edges.push(Object.freeze({
         source,
         target,
         class: ClassKeyValue.of(classRef),
-        props,
+        ...payload,
     }));
 }

package/dist/schema/kernel/projection/types.d.ts

@@ -1,5 +1,6 @@
 import type { Key, Revision } from '@astrale-os/kernel-dsl/v1';
-import type { GraphSpec, GraphSpecEdge, LocalBinding } from '#graph/graph';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { GraphSpec, GraphSpecEdge, GraphSpecEndpoint, LocalBinding } from '#graph/graph';
 import type { NodePath } from '#graph/path';
 export interface ProjectionPart {
     readonly graph: GraphSpec;
@@ -16,3 +17,28 @@ export interface Projection {
     readonly managed: ProjectionPart;
     readonly core: CoreProjection;
 }
+/** Declaration identity only; this is not a Graph Node with absent or defaulted Properties. */
+export interface ProjectionTopologyNode {
+    readonly as: LocalBinding;
+    readonly class: ClassKey;
+}
+export interface ProjectionTopologyEdge {
+    readonly source: GraphSpecEndpoint;
+    readonly target: GraphSpecEndpoint;
+    readonly class: ClassKey;
+}
+export interface ProjectionTopologyPart {
+    readonly paths: ReadonlyMap<LocalBinding, NodePath>;
+    readonly nodes: readonly ProjectionTopologyNode[];
+    readonly edges: readonly ProjectionTopologyEdge[];
+}
+export interface CoreProjectionTopology extends ProjectionTopologyPart {
+    readonly locators: readonly ProjectionTopologyEdge[];
+}
+/** Symbolic ownership coordinates without materialized schema Property payloads. */
+export interface ProjectionTopology {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+    readonly managed: ProjectionTopologyPart;
+    readonly core: CoreProjectionTopology;
+}