@astrale-os/kernel-core 0.9.0-beta.1 → 0.9.0-beta.3

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

@@ -1,5 +1,5 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Implements: builder.EdgeClass<{
+export declare const Implements: builder.DirectedEdgeClass<{
     readonly as: "class";
     readonly accepts: readonly [builder.NodeClass<{
         readonly description: "The installed graph projection of a concrete Node Class or Edge Class declaration.";
@@ -34,6 +34,7 @@ export declare const Implements: builder.EdgeClass<{
             };
         };
     }>];
+    readonly outgoing: "0..*";
 }, {
     readonly as: "interface";
     readonly accepts: readonly [builder.NodeClass<{
@@ -57,15 +58,77 @@ export declare const Implements: builder.EdgeClass<{
             };
         };
     }>];
-}, {
+    readonly incoming: "0..*";
+}, Omit<{
+    readonly source: {
+        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 outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "interface";
+        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..*";
+    };
     readonly description: "The protected projection of a Class implementing a compatible Interface.";
     readonly implements: readonly [builder.Interface<{
         readonly family: "both";
         readonly description: "Explicit kernel marker for Edge definitions; it carries no structural fields.";
     }>];
-    readonly orientation: "directed";
     readonly constraints: {
         readonly noSelf: true;
     };
-}>;
+}, "source" | "target">>;
 //# sourceMappingURL=implements.d.ts.map

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

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

package/dist/schema/definitions/implements.js

@@ -2,10 +2,11 @@ import { edgeClass } from '@astrale-os/kernel-dsl/v1';
 import { Edge } from '../meta/index.js';
 import { Class } from './class.js';
 import { Interface } from './interface.js';
-export const Implements = edgeClass({ as: 'class', accepts: [Class] }, { as: 'interface', accepts: [Interface] }, {
+export const Implements = edgeClass.directed({
+    source: { as: 'class', accepts: [Class], outgoing: '0..*' },
+    target: { as: 'interface', accepts: [Interface], incoming: '0..*' },
     description: 'The protected projection of a Class implementing a compatible Interface.',
     implements: [Edge],
-    orientation: 'directed',
     constraints: { noSelf: true },
 });
 //# sourceMappingURL=implements.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"implements.js","sourceRoot":"","sources":["../../../schema/definitions/implements.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;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,MAAM,CAAC,MAAM,UAAU,GAAG,SAAS,CACjC,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,EACjC,EAAE,EAAE,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,SAAS,CAAC,EAAE,EACzC;IACE,WAAW,EAAE,0EAA0E;IACvF,UAAU,EAAE,CAAC,IAAI,CAAC;IAClB,WAAW,EAAE,UAAU;IACvB,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;CAC9B,CAC0B,CAAA"}
+{"version":3,"file":"implements.js","sourceRoot":"","sources":["../../../schema/definitions/implements.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;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,MAAM,CAAC,MAAM,UAAU,GAAG,SAAS,CAAC,QAAQ,CAAC;IAC3C,MAAM,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IAC3D,MAAM,EAAE,EAAE,EAAE,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IACnE,WAAW,EAAE,0EAA0E;IACvF,UAAU,EAAE,CAAC,IAAI,CAAC;IAClB,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;CAC9B,CAA6B,CAAA"}

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

@@ -1,10 +1,10 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const InstanceOf: builder.EdgeClass<{
+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 cardinality: "1";
+    readonly outgoing: "1";
 }, {
     readonly as: "class";
     readonly accepts: readonly [builder.NodeClass<{
@@ -40,12 +40,56 @@ export declare const InstanceOf: builder.EdgeClass<{
             };
         };
     }>];
-}, {
+    readonly incoming: "0..*";
+}, Omit<{
+    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 outgoing: "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 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..*";
+    };
     readonly description: "The concrete Node Class fact fixed when a node is created.";
     readonly implements: readonly [builder.Interface<{
         readonly family: "both";
         readonly description: "Explicit kernel marker for Edge definitions; it carries no structural fields.";
     }>];
-    readonly orientation: "directed";
-}>;
+}, "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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQM,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAKO,CAAA"}

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

@@ -1,9 +1,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({ as: 'instance', accepts: [Node], cardinality: '1' }, { as: 'class', accepts: [Class] }, {
+export const InstanceOf = edgeClass.directed({
+    source: { as: 'instance', accepts: [Node], outgoing: '1' },
+    target: { as: 'class', accepts: [Class], incoming: '0..*' },
     description: 'The concrete Node Class fact fixed when a node is created.',
     implements: [Edge],
-    orientation: 'directed',
 });
 //# 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,CACjC,EAAE,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE,EACrD,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,EACjC;IACE,WAAW,EAAE,4DAA4D;IACzE,UAAU,EAAE,CAAC,IAAI,CAAC;IAClB,WAAW,EAAE,UAAU;CACxB,CAC0B,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,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"}

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

@@ -35,24 +35,20 @@ export declare const Domain: builder.NodeClass<{
             };
         };
         readonly methods: Readonly<{
-            delegate: builder.Function<Omit<{
-                readonly description: "Issue one attenuated credential from this Identity.";
-                readonly auth: "required";
-                readonly admission: "policy";
-                readonly policy: builder.CallablePolicyBuilder;
+            delegate: builder.Function<{
+                readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
+                readonly auth: "authenticated";
                 readonly input: import("zod").ZodObject<{
                     audience: import("zod").ZodString;
                     ttlSeconds: import("zod").ZodNumber;
-                    delegation: import("zod").ZodUnknown;
-                    attestation: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                    attenuation: import("zod").ZodUnknown;
                 }, import("zod/v4/core").$strict>;
                 readonly output: import("zod").ZodString;
                 readonly inheritance: "default";
-            }, "admission">>;
-            can: builder.Function<Omit<{
+            }>;
+            can: builder.Function<{
                 readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-                readonly auth: "required";
-                readonly admission: "authenticated";
+                readonly auth: "authenticated";
                 readonly input: import("zod").ZodObject<{
                     policy: import("zod").ZodString;
                     object: import("zod").ZodString;
@@ -62,11 +58,10 @@ export declare const Domain: builder.NodeClass<{
                 }, import("zod/v4/core").$strict>;
                 readonly static: true;
                 readonly inheritance: "default";
-            }, "admission">>;
-            whoami: builder.Function<Omit<{
+            }>;
+            whoami: builder.Function<{
                 readonly description: "Return the Identity authenticated for this invocation.";
-                readonly auth: "required";
-                readonly admission: "authenticated";
+                readonly auth: "authenticated";
                 readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
                 readonly output: import("zod").ZodObject<{
                     id: import("zod").ZodString;
@@ -88,12 +83,10 @@ export declare const Domain: builder.NodeClass<{
                 }, import("zod/v4/core").$strict>;
                 readonly static: true;
                 readonly inheritance: "default";
-            }, "admission">>;
-            whois: builder.Function<Omit<{
+            }>;
+            whois: builder.Function<{
                 readonly description: "Resolve one issuer-and-subject Identity.";
-                readonly auth: "required";
-                readonly admission: "policy";
-                readonly policy: builder.CallablePolicyBuilder;
+                readonly auth: "authorized";
                 readonly input: import("zod").ZodObject<{
                     issuer: import("zod").ZodString;
                     subject: import("zod").ZodString;
@@ -118,12 +111,10 @@ export declare const Domain: builder.NodeClass<{
                 }, import("zod/v4/core").$strict>>;
                 readonly static: true;
                 readonly inheritance: "default";
-            }, "admission">>;
-            mint: builder.Function<Omit<{
+            }>;
+            mint: builder.Function<{
                 readonly description: "Resolve and sign one authorized Grant credential.";
-                readonly auth: "required";
-                readonly admission: "policy";
-                readonly policy: builder.CallablePolicyBuilder;
+                readonly auth: "authorized";
                 readonly input: import("zod").ZodObject<{
                     audience: import("zod").ZodOptional<import("zod").ZodString>;
                     ttlSeconds: import("zod").ZodNumber;
@@ -132,7 +123,7 @@ export declare const Domain: builder.NodeClass<{
                 readonly output: import("zod").ZodString;
                 readonly static: true;
                 readonly inheritance: "default";
-            }, "admission">>;
+            }>;
         }>;
     }>];
     readonly properties: {

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBW,CAAA"}

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

@@ -1,10 +1,10 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const OfDomain: builder.EdgeClass<{
+export declare const OfDomain: builder.DirectedEdgeClass<{
     readonly as: "member";
     readonly accepts: readonly [builder.NodeInterface<{
         readonly description: "The universal kernel node contract implicitly satisfied by every Node Interface and Node Class.";
     }>];
-    readonly cardinality: "0..1";
+    readonly outgoing: "0..1";
 }, {
     readonly as: "domain";
     readonly accepts: readonly [builder.NodeClass<{
@@ -43,24 +43,20 @@ export declare const OfDomain: builder.EdgeClass<{
                 };
             };
             readonly methods: Readonly<{
-                delegate: builder.Function<Omit<{
-                    readonly description: "Issue one attenuated credential from this Identity.";
-                    readonly auth: "required";
-                    readonly admission: "policy";
-                    readonly policy: builder.CallablePolicyBuilder;
+                delegate: builder.Function<{
+                    readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
+                    readonly auth: "authenticated";
                     readonly input: import("zod").ZodObject<{
                         audience: import("zod").ZodString;
                         ttlSeconds: import("zod").ZodNumber;
-                        delegation: import("zod").ZodUnknown;
-                        attestation: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                        attenuation: import("zod").ZodUnknown;
                     }, import("zod/v4/core").$strict>;
                     readonly output: import("zod").ZodString;
                     readonly inheritance: "default";
-                }, "admission">>;
-                can: builder.Function<Omit<{
+                }>;
+                can: builder.Function<{
                     readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-                    readonly auth: "required";
-                    readonly admission: "authenticated";
+                    readonly auth: "authenticated";
                     readonly input: import("zod").ZodObject<{
                         policy: import("zod").ZodString;
                         object: import("zod").ZodString;
@@ -70,11 +66,10 @@ export declare const OfDomain: builder.EdgeClass<{
                     }, import("zod/v4/core").$strict>;
                     readonly static: true;
                     readonly inheritance: "default";
-                }, "admission">>;
-                whoami: builder.Function<Omit<{
+                }>;
+                whoami: builder.Function<{
                     readonly description: "Return the Identity authenticated for this invocation.";
-                    readonly auth: "required";
-                    readonly admission: "authenticated";
+                    readonly auth: "authenticated";
                     readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
                     readonly output: import("zod").ZodObject<{
                         id: import("zod").ZodString;
@@ -96,12 +91,10 @@ export declare const OfDomain: builder.EdgeClass<{
                     }, import("zod/v4/core").$strict>;
                     readonly static: true;
                     readonly inheritance: "default";
-                }, "admission">>;
-                whois: builder.Function<Omit<{
+                }>;
+                whois: builder.Function<{
                     readonly description: "Resolve one issuer-and-subject Identity.";
-                    readonly auth: "required";
-                    readonly admission: "policy";
-                    readonly policy: builder.CallablePolicyBuilder;
+                    readonly auth: "authorized";
                     readonly input: import("zod").ZodObject<{
                         issuer: import("zod").ZodString;
                         subject: import("zod").ZodString;
@@ -126,12 +119,10 @@ export declare const OfDomain: builder.EdgeClass<{
                     }, import("zod/v4/core").$strict>>;
                     readonly static: true;
                     readonly inheritance: "default";
-                }, "admission">>;
-                mint: builder.Function<Omit<{
+                }>;
+                mint: builder.Function<{
                     readonly description: "Resolve and sign one authorized Grant credential.";
-                    readonly auth: "required";
-                    readonly admission: "policy";
-                    readonly policy: builder.CallablePolicyBuilder;
+                    readonly auth: "authorized";
                     readonly input: import("zod").ZodObject<{
                         audience: import("zod").ZodOptional<import("zod").ZodString>;
                         ttlSeconds: import("zod").ZodNumber;
@@ -140,7 +131,7 @@ export declare const OfDomain: builder.EdgeClass<{
                     readonly output: import("zod").ZodString;
                     readonly static: true;
                     readonly inheritance: "default";
-                }, "admission">>;
+                }>;
             }>;
         }>];
         readonly properties: {
@@ -170,13 +161,178 @@ export declare const OfDomain: builder.EdgeClass<{
             }>;
         };
     }>];
-}, {
+    readonly incoming: "0..*";
+}, Omit<{
+    readonly source: {
+        readonly as: "member";
+        readonly accepts: readonly [builder.NodeInterface<{
+            readonly description: "The universal kernel node contract implicitly satisfied by every Node Interface and Node Class.";
+        }>];
+        readonly outgoing: "0..1";
+    };
+    readonly target: {
+        readonly as: "domain";
+        readonly accepts: readonly [builder.NodeClass<{
+            readonly description: "A stable Domain principal and the active projection of one canonical DomainSchema revision.";
+            readonly implements: readonly [builder.NodeInterface<{
+                readonly description: "A principal that can be authenticated and can originate persistent authority facts.";
+                readonly properties: {
+                    readonly frozen: builder.Property<{
+                        readonly type: "boolean";
+                    }, {
+                        readonly required: false;
+                        readonly visibility: "private";
+                    }>;
+                    readonly iss: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly requiredClaims: builder.Property<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        claim: import("zod").ZodString;
+                        op: import("zod").ZodLiteral<"contains">;
+                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        claim: import("zod").ZodString;
+                        op: import("zod").ZodLiteral<"eq">;
+                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        claim: import("zod").ZodString;
+                        op: import("zod").ZodLiteral<"exists">;
+                    }, import("zod/v4/core").$strict>], "op">>, {
+                        readonly required: false;
+                        readonly visibility: "private";
+                    }>;
+                    readonly sub: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Function<{
+                        readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
+                        readonly auth: "authenticated";
+                        readonly input: import("zod").ZodObject<{
+                            audience: import("zod").ZodString;
+                            ttlSeconds: import("zod").ZodNumber;
+                            attenuation: import("zod").ZodUnknown;
+                        }, import("zod/v4/core").$strict>;
+                        readonly output: import("zod").ZodString;
+                        readonly inheritance: "default";
+                    }>;
+                    can: builder.Function<{
+                        readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
+                        readonly auth: "authenticated";
+                        readonly input: import("zod").ZodObject<{
+                            policy: import("zod").ZodString;
+                            object: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>;
+                        readonly output: import("zod").ZodObject<{
+                            allowed: import("zod").ZodBoolean;
+                        }, import("zod/v4/core").$strict>;
+                        readonly static: true;
+                        readonly inheritance: "default";
+                    }>;
+                    whoami: builder.Function<{
+                        readonly description: "Return the Identity authenticated for this invocation.";
+                        readonly auth: "authenticated";
+                        readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+                        readonly output: import("zod").ZodObject<{
+                            id: import("zod").ZodString;
+                            issuer: import("zod").ZodString;
+                            subject: import("zod").ZodString;
+                            frozen: import("zod").ZodBoolean;
+                            requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                                claim: import("zod").ZodString;
+                                op: import("zod").ZodLiteral<"contains">;
+                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                                claim: import("zod").ZodString;
+                                op: import("zod").ZodLiteral<"eq">;
+                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                                claim: import("zod").ZodString;
+                                op: import("zod").ZodLiteral<"exists">;
+                            }, import("zod/v4/core").$strict>], "op">>;
+                        }, import("zod/v4/core").$strict>;
+                        readonly static: true;
+                        readonly inheritance: "default";
+                    }>;
+                    whois: builder.Function<{
+                        readonly description: "Resolve one issuer-and-subject Identity.";
+                        readonly auth: "authorized";
+                        readonly input: import("zod").ZodObject<{
+                            issuer: import("zod").ZodString;
+                            subject: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>;
+                        readonly output: import("zod").ZodNullable<import("zod").ZodObject<{
+                            id: import("zod").ZodString;
+                            issuer: import("zod").ZodString;
+                            subject: import("zod").ZodString;
+                            frozen: import("zod").ZodBoolean;
+                            requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                                claim: import("zod").ZodString;
+                                op: import("zod").ZodLiteral<"contains">;
+                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                                claim: import("zod").ZodString;
+                                op: import("zod").ZodLiteral<"eq">;
+                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                                claim: import("zod").ZodString;
+                                op: import("zod").ZodLiteral<"exists">;
+                            }, import("zod/v4/core").$strict>], "op">>;
+                        }, import("zod/v4/core").$strict>>;
+                        readonly static: true;
+                        readonly inheritance: "default";
+                    }>;
+                    mint: builder.Function<{
+                        readonly description: "Resolve and sign one authorized Grant credential.";
+                        readonly auth: "authorized";
+                        readonly input: import("zod").ZodObject<{
+                            audience: import("zod").ZodOptional<import("zod").ZodString>;
+                            ttlSeconds: import("zod").ZodNumber;
+                            grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                        }, import("zod/v4/core").$strict>;
+                        readonly output: import("zod").ZodString;
+                        readonly static: true;
+                        readonly inheritance: "default";
+                    }>;
+                }>;
+            }>];
+            readonly properties: {
+                readonly origin: {
+                    readonly type: "string";
+                    readonly pattern: "[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+";
+                };
+                readonly dependencyContext: builder.Property<{
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                }, {
+                    readonly visibility: "private";
+                    readonly required: false;
+                }>;
+                readonly schema: builder.Property<{
+                    readonly type: "object";
+                }, {
+                    readonly visibility: "private";
+                }>;
+                readonly schemaRevision: builder.Property<{
+                    readonly type: "string";
+                    readonly pattern: "sha256:[0-9a-f]{64}";
+                }, {
+                    readonly visibility: "private";
+                }>;
+            };
+        }>];
+        readonly incoming: "0..*";
+    };
     readonly description: "A schema declaration or Core node belongs to one Domain member namespace.";
     readonly implements: readonly [builder.Interface<{
         readonly family: "both";
         readonly description: "Explicit kernel marker for Edge definitions; it carries no structural fields.";
     }>];
-    readonly orientation: "directed";
     readonly constraints: {
         readonly noSelf: true;
     };
@@ -188,5 +344,5 @@ export declare const OfDomain: builder.EdgeClass<{
             readonly visibility: "private";
         }>;
     };
-}>;
+}, "source" | "target">>;
 //# sourceMappingURL=of-domain.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"of-domain.d.ts","sourceRoot":"","sources":["../../../schema/domain/of-domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAK7E,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QASf,MAAM;;;;;;;EAGiB,CAAA"}
+{"version":3,"file":"of-domain.d.ts","sourceRoot":"","sources":["../../../schema/domain/of-domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAK7E,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAOjB,MAAM;;;;;;;wBAEoB,CAAA"}

package/dist/schema/domain/of-domain.js

@@ -1,10 +1,11 @@
 import { edgeClass, property } from '@astrale-os/kernel-dsl/v1';
 import { Edge, Node } from '../meta/index.js';
 import { Domain } from './domain.js';
-export const OfDomain = edgeClass({ as: 'member', accepts: [Node], cardinality: '0..1' }, { as: 'domain', accepts: [Domain] }, {
+export const OfDomain = edgeClass.directed({
+    source: { as: 'member', accepts: [Node], outgoing: '0..1' },
+    target: { as: 'domain', accepts: [Domain], incoming: '0..*' },
     description: 'A schema declaration or Core node belongs to one Domain member namespace.',
     implements: [Edge],
-    orientation: 'directed',
     constraints: { noSelf: true },
     properties: {
         member: property({ type: 'string', minLength: 3 }, { visibility: 'private' }),

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

@@ -1 +1 @@
-{"version":3,"file":"of-domain.js","sourceRoot":"","sources":["../../../schema/domain/of-domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAgB,MAAM,2BAA2B,CAAA;AAE7E,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEpC,MAAM,CAAC,MAAM,QAAQ,GAAG,SAAS,CAC/B,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,EACtD,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,EACnC;IACE,WAAW,EAAE,2EAA2E;IACxF,UAAU,EAAE,CAAC,IAAI,CAAC;IAClB,WAAW,EAAE,UAAU;IACvB,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;IAC7B,UAAU,EAAE;QACV,MAAM,EAAE,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;KAC9E;CACF,CAC0B,CAAA"}
+{"version":3,"file":"of-domain.js","sourceRoot":"","sources":["../../../schema/domain/of-domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAgB,MAAM,2BAA2B,CAAA;AAE7E,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEpC,MAAM,CAAC,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAC;IACzC,MAAM,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IAC3D,MAAM,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IAC7D,WAAW,EAAE,2EAA2E;IACxF,UAAU,EAAE,CAAC,IAAI,CAAC;IAClB,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;IAC7B,UAAU,EAAE;QACV,MAAM,EAAE,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;KAC9E;CACF,CAA6B,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"composition.d.ts","sourceRoot":"","sources":["../../../schema/identity/composition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKnE,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,YAAY,GAAG,UAAU,GAAG,WAAW,EAC7C,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,SAAS,CAWnB"}
+{"version":3,"file":"composition.d.ts","sourceRoot":"","sources":["../../../schema/identity/composition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKnE,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,YAAY,GAAG,UAAU,GAAG,WAAW,EAC7C,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,SAAS,CAQnB"}