@astrale-os/kernel-core 0.9.0-beta.6 → 0.9.0-beta.61

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

@@ -1,8 +1,12 @@
-import type { DomainDiagnostic } from '#domain';
+interface ProjectionDiagnostic {
+    readonly code: string;
+    readonly message: string;
+    readonly path?: string;
+}
 export type ProjectionErrorCode = 'PROJECTION_DEPENDENCY_MISSING' | 'PROJECTION_DOMAIN_NOT_FOUND' | 'PROJECTION_DOMAIN_AMBIGUOUS' | 'PROJECTION_SCHEMA_UNAVAILABLE' | 'PROJECTION_SCHEMA_REJECTED' | 'PROJECTION_REVISION_MISMATCH' | 'PROJECTION_INVALID';
 export declare class ProjectionError extends Error {
     readonly code: ProjectionErrorCode;
-    readonly diagnostics: readonly DomainDiagnostic[];
-    constructor(code: ProjectionErrorCode, message: string, diagnostics?: readonly DomainDiagnostic[], options?: ErrorOptions);
+    readonly diagnostics: readonly ProjectionDiagnostic[];
+    constructor(code: ProjectionErrorCode, message: string, diagnostics?: readonly ProjectionDiagnostic[], options?: ErrorOptions);
 }
-//# sourceMappingURL=diagnostics.d.ts.map
+export {};

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

@@ -8,4 +8,3 @@ export class ProjectionError extends Error {
         this.name = 'ProjectionError';
     }
 }
-//# sourceMappingURL=diagnostics.js.map

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

@@ -1,7 +1,6 @@
-export { project } from './project.js';
+export { project, projectTopology } from './project.js';
 export { compile } from './compile.js';
-export { projectedCallables } from './callables.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';
-//# sourceMappingURL=index.d.ts.map
+export type { CoreProjection, CoreProjectionTopology, Projection, ProjectionPart, ProjectionTopology, ProjectionTopologyEdge, ProjectionTopologyNode, ProjectionTopologyPart, } from './types.js';

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

@@ -1,5 +1,4 @@
-export { project } from './project.js';
+export { project, projectTopology } from './project.js';
 export { compile } from './compile.js';
-export { projectedCallables } from './callables.js';
+export { projectedCallables, projectedMethodPath } from './callables.js';
 export { ProjectionError } from './diagnostics.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,4 +1,3 @@
-import type { Domain } from '#domain';
-export declare function managedKeys(domain: Domain<any>): readonly string[];
-export declare function coreKeys(domain: Domain<any>): readonly string[];
-//# sourceMappingURL=keys.d.ts.map
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+export declare function managedKeys(domain: Domain): readonly string[];
+export declare function coreKeys(domain: Domain): readonly string[];

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

@@ -3,23 +3,25 @@ import { projectedMethodPath } from './callables.js';
 const encoder = new TextEncoder();
 export function managedKeys(domain) {
     const keys = new Map();
-    add(keys, Path.domain(domain.$.origin).raw);
-    for (const definition of domain.$.definitions.values()) {
-        if (definition.origin !== domain.$.origin)
+    add(keys, Path.domain(domain.origin).raw);
+    for (const definition of domain.definitions()) {
+        if (definition.ref.origin !== domain.origin || definition.ref.kind === 'core')
             continue;
-        if (definition.kind !== 'type' && definition.path !== undefined)
-            add(keys, definition.path.raw);
-        for (const method of definition.methods.values()) {
-            if (method.owner.origin === domain.$.origin && method.definition.inheritance !== 'abstract') {
-                add(keys, projectedMethodPath(domain, method));
+        add(keys, Path.project(definition.ref).raw);
+        if (!('methods' in definition) || definition.kind !== 'node')
+            continue;
+        for (const method of [...definition.methods, ...definition.static.methods]) {
+            if (method.owner.ref.origin !== domain.origin || !method.executable) {
+                continue;
             }
+            add(keys, projectedMethodPath(domain, method));
         }
     }
     return Object.freeze([...keys.values()].sort(compareNodePaths));
 }
 export function coreKeys(domain) {
-    return Object.freeze(Object.keys(domain.$.schema.core.nodes)
-        .map((name) => Path.project({ origin: domain.$.origin, kind: 'core', name }).raw)
+    return Object.freeze(Object.values(domain.core.nodes)
+        .map((definition) => Path.project(definition.ref).raw)
         .sort(compareNodePaths));
 }
 function add(keys, key) {
@@ -35,4 +37,3 @@ function compareNodePaths(left, right) {
     }
     return a.length - b.length;
 }
-//# sourceMappingURL=keys.js.map

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

@@ -1,3 +1,2 @@
 import type { GraphPathWalker } from '#graph/graph';
 export declare const projectionPathWalker: GraphPathWalker;
-//# sourceMappingURL=path.d.ts.map

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

@@ -1,4 +1,4 @@
-import { ClassPath } from '#graph/class';
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { GraphPathAmbiguousError } from '#graph/graph';
 import { K } from '../index.js';
 export const projectionPathWalker = Object.freeze({
@@ -19,11 +19,11 @@ function anchorCandidates(ast, context) {
         const node = context.nodes.byId(ast.anchor.id);
         return node === undefined ? [] : [node];
     }
-    const domainClass = ClassPath.from(K.Domain);
+    const domainClass = ClassKey.of(K.classes.Domain.ref);
     const origin = ast.anchor.origin;
     return context.nodes
         .byClass(domainClass)
-        .filter((node) => node.props[K.Domain.$.property('origin').key] === origin);
+        .filter((node) => node.props[K.classes.Domain.properties.origin.key] === origin);
 }
 function applyStep(current, step, context) {
     switch (step.kind) {
@@ -32,16 +32,16 @@ function applyStep(current, step, context) {
         case 'method':
             return step.dispatch === 'static'
                 ? directMethods(current, step.name, true, context)
-                : instanceMethods(current, step.name, context);
+                : instanceMethods(current.filter((node) => node.class === step.class), step.name, context);
         case 'traverse':
             return traverse(current, step, context);
     }
 }
 function domainMembers(domains, member, context) {
     const domainIds = new Set(domains.map((node) => node.id));
-    return distinctNodes(edgesOf(K.of_domain, context).flatMap((edge) => {
+    return distinctNodes(edgesOf(K.classes.of_domain, context).flatMap((edge) => {
         if (!domainIds.has(edge.target) ||
-            edge.props[K.of_domain.$.property('member').key] !== member) {
+            edge.props[K.classes.of_domain.properties.member.key] !== member) {
             return [];
         }
         const node = context.nodes.byId(edge.source);
@@ -50,10 +50,10 @@ function domainMembers(domains, member, context) {
 }
 function directMethods(owners, name, isStatic, context) {
     const ownerIds = new Set(owners.map((node) => node.id));
-    return distinctNodes(edgesOf(K.method_of, context).flatMap((edge) => {
+    return distinctNodes(edgesOf(K.classes.method_of, context).flatMap((edge) => {
         if (!ownerIds.has(edge.target) ||
-            edge.props[K.method_of.$.property('name').key] !== name ||
-            edge.props[K.method_of.$.property('static').key] !== isStatic) {
+            edge.props[K.classes.method_of.properties.name.key] !== name ||
+            edge.props[K.classes.method_of.properties.static.key] !== isStatic) {
             return [];
         }
         const method = context.nodes.byId(edge.source);
@@ -63,42 +63,15 @@ function directMethods(owners, name, isStatic, context) {
 function instanceMethods(instances, name, context) {
     return distinctNodes(instances.flatMap((instance) => {
         const owner = resolveClassProjection(instance.class, context);
-        return owner.length === 0 ? [] : effectiveMethods(owner, name, context);
+        return owner.length === 0 ? [] : directMethods(owner, name, false, context);
     }));
 }
-function resolveClassProjection(path, context) {
-    const domainClass = ClassPath.from(K.Domain);
+function resolveClassProjection(key, context) {
+    const domainClass = ClassKey.of(K.classes.Domain.ref);
     const domains = context.nodes
         .byClass(domainClass)
-        .filter((node) => node.props[K.Domain.$.property('origin').key] === ClassPath.origin(path));
-    return domainMembers(domains, `class.${ClassPath.name(path)}`, context);
-}
-/** Select the nearest declared Method in the valid Definition inheritance graph. */
-function effectiveMethods(roots, name, context) {
-    let level = distinctNodes(roots);
-    const visited = new Set();
-    while (level.length > 0) {
-        const fresh = level.filter((node) => !visited.has(node.id));
-        for (const node of fresh)
-            visited.add(node.id);
-        if (fresh.length === 0)
-            return [];
-        const methods = directMethods(fresh, name, false, context);
-        if (methods.length > 0)
-            return methods;
-        level = parentDefinitions(fresh, context);
-    }
-    return [];
-}
-function parentDefinitions(definitions, context) {
-    const ids = new Set(definitions.map((node) => node.id));
-    const relations = [K.implements, K.extends];
-    return distinctNodes(relations.flatMap((relation) => edgesOf(relation, context).flatMap((edge) => {
-        if (!ids.has(edge.source))
-            return [];
-        const parent = context.nodes.byId(edge.target);
-        return parent === undefined ? [] : [parent];
-    })));
+        .filter((node) => node.props[K.classes.Domain.properties.origin.key] === ClassKey.ref(key).origin);
+    return domainMembers(domains, `class.${ClassKey.ref(key).name}`, context);
 }
 function traverse(current, step, context) {
     const currentIds = new Set(current.map((node) => node.id));
@@ -129,8 +102,8 @@ function traversedEndpoint(edge, current, direction, orientation) {
         return edge.source;
     return undefined;
 }
-function edgesOf(ref, context) {
-    return context.edges.byClass(ClassPath.from({ origin: ref.origin, kind: 'class', name: ref.name }));
+function edgesOf(relation, context) {
+    return context.edges.byClass(ClassKey.of(relation.ref));
 }
 function distinctNodes(nodes) {
     const byId = new Map();
@@ -138,4 +111,3 @@ function distinctNodes(nodes) {
         byId.set(node.id, node);
     return [...byId.values()];
 }
-//# sourceMappingURL=path.js.map

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

@@ -1,5 +1,6 @@
-import type { Domain } from '#domain';
-import type { Projection } from './types.js';
+import { type SourceDomain, type schema } from '@astrale-os/kernel-dsl/v1';
+import type { Projection, ProjectionTopology } from './types.js';
 /** Project a Domain into an installation-independent symbolic graph. */
-export declare function project(domain: Domain): Projection;
-//# sourceMappingURL=project.d.ts.map
+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;