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

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

@@ -10,10 +10,15 @@ import { CanUse } from './can-use.js';
 import { AuthorityOperationOrder, type AuthorityOperation } from './operation.js';
 export { AuthorityOperationOrder, type AuthorityOperation };
 export declare const AuthorityOperations: Readonly<{
-    create: builder.Node<builder.NodeClass<{
+    create: builder.CoreNode<builder.NodeClass<{
+        readonly abstract: false;
         readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
+        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: {
@@ -23,11 +28,18 @@ export declare const AuthorityOperations: Readonly<{
                 };
             };
         }>];
-    }>>;
-    read: builder.Node<builder.NodeClass<{
+    }>, {
+        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 implements: readonly [builder.Interface<{
-            readonly family: "both";
+        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: {
@@ -37,11 +49,18 @@ export declare const AuthorityOperations: Readonly<{
                 };
             };
         }>];
-    }>>;
-    update: builder.Node<builder.NodeClass<{
+    }>, {
+        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 implements: readonly [builder.Interface<{
-            readonly family: "both";
+        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: {
@@ -51,11 +70,18 @@ export declare const AuthorityOperations: Readonly<{
                 };
             };
         }>];
-    }>>;
-    delete: builder.Node<builder.NodeClass<{
+    }>, {
+        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 implements: readonly [builder.Interface<{
-            readonly family: "both";
+        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: {
@@ -65,11 +91,18 @@ export declare const AuthorityOperations: Readonly<{
                 };
             };
         }>];
-    }>>;
-    traverse: builder.Node<builder.NodeClass<{
+    }>, {
+        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 implements: readonly [builder.Interface<{
-            readonly family: "both";
+        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: {
@@ -79,11 +112,18 @@ export declare const AuthorityOperations: Readonly<{
                 };
             };
         }>];
-    }>>;
-    use: builder.Node<builder.NodeClass<{
+    }>, {
+        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 implements: readonly [builder.Interface<{
-            readonly family: "both";
+        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: {
@@ -93,11 +133,18 @@ export declare const AuthorityOperations: Readonly<{
                 };
             };
         }>];
-    }>>;
-    grant: builder.Node<builder.NodeClass<{
+    }>, {
+        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 implements: readonly [builder.Interface<{
-            readonly family: "both";
+        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: {
@@ -107,11 +154,18 @@ export declare const AuthorityOperations: Readonly<{
                 };
             };
         }>];
-    }>>;
-    revoke: builder.Node<builder.NodeClass<{
+    }>, {
+        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 implements: readonly [builder.Interface<{
-            readonly family: "both";
+        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: {
@@ -121,8 +175,9 @@ export declare const AuthorityOperations: Readonly<{
                 };
             };
         }>];
-    }>>;
+    }>, {
+        readonly name: "revoke";
+    }>;
 }>;
 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;
-//# sourceMappingURL=operations.d.ts.map

package/dist/schema/authority/operations.js

@@ -1,4 +1,4 @@
-import { node } from '@astrale-os/kernel-dsl/v1';
+import { core } from '@astrale-os/kernel-dsl/v1';
 import { CanCreate } from './can-create.js';
 import { CanDelete } from './can-delete.js';
 import { CanGrant } from './can-grant.js';
@@ -10,14 +10,14 @@ import { Operation } from './operation-node.js';
 import { AuthorityOperationOrder } from './operation.js';
 export { AuthorityOperationOrder };
 export const AuthorityOperations = Object.freeze({
-    create: node(Operation, { name: 'create' }),
-    read: node(Operation, { name: 'read' }),
-    update: node(Operation, { name: 'update' }),
-    delete: node(Operation, { name: 'delete' }),
-    traverse: node(Operation, { name: 'traverse' }),
-    use: node(Operation, { name: 'use' }),
-    grant: node(Operation, { name: 'grant' }),
-    revoke: node(Operation, { name: 'revoke' }),
+    create: core.node(Operation, { name: 'create' }),
+    read: core.node(Operation, { name: 'read' }),
+    update: core.node(Operation, { name: 'update' }),
+    delete: core.node(Operation, { name: 'delete' }),
+    traverse: core.node(Operation, { name: 'traverse' }),
+    use: core.node(Operation, { name: 'use' }),
+    grant: core.node(Operation, { name: 'grant' }),
+    revoke: core.node(Operation, { name: 'revoke' }),
 });
 export function operationOf(relation) {
     if (relation === CanCreate)
@@ -36,4 +36,3 @@ export function operationOf(relation) {
         return 'grant';
     return 'revoke';
 }
-//# sourceMappingURL=operations.js.map

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

@@ -1,8 +1,13 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Policy: builder.NodeClass<{
+    readonly abstract: false;
     readonly description: "The installed graph projection of one named closed Policy declaration owned by a Domain.";
-    readonly implements: readonly [builder.Interface<{
-        readonly family: "both";
+    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<{
@@ -15,4 +20,3 @@ export declare const Policy: builder.NodeClass<{
         };
     }>];
 }>;
-//# sourceMappingURL=policy.d.ts.map

package/dist/schema/authority/policy.js

@@ -1,7 +1,7 @@
 import { nodeClass } from '@astrale-os/kernel-dsl/v1';
 import { Descriptable } from '../meta/index.js';
 export const Policy = nodeClass({
+    abstract: false,
     description: 'The installed graph projection of one named closed Policy declaration owned by a Domain.',
-    implements: [Descriptable],
+    extends: [Descriptable],
 });
-//# sourceMappingURL=policy.js.map

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

@@ -1,51 +1,53 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Function: builder.NodeClass<{
+    readonly abstract: false;
     readonly description: "The installed projection of a standalone Function or Node Method declaration; it is not a principal.";
-    readonly implements: readonly [builder.NodeInterface<{
-        readonly description: "Ordinary projection-node contract for a standalone Function or Node Method declaration.";
-        readonly extends: readonly [builder.Interface<{
-            readonly family: "both";
-            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 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: {
-            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"];
-            }, {
+            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.Function<{
+        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<{
@@ -64,4 +66,3 @@ export declare const Function: builder.NodeClass<{
         }>;
     }>;
 }>;
-//# sourceMappingURL=function.d.ts.map

package/dist/schema/callables/function.js

@@ -1,9 +1,18 @@
-import { nodeClass } from '@astrale-os/kernel-dsl/v1';
+import { nodeClass, property } from '@astrale-os/kernel-dsl/v1';
 import { FunctionMethods } from '../kernel/syscalls/declarations/index.js';
-import { FunctionInterface } from './function-interface.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.',
-    implements: [FunctionInterface],
+    extends: [Descriptable],
+    properties: {
+        kind: { enum: ['function', 'method'] },
+        input: {},
+        output: { type: 'object' },
+        auth: { enum: ['anonymous', 'authenticated', 'authorized'] },
+        policy: property({ type: 'object' }, { required: false }),
+        static: property({ type: 'boolean' }, { required: false }),
+        inheritance: property({ enum: ['abstract', 'default', 'sealed'] }, { required: false }),
+    },
     methods: FunctionMethods,
 });
-//# sourceMappingURL=function.js.map

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

@@ -1,7 +1,4 @@
 export { Function } from './function.js';
-export { FunctionInterface } from './function-interface.js';
 export { MethodOf } from './method-of.js';
-export { UI } from './ui.js';
 export { View } from './view.js';
 export { ViewFor } from './view-for.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/callables/index.js

@@ -1,7 +1,4 @@
 export { Function } from './function.js';
-export { FunctionInterface } from './function-interface.js';
 export { MethodOf } from './method-of.js';
-export { UI } from './ui.js';
 export { View } from './view.js';
 export { ViewFor } from './view-for.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,12 +1,17 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const MethodOf: builder.DirectedEdgeClass<{
-    readonly as: "method";
-    readonly accepts: readonly [builder.NodeClass<{
-        readonly description: "The installed projection of a standalone Function or Node Method declaration; it is not a principal.";
-        readonly implements: readonly [builder.NodeInterface<{
-            readonly description: "Ordinary projection-node contract for a standalone Function or Node Method declaration.";
-            readonly extends: readonly [builder.Interface<{
-                readonly family: "both";
+    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<{
@@ -45,134 +50,8 @@ export declare const MethodOf: builder.DirectedEdgeClass<{
                     readonly required: false;
                 }>;
             };
-        }>];
-        readonly methods: Readonly<{
-            admit: builder.Function<{
-                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 as: "owner";
-    readonly accepts: readonly [builder.NodeClass<{
-        readonly description: "The installed graph projection of a concrete Node Class or Edge Class declaration.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            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.Interface<{
-            readonly family: "both";
-            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 family: {
-                readonly enum: readonly ["node", "edge"];
-            };
-        };
-    }>, builder.NodeClass<{
-        readonly description: "The installed graph projection of a both-, Node-, or Edge-family Interface.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            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 family: {
-                readonly enum: readonly ["both", "node", "edge"];
-            };
-        };
-    }>];
-    readonly incoming: "0..*";
-}, Omit<{
-    readonly source: {
-        readonly as: "method";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly description: "The installed projection of a standalone Function or Node Method declaration; it is not a principal.";
-            readonly implements: readonly [builder.NodeInterface<{
-                readonly description: "Ordinary projection-node contract for a standalone Function or Node Method declaration.";
-                readonly extends: readonly [builder.Interface<{
-                    readonly family: "both";
-                    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.Function<{
+                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<{
@@ -196,9 +75,14 @@ export declare const MethodOf: builder.DirectedEdgeClass<{
     readonly target: {
         readonly as: "owner";
         readonly accepts: readonly [builder.NodeClass<{
-            readonly description: "The installed graph projection of a concrete Node Class or Edge Class declaration.";
-            readonly implements: readonly [builder.Interface<{
-                readonly family: "both";
+            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<{
@@ -209,8 +93,12 @@ export declare const MethodOf: builder.DirectedEdgeClass<{
                         readonly required: false;
                     }>;
                 };
-            }>, builder.Interface<{
-                readonly family: "both";
+            }>, 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<{
@@ -223,36 +111,35 @@ export declare const MethodOf: builder.DirectedEdgeClass<{
                 };
             }>];
             readonly properties: {
-                readonly family: {
+                readonly kind: {
                     readonly enum: readonly ["node", "edge"];
                 };
-            };
-        }>, builder.NodeClass<{
-            readonly description: "The installed graph projection of a both-, Node-, or Edge-family Interface.";
-            readonly implements: readonly [builder.Interface<{
-                readonly family: "both";
-                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 family: {
-                    readonly enum: readonly ["both", "node", "edge"];
+                readonly abstract: {
+                    readonly type: "boolean";
                 };
             };
         }>];
         readonly incoming: "0..*";
     };
-    readonly description: "A Function declaration belongs to one Class or Interface for dispatch.";
-    readonly implements: readonly [builder.Interface<{
-        readonly family: "both";
+    readonly description: "A Function declaration belongs to one Class for dispatch.";
+    readonly extends: readonly [builder.DirectedEdgeClass<{
+        readonly abstract: true;
+        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 properties: {
@@ -268,5 +155,4 @@ export declare const MethodOf: builder.DirectedEdgeClass<{
             readonly visibility: "private";
         }>;
     };
-}, "source" | "target">>;
-//# sourceMappingURL=method-of.d.ts.map
+}>;