@astrale-os/kernel-core 0.9.0-beta.65 → 0.9.0-beta.67

package/dist/schema/domain/domain.d.ts

@@ -38,10 +38,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -183,10 +179,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -316,10 +308,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -412,10 +400,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -545,10 +529,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -641,10 +621,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -774,10 +750,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -870,10 +842,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -1003,10 +971,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -1119,10 +1083,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -1252,10 +1212,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -1316,10 +1272,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -1359,10 +1311,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -1492,10 +1440,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -1595,10 +1539,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -1728,10 +1668,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -1830,10 +1766,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -1963,10 +1895,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -2082,10 +2010,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -2215,10 +2139,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -2328,10 +2248,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -2461,10 +2377,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -2524,6 +2436,7 @@ export declare const Domain: builder.NodeClass<{
     }, "authenticated", true, false, undefined>>, "can", unknown>>>>];
     readonly properties: {
         readonly origin: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined>;
+        readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
         readonly dependencyContext: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never>;
         readonly schema: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schema", "self", never>;
         readonly schemaRevision: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schemaRevision", "self", never>;
@@ -2587,10 +2500,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -2720,10 +2629,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -2816,10 +2721,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -2949,10 +2850,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -3045,10 +2942,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -3178,10 +3071,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -3274,10 +3163,6 @@ export declare const Domain: builder.NodeClass<{
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation?: {
-                    kind: "identity";
-                    self: true;
-                } | undefined;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
@@ -3407,10 +3292,6 @@ export declare const Domain: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -3467,7 +3348,7 @@ export declare const Domain: builder.NodeClass<{
                 allowed: boolean;
             }[];
         };
-    }, "authenticated", true, false, undefined>>, "can", unknown>>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schema", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schemaRevision", "self", never>);
+    }, "authenticated", true, false, undefined>>, "can", unknown>>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schema", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schemaRevision", "self", never>);
     readonly abstractInstanceMethods: never;
     readonly abstractStaticMethods: never;
     readonly effectiveInstanceMethods: never;

package/dist/schema/domain/domain.js

@@ -9,6 +9,9 @@ export const Domain = nodeClass({
             type: 'string',
             pattern: '[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+',
         },
+        // The authored display name; a revision that predates it projects its origin instead, which
+        // is why the bound admits a complete origin rather than only an authored name.
+        name: { type: 'string', minLength: 1, maxLength: 253 },
         dependencyContext: property({ type: 'array', items: { type: 'object' } }, { required: false }),
         schema: property({ type: 'object' }, {}),
         schemaRevision: property({ type: 'string', pattern: 'sha256:[0-9a-f]{64}' }, {}),

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

@@ -41,10 +41,6 @@ export declare const Identity: builder.NodeClass<{
             principal: string;
             audience: string;
             ttlSeconds: number;
-            attenuation?: {
-                kind: "identity";
-                self: true;
-            } | undefined;
         }, {
             readonly mode: 'value';
             readonly value: string;
@@ -178,10 +174,6 @@ export declare const Identity: builder.NodeClass<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: {
-            kind: "identity";
-            self: true;
-        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;

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

@@ -0,0 +1,7 @@
+import type { SourceDomain, schema } from '@astrale-os/kernel-dsl/v1';
+import { type Edge, type Part, type Payload } from './part.js';
+/**
+ * Declare each authored Core Node, then each authored Core Edge, and return the locators that
+ * associate every Core Node with its Domain.
+ */
+export declare function projectCore<Extra extends object>(domain: SourceDomain<schema.DomainSchema>, core: Part<Extra>, payload: Payload<Extra>): Edge<Extra>[];

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

@@ -0,0 +1,51 @@
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { Path } from '#graph/path';
+import { K } from '../index.js';
+import { projectedMethodPath } from './callables.js';
+import { ProjectionError } from './diagnostics.js';
+import { edge } from './part.js';
+import { memberProperties } from './properties.js';
+/**
+ * Declare each authored Core Node, then each authored Core Edge, and return the locators that
+ * associate every Core Node with its Domain.
+ */
+export function projectCore(domain, core, payload) {
+    // The Domain Node is persisted before its Core part, so locators address it by its Path.
+    const domainEndpoint = Object.freeze({ path: Path.domain(domain.origin).raw });
+    const locators = [];
+    for (const [slug, declaration] of Object.entries(domain.source.core.nodes)) {
+        assertAuthenticationUnowned(domain, declaration.class, declaration.properties, slug);
+        const created = core.node(Path.project({ origin: domain.origin, kind: 'core', name: slug }).raw, ClassKey.of(declaration.class), payload(() => declaration.properties));
+        locators.push(edge(created, domainEndpoint, K.classes.of_domain.ref, payload(() => memberProperties(`core.${slug}`))));
+    }
+    // Resolved edges carry each endpoint's own identity; the source IR only names it.
+    for (const authored of domain.core.edges) {
+        core.edges.push(edge(endpoint(authored.source, domain, core, domainEndpoint), endpoint(authored.target, domain, core, domainEndpoint), authored.class.ref, payload(() => authored.properties)));
+    }
+    return locators;
+}
+/** Authentication of a Core Identity is established only by the credential-evidenced lifecycle. */
+function assertAuthenticationUnowned(domain, classRef, properties, slug) {
+    const definition = domain.definition(classRef);
+    if (definition?.ref.kind !== 'class' ||
+        definition.kind !== 'node' ||
+        !definition.satisfies(K.classes.Identity)) {
+        return;
+    }
+    const hasIssuer = Object.hasOwn(properties, K.classes.Identity.properties.iss.key);
+    const hasSubject = Object.hasOwn(properties, K.classes.Identity.properties.sub.key);
+    if (hasIssuer || hasSubject) {
+        throw new ProjectionError('PROJECTION_INVALID', `Core Identity ${domain.origin}:core.${slug} cannot declare protected Authentication properties iss or sub.`);
+    }
+}
+/**
+ * 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 endpoint(value, domain, core, domainEndpoint) {
+    if ('ref' in value)
+        return core.endpoint(Path.project(value.ref).raw);
+    if ('owner' in value)
+        return core.endpoint(projectedMethodPath(domain, value));
+    return domainEndpoint;
+}

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

@@ -0,0 +1,13 @@
+import type { SourceDomain, schema } from '@astrale-os/kernel-dsl/v1';
+import type { ResolvedDefinition, ResolvedDefinitionOf } from '@astrale-os/kernel-dsl/v1/language';
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { GraphSpecEndpoint } from '#graph/graph';
+import { type Part, type Payload } from './part.js';
+/** Declare the Domain Node, the target of every of_domain locator. */
+export declare function projectDomain<Extra extends object>(domain: SourceDomain<schema.DomainSchema>, managed: Part<Extra>, payload: Payload<Extra>): GraphSpecEndpoint;
+/** Declare each local Definition's Node and its of_domain locator. */
+export declare function projectDefinitions<Extra extends object>(domain: SourceDomain<schema.DomainSchema>, managed: Part<Extra>, domainEndpoint: GraphSpecEndpoint, payload: Payload<Extra>): void;
+/** Each local Definition projected as a managed declaration, with the Kernel Class it projects to. */
+export declare function projectedDefinitions(domain: SourceDomain<schema.DomainSchema>): Generator<readonly [ResolvedDefinition, ClassKey]>;
+/** Whether a resolved Definition is of the given kind. */
+export declare function is<Kind extends ResolvedDefinition['ref']['kind']>(definition: ResolvedDefinition, kind: Kind): definition is ResolvedDefinitionOf<Kind>;

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

@@ -0,0 +1,71 @@
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { Path } from '#graph/path';
+import { normalizeProperties } from '#graph/properties';
+import { K } from '../index.js';
+import { edge } from './part.js';
+import { EMPTY_PROPERTIES, callableProperties, descriptionProperties, memberProperties, } from './properties.js';
+/** Declare the Domain Node, the target of every of_domain locator. */
+export function projectDomain(domain, managed, payload) {
+    return managed.node(Path.domain(domain.origin).raw, ClassKey.of(K.classes.Domain.ref), payload(() => domainProperties(domain)));
+}
+/** Declare each local Definition's Node and its of_domain locator. */
+export function projectDefinitions(domain, managed, domainEndpoint, payload) {
+    for (const [definition, projectedClass] of projectedDefinitions(domain)) {
+        const definitionEndpoint = managed.node(Path.project(definition.ref).raw, projectedClass, payload(() => definitionProperties(definition)));
+        managed.edges.push(edge(definitionEndpoint, domainEndpoint, K.classes.of_domain.ref, payload(() => memberProperties(`${definition.ref.kind}.${definition.ref.name}`))));
+    }
+}
+/** Each local Definition projected as a managed declaration, with the Kernel Class it projects to. */
+export function* projectedDefinitions(domain) {
+    for (const definition of domain.definitions()) {
+        if (definition.ref.origin !== domain.origin)
+            continue;
+        const projectedClass = classOf(definition);
+        if (projectedClass !== undefined)
+            yield [definition, projectedClass];
+    }
+}
+/** Whether a resolved Definition is of the given kind. */
+export function is(definition, kind) {
+    return definition.ref.kind === kind;
+}
+function classOf(definition) {
+    switch (definition.ref.kind) {
+        case 'class':
+            return ClassKey.of(K.classes.Class.ref);
+        case 'function':
+            return ClassKey.of(K.classes.Function.ref);
+        case 'policy':
+            return ClassKey.of(K.classes.Policy.ref);
+        case 'view':
+            return ClassKey.of(K.classes.View.ref);
+        default:
+            return undefined;
+    }
+}
+/** Identity properties are supplied atomically by trusted lifecycle materialization. */
+function domainProperties(domain) {
+    return normalizeProperties({
+        [K.classes.Domain.self.properties.origin.key]: domain.origin,
+        [K.classes.Domain.self.properties.name.key]: domain.source.name,
+        [K.classes.Domain.self.properties.schema.key]: domain.source,
+        [K.classes.Domain.self.properties.schemaRevision.key]: domain.revision,
+    });
+}
+function definitionProperties(definition) {
+    if (is(definition, 'function'))
+        return callableProperties(definition.definition);
+    if (is(definition, 'core'))
+        return EMPTY_PROPERTIES;
+    const metadata = descriptionProperties(definition.definition.description);
+    if (!is(definition, 'class'))
+        return normalizeProperties(metadata);
+    const declaration = definition.definition;
+    const icon = declaration.kind === 'node' ? declaration.icon : undefined;
+    return normalizeProperties({
+        ...metadata,
+        [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 } : {}),
+    });
+}

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

@@ -0,0 +1,5 @@
+import type { SourceDomain, schema } from '@astrale-os/kernel-dsl/v1';
+import type { GraphSpecEndpoint } from '#graph/graph';
+import { type Part, type Payload } from './part.js';
+/** Declare each executable local Method as a Function Node, with its method_of and of_domain Edges. */
+export declare function projectMethods<Extra extends object>(domain: SourceDomain<schema.DomainSchema>, managed: Part<Extra>, domainEndpoint: GraphSpecEndpoint, payload: Payload<Extra>): void;

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

@@ -0,0 +1,41 @@
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { Path } from '#graph/path';
+import { normalizeProperties } from '#graph/properties';
+import { K } from '../index.js';
+import { projectedMethodPath } from './callables.js';
+import { ProjectionError } from './diagnostics.js';
+import { edge } from './part.js';
+import { callableProperties, memberProperties } from './properties.js';
+/** Declare each executable local Method as a Function Node, with its method_of and of_domain Edges. */
+export function projectMethods(domain, managed, domainEndpoint, payload) {
+    for (const method of executableMethods(domain)) {
+        const methodEndpoint = managed.node(projectedMethodPath(domain, method), ClassKey.of(K.classes.Function.ref), payload(() => callableProperties(method.definition)));
+        managed.edges.push(edge(methodEndpoint, managed.endpoint(Path.project(method.owner.ref).raw), 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,
+        }))));
+        // This structural check must also execute when no Property payload is requested.
+        const member = memberOf(domain, method);
+        managed.edges.push(edge(methodEndpoint, domainEndpoint, K.classes.of_domain.ref, payload(() => memberProperties(member))));
+    }
+}
+/** Each local executable Method once, instance and static, across every Class of the Domain. */
+function executableMethods(domain) {
+    const methods = new Map();
+    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.executable) {
+                methods.set(method.key, method);
+            }
+        }
+    }
+    return methods.values();
+}
+/** The Method's member name within its Domain. */
+function memberOf(domain, method) {
+    const prefix = `${domain.origin}:`;
+    if (!method.key.startsWith(prefix)) {
+        throw new ProjectionError('PROJECTION_INVALID', 'Method key belongs to another Domain.');
+    }
+    return method.key.slice(prefix.length);
+}

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

@@ -0,0 +1,34 @@
+import type { ClassRef } from '@astrale-os/kernel-dsl/v1';
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { GraphSpecEndpoint } from '#graph/graph';
+import type { NodePath } from '#graph/path';
+import type { Properties } from '#graph/properties';
+import { LocalAlias } from '#graph/graph';
+import type { ProjectionTopologyEdge, ProjectionTopologyNode } from './types.js';
+/**
+ * What each declaration carries besides its identity: full projection evaluates the Property
+ * factory, topology projection never does. Call it in argument position, before `node` or `edge`
+ * runs its own checks, so both projections throw the same error first.
+ */
+export type Payload<Extra extends object> = (properties: () => Properties) => Extra;
+export type Node<Extra extends object> = ProjectionTopologyNode & Extra;
+export type Edge<Extra extends object> = ProjectionTopologyEdge & Extra;
+/** One graph part under construction: its local bindings, its declared Nodes and its Edges. */
+export declare class Part<Extra extends object> {
+    #private;
+    readonly edges: Edge<Extra>[];
+    /** Bind each Path, in the given order, to the next local binding `n0`, `n1`, ... */
+    constructor(paths: readonly NodePath[]);
+    /** A Path declared in this part is addressed by its binding, any other by the Path itself. */
+    endpoint(path: NodePath): GraphSpecEndpoint;
+    /** Declare the Node at a bound Path once; declaring it again returns the first binding. */
+    node(path: NodePath, classKey: ClassKey, payload: Extra): GraphSpecEndpoint;
+    /** The declared Nodes and Edges in declaration order, with each binding's Path. */
+    done(): Readonly<{
+        nodes: readonly Node<Extra>[];
+        edges: readonly Edge<Extra>[];
+        paths: Map<LocalAlias, import("../../../graph/path/language/model.js").NodePath>;
+    }>;
+}
+/** One projected Edge. */
+export declare function edge<Extra extends object>(source: GraphSpecEndpoint, target: GraphSpecEndpoint, classRef: ClassRef, payload: Extra): Edge<Extra>;

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

@@ -0,0 +1,42 @@
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { LocalAlias } from '#graph/graph';
+import { ProjectionError } from './diagnostics.js';
+/** One graph part under construction: its local bindings, its declared Nodes and its Edges. */
+export class Part {
+    edges = [];
+    #bindings;
+    #nodes = new Map();
+    /** Bind each Path, in the given order, to the next local binding `n0`, `n1`, ... */
+    constructor(paths) {
+        this.#bindings = new Map(paths.map((path, index) => [path, LocalAlias(`n${index}`)]));
+    }
+    /** A Path declared in this part is addressed by its binding, any other by the Path itself. */
+    endpoint(path) {
+        const created = this.#bindings.get(path);
+        return created === undefined ? Object.freeze({ path }) : Object.freeze({ created });
+    }
+    /** Declare the Node at a bound Path once; declaring it again returns the first binding. */
+    node(path, classKey, payload) {
+        const existing = this.#nodes.get(path);
+        if (existing !== undefined)
+            return Object.freeze({ created: existing.as });
+        const as = this.#bindings.get(path);
+        if (as === undefined) {
+            throw new ProjectionError('PROJECTION_INVALID', `Projection has no binding for ${path}.`);
+        }
+        this.#nodes.set(path, Object.freeze({ as, class: classKey, ...payload }));
+        return Object.freeze({ created: as });
+    }
+    /** The declared Nodes and Edges in declaration order, with each binding's Path. */
+    done() {
+        return Object.freeze({
+            nodes: Object.freeze([...this.#nodes.values()]),
+            edges: Object.freeze(this.edges),
+            paths: new Map([...this.#bindings].map(([path, binding]) => [binding, path])),
+        });
+    }
+}
+/** One projected Edge. */
+export function edge(source, target, classRef, payload) {
+    return Object.freeze({ source, target, class: ClassKey.of(classRef), ...payload });
+}

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

@@ -0,0 +1,6 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type { NodePath } from '#graph/path';
+/** Sorted Paths of the Domain Node, its local Definitions and their executable Methods. */
+export declare function managedPaths(domain: Domain): readonly NodePath[];
+/** Sorted Paths of the Domain's authored Core Nodes. */
+export declare function corePaths(domain: Domain): readonly NodePath[];