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

package/dist/schema/callables/function.js

@@ -1,18 +1,20 @@
 import { nodeClass, property } from '@astrale-os/kernel-dsl/v1';
+import { Identity } from '../identity/index.js';
 import { FunctionMethods } from '../kernel/syscalls/declarations/index.js';
 import { Descriptable } from '../meta/index.js';
 export const Function = nodeClass({
     abstract: false,
-    description: 'The installed projection of a standalone Function or Node Method declaration; it is not a principal.',
-    extends: [Descriptable],
+    description: 'An invocable resource that can carry its own Identity authority.',
+    extends: [Descriptable, Identity],
     properties: {
         kind: { enum: ['function', 'method'] },
         input: {},
         output: { type: 'object' },
         auth: { enum: ['anonymous', 'authenticated', 'authorized'] },
-        policy: property({ type: 'object' }, { required: false }),
+        // Policy checks, or `true`, the rule every caller satisfies. An absent Policy means `false`.
+        policy: property({ anyOf: [{ type: 'object' }, { const: true }] }, { required: false }),
         static: property({ type: 'boolean' }, { required: false }),
-        inheritance: property({ enum: ['abstract', 'default', 'sealed'] }, { required: false }),
+        abstract: property({ type: 'boolean' }, { required: false }),
     },
     methods: FunctionMethods,
 });

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

@@ -1,4 +1,5 @@
+export { Entrypoint } from './entrypoint.js';
+export { Execution } from './execution.js';
 export { Function } from './function.js';
 export { MethodOf } from './method-of.js';
 export { View } from './view.js';
-export { ViewFor } from './view-for.js';

package/dist/schema/callables/index.js

@@ -1,4 +1,5 @@
+export { Entrypoint } from './entrypoint.js';
+export { Execution } from './execution.js';
 export { Function } from './function.js';
 export { MethodOf } from './method-of.js';
 export { View } from './view.js';
-export { ViewFor } from './view-for.js';

package/dist/schema/callables/method-of.d.ts

@@ -1,158 +1,33 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const MethodOf: builder.DirectedEdgeClass<{
+    readonly depth: 1;
     readonly abstract: false;
-    readonly source: {
-        readonly as: "method";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly abstract: false;
-            readonly description: "The installed projection of a standalone Function or Node Method declaration; it is not a principal.";
-            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 properties: {
-                readonly kind: {
-                    readonly enum: readonly ["function", "method"];
-                };
-                readonly input: {};
-                readonly output: {
-                    readonly type: "object";
-                };
-                readonly auth: {
-                    readonly enum: readonly ["anonymous", "authenticated", "authorized"];
-                };
-                readonly policy: builder.Property<{
-                    readonly type: "object";
-                }, {
-                    readonly required: false;
-                }>;
-                readonly static: builder.Property<{
-                    readonly type: "boolean";
-                }, {
-                    readonly required: false;
-                }>;
-                readonly inheritance: builder.Property<{
-                    readonly enum: readonly ["abstract", "default", "sealed"];
-                }, {
-                    readonly required: false;
-                }>;
-            };
-            readonly methods: Readonly<{
-                admit: builder.Method<{
-                    readonly description: "Admit one remote path-only attempt and return its request-scoped execution target.";
-                    readonly auth: "authenticated";
-                    readonly input: import("zod").ZodObject<{
-                        call: import("zod").ZodObject<{
-                            target: import("zod").ZodString;
-                            input: import("zod").ZodUnknown;
-                        }, import("zod/v4/core").$strict>;
-                        credential: import("zod").ZodOptional<import("zod").ZodString>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: import("zod").ZodObject<{
-                        callable: import("zod").ZodString;
-                        receiver: import("zod").ZodOptional<import("zod").ZodString>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly static: true;
-                    readonly inheritance: "sealed";
-                }>;
-            }>;
-        }>];
-        readonly outgoing: "0..1";
-    };
-    readonly target: {
-        readonly as: "owner";
-        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 incoming: "0..*";
-    };
-    readonly description: "A Function declaration belongs to one Class for dispatch.";
-    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: {
-        name: builder.Property<{
-            readonly type: "string";
-            readonly minLength: 1;
-        }, {
-            readonly visibility: "private";
-        }>;
-        static: builder.Property<{
-            readonly type: "boolean";
-        }, {
-            readonly visibility: "private";
-        }>;
+        readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", never>;
+        readonly static: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "static", "self", never>;
+    };
+    readonly source: {
+        readonly as: "method";
+        readonly outgoing: "0..1";
+    };
+    readonly target: {
+        readonly as: "owner";
+        readonly incoming: "0..*";
     };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "static", "self", never>;
 }>;

package/dist/schema/callables/method-of.js

@@ -9,7 +9,7 @@ export const MethodOf = edgeClass.directed({
     description: 'A Function declaration belongs to one Class for dispatch.',
     extends: [Edge],
     properties: {
-        name: property({ type: 'string', minLength: 1 }, { visibility: 'private' }),
-        static: property({ type: 'boolean' }, { visibility: 'private' }),
+        name: property({ type: 'string', minLength: 1 }, {}),
+        static: property({ type: 'boolean' }, {}),
     },
 });

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

@@ -1,60 +1,92 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const View: builder.NodeClass<{
+    readonly depth: 2;
     readonly abstract: false;
-    readonly description: "The installed projection of a declarative browser surface; it is not a principal.";
-    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<{
-        resolve: builder.Method<{
-            readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
-            readonly auth: "authorized";
-            readonly input: import("zod").ZodObject<{
-                target: import("zod").ZodString;
-            }, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodObject<{
-                snapshot: import("zod").ZodString;
-                views: import("zod").ZodArray<import("zod").ZodObject<{
-                    key: import("zod").ZodString;
-                    declaration: import("zod").ZodObject<{
-                        description: import("zod").ZodOptional<import("zod").ZodString>;
-                        target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                            kind: import("zod").ZodLiteral<"domain">;
-                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                            kind: import("zod").ZodLiteral<"definition">;
-                            definitions: import("zod").ZodArray<import("zod").ZodObject<{
-                                origin: import("zod").ZodString;
-                                kind: import("zod").ZodLiteral<"class">;
-                                name: import("zod").ZodString;
-                            }, import("zod/v4/core").$strict>>;
-                        }, import("zod/v4/core").$strict>], "kind">;
-                    }, import("zod/v4/core").$strict>;
-                    href: import("zod").ZodString;
-                    handshake: import("zod").ZodEnum<{
-                        none: "none";
-                        shell: "shell";
-                    }>;
-                    issuer: import("zod").ZodString;
-                    etag: import("zod").ZodString;
-                    revision: import("zod").ZodString;
-                }, import("zod/v4/core").$strict>>;
-            }, import("zod/v4/core").$strict>;
-            readonly static: true;
-            readonly inheritance: "sealed";
-        }>;
+        resolve: builder.Method<builder.CallableProjection<{
+            target: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                snapshot: string;
+                views: {
+                    key: string;
+                    declaration: {
+                        description?: string | undefined;
+                        target: {
+                            kind: "domain";
+                        };
+                    };
+                    href: string;
+                    handshake: "none" | "shell";
+                    host?: {
+                        navigation: {
+                            external: {
+                                origins: string[];
+                            };
+                        };
+                    } | undefined;
+                    issuer: string;
+                    release: string;
+                    revision: string;
+                }[];
+            };
+        }, "authorized", true, false, undefined>>;
     }>;
+    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: builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        target: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            snapshot: string;
+            views: {
+                key: string;
+                declaration: {
+                    description?: string | undefined;
+                    target: {
+                        kind: "domain";
+                    };
+                };
+                href: string;
+                handshake: "none" | "shell";
+                host?: {
+                    navigation: {
+                        external: {
+                            origins: string[];
+                        };
+                    };
+                } | undefined;
+                issuer: string;
+                release: string;
+                revision: string;
+            }[];
+        };
+    }, "authorized", true, false, undefined>>, "resolve", "self">;
 }>;

package/dist/schema/definitions/class.d.ts

@@ -1,46 +1,58 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Class: builder.NodeClass<{
+    readonly depth: 2;
     readonly abstract: false;
-    readonly description: "The installed graph projection of a Node Class or Edge Class declaration.";
-    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>;
         };
-    }>, builder.NodeClass<{
+        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 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 depth: 1;
         readonly properties: {
-            icon: builder.Property<Readonly<{
-                readonly type: 'string';
-                readonly minLength: 1;
-                readonly maxLength: 8000;
-            }>, {
-                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 properties: {
-        readonly kind: {
-            readonly enum: readonly ["node", "edge"];
+        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>, builder.ClassReferenceProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly icon: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "icon", "self", never>;
         };
-        readonly abstract: {
-            readonly type: "boolean";
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "icon", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly icon: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "icon", "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, "icon", unknown, never>, never, never>, never>, never, never>];
+    readonly properties: {
+        readonly kind: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined>;
+        readonly abstract: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "abstract", "self", undefined>;
     };
+    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> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "icon", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly icon: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "icon", "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, "icon", unknown, never>, never, never>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "abstract", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined>);
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;

package/dist/schema/definitions/extends.d.ts

@@ -1,127 +1,33 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Extends: builder.DirectedEdgeClass<{
+    readonly depth: 1;
     readonly abstract: false;
-    readonly source: {
-        readonly as: "sub";
-        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: "super";
-        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 incoming: "0..*";
-    };
-    readonly description: "The protected projection of compatible Class inheritance.";
-    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: never;
+    readonly source: {
+        readonly as: "sub";
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "super";
+        readonly incoming: "0..*";
+    };
     readonly constraints: {
         readonly noSelf: true;
         readonly acyclic: true;
     };
+    readonly effectiveProperties: never;
 }>;