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

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

@@ -1,8 +1,13 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Class: 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<{
@@ -13,8 +18,12 @@ export declare const Class: builder.NodeClass<{
                 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<{
@@ -27,9 +36,12 @@ export declare const Class: builder.NodeClass<{
         };
     }>];
     readonly properties: {
-        readonly family: {
+        readonly kind: {
             readonly enum: readonly ["node", "edge"];
         };
+        readonly abstract: {
+            readonly type: "boolean";
+        };
     };
 }>;
 //# sourceMappingURL=class.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"class.d.ts","sourceRoot":"","sources":["../../../schema/definitions/class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAInE,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMY,CAAA"}
+{"version":3,"file":"class.d.ts","sourceRoot":"","sources":["../../../schema/definitions/class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAInE,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQY,CAAA"}

package/dist/schema/definitions/class.js

@@ -1,10 +1,12 @@
 import { nodeClass } from '@astrale-os/kernel-dsl/v1';
 import { Descriptable, Iconable } from '../meta/index.js';
 export const Class = nodeClass({
-    description: 'The installed graph projection of a concrete Node Class or Edge Class declaration.',
-    implements: [Descriptable, Iconable],
+    abstract: false,
+    description: 'The installed graph projection of a Node Class or Edge Class declaration.',
+    extends: [Descriptable, Iconable],
     properties: {
-        family: { enum: ['node', 'edge'] },
+        kind: { enum: ['node', 'edge'] },
+        abstract: { type: 'boolean' },
     },
 });
 //# sourceMappingURL=class.js.map

package/dist/schema/definitions/class.js.map

@@ -1 +1 @@
-{"version":3,"file":"class.js","sourceRoot":"","sources":["../../../schema/definitions/class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgB,MAAM,2BAA2B,CAAA;AAEnE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEzD,MAAM,CAAC,MAAM,KAAK,GAAG,SAAS,CAAC;IAC7B,WAAW,EAAE,oFAAoF;IACjG,UAAU,EAAE,CAAC,YAAY,EAAE,QAAQ,CAAC;IACpC,UAAU,EAAE;QACV,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;KACnC;CACF,CAA6B,CAAA"}
+{"version":3,"file":"class.js","sourceRoot":"","sources":["../../../schema/definitions/class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgB,MAAM,2BAA2B,CAAA;AAEnE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEzD,MAAM,CAAC,MAAM,KAAK,GAAG,SAAS,CAAC;IAC7B,QAAQ,EAAE,KAAK;IACf,WAAW,EAAE,2EAA2E;IACxF,OAAO,EAAE,CAAC,YAAY,EAAE,QAAQ,CAAC;IACjC,UAAU,EAAE;QACV,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;QAChC,QAAQ,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;KAC9B;CACF,CAA6B,CAAA"}

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

@@ -1,59 +1,17 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Extends: builder.DirectedEdgeClass<{
-    readonly as: "sub";
-    readonly accepts: readonly [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 outgoing: "0..*";
-}, {
-    readonly as: "super";
-    readonly accepts: readonly [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 abstract: false;
     readonly source: {
         readonly as: "sub";
         readonly accepts: readonly [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 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<{
@@ -64,10 +22,29 @@ export declare const Extends: builder.DirectedEdgeClass<{
                         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 family: {
-                    readonly enum: readonly ["both", "node", "edge"];
+                readonly kind: {
+                    readonly enum: readonly ["node", "edge"];
+                };
+                readonly abstract: {
+                    readonly type: "boolean";
                 };
             };
         }>];
@@ -76,9 +53,14 @@ export declare const Extends: builder.DirectedEdgeClass<{
     readonly target: {
         readonly as: "super";
         readonly accepts: readonly [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 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<{
@@ -89,23 +71,58 @@ export declare const Extends: builder.DirectedEdgeClass<{
                         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 family: {
-                    readonly enum: readonly ["both", "node", "edge"];
+                readonly kind: {
+                    readonly enum: readonly ["node", "edge"];
+                };
+                readonly abstract: {
+                    readonly type: "boolean";
                 };
             };
         }>];
         readonly incoming: "0..*";
     };
-    readonly description: "The protected projection of compatible Interface inheritance.";
-    readonly implements: readonly [builder.Interface<{
-        readonly family: "both";
+    readonly description: "The protected projection of compatible Class inheritance.";
+    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 constraints: {
         readonly noSelf: true;
         readonly acyclic: true;
     };
-}, "source" | "target">>;
+}>;
 //# sourceMappingURL=extends.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"extends.d.ts","sourceRoot":"","sources":["../../../schema/definitions/extends.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKnE,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAMU,CAAA"}
+{"version":3,"file":"extends.d.ts","sourceRoot":"","sources":["../../../schema/definitions/extends.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKnE,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOU,CAAA"}

package/dist/schema/definitions/extends.js

@@ -1,11 +1,12 @@
 import { edgeClass } from '@astrale-os/kernel-dsl/v1';
 import { Edge } from '../meta/index.js';
-import { Interface } from './interface.js';
+import { Class } from './class.js';
 export const Extends = edgeClass.directed({
-    source: { as: 'sub', accepts: [Interface], outgoing: '0..*' },
-    target: { as: 'super', accepts: [Interface], incoming: '0..*' },
-    description: 'The protected projection of compatible Interface inheritance.',
-    implements: [Edge],
+    abstract: false,
+    source: { as: 'sub', accepts: [Class], outgoing: '0..*' },
+    target: { as: 'super', accepts: [Class], incoming: '0..*' },
+    description: 'The protected projection of compatible Class inheritance.',
+    extends: [Edge],
     constraints: { noSelf: true, acyclic: true },
 });
 //# sourceMappingURL=extends.js.map

package/dist/schema/definitions/extends.js.map

@@ -1 +1 @@
-{"version":3,"file":"extends.js","sourceRoot":"","sources":["../../../schema/definitions/extends.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgB,MAAM,2BAA2B,CAAA;AAEnE,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,MAAM,CAAC,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC;IACxC,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IAC7D,MAAM,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IAC/D,WAAW,EAAE,+DAA+D;IAC5E,UAAU,EAAE,CAAC,IAAI,CAAC;IAClB,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE;CAC7C,CAA6B,CAAA"}
+{"version":3,"file":"extends.js","sourceRoot":"","sources":["../../../schema/definitions/extends.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgB,MAAM,2BAA2B,CAAA;AAEnE,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC,MAAM,CAAC,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC;IACxC,QAAQ,EAAE,KAAK;IACf,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IACzD,MAAM,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IAC3D,WAAW,EAAE,2DAA2D;IACxE,OAAO,EAAE,CAAC,IAAI,CAAC;IACf,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE;CAC7C,CAA6B,CAAA"}

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

@@ -1,6 +1,4 @@
 export { Class } from './class.js';
 export { Extends } from './extends.js';
-export { Implements } from './implements.js';
 export { InstanceOf } from './instance-of.js';
-export { Interface } from './interface.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/schema/definitions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../schema/definitions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../schema/definitions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/schema/definitions/index.js

@@ -1,6 +1,4 @@
 export { Class } from './class.js';
 export { Extends } from './extends.js';
-export { Implements } from './implements.js';
 export { InstanceOf } from './instance-of.js';
-export { Interface } from './interface.js';
 //# sourceMappingURL=index.js.map

package/dist/schema/definitions/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../schema/definitions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../schema/definitions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/schema/definitions/instance-of.d.ts

@@ -1,60 +1,25 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const InstanceOf: builder.DirectedEdgeClass<{
-    readonly as: "instance";
-    readonly accepts: readonly [builder.NodeInterface<{
-        readonly description: "The universal kernel node contract implicitly satisfied by every Node Interface and Node Class.";
-    }>];
-    readonly outgoing: "1";
-}, {
-    readonly as: "class";
-    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"];
-            };
-        };
-    }>];
-    readonly incoming: "0..*";
-}, Omit<{
+    readonly abstract: false;
     readonly source: {
         readonly as: "instance";
-        readonly accepts: readonly [builder.NodeInterface<{
-            readonly description: "The universal kernel node contract implicitly satisfied by every Node Interface and Node Class.";
+        readonly accepts: readonly [builder.NodeClass<{
+            readonly abstract: true;
+            readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
         }>];
-        readonly outgoing: "1";
+        readonly outgoing: "0..1";
     };
     readonly target: {
         readonly as: "class";
         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<{
@@ -65,8 +30,12 @@ export declare const InstanceOf: 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<{
@@ -79,17 +48,36 @@ export declare const InstanceOf: builder.DirectedEdgeClass<{
                 };
             }>];
             readonly properties: {
-                readonly family: {
+                readonly kind: {
                     readonly enum: readonly ["node", "edge"];
                 };
+                readonly abstract: {
+                    readonly type: "boolean";
+                };
             };
         }>];
         readonly incoming: "0..*";
     };
     readonly description: "The concrete Node Class fact fixed when a node is created.";
-    readonly implements: readonly [builder.Interface<{
-        readonly family: "both";
+    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.";
     }>];
-}, "source" | "target">>;
+}>;
 //# sourceMappingURL=instance-of.d.ts.map

package/dist/schema/definitions/instance-of.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instance-of.d.ts","sourceRoot":"","sources":["../../../schema/definitions/instance-of.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKnE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAKO,CAAA"}
+{"version":3,"file":"instance-of.d.ts","sourceRoot":"","sources":["../../../schema/definitions/instance-of.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKnE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMO,CAAA"}

package/dist/schema/definitions/instance-of.js

@@ -2,9 +2,10 @@ import { edgeClass } from '@astrale-os/kernel-dsl/v1';
 import { Edge, Node } from '../meta/index.js';
 import { Class } from './class.js';
 export const InstanceOf = edgeClass.directed({
-    source: { as: 'instance', accepts: [Node], outgoing: '1' },
+    abstract: false,
+    source: { as: 'instance', accepts: [Node], outgoing: '0..1' },
     target: { as: 'class', accepts: [Class], incoming: '0..*' },
     description: 'The concrete Node Class fact fixed when a node is created.',
-    implements: [Edge],
+    extends: [Edge],
 });
 //# sourceMappingURL=instance-of.js.map

package/dist/schema/definitions/instance-of.js.map

@@ -1 +1 @@
-{"version":3,"file":"instance-of.js","sourceRoot":"","sources":["../../../schema/definitions/instance-of.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgB,MAAM,2BAA2B,CAAA;AAEnE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC,MAAM,CAAC,MAAM,UAAU,GAAG,SAAS,CAAC,QAAQ,CAAC;IAC3C,MAAM,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE;IAC1D,MAAM,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IAC3D,WAAW,EAAE,4DAA4D;IACzE,UAAU,EAAE,CAAC,IAAI,CAAC;CACnB,CAA6B,CAAA"}
+{"version":3,"file":"instance-of.js","sourceRoot":"","sources":["../../../schema/definitions/instance-of.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgB,MAAM,2BAA2B,CAAA;AAEnE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC,MAAM,CAAC,MAAM,UAAU,GAAG,SAAS,CAAC,QAAQ,CAAC;IAC3C,QAAQ,EAAE,KAAK;IACf,MAAM,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IAC7D,MAAM,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IAC3D,WAAW,EAAE,4DAA4D;IACzE,OAAO,EAAE,CAAC,IAAI,CAAC;CAChB,CAA6B,CAAA"}

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

@@ -1,8 +1,14 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Domain: builder.NodeClass<{
+    readonly abstract: false;
     readonly description: "A stable Domain principal and the active projection of one canonical DomainSchema revision.";
-    readonly implements: readonly [builder.NodeInterface<{
+    readonly extends: readonly [builder.NodeClass<{
+        readonly abstract: true;
         readonly description: "A principal that can be authenticated and can originate persistent authority facts.";
+        readonly extends: readonly [builder.NodeClass<{
+            readonly abstract: true;
+            readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
+        }>];
         readonly properties: {
             readonly frozen: builder.Property<{
                 readonly type: "boolean";
@@ -35,7 +41,7 @@ export declare const Domain: builder.NodeClass<{
             };
         };
         readonly methods: Readonly<{
-            delegate: builder.Function<{
+            delegate: builder.Method<{
                 readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
                 readonly auth: "authenticated";
                 readonly input: import("zod").ZodObject<{
@@ -46,7 +52,7 @@ export declare const Domain: builder.NodeClass<{
                 readonly output: import("zod").ZodString;
                 readonly inheritance: "default";
             }>;
-            can: builder.Function<{
+            can: builder.Method<{
                 readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
                 readonly auth: "authenticated";
                 readonly input: import("zod").ZodObject<{
@@ -59,7 +65,7 @@ export declare const Domain: builder.NodeClass<{
                 readonly static: true;
                 readonly inheritance: "default";
             }>;
-            whoami: builder.Function<{
+            whoami: builder.Method<{
                 readonly description: "Return the Identity authenticated for this invocation.";
                 readonly auth: "authenticated";
                 readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
@@ -84,7 +90,7 @@ export declare const Domain: builder.NodeClass<{
                 readonly static: true;
                 readonly inheritance: "default";
             }>;
-            whois: builder.Function<{
+            whois: builder.Method<{
                 readonly description: "Resolve one issuer-and-subject Identity.";
                 readonly auth: "authorized";
                 readonly input: import("zod").ZodObject<{
@@ -112,7 +118,7 @@ export declare const Domain: builder.NodeClass<{
                 readonly static: true;
                 readonly inheritance: "default";
             }>;
-            mint: builder.Function<{
+            mint: builder.Method<{
                 readonly description: "Resolve and sign one authorized Grant credential.";
                 readonly auth: "authorized";
                 readonly input: import("zod").ZodObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../schema/domain/domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAI7E,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBW,CAAA"}
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../schema/domain/domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAI7E,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBW,CAAA"}

package/dist/schema/domain/domain.js

@@ -1,8 +1,9 @@
 import { nodeClass, property } from '@astrale-os/kernel-dsl/v1';
 import { Identity } from '../identity/index.js';
 export const Domain = nodeClass({
+    abstract: false,
     description: 'A stable Domain principal and the active projection of one canonical DomainSchema revision.',
-    implements: [Identity],
+    extends: [Identity],
     properties: {
         origin: {
             type: 'string',

package/dist/schema/domain/domain.js.map

@@ -1 +1 @@
-{"version":3,"file":"domain.js","sourceRoot":"","sources":["../../../schema/domain/domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAgB,MAAM,2BAA2B,CAAA;AAE7E,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAE/C,MAAM,CAAC,MAAM,MAAM,GAAG,SAAS,CAAC;IAC9B,WAAW,EACT,6FAA6F;IAC/F,UAAU,EAAE,CAAC,QAAQ,CAAC;IACtB,UAAU,EAAE;QACV,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,4EAA4E;SACtF;QACD,iBAAiB,EAAE,QAAQ,CACzB,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAC5C,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,CAC3C;QACD,MAAM,EAAE,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;QAC/D,cAAc,EAAE,QAAQ,CACtB,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,qBAAqB,EAAE,EAClD,EAAE,UAAU,EAAE,SAAS,EAAE,CAC1B;KACF;CACF,CAA6B,CAAA"}
+{"version":3,"file":"domain.js","sourceRoot":"","sources":["../../../schema/domain/domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAgB,MAAM,2BAA2B,CAAA;AAE7E,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAE/C,MAAM,CAAC,MAAM,MAAM,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,KAAK;IACf,WAAW,EACT,6FAA6F;IAC/F,OAAO,EAAE,CAAC,QAAQ,CAAC;IACnB,UAAU,EAAE;QACV,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,4EAA4E;SACtF;QACD,iBAAiB,EAAE,QAAQ,CACzB,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAC5C,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,CAC3C;QACD,MAAM,EAAE,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;QAC/D,cAAc,EAAE,QAAQ,CACtB,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,qBAAqB,EAAE,EAClD,EAAE,UAAU,EAAE,SAAS,EAAE,CAC1B;KACF;CACF,CAA6B,CAAA"}