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

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

@@ -1,127 +1,240 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Identity: builder.NodeInterface<{
-    readonly description: "A principal that can be authenticated and can originate persistent authority facts.";
+export declare const Identity: builder.NodeClass<{
+    readonly depth: 1;
+    readonly abstract: true;
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 0;
+        readonly properties: never;
+        readonly methods: Readonly<Record<never, never>>;
+    }, never, never, never>];
     readonly properties: {
-        readonly frozen: builder.Property<{
-            readonly type: "boolean";
-        }, {
-            readonly required: false;
-            readonly visibility: "private";
-        }>;
-        readonly iss: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly requiredClaims: builder.Property<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-            claim: import("zod").ZodString;
-            op: import("zod").ZodLiteral<"contains">;
-            value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-            claim: import("zod").ZodString;
-            op: import("zod").ZodLiteral<"eq">;
-            value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-            claim: import("zod").ZodString;
-            op: import("zod").ZodLiteral<"exists">;
-        }, import("zod/v4/core").$strict>], "op">>, {
-            readonly required: false;
-            readonly visibility: "private";
-        }>;
-        readonly sub: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
+        readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+        readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+        readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+        readonly requiredClaims: builder.AuthoredPropertyProjection<({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[], ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[], false, "requiredClaims", "self", never>;
     };
     readonly methods: Readonly<{
-        delegate: builder.Function<{
-            readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
-            readonly auth: "authenticated";
-            readonly input: import("zod").ZodObject<{
-                audience: import("zod").ZodString;
-                ttlSeconds: import("zod").ZodNumber;
-                attenuation: import("zod").ZodUnknown;
-            }, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodString;
-            readonly inheritance: "default";
-        }>;
-        can: builder.Function<{
-            readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-            readonly auth: "authenticated";
-            readonly input: import("zod").ZodObject<{
-                policy: import("zod").ZodString;
-                object: import("zod").ZodString;
-            }, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodObject<{
-                allowed: import("zod").ZodBoolean;
-            }, import("zod/v4/core").$strict>;
-            readonly static: true;
-            readonly inheritance: "default";
-        }>;
-        whoami: builder.Function<{
-            readonly description: "Return the Identity authenticated for this invocation.";
-            readonly auth: "authenticated";
-            readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                issuer: import("zod").ZodString;
-                subject: import("zod").ZodString;
-                frozen: import("zod").ZodBoolean;
-                requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"contains">;
-                    value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"eq">;
-                    value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"exists">;
-                }, import("zod/v4/core").$strict>], "op">>;
-            }, import("zod/v4/core").$strict>;
-            readonly static: true;
-            readonly inheritance: "default";
-        }>;
-        whois: builder.Function<{
-            readonly description: "Resolve one issuer-and-subject Identity.";
-            readonly auth: "authorized";
-            readonly input: import("zod").ZodObject<{
-                issuer: import("zod").ZodString;
-                subject: import("zod").ZodString;
-            }, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodNullable<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                issuer: import("zod").ZodString;
-                subject: import("zod").ZodString;
-                frozen: import("zod").ZodBoolean;
-                requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"contains">;
-                    value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"eq">;
-                    value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"exists">;
-                }, import("zod/v4/core").$strict>], "op">>;
-            }, import("zod/v4/core").$strict>>;
-            readonly static: true;
-            readonly inheritance: "default";
-        }>;
-        mint: builder.Function<{
-            readonly description: "Resolve and sign one authorized Grant credential.";
-            readonly auth: "authorized";
-            readonly input: import("zod").ZodObject<{
-                audience: import("zod").ZodOptional<import("zod").ZodString>;
-                ttlSeconds: import("zod").ZodNumber;
-                grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
-            }, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodString;
-            readonly static: true;
-            readonly inheritance: "default";
-        }>;
+        delegate: builder.Method<builder.CallableProjection<{
+            principal: string;
+            audience: string;
+            ttlSeconds: number;
+            attenuation?: unknown;
+        }, {
+            readonly mode: 'value';
+            readonly value: string;
+        }, "authenticated", true, false, undefined>>;
+        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, undefined>>;
+        whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                iss: string;
+                sub: string;
+                frozen: boolean;
+                requiredClaims: ({
+                    claim: string;
+                    op: "contains";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "eq";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "exists";
+                })[];
+            };
+        }, "authenticated", true, false, undefined>>;
+        whois: builder.Method<builder.CallableProjection<{
+            iss: string;
+            sub: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                iss: string;
+                sub: string;
+                frozen: boolean;
+                requiredClaims: ({
+                    claim: string;
+                    op: "contains";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "eq";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "exists";
+                })[];
+            } | null;
+        }, "authorized", true, false, undefined>>;
+        mint: builder.Method<builder.CallableProjection<{
+            audience?: string | undefined;
+            ttlSeconds: number;
+            grant?: unknown;
+        }, {
+            readonly mode: 'value';
+            readonly value: string;
+        }, "authenticated", true, false, undefined>>;
+        impersonate: builder.Method<builder.CallableProjection<{
+            audience?: string | undefined;
+            ttlSeconds: number;
+            grant?: unknown;
+            identity: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: string;
+        }, "authorized", true, false, undefined>>;
     }>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never> | builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false, undefined>>, "whoami", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false, undefined>>, "delegate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false, undefined>>, "whois", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false, undefined>>, "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, undefined>>, "impersonate", "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, undefined>>, "can", "self">;
 }>;
-//# sourceMappingURL=identity.d.ts.map

package/dist/schema/identity/identity.js

@@ -1,17 +1,18 @@
-import { nodeInterface, property } from '@astrale-os/kernel-dsl/v1';
+import { nodeClass, property } from '@astrale-os/kernel-dsl/v1';
 import { requiredClaimsSchema } from '../authority/claims.js';
 import { IdentityMethods } from '../kernel/syscalls/declarations/index.js';
-export const Identity = nodeInterface({
+import { Node } from '../meta/index.js';
+export const Identity = nodeClass({
+    abstract: true,
     description: 'A principal that can be authenticated and can originate persistent authority facts.',
+    extends: [Node],
     properties: {
-        frozen: property({ type: 'boolean' }, { required: false, visibility: 'private' }),
-        iss: { type: 'string', minLength: 1 },
+        iss: property({ type: 'string', minLength: 1 }, { required: false }),
+        sub: property({ type: 'string', minLength: 1 }, { required: false }),
+        frozen: property({ type: 'boolean' }, { required: false }),
         requiredClaims: property(requiredClaimsSchema, {
             required: false,
-            visibility: 'private',
         }),
-        sub: { type: 'string', minLength: 1 },
     },
     methods: IdentityMethods,
 });
-//# sourceMappingURL=identity.js.map

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

@@ -2,4 +2,3 @@ export { ConstrainedBy } from './constrained-by.js';
 export { ExcludedFrom } from './excluded-from.js';
 export { ExtendsWith } from './extends-with.js';
 export { Identity } from './identity.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/identity/index.js

@@ -2,4 +2,3 @@ export { ConstrainedBy } from './constrained-by.js';
 export { ExcludedFrom } from './excluded-from.js';
 export { ExtendsWith } from './extends-with.js';
 export { Identity } from './identity.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/index.d.ts

@@ -5,4 +5,3 @@ export * as graph from './kernel/projection/index.js';
 export * as introspection from './introspection/index.js';
 export * as installation from './installation/index.js';
 export { OperationCore } from './core/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.js

@@ -4,4 +4,3 @@ export * as graph from './kernel/projection/index.js';
 export * as introspection from './introspection/index.js';
 export * as installation from './installation/index.js';
 export { OperationCore } from './core/index.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/installation/index.d.ts

@@ -1,2 +1 @@
 export { acceptOperationId, type OperationId } from './operation-id.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/installation/index.js

@@ -1,2 +1 @@
 export { acceptOperationId } from './operation-id.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/installation/operation-id.d.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 declare const OPERATION_ID: unique symbol;
 /** Caller-selected identity for one retryable Schema installation operation. */
 export type OperationId = string & {
@@ -7,6 +6,5 @@ export type OperationId = string & {
 /** Accept one canonical lowercase UUIDv4 without repair or case folding. */
 export declare function acceptOperationId(input: unknown): OperationId;
 /** Internal schema shared by Kernel-owned callable contracts. */
-export declare const operationIdSchema: z.ZodString;
+export declare const operationIdSchema: import("zod").ZodString;
 export {};
-//# sourceMappingURL=operation-id.d.ts.map

package/dist/schema/installation/operation-id.js

@@ -1,5 +1,5 @@
-import { fullMatch } from '@astrale-os/kernel-dsl/v1';
-import { z } from 'zod';
+import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
+import { string } from 'zod';
 const OPERATION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 const OPERATION_ID_MESSAGE = 'OperationId must be a canonical lowercase RFC 9562 UUIDv4.';
 /** Accept one canonical lowercase UUIDv4 without repair or case folding. */
@@ -10,7 +10,4 @@ export function acceptOperationId(input) {
     return input;
 }
 /** Internal schema shared by Kernel-owned callable contracts. */
-export const operationIdSchema = z
-    .string()
-    .check(fullMatch('[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'));
-//# sourceMappingURL=operation-id.js.map
+export const operationIdSchema = string().check(fullMatch('[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'));

package/dist/schema/introspection/index.d.ts

@@ -1,2 +1 @@
-export type { InstallationIntrospection, InstallationSelection, Introspection } from './language.js';
-//# sourceMappingURL=index.d.ts.map
+export type { Introspection } from './language.js';

package/dist/schema/introspection/index.js

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

package/dist/schema/introspection/language.d.ts

@@ -1,31 +1,12 @@
 import type { Key } from '@astrale-os/kernel-dsl/v1';
-type Fields = {
-    readonly state?: true;
-    readonly target?: true;
-    readonly source?: true;
-    readonly bundle?: true;
-    readonly readiness?: true;
-    readonly capabilities?: true;
-};
-type AtLeastOne<Value extends object> = {
-    [Field in keyof Value]-?: Required<Pick<Value, Field>> & Partial<Omit<Value, Field>>;
-}[keyof Value];
-type BundleWithSource = (AtLeastOne<Omit<Fields, 'bundle'>> & {
-    readonly bundle?: never;
-}) | (AtLeastOne<Fields> & {
-    readonly bundle: true;
-    readonly source: true;
-});
-/** Closed version-one field selection for one installed Domain origin. */
-export type InstallationSelection = BundleWithSource;
-export interface InstallationIntrospection<out Selection extends InstallationSelection = InstallationSelection> {
-    readonly from: {
-        readonly kind: 'installation';
-        readonly origin: Key.Origin;
-    };
-    readonly select: Selection;
-}
 /** One admitted read-only Schema control-plane request. */
-export type Introspection<Selection extends InstallationSelection = InstallationSelection> = InstallationIntrospection<Selection>;
-export {};
-//# sourceMappingURL=language.d.ts.map
+export type Introspection = {
+    readonly kind: 'inspect';
+    readonly origin: Key.Origin;
+} | {
+    readonly kind: 'bundle';
+    readonly origin: Key.Origin;
+} | {
+    readonly kind: 'dependencies';
+    readonly origin: Key.Origin;
+};

package/dist/schema/introspection/language.js

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

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

@@ -1,3 +1,2 @@
 export { AuthorityOperationOrder, AuthorityOperations, AuthorityRelations, K, KernelRootFunctions, KernelSchema, operationOf, } from './schema.js';
 export type { AuthorityOperation, AuthorityRelation, Kernel } from './schema.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/kernel/index.js

@@ -1,2 +1 @@
 export { AuthorityOperationOrder, AuthorityOperations, AuthorityRelations, K, KernelRootFunctions, KernelSchema, operationOf, } from './schema.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,8 +1,6 @@
-import type { Key } from '@astrale-os/kernel-dsl/v1';
-import type { Domain, Method } from '#domain';
+import type { Domain, Key, ResolvedMethod } from '@astrale-os/kernel-dsl/v1';
 import type { NodePath } from '#graph/path';
 /** Exact projected Function Node locator -> Domain callable declaration for one Domain revision. */
 export declare function projectedCallables(domain: Domain): ReadonlyMap<NodePath, Key.Callable>;
 /** Canonical schema locator of one projected Method definition, not an invocation receiver. */
-export declare function projectedMethodPath(domain: Domain, method: Method): NodePath;
-//# sourceMappingURL=callables.d.ts.map
+export declare function projectedMethodPath(domain: Domain, method: ResolvedMethod): NodePath;

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

@@ -2,14 +2,17 @@ import { Path } from '#graph/path';
 /** Exact projected Function Node locator -> Domain callable declaration for one Domain revision. */
 export function projectedCallables(domain) {
     const result = new Map();
-    for (const definition of domain.$.definitions.values()) {
-        if (definition.origin !== domain.$.origin)
+    for (const definition of domain.definitions()) {
+        if (definition.ref.origin !== domain.origin)
+            continue;
+        if (definition.ref.kind === 'function') {
+            result.set(Path.project(definition.ref).raw, definition.key);
             continue;
-        if (definition.kind === 'function' && definition.path !== undefined) {
-            result.set(definition.path.raw, definition.key);
         }
-        for (const method of definition.methods.values()) {
-            if (method.owner.origin !== domain.$.origin || method.definition.inheritance === 'abstract') {
+        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;
             }
             result.set(projectedMethodPath(domain, method), method.key);
@@ -19,11 +22,11 @@ export function projectedCallables(domain) {
 }
 /** Canonical schema locator of one projected Method definition, not an invocation receiver. */
 export function projectedMethodPath(domain, method) {
-    const owner = domain.$.inspect(method.owner).path;
-    if (owner === undefined)
-        throw new TypeError(`Method owner ${method.owner.name} has no Path.`);
+    if (method.owner.ref.origin !== domain.origin) {
+        throw new TypeError(`Method owner ${method.owner.ref.name} belongs to another Domain.`);
+    }
+    const owner = Path.project(method.owner.ref);
     return (method.definition.static
         ? Path.staticMethod(owner, method.name)
-        : Path.instanceMethod(owner, method.name)).raw;
+        : Path.instanceMethod(owner, method.key)).raw;
 }
-//# sourceMappingURL=callables.js.map

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

@@ -1,6 +1,4 @@
-import { schema, type Key } from '@astrale-os/kernel-dsl/v1';
+import { schema, type Key, type SourceDomain } from '@astrale-os/kernel-dsl/v1';
 import type { Graph } from '#graph/graph';
-import { type Domain as DomainValue } from '#domain';
 /** Compile one canonical kernel graph projection back into its exact rich Domain. */
-export declare function compile(graph: Graph, origin: Key.Origin, lookup?: schema.Lookup): DomainValue<schema.DomainSchema>;
-//# sourceMappingURL=compile.d.ts.map
+export declare function compile(graph: Graph, origin: Key.Origin, lookup?: schema.Lookup): SourceDomain<schema.DomainSchema>;

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

@@ -1,15 +1,14 @@
 import { schema } from '@astrale-os/kernel-dsl/v1';
-import { Domain } from '#domain';
-import { ClassPath } from '#graph/class';
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { K } from '../index.js';
 import { ProjectionError } from './diagnostics.js';
 const EMPTY_LOOKUP = Object.freeze({ get: () => undefined });
 /** Compile one canonical kernel graph projection back into its exact rich Domain. */
 export function compile(graph, origin, lookup = EMPTY_LOOKUP) {
-    const domainClass = ClassPath.from(K.Domain);
-    const originKey = K.Domain.$.property('origin').key;
-    const schemaKey = K.Domain.$.property('schema').key;
-    const revisionKey = K.Domain.$.property('schemaRevision').key;
+    const domainClass = ClassKey.of(K.classes.Domain.ref);
+    const originKey = K.classes.Domain.properties.origin.key;
+    const schemaKey = K.classes.Domain.properties.schema.key;
+    const revisionKey = K.classes.Domain.properties.schemaRevision.key;
     const candidates = graph.nodes
         .byClass(domainClass)
         .filter((node) => node.props[originKey] === origin);
@@ -23,7 +22,7 @@ export function compile(graph, origin, lookup = EMPTY_LOOKUP) {
     const input = node.props[schemaKey];
     const storedRevision = node.props[revisionKey];
     if (input === undefined || typeof storedRevision !== 'string') {
-        throw new ProjectionError('PROJECTION_SCHEMA_UNAVAILABLE', `The Domain Node for ${origin} does not carry both schema and schemaRevision.`);
+        throw new ProjectionError('PROJECTION_SCHEMA_UNAVAILABLE', `The Domain Node for ${origin} does not carry schema and schemaRevision together.`);
     }
     let domainSchema;
     try {
@@ -43,6 +42,5 @@ export function compile(graph, origin, lookup = EMPTY_LOOKUP) {
     if (storedRevision !== actualRevision) {
         throw new ProjectionError('PROJECTION_REVISION_MISMATCH', `Stored revision ${storedRevision} does not match ${actualRevision}.`);
     }
-    return Domain.fromSchema(domainSchema);
+    return schema.resolve(domainSchema);
 }
-//# sourceMappingURL=compile.js.map