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

package/dist/schema/kernel/syscalls/descriptors/index.d.ts

@@ -1,6 +1,5 @@
-export type { FunctionSyscall, MethodRef, MethodSyscall, Syscall, SyscallRef } from './model.js';
+export type { FunctionSyscall, MethodSyscall, Syscall, SyscallRef } from './model.js';
 export { install, introspect, journal, mutate, provision, query, uninstall } from './functions.js';
 export * as identity from './identity.js';
 export * as function from './function.js';
 export * as view from './view.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/kernel/syscalls/descriptors/index.js

@@ -2,4 +2,3 @@ export { install, introspect, journal, mutate, provision, query, uninstall } fro
 export * as identity from './identity.js';
 export * as function from './function.js';
 export * as view from './view.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/kernel/syscalls/descriptors/model.d.ts

@@ -1,48 +1,25 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
-import type { FunctionRef, MethodRef, SyscallRef } from '../references/index.js';
+import type { ClassRef, FunctionDefinition, FunctionRef as DefinitionFunctionRef, MethodDefinition, MethodAddress, ResolvedClass } from '@astrale-os/kernel-dsl/v1';
+import type { CallableDefinition } from '@astrale-os/kernel-dsl/v1/language';
+import type { FunctionRef, SyscallRef } from '../references/index.js';
 interface FunctionCallable {
-    readonly origin: string;
-    readonly kind: 'function';
-    readonly name: string;
-    readonly definition: schema.FunctionDeclaration;
+    readonly ref: DefinitionFunctionRef;
+    readonly definition: FunctionDefinition;
 }
 interface NodeMethodCallableBase {
     readonly name: string;
-    readonly owner: {
-        readonly origin: string;
-        readonly name: string;
-    };
-    readonly definition: schema.MethodDeclaration;
-}
-interface InterfaceMethodCallable extends NodeMethodCallableBase {
-    readonly owner: NodeMethodCallableBase['owner'] & {
-        readonly kind: 'interface';
-    };
-}
-interface ClassMethodCallable extends NodeMethodCallableBase {
-    readonly owner: NodeMethodCallableBase['owner'] & {
-        readonly kind: 'class';
-    };
+    readonly owner: ResolvedClass<'node'>;
+    readonly definition: MethodDefinition;
 }
-export type { MethodRef, SyscallRef };
+type ClassMethodCallable = NodeMethodCallableBase;
+export type { SyscallRef };
 /** Pure reference to one callable owned by the kernel DomainSchema. */
-export interface Syscall<out Ref extends SyscallRef = SyscallRef, out Declaration extends schema.CallableContract = schema.CallableContract, out Callable = unknown> {
+export interface Syscall<out Ref extends SyscallRef = SyscallRef, out Declaration extends CallableDefinition = CallableDefinition, out Callable = unknown> {
     readonly ref: Ref;
     readonly declaration: Declaration;
     /** Exact rich callable from which handler input, output, and receiver types are inferred. */
     readonly callable: Callable;
 }
-export type FunctionSyscall<Origin extends string = string, Name extends string = string, Callable = unknown> = Syscall<FunctionRef<Origin, Name>, schema.FunctionDeclaration, Callable>;
-export type MethodSyscall<Owner extends schema.DefinitionRef = schema.DefinitionRef, Name extends string = string, Callable = unknown> = Syscall<MethodRef<Owner, Name>, schema.MethodDeclaration, Callable>;
+export type FunctionSyscall<Origin extends string = string, Name extends string = string, Callable = unknown> = Syscall<FunctionRef<Origin, Name>, FunctionDefinition, Callable>;
+export type MethodSyscall<Owner extends ClassRef = ClassRef, Name extends string = string, Callable = unknown> = Syscall<MethodAddress<Owner, Name>, MethodDefinition, Callable>;
 export declare function functionSyscall<const Ref extends FunctionRef, const Callable extends FunctionCallable>(ref: Ref, callable: Callable): FunctionSyscall<Ref['origin'], Ref['name'], Callable>;
-export declare function methodSyscall<const Callable extends InterfaceMethodCallable>(ref: MethodRef<schema.InterfaceRef<Callable['owner']['name']> & {
-    readonly origin: Callable['owner']['origin'];
-}, Callable['name']>, callable: Callable): MethodSyscall<schema.InterfaceRef<Callable['owner']['name']> & {
-    readonly origin: Callable['owner']['origin'];
-}, Callable['name'], Callable>;
-export declare function methodSyscall<const Callable extends ClassMethodCallable>(ref: MethodRef<schema.ClassRef<Callable['owner']['name']> & {
-    readonly origin: Callable['owner']['origin'];
-}, Callable['name']>, callable: Callable): MethodSyscall<schema.ClassRef<Callable['owner']['name']> & {
-    readonly origin: Callable['owner']['origin'];
-}, Callable['name'], Callable>;
-//# sourceMappingURL=model.d.ts.map
+export declare function methodSyscall<const Ref extends MethodAddress, const Callable extends ClassMethodCallable>(ref: Ref, callable: Callable): MethodSyscall<Ref['owner'], Ref['name'], Callable>;

package/dist/schema/kernel/syscalls/descriptors/model.js

@@ -6,10 +6,14 @@ export function functionSyscall(ref, callable) {
     });
 }
 export function methodSyscall(ref, callable) {
+    if (ref.owner.origin !== callable.owner.ref.origin ||
+        ref.owner.name !== callable.owner.ref.name ||
+        ref.name !== callable.name) {
+        throw new TypeError('Kernel Method syscall reference disagrees with its resolved callable.');
+    }
     return Object.freeze({
         ref,
         declaration: callable.definition,
         callable,
     });
 }
-//# sourceMappingURL=model.js.map

package/dist/schema/kernel/syscalls/descriptors/results/view-resolution.d.ts

@@ -1,19 +1,20 @@
+import type { Revision, ViewDefinition } from '@astrale-os/kernel-dsl/v1';
 import type { Key as KeyType } from '@astrale-os/kernel-dsl/v1/addressing';
-import type * as schema from '@astrale-os/kernel-dsl/v1/schema';
 import type { IssuerId } from '../../../../../auth/index.js';
 export interface ResolvedView {
     readonly key: KeyType.View;
-    readonly declaration: schema.ViewDeclaration;
+    readonly declaration: ViewDeclaration;
     readonly href: string;
     readonly handshake: 'shell' | 'none';
     readonly issuer: IssuerId;
     readonly etag: `sha256:${string}`;
-    readonly revision: schema.Revision;
+    readonly revision: Revision;
 }
+type ViewDeclaration = Omit<ViewDefinition, 'ref'>;
 export interface ViewResolution {
     readonly snapshot: `sha256:${string}`;
     readonly views: readonly ResolvedView[];
 }
 /** Admit one detached, deeply immutable result of the Kernel View.resolve syscall. */
 export declare function acceptViewResolution(input: unknown): ViewResolution;
-//# sourceMappingURL=view-resolution.d.ts.map
+export {};

package/dist/schema/kernel/syscalls/descriptors/results/view-resolution.js

@@ -17,7 +17,8 @@ export function acceptViewResolution(input) {
         catch (cause) {
             throw new TypeError(`Resolved View ${index} key is invalid.`, { cause });
         }
-        if (!Key.ref(key).startsWith('view.'))
+        const coordinate = key.slice(key.indexOf(':') + 1);
+        if (!coordinate.startsWith('view.'))
             invalid(`Resolved View ${index} is not a View.`);
         if (!issuer.is(view.issuer))
             invalid(`Resolved View ${index} issuer is not canonical.`);
@@ -51,7 +52,7 @@ function acceptDeclaration(input, viewIndex) {
     }
     const definitions = input.target.definitions.map((definition, definitionIndex) => {
         if (!patterns.origin.test(definition.origin) ||
-            (definition.kind !== 'class' && definition.kind !== 'interface') ||
+            definition.kind !== 'class' ||
             !patterns.memberName.test(definition.name)) {
             invalid(`Resolved View ${viewIndex} target definition ${definitionIndex} is invalid.`);
         }
@@ -90,4 +91,3 @@ function compare(left, right) {
 function invalid(message) {
     throw new TypeError(message);
 }
-//# sourceMappingURL=view-resolution.js.map

package/dist/schema/kernel/syscalls/descriptors/view.d.ts

@@ -1,11 +1,38 @@
-import { K } from '../../index.js';
-import { type MethodSyscall } from './model.js';
 import { acceptViewResolution, type ResolvedView, type ViewResolution } from './results/view-resolution.js';
-export declare const resolve: MethodSyscall<{
-    readonly origin: 'kernel.astrale.ai';
-    readonly kind: 'class';
-    readonly name: 'View';
-}, 'resolve', typeof K.View.resolve>;
+export declare const resolve: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'View';
+}>, "resolve", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    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;
+                    }[];
+                };
+            };
+            href: string;
+            handshake: "none" | "shell";
+            issuer: string;
+            etag: string;
+            revision: string;
+        }[];
+    };
+}, true, "sealed", "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.View.method.resolve"> & {
+    readonly name: "resolve";
+}>;
 export type { ResolvedView, ViewResolution as Resolution };
 export declare const acceptResolution: typeof acceptViewResolution;
-//# sourceMappingURL=view.d.ts.map

package/dist/schema/kernel/syscalls/descriptors/view.js

@@ -2,6 +2,5 @@ import { K } from '../../index.js';
 import { resolve as resolveRef } from '../references/view.js';
 import { methodSyscall } from './model.js';
 import { acceptViewResolution, } from './results/view-resolution.js';
-export const resolve = methodSyscall(resolveRef, K.View.resolve);
+export const resolve = methodSyscall(resolveRef, K.classes.View.static.methods.resolve);
 export const acceptResolution = acceptViewResolution;
-//# sourceMappingURL=view.js.map

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

@@ -1,5 +1,4 @@
-export type { FunctionSyscall, MethodRef, MethodSyscall, Syscall, SyscallRef, } from './descriptors/index.js';
+export type { FunctionSyscall, MethodSyscall, Syscall, SyscallRef } from './descriptors/index.js';
 export * as references from './references/index.js';
 export { install, introspect, journal, mutate, provision, query, uninstall, } from './descriptors/index.js';
 export { function, identity, view } from './descriptors/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/kernel/syscalls/index.js

@@ -1,4 +1,3 @@
 export * as references from './references/index.js';
 export { install, introspect, journal, mutate, provision, query, uninstall, } from './descriptors/index.js';
 export { function, identity, view } from './descriptors/index.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/kernel/syscalls/references/function.d.ts

@@ -1,4 +1,5 @@
 export declare const admit: Readonly<{
+    kind: 'method';
     owner: Readonly<{
         origin: 'kernel.astrale.ai';
         kind: 'class';
@@ -6,4 +7,3 @@ export declare const admit: Readonly<{
     }>;
     name: 'admit';
 }>;
-//# sourceMappingURL=function.d.ts.map

package/dist/schema/kernel/syscalls/references/function.js

@@ -3,5 +3,8 @@ const owner = Object.freeze({
     kind: 'class',
     name: 'Function',
 });
-export const admit = Object.freeze({ owner, name: 'admit' });
-//# sourceMappingURL=function.js.map
+export const admit = Object.freeze({
+    kind: 'method',
+    owner,
+    name: 'admit',
+});

package/dist/schema/kernel/syscalls/references/functions.d.ts

@@ -33,4 +33,3 @@ export declare const journal: Readonly<{
     kind: 'function';
     name: "journal";
 }>;
-//# sourceMappingURL=functions.d.ts.map

package/dist/schema/kernel/syscalls/references/functions.js

@@ -10,4 +10,3 @@ export const install = functionRef('install');
 export const introspect = functionRef('introspect');
 export const uninstall = functionRef('uninstall');
 export const journal = functionRef('journal');
-//# sourceMappingURL=functions.js.map

package/dist/schema/kernel/syscalls/references/identity.d.ts

@@ -1,41 +1,45 @@
 export declare const delegate: Readonly<{
+    kind: 'method';
     owner: Readonly<{
         origin: 'kernel.astrale.ai';
-        kind: 'interface';
+        kind: 'class';
         name: 'Identity';
     }>;
     name: "delegate";
 }>;
 export declare const can: Readonly<{
+    kind: 'method';
     owner: Readonly<{
         origin: 'kernel.astrale.ai';
-        kind: 'interface';
+        kind: 'class';
         name: 'Identity';
     }>;
     name: "can";
 }>;
 export declare const whoami: Readonly<{
+    kind: 'method';
     owner: Readonly<{
         origin: 'kernel.astrale.ai';
-        kind: 'interface';
+        kind: 'class';
         name: 'Identity';
     }>;
     name: "whoami";
 }>;
 export declare const whois: Readonly<{
+    kind: 'method';
     owner: Readonly<{
         origin: 'kernel.astrale.ai';
-        kind: 'interface';
+        kind: 'class';
         name: 'Identity';
     }>;
     name: "whois";
 }>;
 export declare const mint: Readonly<{
+    kind: 'method';
     owner: Readonly<{
         origin: 'kernel.astrale.ai';
-        kind: 'interface';
+        kind: 'class';
         name: 'Identity';
     }>;
     name: "mint";
 }>;
-//# sourceMappingURL=identity.d.ts.map

package/dist/schema/kernel/syscalls/references/identity.js

@@ -1,12 +1,11 @@
 const owner = Object.freeze({
     origin: 'kernel.astrale.ai',
-    kind: 'interface',
+    kind: 'class',
     name: 'Identity',
 });
-const methodRef = (name) => Object.freeze({ owner, name });
+const methodRef = (name) => Object.freeze({ kind: 'method', owner, name });
 export const delegate = methodRef('delegate');
 export const can = methodRef('can');
 export const whoami = methodRef('whoami');
 export const whois = methodRef('whois');
 export const mint = methodRef('mint');
-//# sourceMappingURL=identity.js.map

package/dist/schema/kernel/syscalls/references/index.d.ts

@@ -1,6 +1,5 @@
-export type { FunctionRef, MethodRef, SyscallRef } from './reference.js';
+export type { FunctionRef, SyscallRef } from './reference.js';
 export { install, introspect, journal, mutate, provision, query, uninstall } from './functions.js';
 export * as identity from './identity.js';
 export * as function from './function.js';
 export * as view from './view.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/kernel/syscalls/references/index.js

@@ -2,4 +2,3 @@ export { install, introspect, journal, mutate, provision, query, uninstall } fro
 export * as identity from './identity.js';
 export * as function from './function.js';
 export * as view from './view.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/kernel/syscalls/references/reference.d.ts

@@ -1,10 +1,5 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
-export type FunctionRef<Origin extends string = string, Name extends string = string> = schema.FunctionRef<Name> & {
+import type { FunctionRef as DefinitionFunctionRef, MethodAddress } from '@astrale-os/kernel-dsl/v1';
+export type FunctionRef<Origin extends string = string, Name extends string = string> = DefinitionFunctionRef<Name> & {
     readonly origin: Origin;
 };
-export interface MethodRef<out Owner extends schema.DefinitionRef = schema.DefinitionRef, out Name extends string = string> {
-    readonly owner: Owner;
-    readonly name: Name;
-}
-export type SyscallRef = FunctionRef | MethodRef;
-//# sourceMappingURL=reference.d.ts.map
+export type SyscallRef = FunctionRef | MethodAddress;

package/dist/schema/kernel/syscalls/references/reference.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=reference.js.map

package/dist/schema/kernel/syscalls/references/view.d.ts

@@ -1,4 +1,5 @@
 export declare const resolve: Readonly<{
+    kind: 'method';
     owner: Readonly<{
         origin: 'kernel.astrale.ai';
         kind: 'class';
@@ -6,4 +7,3 @@ export declare const resolve: Readonly<{
     }>;
     name: 'resolve';
 }>;
-//# sourceMappingURL=view.d.ts.map

package/dist/schema/kernel/syscalls/references/view.js

@@ -4,7 +4,7 @@ const owner = Object.freeze({
     name: 'View',
 });
 export const resolve = Object.freeze({
+    kind: 'method',
     owner,
     name: 'resolve',
 });
-//# sourceMappingURL=view.js.map

package/dist/schema/meta/descriptable.d.ts

@@ -1,6 +1,10 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Descriptable: builder.Interface<{
-    readonly family: "both";
+export declare const Descriptable: 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<{
@@ -12,4 +16,3 @@ export declare const Descriptable: builder.Interface<{
         }>;
     };
 }>;
-//# sourceMappingURL=descriptable.d.ts.map

package/dist/schema/meta/descriptable.js

@@ -1,9 +1,10 @@
-import { defineInterface, property, schema } from '@astrale-os/kernel-dsl/v1';
-export const Descriptable = defineInterface({
-    family: 'both',
+import { metadata, nodeClass, property } from '@astrale-os/kernel-dsl/v1';
+import { Node } from './node.js';
+export const Descriptable = nodeClass({
+    abstract: true,
+    extends: [Node],
     description: 'Optional human-facing description metadata with no identity or authority semantics.',
     properties: {
-        description: property(schema.metadata.description, { required: false }),
+        description: property(metadata.description, { required: false }),
     },
 });
-//# sourceMappingURL=descriptable.js.map

package/dist/schema/meta/edge.d.ts

@@ -1,6 +1,21 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Edge: builder.Interface<{
-    readonly family: "both";
+export declare const Edge: 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.";
 }>;
-//# sourceMappingURL=edge.d.ts.map

package/dist/schema/meta/edge.js

@@ -1,6 +1,8 @@
-import { defineInterface } from '@astrale-os/kernel-dsl/v1';
-export const Edge = defineInterface({
-    family: 'both',
+import { edgeClass } from '@astrale-os/kernel-dsl/v1';
+import { Node } from './node.js';
+export const Edge = edgeClass.directed({
+    abstract: true,
+    source: { as: 'source', accepts: [Node], outgoing: '0..*' },
+    target: { as: 'target', accepts: [Node], incoming: '0..*' },
     description: 'Explicit kernel marker for Edge definitions; it carries no structural fields.',
 });
-//# sourceMappingURL=edge.js.map

package/dist/schema/meta/iconable.d.ts

@@ -1,6 +1,10 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Iconable: builder.Interface<{
-    readonly family: "both";
+export declare const Iconable: 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<{
@@ -12,4 +16,3 @@ export declare const Iconable: builder.Interface<{
         }>;
     };
 }>;
-//# sourceMappingURL=iconable.d.ts.map

package/dist/schema/meta/iconable.js

@@ -1,9 +1,10 @@
-import { defineInterface, property, schema } from '@astrale-os/kernel-dsl/v1';
-export const Iconable = defineInterface({
-    family: 'both',
+import { metadata, nodeClass, property } from '@astrale-os/kernel-dsl/v1';
+import { Node } from './node.js';
+export const Iconable = nodeClass({
+    abstract: true,
+    extends: [Node],
     description: 'Optional bounded presentation icon metadata.',
     properties: {
-        icon: property(schema.metadata.icon, { required: false }),
+        icon: property(metadata.icon, { required: false }),
     },
 });
-//# sourceMappingURL=iconable.js.map

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

@@ -6,4 +6,3 @@ export { Node } from './node.js';
 export { Remotable } from './remotable.js';
 export { Statused } from './statused.js';
 export { Timestamped } from './timestamped.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/meta/index.js

@@ -6,4 +6,3 @@ export { Node } from './node.js';
 export { Remotable } from './remotable.js';
 export { Statused } from './statused.js';
 export { Timestamped } from './timestamped.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/meta/named.d.ts

@@ -1,6 +1,10 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Named: builder.Interface<{
-    readonly family: "both";
+export declare const Named: 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: "Stable human-facing name metadata that never acts as a locator.";
     readonly properties: {
         readonly name: {
@@ -10,4 +14,3 @@ export declare const Named: builder.Interface<{
         };
     };
 }>;
-//# sourceMappingURL=named.d.ts.map

package/dist/schema/meta/named.js

@@ -1,9 +1,10 @@
-import { defineInterface } from '@astrale-os/kernel-dsl/v1';
-export const Named = defineInterface({
-    family: 'both',
+import { nodeClass } from '@astrale-os/kernel-dsl/v1';
+import { Node } from './node.js';
+export const Named = nodeClass({
+    abstract: true,
+    extends: [Node],
     description: 'Stable human-facing name metadata that never acts as a locator.',
     properties: {
         name: { type: 'string', minLength: 1, maxLength: 100 },
     },
 });
-//# sourceMappingURL=named.js.map

package/dist/schema/meta/node.d.ts

@@ -1,5 +1,5 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Node: builder.NodeInterface<{
-    readonly description: "The universal kernel node contract implicitly satisfied by every Node Interface and Node Class.";
+export declare const Node: builder.NodeClass<{
+    readonly abstract: true;
+    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
 }>;
-//# sourceMappingURL=node.d.ts.map

package/dist/schema/meta/node.js

@@ -1,5 +1,5 @@
-import { nodeInterface } from '@astrale-os/kernel-dsl/v1';
-export const Node = nodeInterface({
-    description: 'The universal kernel node contract implicitly satisfied by every Node Interface and Node Class.',
+import { nodeClass } from '@astrale-os/kernel-dsl/v1';
+export const Node = nodeClass({
+    abstract: true,
+    description: 'The abstract universal kernel Node Class extended by every Kernel Node Class.',
 });
-//# sourceMappingURL=node.js.map

package/dist/schema/meta/remotable.d.ts

@@ -1,6 +1,10 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Remotable: builder.Interface<{
-    readonly family: "both";
+export declare const Remotable: 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 synchronization metadata for a value originating outside the local kernel.";
     readonly properties: {
         externalId: builder.Property<{
@@ -23,4 +27,3 @@ export declare const Remotable: builder.Interface<{
         }>;
     };
 }>;
-//# sourceMappingURL=remotable.d.ts.map

package/dist/schema/meta/remotable.js

@@ -1,6 +1,8 @@
-import { defineInterface, property, schema } from '@astrale-os/kernel-dsl/v1';
-export const Remotable = defineInterface({
-    family: 'both',
+import { nodeClass, property, schema } from '@astrale-os/kernel-dsl/v1';
+import { Node } from './node.js';
+export const Remotable = nodeClass({
+    abstract: true,
+    extends: [Node],
     description: 'Optional synchronization metadata for a value originating outside the local kernel.',
     properties: {
         externalId: property({ type: 'string', minLength: 1, maxLength: 512 }, { required: false }),
@@ -8,4 +10,3 @@ export const Remotable = defineInterface({
         updatedAt: property(schema.values.instant, { required: false }),
     },
 });
-//# sourceMappingURL=remotable.js.map

package/dist/schema/meta/statused.d.ts

@@ -1,6 +1,10 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Statused: builder.Interface<{
-    readonly family: "both";
+export declare const Statused: 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: "Explicit lifecycle-state metadata for values whose contract declares such a state.";
     readonly properties: {
         readonly status: {
@@ -8,4 +12,3 @@ export declare const Statused: builder.Interface<{
         };
     };
 }>;
-//# sourceMappingURL=statused.d.ts.map

package/dist/schema/meta/statused.js

@@ -1,9 +1,10 @@
-import { defineInterface } from '@astrale-os/kernel-dsl/v1';
-export const Statused = defineInterface({
-    family: 'both',
+import { nodeClass } from '@astrale-os/kernel-dsl/v1';
+import { Node } from './node.js';
+export const Statused = nodeClass({
+    abstract: true,
+    extends: [Node],
     description: 'Explicit lifecycle-state metadata for values whose contract declares such a state.',
     properties: {
         status: { enum: ['active', 'creating', 'deleting', 'error', 'updating'] },
     },
 });
-//# sourceMappingURL=statused.js.map