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

package/dist/schema/callables/method-of.js

@@ -1,15 +1,15 @@
 import { edgeClass, property } from '@astrale-os/kernel-dsl/v1';
-import { Class, Interface } from '../definitions/index.js';
+import { Class } from '../definitions/index.js';
 import { Edge } from '../meta/index.js';
 import { Function } from './function.js';
 export const MethodOf = edgeClass.directed({
+    abstract: false,
     source: { as: 'method', accepts: [Function], outgoing: '0..1' },
-    target: { as: 'owner', accepts: [Class, Interface], incoming: '0..*' },
-    description: 'A Function declaration belongs to one Class or Interface for dispatch.',
-    implements: [Edge],
+    target: { as: 'owner', accepts: [Class], incoming: '0..*' },
+    description: 'A Function declaration belongs to one Class for dispatch.',
+    extends: [Edge],
     properties: {
         name: property({ type: 'string', minLength: 1 }, { visibility: 'private' }),
         static: property({ type: 'boolean' }, { visibility: 'private' }),
     },
 });
-//# sourceMappingURL=method-of.js.map

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,28 @@ 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.js

@@ -1,12 +1,12 @@
 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.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;
@@ -60,4 +58,3 @@ export declare const View: builder.NodeClass<{
         }>;
     }>;
 }>;
-//# sourceMappingURL=view.d.ts.map

package/dist/schema/callables/view.js

@@ -1,9 +1,9 @@
 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/core/index.d.ts

@@ -1,2 +1 @@
 export { OperationCore } from './operations/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/core/index.js

@@ -1,2 +1 @@
 export { OperationCore } from './operations/index.js';
-//# sourceMappingURL=index.js.map

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

@@ -2,6 +2,5 @@ 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.js

@@ -3,4 +3,3 @@ export const OperationCore = Object.freeze({
     nodes: AuthorityOperations,
     edges: Object.freeze([]),
 });
-//# sourceMappingURL=index.js.map