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

package/dist/schema/kernel/schema.d.ts

@@ -1,6 +1,5 @@
 import { type builder, type schema } from '@astrale-os/kernel-dsl/v1';
 import { type Domain as DomainValue } from '#domain';
-import { CapabilityCore } from '../core/index.js';
 declare const KernelDefinitions: {
     readonly interfaces: {
         readonly Descriptable: builder.Interface<{
@@ -44,7 +43,7 @@ declare const KernelDefinitions: {
                     readonly type: "object";
                 };
                 readonly auth: {
-                    readonly enum: readonly ["required", "optional", "public"];
+                    readonly enum: readonly ["anonymous", "authenticated", "authorized"];
                 };
                 readonly policy: builder.Property<{
                     readonly type: "object";
@@ -110,24 +109,20 @@ declare const KernelDefinitions: {
                 };
             };
             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;
@@ -137,11 +132,10 @@ declare const KernelDefinitions: {
                     }, 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;
@@ -163,12 +157,10 @@ declare const KernelDefinitions: {
                     }, 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;
@@ -193,12 +185,10 @@ declare const KernelDefinitions: {
                     }, 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;
@@ -207,7 +197,7 @@ declare const KernelDefinitions: {
                     readonly output: import("zod").ZodString;
                     readonly static: true;
                     readonly inheritance: "default";
-                }, "admission">>;
+                }>;
             }>;
         }>;
         readonly Named: builder.Interface<{
@@ -261,14 +251,14 @@ declare const KernelDefinitions: {
             readonly family: "both";
             readonly description: "Explicit creation and update timestamp metadata.";
             readonly properties: {
-                createdAt: Readonly<{
+                createdAt: builder.AutoProperty<builder.Property<Readonly<{
                     readonly type: 'string';
                     readonly 'x-astrale-value-kind': 'instant';
-                }>;
-                updatedAt: Readonly<{
+                }>, builder.PropertyOptions>>;
+                updatedAt: builder.AutoProperty<builder.Property<Readonly<{
                     readonly type: 'string';
                     readonly 'x-astrale-value-kind': 'instant';
-                }>;
+                }>, builder.PropertyOptions>>;
             };
         }>;
         readonly UI: builder.NodeInterface<{
@@ -294,9 +284,6 @@ declare const KernelDefinitions: {
         }>;
     };
     readonly classes: {
-        readonly Capability: builder.NodeClass<{
-            readonly description: "A closed kernel authority definition represented by one canonical Core node.";
-        }>;
         readonly Class: builder.NodeClass<{
             readonly description: "The installed graph projection of a concrete Node Class or Edge Class declaration.";
             readonly implements: readonly [builder.Interface<{
@@ -366,24 +353,20 @@ declare const KernelDefinitions: {
                     };
                 };
                 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;
@@ -393,11 +376,10 @@ declare const KernelDefinitions: {
                         }, 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;
@@ -419,12 +401,10 @@ declare const KernelDefinitions: {
                         }, 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;
@@ -449,12 +429,10 @@ declare const KernelDefinitions: {
                         }, 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;
@@ -463,7 +441,7 @@ declare const KernelDefinitions: {
                         readonly output: import("zod").ZodString;
                         readonly static: true;
                         readonly inheritance: "default";
-                    }, "admission">>;
+                    }>;
                 }>;
             }>];
             readonly properties: {
@@ -519,7 +497,7 @@ declare const KernelDefinitions: {
                         readonly type: "object";
                     };
                     readonly auth: {
-                        readonly enum: readonly ["required", "optional", "public"];
+                        readonly enum: readonly ["anonymous", "authenticated", "authorized"];
                     };
                     readonly policy: builder.Property<{
                         readonly type: "object";
@@ -539,10 +517,9 @@ declare const KernelDefinitions: {
                 };
             }>];
             readonly methods: Readonly<{
-                admit: builder.Function<Omit<{
+                admit: builder.Function<{
                     readonly description: "Admit one remote path-only attempt and return its request-scoped execution target.";
-                    readonly auth: "required";
-                    readonly admission: "authenticated";
+                    readonly auth: "authenticated";
                     readonly input: import("zod").ZodObject<{
                         call: import("zod").ZodObject<{
                             target: import("zod").ZodString;
@@ -556,7 +533,7 @@ declare const KernelDefinitions: {
                     }, import("zod/v4/core").$strict>;
                     readonly static: true;
                     readonly inheritance: "sealed";
-                }, "admission">>;
+                }>;
             }>;
         }>;
         readonly Interface: builder.NodeClass<{
@@ -580,6 +557,20 @@ declare const KernelDefinitions: {
                 };
             };
         }>;
+        readonly Operation: builder.NodeClass<{
+            readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
+            readonly implements: readonly [builder.Interface<{
+                readonly family: "both";
+                readonly description: "Stable human-facing name metadata that never acts as a locator.";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 100;
+                    };
+                };
+            }>];
+        }>;
         readonly Policy: builder.NodeClass<{
             readonly description: "The installed graph projection of one named closed Policy declaration owned by a Domain.";
             readonly implements: readonly [builder.Interface<{
@@ -620,11 +611,9 @@ declare const KernelDefinitions: {
                 };
             }>];
             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>;
@@ -666,18 +655,20 @@ declare const KernelDefinitions: {
                     }, import("zod/v4/core").$strict>;
                     readonly static: true;
                     readonly inheritance: "sealed";
-                }, "admission">>;
+                }>;
             }>;
         }>;
-        readonly can_create: builder.EdgeClass<builder.Endpoint, builder.Endpoint, builder.EdgeClassOptions>;
-        readonly can_read: builder.EdgeClass<builder.Endpoint, builder.Endpoint, builder.EdgeClassOptions>;
-        readonly can_traverse: builder.EdgeClass<builder.Endpoint, builder.Endpoint, builder.EdgeClassOptions>;
-        readonly can_update: builder.EdgeClass<builder.Endpoint, builder.Endpoint, builder.EdgeClassOptions>;
-        readonly can_delete: builder.EdgeClass<builder.Endpoint, builder.Endpoint, builder.EdgeClassOptions>;
-        readonly can_use: builder.EdgeClass<builder.Endpoint, builder.Endpoint, builder.EdgeClassOptions>;
-        readonly constrained_by: builder.EdgeClass<builder.Endpoint, builder.Endpoint, builder.EdgeClassOptions>;
-        readonly excluded_from: builder.EdgeClass<builder.Endpoint, builder.Endpoint, builder.EdgeClassOptions>;
-        readonly extends: builder.EdgeClass<{
+        readonly can_create: builder.EdgeClass;
+        readonly can_read: builder.EdgeClass;
+        readonly can_traverse: builder.EdgeClass;
+        readonly can_update: builder.EdgeClass;
+        readonly can_delete: builder.EdgeClass;
+        readonly can_grant: builder.EdgeClass;
+        readonly can_revoke: builder.EdgeClass;
+        readonly can_use: builder.EdgeClass;
+        readonly constrained_by: builder.EdgeClass;
+        readonly excluded_from: builder.EdgeClass;
+        readonly 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.";
@@ -700,6 +691,7 @@ declare const KernelDefinitions: {
                     };
                 };
             }>];
+            readonly outgoing: "0..*";
         }, {
             readonly as: "super";
             readonly accepts: readonly [builder.NodeClass<{
@@ -723,20 +715,70 @@ declare const KernelDefinitions: {
                     };
                 };
             }>];
-        }, {
+            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;
             };
-        }>;
-        readonly extends_with: builder.EdgeClass<builder.Endpoint, builder.Endpoint, builder.EdgeClassOptions>;
-        readonly governed_by: builder.EdgeClass<{
+        }, "source" | "target">>;
+        readonly extends_with: builder.EdgeClass;
+        readonly governed_by: 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.";
@@ -771,6 +813,7 @@ declare const KernelDefinitions: {
                     };
                 };
             }>];
+            readonly outgoing: "0..*";
         }, {
             readonly as: "policy";
             readonly accepts: readonly [builder.NodeClass<{
@@ -789,13 +832,70 @@ declare const KernelDefinitions: {
                     };
                 }>];
             }>];
-        }, {
+            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: "policy";
+                readonly accepts: readonly [builder.NodeClass<{
+                    readonly description: "The installed graph projection of one named closed Policy declaration owned by a Domain.";
+                    readonly implements: readonly [builder.Interface<{
+                        readonly family: "both";
+                        readonly 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 incoming: "0..*";
+            };
             readonly description: "The protected projection of one Class read or traverse Policy assignment.";
             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 properties: {
                 operations: builder.Property<{
                     readonly enum: readonly [readonly ["read"], readonly ["traverse"], readonly ["read", "traverse"]];
@@ -806,8 +906,8 @@ declare const KernelDefinitions: {
             readonly constraints: {
                 readonly noSelf: true;
             };
-        }>;
-        readonly implements: builder.EdgeClass<{
+        }, "source" | "target">>;
+        readonly 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.";
@@ -842,6 +942,7 @@ declare const KernelDefinitions: {
                     };
                 };
             }>];
+            readonly outgoing: "0..*";
         }, {
             readonly as: "interface";
             readonly accepts: readonly [builder.NodeClass<{
@@ -865,23 +966,85 @@ declare const KernelDefinitions: {
                     };
                 };
             }>];
-        }, {
+            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;
             };
-        }>;
-        readonly instance_of: builder.EdgeClass<{
+        }, "source" | "target">>;
+        readonly instance_of: 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<{
@@ -917,15 +1080,59 @@ declare const KernelDefinitions: {
                     };
                 };
             }>];
-        }, {
+            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";
-        }>;
-        readonly method_of: builder.EdgeClass<{
+        }, "source" | "target">>;
+        readonly method_of: builder.DirectedEdgeClass<{
             readonly as: "method";
             readonly accepts: readonly [builder.NodeClass<{
                 readonly description: "The installed projection of a standalone Function or Node Method declaration; it is not a principal.";
@@ -953,7 +1160,7 @@ declare const KernelDefinitions: {
                             readonly type: "object";
                         };
                         readonly auth: {
-                            readonly enum: readonly ["required", "optional", "public"];
+                            readonly enum: readonly ["anonymous", "authenticated", "authorized"];
                         };
                         readonly policy: builder.Property<{
                             readonly type: "object";
@@ -973,10 +1180,9 @@ declare const KernelDefinitions: {
                     };
                 }>];
                 readonly methods: Readonly<{
-                    admit: builder.Function<Omit<{
+                    admit: builder.Function<{
                         readonly description: "Admit one remote path-only attempt and return its request-scoped execution target.";
-                        readonly auth: "required";
-                        readonly admission: "authenticated";
+                        readonly auth: "authenticated";
                         readonly input: import("zod").ZodObject<{
                             call: import("zod").ZodObject<{
                                 target: import("zod").ZodString;
@@ -990,10 +1196,10 @@ declare const KernelDefinitions: {
                         }, import("zod/v4/core").$strict>;
                         readonly static: true;
                         readonly inheritance: "sealed";
-                    }, "admission">>;
+                    }>;
                 }>;
             }>];
-            readonly cardinality: "0..1";
+            readonly outgoing: "0..1";
         }, {
             readonly as: "owner";
             readonly accepts: readonly [builder.NodeClass<{
@@ -1049,13 +1255,139 @@ declare const KernelDefinitions: {
                     };
                 };
             }>];
-        }, {
+            readonly incoming: "0..*";
+        }, Omit<{
+            readonly source: {
+                readonly as: "method";
+                readonly accepts: readonly [builder.NodeClass<{
+                    readonly description: "The installed projection of a standalone Function or Node Method declaration; it is not a principal.";
+                    readonly implements: readonly [builder.NodeInterface<{
+                        readonly description: "Ordinary projection-node contract for a standalone Function or Node Method declaration.";
+                        readonly extends: readonly [builder.Interface<{
+                            readonly family: "both";
+                            readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
+                            readonly properties: {
+                                description: builder.Property<Readonly<{
+                                    readonly type: 'string';
+                                    readonly minLength: 1;
+                                    readonly maxLength: 1000;
+                                }>, {
+                                    readonly required: false;
+                                }>;
+                            };
+                        }>];
+                        readonly properties: {
+                            readonly kind: {
+                                readonly enum: readonly ["function", "method"];
+                            };
+                            readonly input: {};
+                            readonly output: {
+                                readonly type: "object";
+                            };
+                            readonly auth: {
+                                readonly enum: readonly ["anonymous", "authenticated", "authorized"];
+                            };
+                            readonly policy: builder.Property<{
+                                readonly type: "object";
+                            }, {
+                                readonly required: false;
+                            }>;
+                            readonly static: builder.Property<{
+                                readonly type: "boolean";
+                            }, {
+                                readonly required: false;
+                            }>;
+                            readonly inheritance: builder.Property<{
+                                readonly enum: readonly ["abstract", "default", "sealed"];
+                            }, {
+                                readonly required: false;
+                            }>;
+                        };
+                    }>];
+                    readonly methods: Readonly<{
+                        admit: builder.Function<{
+                            readonly description: "Admit one remote path-only attempt and return its request-scoped execution target.";
+                            readonly auth: "authenticated";
+                            readonly input: import("zod").ZodObject<{
+                                call: import("zod").ZodObject<{
+                                    target: import("zod").ZodString;
+                                    input: import("zod").ZodUnknown;
+                                }, import("zod/v4/core").$strict>;
+                                credential: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strict>;
+                            readonly output: import("zod").ZodObject<{
+                                callable: import("zod").ZodString;
+                                receiver: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strict>;
+                            readonly static: true;
+                            readonly inheritance: "sealed";
+                        }>;
+                    }>;
+                }>];
+                readonly outgoing: "0..1";
+            };
+            readonly target: {
+                readonly as: "owner";
+                readonly accepts: readonly [builder.NodeClass<{
+                    readonly description: "The installed graph projection of a concrete Node Class or Edge Class declaration.";
+                    readonly implements: readonly [builder.Interface<{
+                        readonly family: "both";
+                        readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
+                        readonly properties: {
+                            description: builder.Property<Readonly<{
+                                readonly type: 'string';
+                                readonly minLength: 1;
+                                readonly maxLength: 1000;
+                            }>, {
+                                readonly required: false;
+                            }>;
+                        };
+                    }>, builder.Interface<{
+                        readonly family: "both";
+                        readonly description: "Optional bounded presentation icon metadata.";
+                        readonly properties: {
+                            icon: builder.Property<Readonly<{
+                                readonly type: 'string';
+                                readonly minLength: 1;
+                                readonly maxLength: 8000;
+                            }>, {
+                                readonly required: false;
+                            }>;
+                        };
+                    }>];
+                    readonly properties: {
+                        readonly family: {
+                            readonly enum: readonly ["node", "edge"];
+                        };
+                    };
+                }>, builder.NodeClass<{
+                    readonly description: "The installed graph projection of a both-, Node-, or Edge-family Interface.";
+                    readonly implements: readonly [builder.Interface<{
+                        readonly family: "both";
+                        readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
+                        readonly properties: {
+                            description: builder.Property<Readonly<{
+                                readonly type: 'string';
+                                readonly minLength: 1;
+                                readonly maxLength: 1000;
+                            }>, {
+                                readonly required: false;
+                            }>;
+                        };
+                    }>];
+                    readonly properties: {
+                        readonly family: {
+                            readonly enum: readonly ["both", "node", "edge"];
+                        };
+                    };
+                }>];
+                readonly incoming: "0..*";
+            };
             readonly description: "A Function declaration belongs to one Class or Interface for dispatch.";
             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 properties: {
                 name: builder.Property<{
                     readonly type: "string";
@@ -1069,13 +1401,13 @@ declare const KernelDefinitions: {
                     readonly visibility: "private";
                 }>;
             };
-        }>;
-        readonly of_domain: builder.EdgeClass<{
+        }, "source" | "target">>;
+        readonly of_domain: 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<{
@@ -1114,24 +1446,20 @@ declare const KernelDefinitions: {
                         };
                     };
                     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;
@@ -1141,11 +1469,10 @@ declare const KernelDefinitions: {
                             }, 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;
@@ -1167,12 +1494,10 @@ declare const KernelDefinitions: {
                             }, 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;
@@ -1197,12 +1522,10 @@ declare const KernelDefinitions: {
                             }, 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;
@@ -1211,7 +1534,7 @@ declare const KernelDefinitions: {
                             readonly output: import("zod").ZodString;
                             readonly static: true;
                             readonly inheritance: "default";
-                        }, "admission">>;
+                        }>;
                     }>;
                 }>];
                 readonly properties: {
@@ -1241,15 +1564,180 @@ declare const KernelDefinitions: {
                     }>;
                 };
             }>];
-        }, {
-            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;
+            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 constraints: {
+                readonly noSelf: true;
             };
             readonly properties: {
                 member: builder.Property<{
@@ -1259,8 +1747,8 @@ declare const KernelDefinitions: {
                     readonly visibility: "private";
                 }>;
             };
-        }>;
-        readonly view_for: builder.EdgeClass<{
+        }, "source" | "target">>;
+        readonly view_for: 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.";
@@ -1286,11 +1774,9 @@ declare const KernelDefinitions: {
                     };
                 }>];
                 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>;
@@ -1332,10 +1818,10 @@ declare const KernelDefinitions: {
                         }, 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<{
@@ -1406,24 +1892,20 @@ declare const KernelDefinitions: {
                         };
                     };
                     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;
@@ -1433,11 +1915,10 @@ declare const KernelDefinitions: {
                             }, 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;
@@ -1459,12 +1940,10 @@ declare const KernelDefinitions: {
                             }, 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;
@@ -1489,12 +1968,10 @@ declare const KernelDefinitions: {
                             }, 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;
@@ -1503,7 +1980,7 @@ declare const KernelDefinitions: {
                             readonly output: import("zod").ZodString;
                             readonly static: true;
                             readonly inheritance: "default";
-                        }, "admission">>;
+                        }>;
                     }>;
                 }>];
                 readonly properties: {
@@ -1553,24 +2030,305 @@ declare const KernelDefinitions: {
                     };
                 };
             }>];
-        }, {
+            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";
-        }>;
-    };
-    readonly policies: {
-        readonly may_use_capability: builder.Policy;
+        }, "source" | "target">>;
     };
+    readonly policies: {};
     readonly functions: Readonly<{
-        query: builder.Function<Omit<{
+        query: builder.Function<{
             readonly description: "Execute one finite authorized graph query.";
-            readonly auth: "required";
-            readonly admission: "policy";
-            readonly policy: builder.CallablePolicyBuilder;
+            readonly auth: "authorized";
             readonly input: import("zod").ZodObject<{
                 ast: import("zod").ZodObject<{
                     format: import("zod").ZodLiteral<"astrale.graph.query">;
@@ -1827,12 +2585,10 @@ declare const KernelDefinitions: {
                     next: import("zod").ZodOptional<import("zod").ZodString>;
                 }, import("zod/v4/core").$strict>;
             }, import("zod/v4/core").$strict>;
-        }, "admission">>;
-        mutate: builder.Function<Omit<{
+        }>;
+        mutate: builder.Function<{
             readonly description: "Validate, authorize, and commit one atomic graph mutation.";
-            readonly auth: "required";
-            readonly admission: "policy";
-            readonly policy: builder.CallablePolicyBuilder;
+            readonly auth: "authorized";
             readonly input: import("zod").ZodObject<{
                 format: import("zod").ZodLiteral<"astrale.graph.mutation">;
                 version: import("zod").ZodLiteral<"v3">;
@@ -2089,12 +2845,10 @@ declare const KernelDefinitions: {
             readonly output: import("zod").ZodObject<{
                 createdNodes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
             }, import("zod/v4/core").$strict>;
-        }, "admission">>;
-        provision: builder.Function<Omit<{
+        }>;
+        provision: builder.Function<{
             readonly description: "Atomically execute a graph transition whose designated Identities are born complete.";
-            readonly auth: "required";
-            readonly admission: "policy";
-            readonly policy: builder.CallablePolicyBuilder;
+            readonly auth: "authorized";
             readonly input: import("zod").ZodObject<{
                 idempotencyKey: import("zod").ZodString;
                 mutation: import("zod").ZodObject<{
@@ -2391,71 +3145,2740 @@ declare const KernelDefinitions: {
                     subject: import("zod").ZodString;
                 }, import("zod/v4/core").$strict>>;
             }, import("zod/v4/core").$strict>;
-        }, "admission">>;
-        install: builder.Function<Omit<{
-            readonly description: "Fetch, verify, and atomically activate one or more explicit Domain roots.";
-            readonly auth: "required";
-            readonly admission: "policy";
-            readonly policy: builder.CallablePolicyBuilder;
+        }>;
+        install: builder.Function<{
+            readonly description: "Durably install one or more exact Schema targets and return a terminal receipt.";
+            readonly auth: "authorized";
             readonly input: import("zod").ZodObject<{
-                domains: import("zod").ZodArray<import("zod").ZodObject<{
-                    url: import("zod").ZodString;
-                    token: import("zod").ZodOptional<import("zod").ZodString>;
+                operation: import("zod").ZodString;
+                domains: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    source: import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"local">;
+                        artifact: import("zod").ZodObject<{
+                            digest: import("zod").ZodString;
+                            mediaType: import("zod").ZodString;
+                            size: import("zod").ZodNumber;
+                        }, import("zod/v4/core").$strict>;
+                    }, import("zod/v4/core").$strict>;
+                    currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    source: import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"remote">;
+                        url: import("zod").ZodString;
+                        token: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strict>;
                     targetRevision: import("zod").ZodOptional<import("zod").ZodString>;
                     targetEtag: import("zod").ZodOptional<import("zod").ZodString>;
                     currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strict>;
+            readonly output: import("zod").ZodObject<{
+                operation: import("zod").ZodString;
+                transitions: import("zod").ZodArray<import("zod").ZodObject<{
+                    intent: import("zod").ZodObject<{
+                        transition: import("zod").ZodString;
+                        operation: import("zod").ZodString;
+                        installation: import("zod").ZodString;
+                        origin: import("zod").ZodString;
+                        source: import("zod").ZodNullable<import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            schemaRevision: import("zod").ZodString;
+                            schemaBundle: import("zod").ZodString;
+                            service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                                kind: import("zod").ZodLiteral<"local">;
+                                artifact: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                                kind: import("zod").ZodLiteral<"remote">;
+                                etag: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>], "kind">;
+                            capabilities: import("zod").ZodObject<{
+                                functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                                classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                                    class: import("zod").ZodObject<{
+                                        origin: import("zod").ZodString;
+                                        kind: import("zod").ZodLiteral<"class">;
+                                        name: import("zod").ZodString;
+                                    }, import("zod/v4/core").$strict>;
+                                    operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        read: "read";
+                                        traverse: "traverse";
+                                        update: "update";
+                                    }>>;
+                                }, import("zod/v4/core").$strict>>>;
+                                admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                                    grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        grant: "grant";
+                                        read: "read";
+                                        revoke: "revoke";
+                                        traverse: "traverse";
+                                        update: "update";
+                                        use: "use";
+                                    }>>>;
+                                    revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        grant: "grant";
+                                        read: "read";
+                                        revoke: "revoke";
+                                        traverse: "traverse";
+                                        update: "update";
+                                        use: "use";
+                                    }>>>;
+                                }, import("zod/v4/core").$strict>>;
+                            }, import("zod/v4/core").$strict>;
+                            dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                                origin: import("zod").ZodString;
+                                installation: import("zod").ZodString;
+                                target: import("zod").ZodString;
+                                readinessReceipt: import("zod").ZodString;
+                                meaningComparison: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>>;
+                        target: import("zod").ZodNullable<import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            schemaRevision: import("zod").ZodString;
+                            schemaBundle: import("zod").ZodString;
+                            service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                                kind: import("zod").ZodLiteral<"local">;
+                                artifact: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                                kind: import("zod").ZodLiteral<"remote">;
+                                etag: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>], "kind">;
+                            capabilities: import("zod").ZodObject<{
+                                functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                                classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                                    class: import("zod").ZodObject<{
+                                        origin: import("zod").ZodString;
+                                        kind: import("zod").ZodLiteral<"class">;
+                                        name: import("zod").ZodString;
+                                    }, import("zod/v4/core").$strict>;
+                                    operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        read: "read";
+                                        traverse: "traverse";
+                                        update: "update";
+                                    }>>;
+                                }, import("zod/v4/core").$strict>>>;
+                                admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                                    grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        grant: "grant";
+                                        read: "read";
+                                        revoke: "revoke";
+                                        traverse: "traverse";
+                                        update: "update";
+                                        use: "use";
+                                    }>>>;
+                                    revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        grant: "grant";
+                                        read: "read";
+                                        revoke: "revoke";
+                                        traverse: "traverse";
+                                        update: "update";
+                                        use: "use";
+                                    }>>>;
+                                }, import("zod/v4/core").$strict>>;
+                            }, import("zod/v4/core").$strict>;
+                            dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                                origin: import("zod").ZodString;
+                                installation: import("zod").ZodString;
+                                target: import("zod").ZodString;
+                                readinessReceipt: import("zod").ZodString;
+                                meaningComparison: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>;
+                    phase: import("zod").ZodEnum<{
+                        converge: "converge";
+                        cutover: "cutover";
+                    }>;
+                    state: import("zod").ZodLiteral<"committed">;
+                    readiness: import("zod").ZodOptional<import("zod").ZodObject<{
+                        installation: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        transition: import("zod").ZodString;
+                        dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            installation: import("zod").ZodString;
+                            target: import("zod").ZodString;
+                            readinessReceipt: import("zod").ZodString;
+                            meaningComparison: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>>;
                 }, import("zod/v4/core").$strict>>;
             }, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodArray<import("zod").ZodObject<{
-                origin: import("zod").ZodString;
-                revision: import("zod").ZodString;
-                etag: import("zod").ZodOptional<import("zod").ZodString>;
-            }, import("zod/v4/core").$strict>>;
-        }, "admission">>;
-        uninstall: builder.Function<Omit<{
-            readonly description: "Atomically deactivate one installed Domain.";
-            readonly auth: "required";
-            readonly admission: "policy";
-            readonly policy: builder.CallablePolicyBuilder;
+        }>;
+        introspect: builder.Function<{
+            readonly description: "Return bounded installed-Publication evidence to an authenticated Kernel session.";
+            readonly auth: "authenticated";
             readonly input: import("zod").ZodObject<{
-                origin: import("zod").ZodString;
-            }, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodObject<{
-                origin: import("zod").ZodString;
-                revision: import("zod").ZodString;
+                from: import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"installation">;
+                    origin: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                select: import("zod").ZodObject<{
+                    state: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                    target: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                    source: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                    bundle: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                    readiness: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                    capabilities: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                }, import("zod/v4/core").$strict>;
             }, import("zod/v4/core").$strict>;
-        }, "admission">>;
-        journal: builder.Function<Omit<{
-            readonly description: "Read one authorized page from the kernel journal.";
-            readonly auth: "required";
-            readonly admission: "policy";
-            readonly policy: builder.CallablePolicyBuilder;
+            readonly output: builder.BinaryOutput;
+        }>;
+        uninstall: builder.Function<{
+            readonly description: "Durably uninstall one Domain installation epoch and return its terminal receipt.";
+            readonly auth: "authorized";
             readonly input: import("zod").ZodObject<{
-                topics: import("zod").ZodOptional<import("zod").ZodObject<{
-                    exact: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    prefixes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                }, import("zod/v4/core").$strict>>;
-                principal: import("zod").ZodOptional<import("zod").ZodString>;
-                since: import("zod").ZodOptional<import("zod").ZodString>;
-                until: import("zod").ZodOptional<import("zod").ZodString>;
-                cursor: import("zod").ZodOptional<import("zod").ZodString>;
-                limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+                operation: import("zod").ZodString;
+                origin: import("zod").ZodString;
             }, import("zod/v4/core").$strict>;
             readonly output: import("zod").ZodObject<{
-                records: import("zod").ZodArray<import("zod").ZodUnknown>;
-                cursor: import("zod").ZodOptional<import("zod").ZodString>;
-            }, import("zod/v4/core").$strict>;
-        }, "admission">>;
-    }>;
-};
-type KernelSchemaInput = typeof KernelDefinitions & {
-    readonly core: typeof CapabilityCore;
+                operation: import("zod").ZodString;
+                transition: import("zod").ZodObject<{
+                    intent: import("zod").ZodObject<{
+                        transition: import("zod").ZodString;
+                        operation: import("zod").ZodString;
+                        installation: import("zod").ZodString;
+                        origin: import("zod").ZodString;
+                        source: import("zod").ZodNullable<import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            schemaRevision: import("zod").ZodString;
+                            schemaBundle: import("zod").ZodString;
+                            service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                                kind: import("zod").ZodLiteral<"local">;
+                                artifact: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                                kind: import("zod").ZodLiteral<"remote">;
+                                etag: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>], "kind">;
+                            capabilities: import("zod").ZodObject<{
+                                functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                                classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                                    class: import("zod").ZodObject<{
+                                        origin: import("zod").ZodString;
+                                        kind: import("zod").ZodLiteral<"class">;
+                                        name: import("zod").ZodString;
+                                    }, import("zod/v4/core").$strict>;
+                                    operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        read: "read";
+                                        traverse: "traverse";
+                                        update: "update";
+                                    }>>;
+                                }, import("zod/v4/core").$strict>>>;
+                                admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                                    grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        grant: "grant";
+                                        read: "read";
+                                        revoke: "revoke";
+                                        traverse: "traverse";
+                                        update: "update";
+                                        use: "use";
+                                    }>>>;
+                                    revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        grant: "grant";
+                                        read: "read";
+                                        revoke: "revoke";
+                                        traverse: "traverse";
+                                        update: "update";
+                                        use: "use";
+                                    }>>>;
+                                }, import("zod/v4/core").$strict>>;
+                            }, import("zod/v4/core").$strict>;
+                            dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                                origin: import("zod").ZodString;
+                                installation: import("zod").ZodString;
+                                target: import("zod").ZodString;
+                                readinessReceipt: import("zod").ZodString;
+                                meaningComparison: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>>;
+                        target: import("zod").ZodNullable<import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            schemaRevision: import("zod").ZodString;
+                            schemaBundle: import("zod").ZodString;
+                            service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                                kind: import("zod").ZodLiteral<"local">;
+                                artifact: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                                kind: import("zod").ZodLiteral<"remote">;
+                                etag: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>], "kind">;
+                            capabilities: import("zod").ZodObject<{
+                                functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                                classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                                    class: import("zod").ZodObject<{
+                                        origin: import("zod").ZodString;
+                                        kind: import("zod").ZodLiteral<"class">;
+                                        name: import("zod").ZodString;
+                                    }, import("zod/v4/core").$strict>;
+                                    operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        read: "read";
+                                        traverse: "traverse";
+                                        update: "update";
+                                    }>>;
+                                }, import("zod/v4/core").$strict>>>;
+                                admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                                    grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        grant: "grant";
+                                        read: "read";
+                                        revoke: "revoke";
+                                        traverse: "traverse";
+                                        update: "update";
+                                        use: "use";
+                                    }>>>;
+                                    revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                        create: "create";
+                                        delete: "delete";
+                                        grant: "grant";
+                                        read: "read";
+                                        revoke: "revoke";
+                                        traverse: "traverse";
+                                        update: "update";
+                                        use: "use";
+                                    }>>>;
+                                }, import("zod/v4/core").$strict>>;
+                            }, import("zod/v4/core").$strict>;
+                            dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                                origin: import("zod").ZodString;
+                                installation: import("zod").ZodString;
+                                target: import("zod").ZodString;
+                                readinessReceipt: import("zod").ZodString;
+                                meaningComparison: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>;
+                    phase: import("zod").ZodEnum<{
+                        converge: "converge";
+                        cutover: "cutover";
+                    }>;
+                    state: import("zod").ZodLiteral<"committed">;
+                    readiness: import("zod").ZodOptional<import("zod").ZodObject<{
+                        installation: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        transition: import("zod").ZodString;
+                        dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            installation: import("zod").ZodString;
+                            target: import("zod").ZodString;
+                            readinessReceipt: import("zod").ZodString;
+                            meaningComparison: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>;
+        }>;
+        journal: builder.Function<{
+            readonly description: "Read one authorized page of semantic operations from the kernel journal.";
+            readonly auth: "authorized";
+            readonly input: import("zod").ZodObject<{
+                invocation: import("zod").ZodOptional<import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    id: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>;
+                topics: import("zod").ZodOptional<import("zod").ZodObject<{
+                    exact: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    prefixes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strict>>;
+                principal: import("zod").ZodOptional<import("zod").ZodString>;
+                since: import("zod").ZodOptional<import("zod").ZodString>;
+                until: import("zod").ZodOptional<import("zod").ZodString>;
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strict>;
+            readonly output: import("zod").ZodObject<{
+                records: import("zod").ZodArray<import("zod").ZodUnknown>;
+                frontier: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    first: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    committed: import("zod").ZodNumber;
+                    durable: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strict>;
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                gap: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strict>;
+        }>;
+    }>;
+};
+type KernelSchemaInput = typeof KernelDefinitions & {
+    readonly core: typeof KernelCore;
 };
+declare const KernelCore: Readonly<{
+    nodes: Readonly<{
+        use: builder.Node<builder.NodeClass<{
+            readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
+            readonly implements: readonly [builder.Interface<{
+                readonly family: "both";
+                readonly description: "Stable human-facing name metadata that never acts as a locator.";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 100;
+                    };
+                };
+            }>];
+        }>>;
+        create: builder.Node<builder.NodeClass<{
+            readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
+            readonly implements: readonly [builder.Interface<{
+                readonly family: "both";
+                readonly description: "Stable human-facing name metadata that never acts as a locator.";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 100;
+                    };
+                };
+            }>];
+        }>>;
+        read: builder.Node<builder.NodeClass<{
+            readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
+            readonly implements: readonly [builder.Interface<{
+                readonly family: "both";
+                readonly description: "Stable human-facing name metadata that never acts as a locator.";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 100;
+                    };
+                };
+            }>];
+        }>>;
+        traverse: builder.Node<builder.NodeClass<{
+            readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
+            readonly implements: readonly [builder.Interface<{
+                readonly family: "both";
+                readonly description: "Stable human-facing name metadata that never acts as a locator.";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 100;
+                    };
+                };
+            }>];
+        }>>;
+        update: builder.Node<builder.NodeClass<{
+            readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
+            readonly implements: readonly [builder.Interface<{
+                readonly family: "both";
+                readonly description: "Stable human-facing name metadata that never acts as a locator.";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 100;
+                    };
+                };
+            }>];
+        }>>;
+        delete: builder.Node<builder.NodeClass<{
+            readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
+            readonly implements: readonly [builder.Interface<{
+                readonly family: "both";
+                readonly description: "Stable human-facing name metadata that never acts as a locator.";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 100;
+                    };
+                };
+            }>];
+        }>>;
+        grant: builder.Node<builder.NodeClass<{
+            readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
+            readonly implements: readonly [builder.Interface<{
+                readonly family: "both";
+                readonly description: "Stable human-facing name metadata that never acts as a locator.";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 100;
+                    };
+                };
+            }>];
+        }>>;
+        revoke: builder.Node<builder.NodeClass<{
+            readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
+            readonly implements: readonly [builder.Interface<{
+                readonly family: "both";
+                readonly description: "Stable human-facing name metadata that never acts as a locator.";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 100;
+                    };
+                };
+            }>];
+        }>>;
+    }>;
+    edges: readonly builder.Edge<builder.CoreEndpoint, builder.Lazy<builder.EdgeClass>, builder.CoreEndpoint>[];
+}>;
 declare const KernelSchemaInput: KernelSchemaInput;
 export declare const KernelSchema: schema.DomainSchema<'kernel.astrale.ai', KernelSchemaInput>;
 export type KernelSchema = typeof KernelSchema;
 /** The kernel schema as the same immutable rich Domain model exposed for every DomainSchema. */
 export declare const K: DomainValue<KernelSchema>;
 export type Kernel = typeof K;
-export {};
+/** Sole rich Operation-to-relation index; downstream owners never redeclare the closed mapping. */
+export declare const AuthorityRelations: Readonly<{
+    use: import("../../domain/catalog/projection.js").DefinitionOf<builder.EdgeClass, import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, builder.EdgeClass, "can_use", "class">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>>;
+    create: import("../../domain/catalog/projection.js").DefinitionOf<builder.EdgeClass, import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, builder.EdgeClass, "can_create", "class">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>>;
+    read: import("../../domain/catalog/projection.js").DefinitionOf<builder.EdgeClass, import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, builder.EdgeClass, "can_read", "class">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>>;
+    traverse: import("../../domain/catalog/projection.js").DefinitionOf<builder.EdgeClass, import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, builder.EdgeClass, "can_traverse", "class">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>>;
+    update: import("../../domain/catalog/projection.js").DefinitionOf<builder.EdgeClass, import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, builder.EdgeClass, "can_update", "class">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>>;
+    delete: import("../../domain/catalog/projection.js").DefinitionOf<builder.EdgeClass, import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, builder.EdgeClass, "can_delete", "class">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>>;
+    grant: import("../../domain/catalog/projection.js").DefinitionOf<builder.EdgeClass, import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, builder.EdgeClass, "can_grant", "class">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>>;
+    revoke: import("../../domain/catalog/projection.js").DefinitionOf<builder.EdgeClass, import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, builder.EdgeClass, "can_revoke", "class">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>>;
+}>;
+/** Exact authorized Kernel Functions for which pristine Root receives direct can_use authority. */
+export declare const KernelRootFunctions: readonly (import("../../domain/catalog/projection.js").DefinitionOf<builder.Function<{
+    readonly description: "Durably install one or more exact Schema targets and return a terminal receipt.";
+    readonly auth: "authorized";
+    readonly input: import("zod").ZodObject<{
+        operation: import("zod").ZodString;
+        domains: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            source: import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"local">;
+                artifact: import("zod").ZodObject<{
+                    digest: import("zod").ZodString;
+                    mediaType: import("zod").ZodString;
+                    size: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>;
+            currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            source: import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"remote">;
+                url: import("zod").ZodString;
+                token: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+            targetRevision: import("zod").ZodOptional<import("zod").ZodString>;
+            targetEtag: import("zod").ZodOptional<import("zod").ZodString>;
+            currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strict>]>>;
+    }, import("zod/v4/core").$strict>;
+    readonly output: import("zod").ZodObject<{
+        operation: import("zod").ZodString;
+        transitions: import("zod").ZodArray<import("zod").ZodObject<{
+            intent: import("zod").ZodObject<{
+                transition: import("zod").ZodString;
+                operation: import("zod").ZodString;
+                installation: import("zod").ZodString;
+                origin: import("zod").ZodString;
+                source: import("zod").ZodNullable<import("zod").ZodObject<{
+                    origin: import("zod").ZodString;
+                    schemaRevision: import("zod").ZodString;
+                    schemaBundle: import("zod").ZodString;
+                    service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"local">;
+                        artifact: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"remote">;
+                        etag: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>], "kind">;
+                    capabilities: import("zod").ZodObject<{
+                        functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                            class: import("zod").ZodObject<{
+                                origin: import("zod").ZodString;
+                                kind: import("zod").ZodLiteral<"class">;
+                                name: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>;
+                            operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                read: "read";
+                                traverse: "traverse";
+                                update: "update";
+                            }>>;
+                        }, import("zod/v4/core").$strict>>>;
+                        admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                            grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                grant: "grant";
+                                read: "read";
+                                revoke: "revoke";
+                                traverse: "traverse";
+                                update: "update";
+                                use: "use";
+                            }>>>;
+                            revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                grant: "grant";
+                                read: "read";
+                                revoke: "revoke";
+                                traverse: "traverse";
+                                update: "update";
+                                use: "use";
+                            }>>>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>;
+                    dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        installation: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        readinessReceipt: import("zod").ZodString;
+                        meaningComparison: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>>;
+                target: import("zod").ZodNullable<import("zod").ZodObject<{
+                    origin: import("zod").ZodString;
+                    schemaRevision: import("zod").ZodString;
+                    schemaBundle: import("zod").ZodString;
+                    service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"local">;
+                        artifact: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"remote">;
+                        etag: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>], "kind">;
+                    capabilities: import("zod").ZodObject<{
+                        functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                            class: import("zod").ZodObject<{
+                                origin: import("zod").ZodString;
+                                kind: import("zod").ZodLiteral<"class">;
+                                name: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>;
+                            operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                read: "read";
+                                traverse: "traverse";
+                                update: "update";
+                            }>>;
+                        }, import("zod/v4/core").$strict>>>;
+                        admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                            grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                grant: "grant";
+                                read: "read";
+                                revoke: "revoke";
+                                traverse: "traverse";
+                                update: "update";
+                                use: "use";
+                            }>>>;
+                            revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                grant: "grant";
+                                read: "read";
+                                revoke: "revoke";
+                                traverse: "traverse";
+                                update: "update";
+                                use: "use";
+                            }>>>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>;
+                    dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        installation: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        readinessReceipt: import("zod").ZodString;
+                        meaningComparison: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>;
+            phase: import("zod").ZodEnum<{
+                converge: "converge";
+                cutover: "cutover";
+            }>;
+            state: import("zod").ZodLiteral<"committed">;
+            readiness: import("zod").ZodOptional<import("zod").ZodObject<{
+                installation: import("zod").ZodString;
+                target: import("zod").ZodString;
+                transition: import("zod").ZodString;
+                dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                    origin: import("zod").ZodString;
+                    installation: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    readinessReceipt: import("zod").ZodString;
+                    meaningComparison: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>;
+}>, import("#domain").DefinitionIdentity<"function", "install", "kernel.astrale.ai">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> | import("../../domain/catalog/projection.js").DefinitionOf<builder.Function<{
+    readonly description: "Return bounded installed-Publication evidence to an authenticated Kernel session.";
+    readonly auth: "authenticated";
+    readonly input: import("zod").ZodObject<{
+        from: import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"installation">;
+            origin: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        select: import("zod").ZodObject<{
+            state: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+            target: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+            source: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+            bundle: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+            readiness: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+            capabilities: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>;
+    readonly output: builder.BinaryOutput;
+}>, import("#domain").DefinitionIdentity<"function", "introspect", "kernel.astrale.ai">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> | import("../../domain/catalog/projection.js").DefinitionOf<builder.Function<{
+    readonly description: "Read one authorized page of semantic operations from the kernel journal.";
+    readonly auth: "authorized";
+    readonly input: import("zod").ZodObject<{
+        invocation: import("zod").ZodOptional<import("zod").ZodObject<{
+            source: import("zod").ZodString;
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        topics: import("zod").ZodOptional<import("zod").ZodObject<{
+            exact: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            prefixes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strict>>;
+        principal: import("zod").ZodOptional<import("zod").ZodString>;
+        since: import("zod").ZodOptional<import("zod").ZodString>;
+        until: import("zod").ZodOptional<import("zod").ZodString>;
+        cursor: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strict>;
+    readonly output: import("zod").ZodObject<{
+        records: import("zod").ZodArray<import("zod").ZodUnknown>;
+        frontier: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            first: import("zod").ZodOptional<import("zod").ZodNumber>;
+            committed: import("zod").ZodNumber;
+            durable: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>;
+        cursor: import("zod").ZodOptional<import("zod").ZodString>;
+        gap: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>;
+}>, import("#domain").DefinitionIdentity<"function", "journal", "kernel.astrale.ai">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> | import("../../domain/catalog/projection.js").DefinitionOf<builder.Function<{
+    readonly description: "Validate, authorize, and commit one atomic graph mutation.";
+    readonly auth: "authorized";
+    readonly input: import("zod").ZodObject<{
+        format: import("zod").ZodLiteral<"astrale.graph.mutation">;
+        version: import("zod").ZodLiteral<"v3">;
+        preconditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"node">;
+            node: import("zod").ZodString;
+            class: import("zod").ZodString;
+            props: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                equals: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                absent: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                absent: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>]>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"edge">;
+            edge: import("zod").ZodObject<{
+                source: import("zod").ZodString;
+                target: import("zod").ZodString;
+                class: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            slug: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodType<import("../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../graph/edge/index.js").EdgeSlug, unknown>>>>;
+            props: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                equals: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                absent: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                absent: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>]>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"query">;
+            query: import("zod").ZodObject<{
+                format: import("zod").ZodLiteral<"astrale.graph.query">;
+                version: import("zod").ZodLiteral<"v6">;
+                source: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"node">;
+                    terms: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"path">;
+                        path: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"definition">;
+                        definition: import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            kind: import("zod").ZodEnum<{
+                                class: "class";
+                                interface: "interface";
+                            }>;
+                            name: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>;
+                    }, import("zod/v4/core").$strict>], "kind">>;
+                    binding: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"edge">;
+                    terms: import("zod").ZodArray<import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"definition">;
+                        definition: import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            kind: import("zod").ZodEnum<{
+                                class: "class";
+                                interface: "interface";
+                            }>;
+                            name: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>;
+                    }, import("zod/v4/core").$strict>>;
+                    bindings: import("zod").ZodObject<{
+                        source: import("zod").ZodString;
+                        edge: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>], "kind">;
+                steps: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    op: import("zod").ZodLiteral<"filter">;
+                    binding: import("zod").ZodString;
+                    predicate: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"definition.satisfies">;
+                        definition: import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            kind: import("zod").ZodEnum<{
+                                class: "class";
+                                interface: "interface";
+                            }>;
+                            name: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"property.equal">;
+                        property: import("zod").ZodString;
+                        value: import("zod").ZodUnknown;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"property.present">;
+                        property: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"identity.equal">;
+                        identity: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                            source: import("zod").ZodString;
+                            target: import("zod").ZodString;
+                            class: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>]>;
+                    }, import("zod/v4/core").$strict>], "kind">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    op: import("zod").ZodLiteral<"expand">;
+                    from: import("zod").ZodString;
+                    via: import("zod").ZodArray<import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        kind: import("zod").ZodEnum<{
+                            class: "class";
+                            interface: "interface";
+                        }>;
+                        name: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>;
+                    direction: import("zod").ZodEnum<{
+                        incident: "incident";
+                        incoming: "incoming";
+                        outgoing: "outgoing";
+                    }>;
+                    bindings: import("zod").ZodObject<{
+                        edge: import("zod").ZodString;
+                        node: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>], "op">>;
+                select: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"graph">;
+                    binding: import("zod").ZodString;
+                    order: import("zod").ZodOptional<import("zod").ZodObject<{
+                        property: import("zod").ZodString;
+                        direction: import("zod").ZodEnum<{
+                            asc: "asc";
+                            desc: "desc";
+                        }>;
+                        unranked: import("zod").ZodEnum<{
+                            first: "first";
+                            last: "last";
+                        }>;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"nodes">;
+                    binding: import("zod").ZodString;
+                    projection: import("zod").ZodObject<{
+                        kind: import("zod").ZodEnum<{
+                            reference: "reference";
+                            value: "value";
+                        }>;
+                    }, import("zod/v4/core").$strict>;
+                    order: import("zod").ZodOptional<import("zod").ZodObject<{
+                        property: import("zod").ZodString;
+                        direction: import("zod").ZodEnum<{
+                            asc: "asc";
+                            desc: "desc";
+                        }>;
+                        unranked: import("zod").ZodEnum<{
+                            first: "first";
+                            last: "last";
+                        }>;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"edges">;
+                    binding: import("zod").ZodString;
+                    projection: import("zod").ZodObject<{
+                        edge: import("zod").ZodEnum<{
+                            reference: "reference";
+                            value: "value";
+                        }>;
+                        source: import("zod").ZodEnum<{
+                            reference: "reference";
+                            value: "value";
+                        }>;
+                        target: import("zod").ZodEnum<{
+                            reference: "reference";
+                            value: "value";
+                        }>;
+                    }, import("zod/v4/core").$strict>;
+                    order: import("zod").ZodOptional<import("zod").ZodObject<{
+                        property: import("zod").ZodString;
+                        direction: import("zod").ZodEnum<{
+                            asc: "asc";
+                            desc: "desc";
+                        }>;
+                        unranked: import("zod").ZodEnum<{
+                            first: "first";
+                            last: "last";
+                        }>;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>], "kind">;
+            }, import("zod/v4/core").$strict>;
+            equals: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"node">;
+                ids: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"edge">;
+                keys: import("zod").ZodArray<import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>], "kind">;
+        }, import("zod/v4/core").$strict>]>>;
+        operations: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            op: import("zod").ZodLiteral<"node.create">;
+            as: import("zod").ZodString;
+            class: import("zod").ZodString;
+            props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            op: import("zod").ZodLiteral<"node.update">;
+            node: import("zod").ZodString;
+            class: import("zod").ZodString;
+            props: import("zod").ZodObject<{
+                set: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                unset: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            op: import("zod").ZodLiteral<"node.delete">;
+            node: import("zod").ZodString;
+            class: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            op: import("zod").ZodLiteral<"edge.create">;
+            class: import("zod").ZodString;
+            source: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                created: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>]>;
+            target: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                created: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>]>;
+            slug: import("zod").ZodOptional<import("zod").ZodType<import("../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../graph/edge/index.js").EdgeSlug, unknown>>>;
+            props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            op: import("zod").ZodLiteral<"edge.update">;
+            edge: import("zod").ZodObject<{
+                source: import("zod").ZodString;
+                target: import("zod").ZodString;
+                class: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            slug: import("zod").ZodNullable<import("zod").ZodType<import("../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../graph/edge/index.js").EdgeSlug, unknown>>>;
+            props: import("zod").ZodOptional<import("zod").ZodObject<{
+                set: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                unset: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            op: import("zod").ZodLiteral<"edge.update">;
+            edge: import("zod").ZodObject<{
+                source: import("zod").ZodString;
+                target: import("zod").ZodString;
+                class: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            props: import("zod").ZodObject<{
+                set: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                unset: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            op: import("zod").ZodLiteral<"edge.delete">;
+            edge: import("zod").ZodObject<{
+                source: import("zod").ZodString;
+                target: import("zod").ZodString;
+                class: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>]>>;
+    }, import("zod/v4/core").$strict>;
+    readonly output: import("zod").ZodObject<{
+        createdNodes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>;
+}>, import("#domain").DefinitionIdentity<"function", "mutate", "kernel.astrale.ai">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> | import("../../domain/catalog/projection.js").DefinitionOf<builder.Function<{
+    readonly description: "Atomically execute a graph transition whose designated Identities are born complete.";
+    readonly auth: "authorized";
+    readonly input: import("zod").ZodObject<{
+        idempotencyKey: import("zod").ZodString;
+        mutation: import("zod").ZodObject<{
+            format: import("zod").ZodLiteral<"astrale.graph.mutation">;
+            version: import("zod").ZodLiteral<"v3">;
+            preconditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"node">;
+                node: import("zod").ZodString;
+                class: import("zod").ZodString;
+                props: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    equals: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    absent: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    absent: import("zod").ZodArray<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"edge">;
+                edge: import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                slug: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodType<import("../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../graph/edge/index.js").EdgeSlug, unknown>>>>;
+                props: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    equals: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    absent: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    absent: import("zod").ZodArray<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"query">;
+                query: import("zod").ZodObject<{
+                    format: import("zod").ZodLiteral<"astrale.graph.query">;
+                    version: import("zod").ZodLiteral<"v6">;
+                    source: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"node">;
+                        terms: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"path">;
+                            path: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"definition">;
+                            definition: import("zod").ZodObject<{
+                                origin: import("zod").ZodString;
+                                kind: import("zod").ZodEnum<{
+                                    class: "class";
+                                    interface: "interface";
+                                }>;
+                                name: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>;
+                        }, import("zod/v4/core").$strict>], "kind">>;
+                        binding: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"edge">;
+                        terms: import("zod").ZodArray<import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"definition">;
+                            definition: import("zod").ZodObject<{
+                                origin: import("zod").ZodString;
+                                kind: import("zod").ZodEnum<{
+                                    class: "class";
+                                    interface: "interface";
+                                }>;
+                                name: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>;
+                        }, import("zod/v4/core").$strict>>;
+                        bindings: import("zod").ZodObject<{
+                            source: import("zod").ZodString;
+                            edge: import("zod").ZodString;
+                            target: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>;
+                    }, import("zod/v4/core").$strict>], "kind">;
+                    steps: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        op: import("zod").ZodLiteral<"filter">;
+                        binding: import("zod").ZodString;
+                        predicate: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"definition.satisfies">;
+                            definition: import("zod").ZodObject<{
+                                origin: import("zod").ZodString;
+                                kind: import("zod").ZodEnum<{
+                                    class: "class";
+                                    interface: "interface";
+                                }>;
+                                name: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>;
+                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"property.equal">;
+                            property: import("zod").ZodString;
+                            value: import("zod").ZodUnknown;
+                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"property.present">;
+                            property: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"identity.equal">;
+                            identity: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                                source: import("zod").ZodString;
+                                target: import("zod").ZodString;
+                                class: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>]>;
+                        }, import("zod/v4/core").$strict>], "kind">;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        op: import("zod").ZodLiteral<"expand">;
+                        from: import("zod").ZodString;
+                        via: import("zod").ZodArray<import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            kind: import("zod").ZodEnum<{
+                                class: "class";
+                                interface: "interface";
+                            }>;
+                            name: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                        direction: import("zod").ZodEnum<{
+                            incident: "incident";
+                            incoming: "incoming";
+                            outgoing: "outgoing";
+                        }>;
+                        bindings: import("zod").ZodObject<{
+                            edge: import("zod").ZodString;
+                            node: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>;
+                    }, import("zod/v4/core").$strict>], "op">>;
+                    select: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"graph">;
+                        binding: import("zod").ZodString;
+                        order: import("zod").ZodOptional<import("zod").ZodObject<{
+                            property: import("zod").ZodString;
+                            direction: import("zod").ZodEnum<{
+                                asc: "asc";
+                                desc: "desc";
+                            }>;
+                            unranked: import("zod").ZodEnum<{
+                                first: "first";
+                                last: "last";
+                            }>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"nodes">;
+                        binding: import("zod").ZodString;
+                        projection: import("zod").ZodObject<{
+                            kind: import("zod").ZodEnum<{
+                                reference: "reference";
+                                value: "value";
+                            }>;
+                        }, import("zod/v4/core").$strict>;
+                        order: import("zod").ZodOptional<import("zod").ZodObject<{
+                            property: import("zod").ZodString;
+                            direction: import("zod").ZodEnum<{
+                                asc: "asc";
+                                desc: "desc";
+                            }>;
+                            unranked: import("zod").ZodEnum<{
+                                first: "first";
+                                last: "last";
+                            }>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"edges">;
+                        binding: import("zod").ZodString;
+                        projection: import("zod").ZodObject<{
+                            edge: import("zod").ZodEnum<{
+                                reference: "reference";
+                                value: "value";
+                            }>;
+                            source: import("zod").ZodEnum<{
+                                reference: "reference";
+                                value: "value";
+                            }>;
+                            target: import("zod").ZodEnum<{
+                                reference: "reference";
+                                value: "value";
+                            }>;
+                        }, import("zod/v4/core").$strict>;
+                        order: import("zod").ZodOptional<import("zod").ZodObject<{
+                            property: import("zod").ZodString;
+                            direction: import("zod").ZodEnum<{
+                                asc: "asc";
+                                desc: "desc";
+                            }>;
+                            unranked: import("zod").ZodEnum<{
+                                first: "first";
+                                last: "last";
+                            }>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>], "kind">;
+                }, import("zod/v4/core").$strict>;
+                equals: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"node">;
+                    ids: import("zod").ZodArray<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"edge">;
+                    keys: import("zod").ZodArray<import("zod").ZodObject<{
+                        source: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        class: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>], "kind">;
+            }, import("zod/v4/core").$strict>]>>;
+            operations: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"node.create">;
+                as: import("zod").ZodString;
+                class: import("zod").ZodString;
+                props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"node.update">;
+                node: import("zod").ZodString;
+                class: import("zod").ZodString;
+                props: import("zod").ZodObject<{
+                    set: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    unset: import("zod").ZodArray<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"node.delete">;
+                node: import("zod").ZodString;
+                class: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"edge.create">;
+                class: import("zod").ZodString;
+                source: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                    created: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>]>;
+                target: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                    created: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>]>;
+                slug: import("zod").ZodOptional<import("zod").ZodType<import("../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../graph/edge/index.js").EdgeSlug, unknown>>>;
+                props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"edge.update">;
+                edge: import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                slug: import("zod").ZodNullable<import("zod").ZodType<import("../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../graph/edge/index.js").EdgeSlug, unknown>>>;
+                props: import("zod").ZodOptional<import("zod").ZodObject<{
+                    set: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    unset: import("zod").ZodArray<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"edge.update">;
+                edge: import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                props: import("zod").ZodObject<{
+                    set: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    unset: import("zod").ZodArray<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"edge.delete">;
+                edge: import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>]>>;
+        }, import("zod/v4/core").$strict>;
+        identities: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            issuer: import("zod").ZodString;
+            subject: import("zod").ZodString;
+            requiredClaims: import("zod").ZodOptional<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>, import("zod").ZodObject<{
+            credentials: import("zod").ZodObject<{
+                publicKey: import("zod").ZodUnknown;
+                proof: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            requiredClaims: import("zod").ZodOptional<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>]>>;
+    }, import("zod/v4/core").$strict>;
+    readonly output: import("zod").ZodObject<{
+        createdNodes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        identities: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            issuer: import("zod").ZodString;
+            subject: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>;
+}>, import("#domain").DefinitionIdentity<"function", "provision", "kernel.astrale.ai">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> | import("../../domain/catalog/projection.js").DefinitionOf<builder.Function<{
+    readonly description: "Execute one finite authorized graph query.";
+    readonly auth: "authorized";
+    readonly input: import("zod").ZodObject<{
+        ast: import("zod").ZodObject<{
+            format: import("zod").ZodLiteral<"astrale.graph.query">;
+            version: import("zod").ZodLiteral<"v6">;
+            source: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"node">;
+                terms: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"path">;
+                    path: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"definition">;
+                    definition: import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        kind: import("zod").ZodEnum<{
+                            class: "class";
+                            interface: "interface";
+                        }>;
+                        name: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>], "kind">>;
+                binding: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"edge">;
+                terms: import("zod").ZodArray<import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"definition">;
+                    definition: import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        kind: import("zod").ZodEnum<{
+                            class: "class";
+                            interface: "interface";
+                        }>;
+                        name: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>>;
+                bindings: import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    edge: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>], "kind">;
+            steps: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"filter">;
+                binding: import("zod").ZodString;
+                predicate: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"definition.satisfies">;
+                    definition: import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        kind: import("zod").ZodEnum<{
+                            class: "class";
+                            interface: "interface";
+                        }>;
+                        name: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"property.equal">;
+                    property: import("zod").ZodString;
+                    value: import("zod").ZodUnknown;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"property.present">;
+                    property: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"identity.equal">;
+                    identity: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                        source: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        class: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>]>;
+                }, import("zod/v4/core").$strict>], "kind">;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"expand">;
+                from: import("zod").ZodString;
+                via: import("zod").ZodArray<import("zod").ZodObject<{
+                    origin: import("zod").ZodString;
+                    kind: import("zod").ZodEnum<{
+                        class: "class";
+                        interface: "interface";
+                    }>;
+                    name: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>;
+                direction: import("zod").ZodEnum<{
+                    incident: "incident";
+                    incoming: "incoming";
+                    outgoing: "outgoing";
+                }>;
+                bindings: import("zod").ZodObject<{
+                    edge: import("zod").ZodString;
+                    node: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>], "op">>;
+            select: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"graph">;
+                binding: import("zod").ZodString;
+                order: import("zod").ZodOptional<import("zod").ZodObject<{
+                    property: import("zod").ZodString;
+                    direction: import("zod").ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>;
+                    unranked: import("zod").ZodEnum<{
+                        first: "first";
+                        last: "last";
+                    }>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"nodes">;
+                binding: import("zod").ZodString;
+                projection: import("zod").ZodObject<{
+                    kind: import("zod").ZodEnum<{
+                        reference: "reference";
+                        value: "value";
+                    }>;
+                }, import("zod/v4/core").$strict>;
+                order: import("zod").ZodOptional<import("zod").ZodObject<{
+                    property: import("zod").ZodString;
+                    direction: import("zod").ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>;
+                    unranked: import("zod").ZodEnum<{
+                        first: "first";
+                        last: "last";
+                    }>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"edges">;
+                binding: import("zod").ZodString;
+                projection: import("zod").ZodObject<{
+                    edge: import("zod").ZodEnum<{
+                        reference: "reference";
+                        value: "value";
+                    }>;
+                    source: import("zod").ZodEnum<{
+                        reference: "reference";
+                        value: "value";
+                    }>;
+                    target: import("zod").ZodEnum<{
+                        reference: "reference";
+                        value: "value";
+                    }>;
+                }, import("zod/v4/core").$strict>;
+                order: import("zod").ZodOptional<import("zod").ZodObject<{
+                    property: import("zod").ZodString;
+                    direction: import("zod").ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>;
+                    unranked: import("zod").ZodEnum<{
+                        first: "first";
+                        last: "last";
+                    }>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>], "kind">;
+        }, import("zod/v4/core").$strict>;
+        page: import("zod").ZodObject<{
+            size: import("zod").ZodNumber;
+            after: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>;
+    readonly output: import("zod").ZodObject<{
+        result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"graph">;
+            graph: import("zod").ZodObject<{
+                nodes: import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                    props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strict>>;
+                edges: import("zod").ZodArray<import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                    slug: import("zod").ZodOptional<import("zod").ZodType<import("../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../graph/edge/index.js").EdgeSlug, unknown>>>;
+                    props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>;
+            selection: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"node">;
+                ids: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"edge">;
+                keys: import("zod").ZodArray<import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>], "kind">;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"nodes">;
+            nodes: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"reference">;
+                value: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"value">;
+                value: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                    props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>], "kind">>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"edges">;
+            edges: import("zod").ZodArray<import("zod").ZodObject<{
+                edge: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"reference">;
+                    value: import("zod").ZodObject<{
+                        source: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        class: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"value">;
+                    value: import("zod").ZodObject<{
+                        source: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        class: import("zod").ZodString;
+                        slug: import("zod").ZodOptional<import("zod").ZodType<import("../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../graph/edge/index.js").EdgeSlug, unknown>>>;
+                        props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>], "kind">;
+                source: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"reference">;
+                    value: import("zod").ZodObject<{
+                        id: import("zod").ZodString;
+                        class: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"value">;
+                    value: import("zod").ZodObject<{
+                        id: import("zod").ZodString;
+                        class: import("zod").ZodString;
+                        props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>], "kind">;
+                target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"reference">;
+                    value: import("zod").ZodObject<{
+                        id: import("zod").ZodString;
+                        class: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"value">;
+                    value: import("zod").ZodObject<{
+                        id: import("zod").ZodString;
+                        class: import("zod").ZodString;
+                        props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>], "kind">;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>], "kind">;
+        page: import("zod").ZodObject<{
+            next: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>;
+}>, import("#domain").DefinitionIdentity<"function", "query", "kernel.astrale.ai">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> | import("../../domain/catalog/projection.js").DefinitionOf<builder.Function<{
+    readonly description: "Durably uninstall one Domain installation epoch and return its terminal receipt.";
+    readonly auth: "authorized";
+    readonly input: import("zod").ZodObject<{
+        operation: import("zod").ZodString;
+        origin: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>;
+    readonly output: import("zod").ZodObject<{
+        operation: import("zod").ZodString;
+        transition: import("zod").ZodObject<{
+            intent: import("zod").ZodObject<{
+                transition: import("zod").ZodString;
+                operation: import("zod").ZodString;
+                installation: import("zod").ZodString;
+                origin: import("zod").ZodString;
+                source: import("zod").ZodNullable<import("zod").ZodObject<{
+                    origin: import("zod").ZodString;
+                    schemaRevision: import("zod").ZodString;
+                    schemaBundle: import("zod").ZodString;
+                    service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"local">;
+                        artifact: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"remote">;
+                        etag: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>], "kind">;
+                    capabilities: import("zod").ZodObject<{
+                        functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                            class: import("zod").ZodObject<{
+                                origin: import("zod").ZodString;
+                                kind: import("zod").ZodLiteral<"class">;
+                                name: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>;
+                            operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                read: "read";
+                                traverse: "traverse";
+                                update: "update";
+                            }>>;
+                        }, import("zod/v4/core").$strict>>>;
+                        admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                            grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                grant: "grant";
+                                read: "read";
+                                revoke: "revoke";
+                                traverse: "traverse";
+                                update: "update";
+                                use: "use";
+                            }>>>;
+                            revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                grant: "grant";
+                                read: "read";
+                                revoke: "revoke";
+                                traverse: "traverse";
+                                update: "update";
+                                use: "use";
+                            }>>>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>;
+                    dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        installation: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        readinessReceipt: import("zod").ZodString;
+                        meaningComparison: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>>;
+                target: import("zod").ZodNullable<import("zod").ZodObject<{
+                    origin: import("zod").ZodString;
+                    schemaRevision: import("zod").ZodString;
+                    schemaBundle: import("zod").ZodString;
+                    service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"local">;
+                        artifact: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"remote">;
+                        etag: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>], "kind">;
+                    capabilities: import("zod").ZodObject<{
+                        functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                            class: import("zod").ZodObject<{
+                                origin: import("zod").ZodString;
+                                kind: import("zod").ZodLiteral<"class">;
+                                name: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>;
+                            operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                read: "read";
+                                traverse: "traverse";
+                                update: "update";
+                            }>>;
+                        }, import("zod/v4/core").$strict>>>;
+                        admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                            grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                grant: "grant";
+                                read: "read";
+                                revoke: "revoke";
+                                traverse: "traverse";
+                                update: "update";
+                                use: "use";
+                            }>>>;
+                            revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                create: "create";
+                                delete: "delete";
+                                grant: "grant";
+                                read: "read";
+                                revoke: "revoke";
+                                traverse: "traverse";
+                                update: "update";
+                                use: "use";
+                            }>>>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>;
+                    dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        installation: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        readinessReceipt: import("zod").ZodString;
+                        meaningComparison: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>;
+            phase: import("zod").ZodEnum<{
+                converge: "converge";
+                cutover: "cutover";
+            }>;
+            state: import("zod").ZodLiteral<"committed">;
+            readiness: import("zod").ZodOptional<import("zod").ZodObject<{
+                installation: import("zod").ZodString;
+                target: import("zod").ZodString;
+                transition: import("zod").ZodString;
+                dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                    origin: import("zod").ZodString;
+                    installation: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    readinessReceipt: import("zod").ZodString;
+                    meaningComparison: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>;
+}>, import("#domain").DefinitionIdentity<"function", "uninstall", "kernel.astrale.ai">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> | (import("#domain").StaticMethod<import("../../domain/catalog/method/signature/signature.js").MethodSignature<{
+    audience?: string | undefined;
+    ttlSeconds: number;
+    grant?: unknown;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, true, "default", import("../../domain/catalog/projection.js").DefinitionOf<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";
+        }>;
+    }>;
+}>, import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, 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";
+        }>;
+    }>;
+}>, "Identity", "interface">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>>>> & import("../../domain/catalog/source/inference.js").RootDomainSchemaWitness<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> & import("../../domain/catalog/source/inference.js").RemoteCallableSchemaWitness<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> & {
+    readonly ref: "interface.Identity.method.mint";
+    readonly key: "kernel.astrale.ai:interface.Identity.method.mint";
+    readonly name: "mint";
+    readonly owner: import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, 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";
+            }>;
+        }>;
+    }>, "Identity", "interface">;
+    readonly definition: schema.MethodDeclaration;
+}) | (import("#domain").StaticMethod<import("../../domain/catalog/method/signature/signature.js").MethodSignature<{
+    target: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        snapshot: string;
+        views: {
+            key: string;
+            declaration: {
+                description?: string | undefined;
+                target: {
+                    kind: "domain";
+                } | {
+                    kind: "definition";
+                    definitions: ({
+                        origin: string;
+                        kind: "class";
+                        name: string;
+                    } | {
+                        origin: string;
+                        kind: "interface";
+                        name: string;
+                    })[];
+                };
+                auth: "optional" | "public" | "required";
+            };
+            href: string;
+            handshake: "none" | "shell";
+            issuer: string;
+            etag: string;
+            revision: string;
+        }[];
+    };
+}, true, "sealed", import("../../domain/catalog/projection.js").DefinitionOf<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";
+        }>;
+    }>;
+}>, import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, 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";
+        }>;
+    }>;
+}>, "View", "class">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>>>> & import("../../domain/catalog/source/inference.js").RootDomainSchemaWitness<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> & import("../../domain/catalog/source/inference.js").RemoteCallableSchemaWitness<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> & {
+    readonly ref: "class.View.method.resolve";
+    readonly key: "kernel.astrale.ai:class.View.method.resolve";
+    readonly name: "resolve";
+    readonly owner: import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, 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";
+            }>;
+        }>;
+    }>, "View", "class">;
+    readonly definition: schema.MethodDeclaration;
+}) | (import("#domain").StaticMethod<import("../../domain/catalog/method/signature/signature.js").MethodSignature<{
+    issuer: string;
+    subject: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        issuer: string;
+        subject: string;
+        frozen: boolean;
+        requiredClaims: ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[];
+    } | null;
+}, true, "default", import("../../domain/catalog/projection.js").DefinitionOf<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";
+        }>;
+    }>;
+}>, import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, 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";
+        }>;
+    }>;
+}>, "Identity", "interface">, schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>>>> & import("../../domain/catalog/source/inference.js").RootDomainSchemaWitness<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> & import("../../domain/catalog/source/inference.js").RemoteCallableSchemaWitness<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>> & {
+    readonly ref: "interface.Identity.method.whois";
+    readonly key: "kernel.astrale.ai:interface.Identity.method.whois";
+    readonly name: "whois";
+    readonly owner: import("../../domain/catalog/source/inference.js").IdentityFor<schema.DomainSchema<"kernel.astrale.ai", KernelSchemaInput>, 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";
+            }>;
+        }>;
+    }>, "Identity", "interface">;
+    readonly definition: schema.MethodDeclaration;
+}))[];
+export { AuthorityOperationOrder, AuthorityOperations, operationOf } from '../authority/index.js';
+export type { AuthorityOperation, AuthorityRelation } from '../authority/index.js';
 //# sourceMappingURL=schema.d.ts.map