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

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

@@ -1,5 +1,5 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const ViewFor: builder.EdgeClass<{
+export declare const ViewFor: builder.DirectedEdgeClass<{
     readonly as: "view";
     readonly accepts: readonly [builder.NodeClass<{
         readonly description: "The installed projection of a declarative browser surface; it is not a principal.";
@@ -25,11 +25,9 @@ export declare const ViewFor: builder.EdgeClass<{
             };
         }>];
         readonly methods: Readonly<{
-            resolve: builder.Function<Omit<{
+            resolve: builder.Function<{
                 readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
-                readonly auth: "required";
-                readonly admission: "policy";
-                readonly policy: builder.CallablePolicyBuilder;
+                readonly auth: "authorized";
                 readonly input: import("zod").ZodObject<{
                     target: import("zod").ZodString;
                 }, import("zod/v4/core").$strict>;
@@ -71,10 +69,10 @@ export declare const ViewFor: builder.EdgeClass<{
                 }, import("zod/v4/core").$strict>;
                 readonly static: true;
                 readonly inheritance: "sealed";
-            }, "admission">>;
+            }>;
         }>;
     }>];
-    readonly cardinality: "1..*";
+    readonly outgoing: "1..*";
 }, {
     readonly as: "target";
     readonly accepts: readonly [builder.NodeClass<{
@@ -145,24 +143,20 @@ export declare const ViewFor: 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;
@@ -172,11 +166,10 @@ export declare const ViewFor: 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;
@@ -198,12 +191,10 @@ export declare const ViewFor: 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;
@@ -228,12 +219,10 @@ export declare const ViewFor: 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;
@@ -242,7 +231,7 @@ export declare const ViewFor: builder.EdgeClass<{
                     readonly output: import("zod").ZodString;
                     readonly static: true;
                     readonly inheritance: "default";
-                }, "admission">>;
+                }>;
             }>;
         }>];
         readonly properties: {
@@ -292,12 +281,297 @@ export declare const ViewFor: builder.EdgeClass<{
             };
         };
     }>];
-}, {
+    readonly incoming: "0..*";
+}, Omit<{
+    readonly source: {
+        readonly as: "view";
+        readonly accepts: readonly [builder.NodeClass<{
+            readonly description: "The installed projection of a declarative browser surface; it is not a principal.";
+            readonly implements: readonly [builder.NodeInterface<{
+                readonly description: "Ordinary projection-node contract for a declarative browser surface.";
+                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 auth: {
+                        readonly enum: readonly ["required", "optional", "public"];
+                    };
+                };
+            }>];
+            readonly methods: Readonly<{
+                resolve: builder.Function<{
+                    readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
+                    readonly auth: "authorized";
+                    readonly input: import("zod").ZodObject<{
+                        target: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: import("zod").ZodObject<{
+                        snapshot: import("zod").ZodString;
+                        views: import("zod").ZodArray<import("zod").ZodObject<{
+                            key: import("zod").ZodString;
+                            declaration: import("zod").ZodObject<{
+                                description: import("zod").ZodOptional<import("zod").ZodString>;
+                                target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                                    kind: import("zod").ZodLiteral<"domain">;
+                                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                                    kind: import("zod").ZodLiteral<"definition">;
+                                    definitions: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                                        origin: import("zod").ZodString;
+                                        kind: import("zod").ZodLiteral<"class">;
+                                        name: import("zod").ZodString;
+                                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                                        origin: import("zod").ZodString;
+                                        kind: import("zod").ZodLiteral<"interface">;
+                                        name: import("zod").ZodString;
+                                    }, import("zod/v4/core").$strict>], "kind">>;
+                                }, import("zod/v4/core").$strict>], "kind">;
+                                auth: import("zod").ZodEnum<{
+                                    optional: "optional";
+                                    public: "public";
+                                    required: "required";
+                                }>;
+                            }, import("zod/v4/core").$strict>;
+                            href: import("zod").ZodString;
+                            handshake: import("zod").ZodEnum<{
+                                none: "none";
+                                shell: "shell";
+                            }>;
+                            issuer: import("zod").ZodString;
+                            etag: import("zod").ZodString;
+                            revision: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly static: true;
+                    readonly inheritance: "sealed";
+                }>;
+            }>;
+        }>];
+        readonly outgoing: "1..*";
+    };
+    readonly target: {
+        readonly as: "target";
+        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: "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";
+                }>;
+            };
+        }>, 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: "A View declaration targets one Domain or a non-empty set of Classes and Interfaces.";
     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=view-for.d.ts.map

package/dist/schema/callables/view-for.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"view-for.d.ts","sourceRoot":"","sources":["../../../schema/callables/view-for.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAOnE,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASS,CAAA"}
+{"version":3,"file":"view-for.d.ts","sourceRoot":"","sources":["../../../schema/callables/view-for.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAOnE,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAMU,CAAA"}

package/dist/schema/callables/view-for.js

@@ -3,9 +3,10 @@ import { Class, Interface } from '../definitions/index.js';
 import { Domain } from '../domain/index.js';
 import { Edge } from '../meta/index.js';
 import { View } from './view.js';
-export const ViewFor = edgeClass({ as: 'view', accepts: [View], cardinality: '1..*' }, { as: 'target', accepts: [Class, Domain, Interface] }, {
+export const ViewFor = edgeClass.directed({
+    source: { as: 'view', accepts: [View], outgoing: '1..*' },
+    target: { as: 'target', accepts: [Class, Domain, Interface], incoming: '0..*' },
     description: 'A View declaration targets one Domain or a non-empty set of Classes and Interfaces.',
     implements: [Edge],
-    orientation: 'directed',
 });
 //# sourceMappingURL=view-for.js.map

package/dist/schema/callables/view-for.js.map

@@ -1 +1 @@
-{"version":3,"file":"view-for.js","sourceRoot":"","sources":["../../../schema/callables/view-for.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgB,MAAM,2BAA2B,CAAA;AAEnE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAEhC,MAAM,CAAC,MAAM,OAAO,GAAG,SAAS,CAC9B,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,EACpD,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,EACrD;IACE,WAAW,EACT,qFAAqF;IACvF,UAAU,EAAE,CAAC,IAAI,CAAC;IAClB,WAAW,EAAE,UAAU;CACxB,CAC0B,CAAA"}
+{"version":3,"file":"view-for.js","sourceRoot":"","sources":["../../../schema/callables/view-for.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgB,MAAM,2BAA2B,CAAA;AAEnE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAEhC,MAAM,CAAC,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC;IACxC,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IACzD,MAAM,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE;IAC/E,WAAW,EACT,qFAAqF;IACvF,UAAU,EAAE,CAAC,IAAI,CAAC;CACnB,CAA6B,CAAA"}

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

@@ -23,11 +23,9 @@ export declare const View: builder.NodeClass<{
         };
     }>];
     readonly methods: Readonly<{
-        resolve: builder.Function<Omit<{
+        resolve: builder.Function<{
             readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
-            readonly auth: "required";
-            readonly admission: "policy";
-            readonly policy: builder.CallablePolicyBuilder;
+            readonly auth: "authorized";
             readonly input: import("zod").ZodObject<{
                 target: import("zod").ZodString;
             }, import("zod/v4/core").$strict>;
@@ -69,7 +67,7 @@ export declare const View: builder.NodeClass<{
             }, import("zod/v4/core").$strict>;
             readonly static: true;
             readonly inheritance: "sealed";
-        }, "admission">>;
+        }>;
     }>;
 }>;
 //# sourceMappingURL=view.d.ts.map

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

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

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

@@ -1,2 +1,2 @@
-export { CapabilityCore, DelegateCapability, IdentityLookupCapability, InstallCapability, JournalCapability, MintCapability, MutateCapability, ProvisionCapability, QueryCapability, UninstallCapability, ViewResolveCapability, } from './capabilities/index.js';
+export { OperationCore } from './operations/index.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../schema/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,wBAAwB,EACxB,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,yBAAyB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../schema/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/schema/core/index.js

@@ -1,2 +1,2 @@
-export { CapabilityCore, DelegateCapability, IdentityLookupCapability, InstallCapability, JournalCapability, MintCapability, MutateCapability, ProvisionCapability, QueryCapability, UninstallCapability, ViewResolveCapability, } from './capabilities/index.js';
+export { OperationCore } from './operations/index.js';
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../schema/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,wBAAwB,EACxB,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,yBAAyB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../schema/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/schema/core/operations/index.d.ts

@@ -0,0 +1,7 @@
+import type { builder } from '@astrale-os/kernel-dsl/v1';
+import { AuthorityOperations } from '../../authority/index.js';
+export declare const OperationCore: {
+    readonly nodes: typeof AuthorityOperations;
+    readonly edges: NonNullable<builder.Core['edges']>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/core/operations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../schema/core/operations/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAExD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAE9D,eAAO,MAAM,aAAa,EAAE;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,mBAAmB,CAAA;IAC1C,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;CAIlD,CAAA"}

package/dist/schema/core/operations/index.js

@@ -0,0 +1,6 @@
+import { AuthorityOperations } from '../../authority/index.js';
+export const OperationCore = Object.freeze({
+    nodes: AuthorityOperations,
+    edges: Object.freeze([]),
+});
+//# sourceMappingURL=index.js.map

package/dist/schema/core/operations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../schema/core/operations/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAE9D,MAAM,CAAC,MAAM,aAAa,GAGtB,MAAM,CAAC,MAAM,CAAC;IAChB,KAAK,EAAE,mBAAmB;IAC1B,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;CACzB,CAAC,CAAA"}

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

@@ -1,5 +1,5 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Extends: builder.EdgeClass<{
+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.";
@@ -22,6 +22,7 @@ export declare const Extends: builder.EdgeClass<{
             };
         };
     }>];
+    readonly outgoing: "0..*";
 }, {
     readonly as: "super";
     readonly accepts: readonly [builder.NodeClass<{
@@ -45,16 +46,66 @@ export declare const Extends: builder.EdgeClass<{
             };
         };
     }>];
-}, {
+    readonly incoming: "0..*";
+}, Omit<{
+    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 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 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 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 compatible Interface inheritance.";
     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;
         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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASS,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAMU,CAAA"}

package/dist/schema/definitions/extends.js

@@ -1,10 +1,11 @@
 import { edgeClass } from '@astrale-os/kernel-dsl/v1';
 import { Edge } from '../meta/index.js';
 import { Interface } from './interface.js';
-export const Extends = edgeClass({ as: 'sub', accepts: [Interface] }, { as: 'super', accepts: [Interface] }, {
+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],
-    orientation: 'directed',
     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,CAC9B,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,SAAS,CAAC,EAAE,EACnC,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,SAAS,CAAC,EAAE,EACrC;IACE,WAAW,EAAE,+DAA+D;IAC5E,UAAU,EAAE,CAAC,IAAI,CAAC;IAClB,WAAW,EAAE,UAAU;IACvB,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE;CAC7C,CAC0B,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,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"}