@astrale-os/kernel-core 0.9.0-beta.7 → 0.9.0-beta.9

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

@@ -2,4 +2,3 @@ export { project } from './project.js';
 export { compile } from './compile.js';
 export { projectedCallables } 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,26 @@ 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.definition.inheritance === 'abstract') {
+                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 +38,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) {
@@ -39,9 +39,9 @@ function applyStep(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);
@@ -66,12 +66,12 @@ function instanceMethods(instances, name, context) {
         return owner.length === 0 ? [] : effectiveMethods(owner, name, 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);
+        .filter((node) => node.props[K.classes.Domain.properties.origin.key] === ClassKey.ref(key).origin);
+    return domainMembers(domains, `class.${ClassKey.ref(key).name}`, context);
 }
 /** Select the nearest declared Method in the valid Definition inheritance graph. */
 function effectiveMethods(roots, name, context) {
@@ -92,7 +92,7 @@ function effectiveMethods(roots, name, context) {
 }
 function parentDefinitions(definitions, context) {
     const ids = new Set(definitions.map((node) => node.id));
-    const relations = [K.implements, K.extends];
+    const relations = [K.classes.extends];
     return distinctNodes(relations.flatMap((relation) => edgesOf(relation, context).flatMap((edge) => {
         if (!ids.has(edge.source))
             return [];
@@ -129,8 +129,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 +138,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,4 @@
-import type { Domain } from '#domain';
+import { type SourceDomain, type schema } from '@astrale-os/kernel-dsl/v1';
 import type { Projection } 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;

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

@@ -1,5 +1,5 @@
-import { Key } from '@astrale-os/kernel-dsl/v1';
-import { ClassPath as ClassPathValue } from '#graph/class';
+import { Key, } from '@astrale-os/kernel-dsl/v1';
+import { ClassKey as ClassKeyValue } from '@astrale-os/kernel-dsl/v1/addressing';
 import { LocalBinding as LocalBindingValue } from '#graph/graph';
 import { NodePath as NodePathValue, Path as PathValue } from '#graph/path';
 import { normalizeProperties } from '#graph/properties';
@@ -10,7 +10,7 @@ import { coreKeys, managedKeys } from './keys.js';
 const EMPTY_PROPERTIES = normalizeProperties({});
 /** Project a Domain into an installation-independent symbolic graph. */
 export function project(domain) {
-    const domainSchema = domain.$.schema;
+    const domainSchema = domain.source;
     const managedLocations = projectionLocations(managedKeys(domain));
     const coreLocations = projectionLocations(coreKeys(domain));
     const managedNodes = new Map();
@@ -18,62 +18,61 @@ export function project(domain) {
     const coreNodes = new Map();
     const coreEdges = [];
     const locators = [];
-    const domainPath = PathValue.domain(domain.$.origin).raw;
+    const domainPath = PathValue.domain(domain.origin).raw;
     const domainEndpoint = endpoint(domainPath, managedLocations);
     const persistedDomainEndpoint = Object.freeze({ path: NodePathValue(domainPath) });
-    addNode(managedNodes, domainPath, ClassPathValue.from(K.Domain), domainPropertiesFor(domain), managedLocations);
-    for (const definition of domain.$.definitions.values()) {
-        if (definition.origin !== domain.$.origin || definition.path === undefined)
+    addNode(managedNodes, domainPath, ClassKeyValue.of(K.classes.Domain.ref), domainPropertiesFor(domain), managedLocations);
+    for (const definition of domain.definitions()) {
+        if (definition.ref.origin !== domain.origin)
             continue;
         const projectedClass = projectionClassFor(definition);
         if (projectedClass === undefined)
             continue;
-        const definitionEndpoint = addNode(managedNodes, definition.path.raw, projectedClass, definitionPropertiesFor(definition), managedLocations);
-        addEdge(managedEdges, definitionEndpoint, domainEndpoint, K.of_domain, normalizeProperties({
-            [K.of_domain.$.property('member').key]: memberKey(definition),
+        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({
+            [K.classes.of_domain.self.properties.member.key]: memberKey(definition),
         }));
     }
-    for (const definition of domain.$.definitions.values()) {
-        if (definition.origin !== domain.$.origin || definition.path === undefined)
+    for (const definition of domain.definitions()) {
+        if (definition.ref.origin !== domain.origin)
             continue;
         const projectedClass = projectionClassFor(definition);
         if (projectedClass === undefined)
             continue;
-        projectDefinitionRelations(domain, definition, endpoint(definition.path.raw, managedLocations), managedLocations, managedEdges);
+        projectDefinitionRelations(domain, definition, endpoint(PathValue.project(definition.ref).raw, managedLocations), managedLocations, managedEdges);
     }
     const methods = new Map();
-    for (const definition of domain.$.definitions.values()) {
-        if (definition.origin !== domain.$.origin)
-            continue;
-        for (const method of definition.methods.values()) {
-            if (method.owner.origin === domain.$.origin && method.definition.inheritance !== 'abstract') {
+    for (const definition of Object.values(domain.classes)) {
+        for (const method of [...definition.methods, ...definition.static.methods]) {
+            if (method.owner.ref.origin === domain.origin &&
+                method.definition.inheritance !== 'abstract') {
                 methods.set(method.key, method);
             }
         }
     }
     for (const method of methods.values()) {
         const methodPath = projectedMethodPath(domain, method);
-        const methodEndpoint = addNode(managedNodes, methodPath, ClassPathValue.from(K.$.class('Function')), callablePropertiesFor(method.definition), managedLocations);
-        const ownerPath = domain.$.inspect(method.owner).path;
-        if (ownerPath === undefined) {
-            throw new ProjectionError('PROJECTION_INVALID', `Method owner ${method.owner.name} has no projected Path.`);
-        }
-        addEdge(managedEdges, methodEndpoint, endpoint(ownerPath.raw, managedLocations), K.method_of, normalizeProperties({
-            [K.method_of.$.property('name').key]: method.name,
-            [K.method_of.$.property('static').key]: method.definition.static,
+        const methodEndpoint = addNode(managedNodes, methodPath, ClassKeyValue.of(K.classes.Function.ref), callablePropertiesFor(method.definition), managedLocations);
+        const ownerPath = PathValue.project(method.owner.ref);
+        addEdge(managedEdges, methodEndpoint, endpoint(ownerPath.raw, managedLocations), K.classes.method_of.ref, normalizeProperties({
+            [K.classes.method_of.self.properties.name.key]: method.name,
+            [K.classes.method_of.self.properties.static.key]: method.definition.static,
         }));
     }
     for (const [slug, declaration] of Object.entries(domainSchema.core.nodes)) {
-        const path = PathValue.project({ origin: domain.$.origin, kind: 'core', name: slug }).raw;
-        const created = addNode(coreNodes, path, ClassPathValue.from(declaration.class), domain.$.properties({ ...declaration.class }, declaration.properties), coreLocations);
-        addEdge(locators, created, persistedDomainEndpoint, K.of_domain, normalizeProperties({ [K.of_domain.$.property('member').key]: `core.${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({
+            [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, domain.$.properties({ ...declaration.class }, declaration.properties));
+        addEdge(coreEdges, coreEndpoint(declaration.source, domain, persistedDomainEndpoint, coreLocations), coreEndpoint(declaration.target, domain, persistedDomainEndpoint, coreLocations), declaration.class, declaration.properties);
     }
     return Object.freeze({
-        origin: domain.$.origin,
-        revision: domain.$.revision,
+        origin: domain.origin,
+        revision: domain.revision,
         managed: Object.freeze({
             graph: Object.freeze({
                 nodes: Object.freeze([...managedNodes.values()]),
@@ -100,28 +99,18 @@ function invert(locations) {
 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);
+    return endpoint(PathValue.project({ origin: domain.origin, kind: 'core', name: value.name }).raw, locations);
 }
 function projectDefinitionRelations(domain, definition, definitionEndpoint, locations, edges) {
-    if (definition.kind === 'class') {
-        for (const parent of definition.definition.implements) {
-            const path = domain.$.inspect({ ...parent }).path;
-            if (path === undefined)
-                continue;
-            addEdge(edges, definitionEndpoint, endpoint(path.raw, locations), K.implements, EMPTY_PROPERTIES);
-        }
-    }
-    else if (definition.kind === 'interface') {
+    if (isResolvedClass(definition)) {
         for (const parent of definition.definition.extends) {
-            const path = domain.$.inspect({ ...parent }).path;
-            if (path === undefined)
-                continue;
-            addEdge(edges, definitionEndpoint, endpoint(path.raw, locations), K.extends, EMPTY_PROPERTIES);
+            const path = PathValue.project(parent);
+            addEdge(edges, definitionEndpoint, endpoint(path.raw, locations), K.classes.extends.ref, EMPTY_PROPERTIES);
         }
     }
-    if (definition.kind === 'class') {
+    if (isResolvedClass(definition)) {
         const declaration = definition.definition;
-        const assignments = declaration.family === 'node'
+        const assignments = declaration.kind === 'node'
             ? [
                 ['read', declaration.policies.read],
                 ['traverse', declaration.policies.traverse],
@@ -131,7 +120,7 @@ function projectDefinitionRelations(domain, definition, definitionEndpoint, loca
         for (const [operation, policy] of assignments) {
             if (policy === undefined)
                 continue;
-            const key = Key.fromSchema(policy);
+            const key = Key.of(policy);
             const existing = policies.get(key);
             if (existing === undefined) {
                 policies.set(key, { policy, operations: new Set([operation]) });
@@ -141,34 +130,41 @@ function projectDefinitionRelations(domain, definition, definitionEndpoint, loca
             }
         }
         for (const { policy, operations } of policies.values()) {
-            addEdge(edges, definitionEndpoint, endpoint(PathValue.project(policy).raw, locations), K.governed_by, normalizeProperties({
-                [K.governed_by.$.property('operations').key]: Object.freeze(['read', 'traverse'].filter((operation) => operations.has(operation))),
+            addEdge(edges, definitionEndpoint, endpoint(PathValue.project(policy).raw, locations), K.classes.governed_by.ref, normalizeProperties({
+                [K.classes.governed_by.self.properties.operations.key]: Object.freeze(['read', 'traverse'].filter((operation) => operations.has(operation))),
             }));
         }
     }
-    if (definition.kind === 'view') {
+    if (isResolvedView(definition)) {
         const target = definition.definition.target;
         const paths = target.kind === 'domain'
-            ? [PathValue.domain(domain.$.origin)]
-            : target.definitions.map((reference) => PathValue.project(reference));
+            ? [PathValue.domain(domain.origin)]
+            : target.definitions.map((reference) => {
+                if (reference.kind !== 'class') {
+                    throw new ProjectionError('PROJECTION_INVALID', `View target ${reference.origin}:${reference.kind}.${reference.name} is not a Class.`);
+                }
+                return PathValue.project({
+                    origin: reference.origin,
+                    kind: 'class',
+                    name: reference.name,
+                });
+            });
         for (const path of paths) {
-            addEdge(edges, definitionEndpoint, endpoint(path.raw, locations), K.view_for, EMPTY_PROPERTIES);
+            addEdge(edges, definitionEndpoint, endpoint(path.raw, locations), K.classes.view_for.ref, EMPTY_PROPERTIES);
         }
     }
 }
 function projectionClassFor(definition) {
-    if (definition.kind === 'class')
-        return ClassPathValue.from(K.Class);
-    if (definition.kind === 'interface')
-        return ClassPathValue.from(K.Interface);
-    switch (definition.kind) {
+    if (definition.ref.kind === 'class')
+        return ClassKeyValue.of(K.classes.Class.ref);
+    switch (definition.ref.kind) {
         case 'function':
-            return ClassPathValue.from(K.$.class('Function'));
+            return ClassKeyValue.of(K.classes.Function.ref);
         case 'policy':
-            return ClassPathValue.from(K.Policy);
+            return ClassKeyValue.of(K.classes.Policy.ref);
         case 'view':
-            return ClassPathValue.from(K.View);
-        case 'type':
+            return ClassKeyValue.of(K.classes.View.ref);
+        case 'core':
             return undefined;
         default:
             return undefined;
@@ -177,48 +173,52 @@ function projectionClassFor(definition) {
 function definitionPropertiesFor(definition) {
     const description = declarationDescription(definition);
     const metadata = descriptionProperties(description);
-    if (definition.kind === 'class') {
+    if (isResolvedClass(definition)) {
         const declaration = definition.definition;
-        const icon = definition.family === 'node' ? declaration.icon : undefined;
+        const icon = declaration.kind === 'node' ? declaration.icon : undefined;
         return normalizeProperties({
             ...metadata,
-            [K.Class.$.property('family').key]: definition.family,
-            ...(icon !== undefined ? { [K.$.interface('Iconable').$.property('icon').key]: icon } : {}),
+            [K.classes.Class.self.properties.kind.key]: declaration.kind,
+            [K.classes.Class.self.properties.abstract.key]: declaration.abstract,
+            ...(icon !== undefined ? { [K.classes.Iconable.self.properties.icon.key]: icon } : {}),
         });
     }
-    if (definition.kind === 'interface') {
-        return normalizeProperties({
-            ...metadata,
-            [K.Interface.$.property('family').key]: definition.family,
-        });
-    }
-    if (definition.kind === 'function') {
+    if (isResolvedFunction(definition)) {
         return callablePropertiesFor(definition.definition);
     }
-    if (definition.kind === 'view') {
+    if (definition.ref.kind === 'view') {
         return normalizeProperties(metadata);
     }
-    if (definition.kind === 'policy')
+    if (definition.ref.kind === 'policy')
         return normalizeProperties(metadata);
     return EMPTY_PROPERTIES;
 }
+function isResolvedClass(definition) {
+    return definition.ref.kind === 'class';
+}
+function isResolvedFunction(definition) {
+    return definition.ref.kind === 'function';
+}
+function isResolvedView(definition) {
+    return definition.ref.kind === 'view';
+}
 function callablePropertiesFor(declaration) {
     const method = 'static' in declaration;
     return normalizeProperties({
         ...descriptionProperties(declaration.description),
-        [K.$.interface('Function').$.property('kind').key]: method ? 'method' : 'function',
-        [K.$.interface('Function').$.property('input').key]: declaration.input,
-        [K.$.interface('Function').$.property('output').key]: declaration.output,
-        [K.$.interface('Function').$.property('auth').key]: declaration.auth,
+        [K.classes.Function.self.properties.kind.key]: method ? 'method' : 'function',
+        [K.classes.Function.self.properties.input.key]: declaration.input,
+        [K.classes.Function.self.properties.output.key]: declaration.output,
+        [K.classes.Function.self.properties.auth.key]: declaration.auth,
         ...(declaration.policy === undefined
             ? {}
             : {
-                [K.$.interface('Function').$.property('policy').key]: declaration.policy,
+                [K.classes.Function.self.properties.policy.key]: declaration.policy,
             }),
         ...(method
             ? {
-                [K.$.interface('Function').$.property('static').key]: declaration.static,
-                [K.$.interface('Function').$.property('inheritance').key]: declaration.inheritance,
+                [K.classes.Function.self.properties.static.key]: declaration.static,
+                [K.classes.Function.self.properties.inheritance.key]: declaration.inheritance,
             }
             : {}),
     });
@@ -226,33 +226,29 @@ function callablePropertiesFor(declaration) {
 function descriptionProperties(description) {
     if (description === undefined)
         return {};
-    return { [K.$.interface('Descriptable').$.property('description').key]: description };
+    return { [K.classes.Descriptable.self.properties.description.key]: description };
 }
 function declarationDescription(definition) {
-    if (definition.kind === 'type')
+    if (definition.ref.kind === 'core')
         return undefined;
     return definition.definition.description;
 }
 function memberKey(definition) {
-    if (definition.kind.endsWith('-class'))
-        return `class.${definition.name}`;
-    if (definition.kind.endsWith('-interface'))
-        return `interface.${definition.name}`;
-    return `${definition.kind}.${definition.name}`;
+    return `${definition.ref.kind}.${definition.ref.name}`;
 }
 /** Identity properties are supplied atomically by trusted lifecycle materialization. */
 function domainPropertiesFor(domain) {
     return normalizeProperties({
-        [K.Domain.$.property('origin').key]: domain.$.origin,
-        [K.Domain.$.property('schema').key]: domain.$.schema,
-        [K.Domain.$.property('schemaRevision').key]: domain.$.revision,
+        [K.classes.Domain.self.properties.origin.key]: domain.origin,
+        [K.classes.Domain.self.properties.schema.key]: domain.source,
+        [K.classes.Domain.self.properties.schemaRevision.key]: domain.revision,
     });
 }
 function endpoint(path, locations) {
     const created = locations.get(path);
     return created === undefined ? Object.freeze({ path }) : Object.freeze({ created });
 }
-function addNode(nodes, path, classPath, props, locations) {
+function addNode(nodes, path, classKey, props, locations) {
     const existing = nodes.get(path);
     if (existing !== undefined)
         return Object.freeze({ created: existing.as });
@@ -260,15 +256,14 @@ function addNode(nodes, path, classPath, props, locations) {
     if (as === undefined) {
         throw new ProjectionError('PROJECTION_INVALID', `Projection has no binding for ${path}.`);
     }
-    nodes.set(path, Object.freeze({ as, class: classPath, props }));
+    nodes.set(path, Object.freeze({ as, class: classKey, props }));
     return Object.freeze({ created: as });
 }
 function addEdge(edges, source, target, classRef, props) {
     edges.push(Object.freeze({
         source,
         target,
-        class: ClassPathValue.from(classRef),
+        class: ClassKeyValue.of(classRef),
         props,
     }));
 }
-//# sourceMappingURL=project.js.map

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

@@ -1,4 +1,4 @@
-import type { Key, schema } from '@astrale-os/kernel-dsl/v1';
+import type { Key, Revision } from '@astrale-os/kernel-dsl/v1';
 import type { GraphSpec, GraphSpecEdge, LocalBinding } from '#graph/graph';
 import type { NodePath } from '#graph/path';
 export interface ProjectionPart {
@@ -12,8 +12,7 @@ export interface CoreProjection extends ProjectionPart {
 }
 export interface Projection {
     readonly origin: Key.Origin;
-    readonly revision: schema.Revision;
+    readonly revision: Revision;
     readonly managed: ProjectionPart;
     readonly core: CoreProjection;
 }
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map