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

package/dist/graph/reconcile/planning/context.d.ts

@@ -2,15 +2,15 @@ import { type CorrespondenceEntry } from '#graph/reconcile/correspondence';
 import { type ObservationEvidence, type ObservationRequirement } from '#graph/reconcile/evidence';
 import { type Observation } from '#graph/reconcile/observation';
 import type { Edge } from '../../edge/index.js';
-import type { LocalBinding } from '../../graph/index.js';
+import type { LocalAlias } from '../../graph/index.js';
 import type { Node, NodeId } from '../../node/index.js';
 import type { Effect, PlanningBlocker, PlanningConflict, Premise } from './model.js';
 import { type DesiredProperties } from '../../properties/index.js';
 export interface PlanningContext {
     readonly nodes: ReadonlyMap<NodeId, Node>;
     readonly edges: ReadonlyMap<string, Edge>;
-    readonly correspondence: ReadonlyMap<LocalBinding, CorrespondenceEntry>;
-    readonly created: Set<LocalBinding>;
+    readonly correspondence: ReadonlyMap<LocalAlias, CorrespondenceEntry>;
+    readonly created: Set<LocalAlias>;
     readonly evidence: readonly ObservationEvidence[];
     readonly premises: Premise[];
     readonly effects: Effect[];

package/dist/graph/reconcile/planning/model.d.ts

@@ -3,12 +3,12 @@ import type { CorrespondenceConflict } from '#graph/reconcile/correspondence';
 import type { ObservationRequirement, QueryObservation } from '#graph/reconcile/evidence';
 import type { ObservationConflict } from '#graph/reconcile/observation';
 import type { EdgeKey, EdgeSlug } from '../../edge/index.js';
-import type { LocalBinding } from '../../graph/index.js';
+import type { LocalAlias } from '../../graph/index.js';
 import type { NodeId } from '../../node/index.js';
 import type { Delta, DesiredProperties, Properties } from '../../properties/index.js';
 import type { DesiredFingerprint, DesiredSelection, Expectation, ReconcileConflict } from '../condition/index.js';
 export type ResolvedNodeRef = NodeId | {
-    readonly created: LocalBinding;
+    readonly created: LocalAlias;
 };
 export interface ResolvedEdgeRef {
     readonly source: ResolvedNodeRef;
@@ -35,7 +35,7 @@ export interface QueryPremise {
 }
 export type Effect = {
     readonly op: 'node.create';
-    readonly as: LocalBinding;
+    readonly as: LocalAlias;
     readonly class: ClassKey;
     readonly properties: Properties;
 } | {
@@ -63,7 +63,7 @@ export type Effect = {
 };
 export type PlanningConflict = ReconcileConflict | CorrespondenceConflict | ObservationConflict | {
     readonly kind: 'desired-binding-uncreated';
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
 } | {
     readonly kind: 'node-class-observed';
     readonly node: NodeId;
@@ -72,6 +72,10 @@ export type PlanningConflict = ReconcileConflict | CorrespondenceConflict | Obse
 } | {
     readonly kind: 'node-identity-absent';
     readonly node: NodeId;
+} | {
+    /** One effect target reached through aliasing refs with different desired content. */
+    readonly kind: 'desired-target-contradictory';
+    readonly effects: readonly Effect[];
 };
 export type PlanningBlocker = {
     readonly kind: 'selection-unsatisfied';

package/dist/graph/reconcile/planning/plan.js

@@ -1,5 +1,5 @@
 import { fingerprint } from '../condition/index.js';
-import { canonicalBlockers, canonicalConflicts, canonicalEffects, canonicalPremises, canonicalRequirements, createPlan, } from './canonical.js';
+import { canonicalBlockers, canonicalConflicts, canonicalEffects, canonicalPremises, canonicalRequirements, contradictoryEffects, createPlan, } from './canonical.js';
 import { createPlanningContext } from './context.js';
 import { planEdge } from './edge.js';
 import { planNode } from './node.js';
@@ -13,6 +13,7 @@ export function plan(input) {
         planEdge(edge, context);
     for (const selection of input.desired.selections)
         planSelection(selection, context);
+    context.conflicts.push(...contradictoryEffects(context.effects));
     if (context.conflicts.length > 0) {
         return Object.freeze({
             kind: 'conflict',

package/dist/schema/authority/authority-relation.js

@@ -12,5 +12,8 @@ export function authorityRelation(target, role, description) {
         target: { as: role, accepts: [target], incoming: '0..*' },
         description,
         extends: [Edge],
+        // The installed authority map is observed through Identity.can, never read wholesale: only the
+        // Kernel Domain and Root read its Edges.
+        policies: { read: false, traverse: false },
     });
 }

package/dist/schema/authority/claims.d.ts

@@ -1,27 +1,26 @@
-import { z } from 'zod';
 /** Exact reusable schema for one ClaimConstraint in a graph or callable contract. */
-export declare const claimConstraintSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    claim: z.ZodString;
-    op: z.ZodLiteral<"contains">;
-    value: z.ZodNonOptional<z.ZodUnknown>;
-}, z.core.$strict>, z.ZodObject<{
-    claim: z.ZodString;
-    op: z.ZodLiteral<"eq">;
-    value: z.ZodNonOptional<z.ZodUnknown>;
-}, z.core.$strict>, z.ZodObject<{
-    claim: z.ZodString;
-    op: z.ZodLiteral<"exists">;
-}, z.core.$strict>], "op">;
+export declare const claimConstraintSchema: 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">;
 /** Exact reusable bounded schema for an Identity's required ClaimConstraints. */
-export declare const requiredClaimsSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-    claim: z.ZodString;
-    op: z.ZodLiteral<"contains">;
-    value: z.ZodNonOptional<z.ZodUnknown>;
-}, z.core.$strict>, z.ZodObject<{
-    claim: z.ZodString;
-    op: z.ZodLiteral<"eq">;
-    value: z.ZodNonOptional<z.ZodUnknown>;
-}, z.core.$strict>, z.ZodObject<{
-    claim: z.ZodString;
-    op: z.ZodLiteral<"exists">;
-}, z.core.$strict>], "op">>;
+export declare const requiredClaimsSchema: 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">>;

package/dist/schema/authority/claims.js

@@ -1,12 +1,12 @@
-import { z } from 'zod';
+import { array, discriminatedUnion, literal, strictObject, string, unknown as unknownSchema, } from 'zod';
 import { claims } from '#auth';
-const claim = z.string().min(1);
-const portableValue = z.unknown().nonoptional();
+const claim = string().min(1);
+const portableValue = unknownSchema().nonoptional();
 /** Exact reusable schema for one ClaimConstraint in a graph or callable contract. */
-export const claimConstraintSchema = z.discriminatedUnion('op', [
-    z.strictObject({ claim, op: z.literal('contains'), value: portableValue }),
-    z.strictObject({ claim, op: z.literal('eq'), value: portableValue }),
-    z.strictObject({ claim, op: z.literal('exists') }),
+export const claimConstraintSchema = discriminatedUnion('op', [
+    strictObject({ claim, op: literal('contains'), value: portableValue }),
+    strictObject({ claim, op: literal('eq'), value: portableValue }),
+    strictObject({ claim, op: literal('exists') }),
 ]);
 /** Exact reusable bounded schema for an Identity's required ClaimConstraints. */
-export const requiredClaimsSchema = z.array(claimConstraintSchema).max(claims.MAX_REQUIRED_CLAIMS);
+export const requiredClaimsSchema = array(claimConstraintSchema).max(claims.MAX_REQUIRED_CLAIMS);

package/dist/schema/authority/governed-by.d.ts

@@ -1,109 +1,34 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const GovernedBy: builder.DirectedEdgeClass<{
+    readonly depth: 1;
     readonly abstract: false;
-    readonly source: {
-        readonly as: "class";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly abstract: false;
-            readonly description: "The installed graph projection of a Node Class or Edge Class declaration.";
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-                readonly properties: {
-                    description: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 1000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>, builder.NodeClass<{
-                readonly abstract: true;
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly description: "Optional bounded presentation icon metadata.";
-                readonly properties: {
-                    icon: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 8000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>];
-            readonly properties: {
-                readonly kind: {
-                    readonly enum: readonly ["node", "edge"];
-                };
-                readonly abstract: {
-                    readonly type: "boolean";
-                };
-            };
-        }>];
-        readonly outgoing: "0..*";
-    };
-    readonly target: {
-        readonly as: "policy";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly abstract: false;
-            readonly description: "The installed graph projection of one named closed Policy declaration owned by a Domain.";
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-                readonly properties: {
-                    description: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 1000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>];
-        }>];
-        readonly incoming: "0..*";
-    };
-    readonly description: "The protected projection of one Class read or traverse Policy assignment.";
-    readonly extends: readonly [builder.DirectedEdgeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"edge", {
         readonly abstract: true;
+        readonly depth: 0;
+        readonly properties: never;
         readonly source: {
             readonly as: "source";
-            readonly accepts: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
             readonly outgoing: "0..*";
         };
         readonly target: {
             readonly as: "target";
-            readonly accepts: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
             readonly incoming: "0..*";
         };
-        readonly description: "Explicit kernel marker for Edge definitions; it carries no structural fields.";
-    }>];
+        readonly constraints: Record<never, never>;
+    }, never, never, never>];
     readonly properties: {
-        operations: builder.Property<{
-            readonly enum: readonly [readonly ["read"], readonly ["traverse"], readonly ["read", "traverse"]];
-        }, {
-            readonly visibility: "private";
-        }>;
+        readonly operations: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "operations", "self", never>;
+    };
+    readonly source: {
+        readonly as: "class";
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "policy";
+        readonly incoming: "0..*";
     };
     readonly constraints: {
         readonly noSelf: true;
     };
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "operations", "self", never>;
 }>;

package/dist/schema/authority/governed-by.js

@@ -9,7 +9,7 @@ export const GovernedBy = edgeClass.directed({
     description: 'The protected projection of one Class read or traverse Policy assignment.',
     extends: [Edge],
     properties: {
-        operations: property({ enum: [['read'], ['traverse'], ['read', 'traverse']] }, { visibility: 'private' }),
+        operations: property({ enum: [['read'], ['traverse'], ['read', 'traverse']] }, {}),
     },
     constraints: { noSelf: true },
 });

package/dist/schema/authority/operation-node.d.ts

@@ -1,20 +1,34 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Operation: builder.NodeClass<{
+    readonly depth: 2;
     readonly abstract: false;
-    readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-    readonly extends: readonly [builder.NodeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
         readonly abstract: true;
-        readonly extends: readonly [builder.NodeClass<{
-            readonly abstract: true;
-            readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-        }>];
-        readonly description: "Stable human-facing name metadata that never acts as a locator.";
+        readonly depth: 1;
         readonly properties: {
-            readonly name: {
-                readonly type: "string";
-                readonly minLength: 1;
-                readonly maxLength: 100;
-            };
+            readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
         };
-    }>];
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", unknown, undefined>, never, never>, undefined>, never, never>];
+    readonly properties: never;
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", unknown, undefined>, never, never>, undefined>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;

package/dist/schema/authority/operations.d.ts

@@ -10,174 +10,14 @@ import { CanUse } from './can-use.js';
 import { AuthorityOperationOrder, type AuthorityOperation } from './operation.js';
 export { AuthorityOperationOrder, type AuthorityOperation };
 export declare const AuthorityOperations: Readonly<{
-    create: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly extends: readonly [builder.NodeClass<{
-            readonly abstract: true;
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "create";
-    }>;
-    read: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly extends: readonly [builder.NodeClass<{
-            readonly abstract: true;
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "read";
-    }>;
-    update: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly extends: readonly [builder.NodeClass<{
-            readonly abstract: true;
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "update";
-    }>;
-    delete: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly extends: readonly [builder.NodeClass<{
-            readonly abstract: true;
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "delete";
-    }>;
-    traverse: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly extends: readonly [builder.NodeClass<{
-            readonly abstract: true;
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "traverse";
-    }>;
-    use: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly extends: readonly [builder.NodeClass<{
-            readonly abstract: true;
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "use";
-    }>;
-    grant: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly extends: readonly [builder.NodeClass<{
-            readonly abstract: true;
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "grant";
-    }>;
-    revoke: builder.CoreNode<builder.NodeClass<{
-        readonly abstract: false;
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly extends: readonly [builder.NodeClass<{
-            readonly abstract: true;
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>, {
-        readonly name: "revoke";
-    }>;
+    create: builder.CoreNode;
+    read: builder.CoreNode;
+    update: builder.CoreNode;
+    delete: builder.CoreNode;
+    traverse: builder.CoreNode;
+    use: builder.CoreNode;
+    grant: builder.CoreNode;
+    revoke: builder.CoreNode;
 }>;
 export type AuthorityRelation = typeof CanCreate | typeof CanRead | typeof CanUpdate | typeof CanDelete | typeof CanTraverse | typeof CanUse | typeof CanGrant | typeof CanRevoke;
 export declare function operationOf(relation: AuthorityRelation): AuthorityOperation;

package/dist/schema/authority/policy.d.ts

@@ -1,22 +1,34 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Policy: builder.NodeClass<{
+    readonly depth: 2;
     readonly abstract: false;
-    readonly description: "The installed graph projection of one named closed Policy declaration owned by a Domain.";
-    readonly extends: readonly [builder.NodeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
         readonly abstract: true;
-        readonly extends: readonly [builder.NodeClass<{
-            readonly abstract: true;
-            readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-        }>];
-        readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
+        readonly depth: 1;
         readonly properties: {
-            description: builder.Property<Readonly<{
-                readonly type: 'string';
-                readonly minLength: 1;
-                readonly maxLength: 1000;
-            }>, {
-                readonly required: false;
-            }>;
+            readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
         };
-    }>];
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>, never, never>];
+    readonly properties: never;
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;

package/dist/schema/authority/vocabulary.d.ts

@@ -0,0 +1,3 @@
+import type { authority } from '../../auth/index.js';
+/** The Kernel instance of the authority vocabulary; Core Auth interprets authority through it. */
+export declare const authorityVocabulary: authority.AuthorityVocabulary;

package/dist/schema/authority/vocabulary.js

@@ -0,0 +1,25 @@
+import { K } from '../kernel/schema.js';
+/** The Kernel instance of the authority vocabulary; Core Auth interprets authority through it. */
+export const authorityVocabulary = Object.freeze({
+    identity: ref(K.classes.Identity.ref),
+    composition: Object.freeze({
+        extension: ref(K.classes.extends_with.ref),
+        constraint: ref(K.classes.constrained_by.ref),
+        exclusion: ref(K.classes.excluded_from.ref),
+    }),
+    capabilities: Object.freeze({
+        create: ref(K.classes.can_create.ref),
+        read: ref(K.classes.can_read.ref),
+        traverse: ref(K.classes.can_traverse.ref),
+        update: ref(K.classes.can_update.ref),
+        delete: ref(K.classes.can_delete.ref),
+    }),
+    instanceOf: ref(K.classes.instance_of.ref),
+});
+function ref(value) {
+    return Object.freeze({
+        origin: value.origin,
+        kind: 'class',
+        name: value.name,
+    });
+}

package/dist/schema/callables/entrypoint.d.ts

@@ -0,0 +1,32 @@
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Entrypoint: builder.DirectedEdgeClass<{
+    readonly depth: 1;
+    readonly abstract: false;
+    readonly extends: readonly [builder.ClassReferenceProjection<"edge", {
+        readonly abstract: true;
+        readonly depth: 0;
+        readonly properties: never;
+        readonly source: {
+            readonly as: "source";
+            readonly outgoing: "0..*";
+        };
+        readonly target: {
+            readonly as: "target";
+            readonly incoming: "0..*";
+        };
+        readonly constraints: Record<never, never>;
+    }, never, never, never>];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "view";
+        readonly outgoing: "0..1";
+    };
+    readonly target: {
+        readonly as: "domain";
+        readonly incoming: "0..1";
+    };
+    readonly constraints: {
+        readonly noSelf: true;
+    };
+    readonly effectiveProperties: never;
+}>;