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

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

@@ -1,12 +1,17 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const ViewFor: builder.DirectedEdgeClass<{
-    readonly as: "view";
-    readonly accepts: readonly [builder.NodeClass<{
-        readonly description: "The installed projection of a declarative browser surface; it is not a principal.";
-        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 abstract: false;
+    readonly source: {
+        readonly as: "view";
+        readonly accepts: readonly [builder.NodeClass<{
+            readonly abstract: false;
+            readonly description: "The installed projection of a declarative browser surface; it is not a principal.";
+            readonly extends: readonly [builder.NodeClass<{
+                readonly abstract: true;
+                readonly extends: readonly [builder.NodeClass<{
+                    readonly abstract: true;
+                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
+                }>];
                 readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
                 readonly properties: {
                     description: builder.Property<Readonly<{
@@ -18,283 +23,8 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
                     }>;
                 };
             }>];
-        }>];
-        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">;
-                        }, 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 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..*";
-}, 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 methods: Readonly<{
-                resolve: builder.Function<{
+                resolve: builder.Method<{
                     readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
                     readonly auth: "authorized";
                     readonly input: import("zod").ZodObject<{
@@ -310,15 +40,11 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
                                     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<{
+                                    definitions: import("zod").ZodArray<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>>;
                                 }, import("zod/v4/core").$strict>], "kind">;
                             }, import("zod/v4/core").$strict>;
                             href: import("zod").ZodString;
@@ -341,9 +67,14 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
     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 abstract: false;
+            readonly description: "The installed graph projection of a Node Class or Edge Class declaration.";
+            readonly extends: readonly [builder.NodeClass<{
+                readonly abstract: true;
+                readonly extends: readonly [builder.NodeClass<{
+                    readonly abstract: true;
+                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
+                }>];
                 readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
                 readonly properties: {
                     description: builder.Property<Readonly<{
@@ -354,8 +85,12 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
                         readonly required: false;
                     }>;
                 };
-            }>, builder.Interface<{
-                readonly family: "both";
+            }>, builder.NodeClass<{
+                readonly abstract: true;
+                readonly extends: readonly [builder.NodeClass<{
+                    readonly abstract: true;
+                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
+                }>];
                 readonly description: "Optional bounded presentation icon metadata.";
                 readonly properties: {
                     icon: builder.Property<Readonly<{
@@ -368,14 +103,23 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
                 };
             }>];
             readonly properties: {
-                readonly family: {
+                readonly kind: {
                     readonly enum: readonly ["node", "edge"];
                 };
+                readonly abstract: {
+                    readonly type: "boolean";
+                };
             };
         }>, builder.NodeClass<{
+            readonly abstract: false;
             readonly description: "A stable Domain principal and the active projection of one canonical DomainSchema revision.";
-            readonly implements: readonly [builder.NodeInterface<{
+            readonly extends: readonly [builder.NodeClass<{
+                readonly abstract: true;
                 readonly description: "A principal that can be authenticated and can originate persistent authority facts.";
+                readonly extends: readonly [builder.NodeClass<{
+                    readonly abstract: true;
+                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
+                }>];
                 readonly properties: {
                     readonly frozen: builder.Property<{
                         readonly type: "boolean";
@@ -408,7 +152,7 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
                     };
                 };
                 readonly methods: Readonly<{
-                    delegate: builder.Function<{
+                    delegate: builder.Method<{
                         readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
                         readonly auth: "authenticated";
                         readonly input: import("zod").ZodObject<{
@@ -419,7 +163,7 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
                         readonly output: import("zod").ZodString;
                         readonly inheritance: "default";
                     }>;
-                    can: builder.Function<{
+                    can: builder.Method<{
                         readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
                         readonly auth: "authenticated";
                         readonly input: import("zod").ZodObject<{
@@ -432,7 +176,7 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
                         readonly static: true;
                         readonly inheritance: "default";
                     }>;
-                    whoami: builder.Function<{
+                    whoami: builder.Method<{
                         readonly description: "Return the Identity authenticated for this invocation.";
                         readonly auth: "authenticated";
                         readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
@@ -457,7 +201,7 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
                         readonly static: true;
                         readonly inheritance: "default";
                     }>;
-                    whois: builder.Function<{
+                    whois: builder.Method<{
                         readonly description: "Resolve one issuer-and-subject Identity.";
                         readonly auth: "authorized";
                         readonly input: import("zod").ZodObject<{
@@ -485,7 +229,7 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
                         readonly static: true;
                         readonly inheritance: "default";
                     }>;
-                    mint: builder.Function<{
+                    mint: builder.Method<{
                         readonly description: "Resolve and sign one authorized Grant credential.";
                         readonly auth: "authorized";
                         readonly input: import("zod").ZodObject<{
@@ -525,33 +269,29 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
                     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: "A View declaration targets one Domain or a non-empty set of Classes.";
+    readonly extends: readonly [builder.DirectedEdgeClass<{
+        readonly abstract: true;
+        readonly source: {
+            readonly as: "source";
+            readonly accepts: readonly [builder.NodeClass<{
+                readonly abstract: true;
+                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
+            }>];
+            readonly outgoing: "0..*";
+        };
+        readonly target: {
+            readonly as: "target";
+            readonly accepts: readonly [builder.NodeClass<{
+                readonly abstract: true;
+                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
+            }>];
+            readonly incoming: "0..*";
+        };
         readonly description: "Explicit kernel marker for Edge definitions; it carries no structural fields.";
     }>];
-}, "source" | "target">>;
+}>;
 //# sourceMappingURL=view-for.d.ts.map

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

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

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

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

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

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

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

@@ -1,24 +1,26 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const View: builder.NodeClass<{
+    readonly abstract: false;
     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 extends: readonly [builder.NodeClass<{
+        readonly abstract: true;
+        readonly extends: readonly [builder.NodeClass<{
+            readonly abstract: true;
+            readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
         }>];
+        readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
+        readonly properties: {
+            description: builder.Property<Readonly<{
+                readonly type: 'string';
+                readonly minLength: 1;
+                readonly maxLength: 1000;
+            }>, {
+                readonly required: false;
+            }>;
+        };
     }>];
     readonly methods: Readonly<{
-        resolve: builder.Function<{
+        resolve: builder.Method<{
             readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
             readonly auth: "authorized";
             readonly input: import("zod").ZodObject<{
@@ -34,15 +36,11 @@ export declare const View: builder.NodeClass<{
                             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<{
+                            definitions: import("zod").ZodArray<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>>;
                         }, import("zod/v4/core").$strict>], "kind">;
                     }, import("zod/v4/core").$strict>;
                     href: import("zod").ZodString;

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

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

package/dist/schema/callables/view.js

@@ -1,9 +1,10 @@
 import { nodeClass } from '@astrale-os/kernel-dsl/v1';
 import { ViewMethods } from '../kernel/syscalls/declarations/index.js';
-import { UI } from './ui.js';
+import { Descriptable } from '../meta/index.js';
 export const View = nodeClass({
+    abstract: false,
     description: 'The installed projection of a declarative browser surface; it is not a principal.',
-    implements: [UI],
+    extends: [Descriptable],
     methods: ViewMethods,
 });
 //# sourceMappingURL=view.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../schema/callables/view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgB,MAAM,2BAA2B,CAAA;AAEnE,OAAO,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAA;AACtE,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAE5B,MAAM,CAAC,MAAM,IAAI,GAAG,SAAS,CAAC;IAC5B,WAAW,EAAE,mFAAmF;IAChG,UAAU,EAAE,CAAC,EAAE,CAAC;IAChB,OAAO,EAAE,WAAW;CACrB,CAA6B,CAAA"}
+{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../schema/callables/view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgB,MAAM,2BAA2B,CAAA;AAEnE,OAAO,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAA;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE/C,MAAM,CAAC,MAAM,IAAI,GAAG,SAAS,CAAC;IAC5B,QAAQ,EAAE,KAAK;IACf,WAAW,EAAE,mFAAmF;IAChG,OAAO,EAAE,CAAC,YAAY,CAAC;IACvB,OAAO,EAAE,WAAW;CACrB,CAA6B,CAAA"}

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

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

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

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