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

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

@@ -15,25 +15,26 @@ export declare const resolve: import("./model.js").MethodSyscall<Readonly<{
                 description?: string | undefined;
                 target: {
                     kind: "domain";
-                } | {
-                    kind: "definition";
-                    definitions: {
-                        origin: string;
-                        kind: "class";
-                        name: string;
-                    }[];
                 };
             };
             href: string;
             handshake: "none" | "shell";
+            host?: {
+                navigation: {
+                    external: {
+                        origins: string[];
+                    };
+                };
+            } | undefined;
             issuer: string;
-            etag: string;
+            release: 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"> & {
+}, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.View.method.resolve"> & {
     readonly name: "resolve";
+    readonly executable: true;
+    readonly execution: undefined;
 }>;
 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

@@ -4,4 +4,3 @@ import { methodSyscall } from './model.js';
 import { acceptViewResolution, } from './results/view-resolution.js';
 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, 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
+export { download, install, introspect, journal, mutate, register, query, uninstall, upload, } from './descriptors/index.js';
+export { execution, function, identity, view } from './descriptors/index.js';

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
+export { download, install, introspect, journal, mutate, register, query, uninstall, upload, } from './descriptors/index.js';
+export { execution, function, identity, view } from './descriptors/index.js';

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

@@ -0,0 +1,55 @@
+export declare const status: Readonly<{
+    kind: 'method';
+    owner: Readonly<{
+        origin: 'kernel.astrale.ai';
+        kind: 'class';
+        name: 'Execution';
+    }>;
+    name: "status";
+}>;
+export declare const result: Readonly<{
+    kind: 'method';
+    owner: Readonly<{
+        origin: 'kernel.astrale.ai';
+        kind: 'class';
+        name: 'Execution';
+    }>;
+    name: "result";
+}>;
+export declare const cancel: Readonly<{
+    kind: 'method';
+    owner: Readonly<{
+        origin: 'kernel.astrale.ai';
+        kind: 'class';
+        name: 'Execution';
+    }>;
+    name: "cancel";
+}>;
+export declare const signal: Readonly<{
+    kind: 'method';
+    owner: Readonly<{
+        origin: 'kernel.astrale.ai';
+        kind: 'class';
+        name: 'Execution';
+    }>;
+    name: "signal";
+}>;
+export declare const resume: Readonly<{
+    kind: 'method';
+    owner: Readonly<{
+        origin: 'kernel.astrale.ai';
+        kind: 'class';
+        name: 'Execution';
+    }>;
+    name: "resume";
+}>;
+declare const remove: Readonly<{
+    kind: 'method';
+    owner: Readonly<{
+        origin: 'kernel.astrale.ai';
+        kind: 'class';
+        name: 'Execution';
+    }>;
+    name: "delete";
+}>;
+export { remove as delete };

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

@@ -0,0 +1,13 @@
+const owner = Object.freeze({
+    origin: 'kernel.astrale.ai',
+    kind: 'class',
+    name: 'Execution',
+});
+const methodRef = (name) => Object.freeze({ kind: 'method', owner, name });
+export const status = methodRef('status');
+export const result = methodRef('result');
+export const cancel = methodRef('cancel');
+export const signal = methodRef('signal');
+export const resume = methodRef('resume');
+const remove = methodRef('delete');
+export { remove as delete };

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

@@ -7,4 +7,3 @@ export declare const admit: Readonly<{
     }>;
     name: 'admit';
 }>;
-//# sourceMappingURL=function.d.ts.map

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

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

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

@@ -8,10 +8,10 @@ export declare const mutate: Readonly<{
     kind: 'function';
     name: "mutate";
 }>;
-export declare const provision: Readonly<{
+export declare const register: Readonly<{
     origin: 'kernel.astrale.ai';
     kind: 'function';
-    name: "provision";
+    name: "register";
 }>;
 export declare const install: Readonly<{
     origin: 'kernel.astrale.ai';
@@ -33,4 +33,13 @@ export declare const journal: Readonly<{
     kind: 'function';
     name: "journal";
 }>;
-//# sourceMappingURL=functions.d.ts.map
+export declare const upload: Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'function';
+    name: "upload";
+}>;
+export declare const download: Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'function';
+    name: "download";
+}>;

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

@@ -5,9 +5,10 @@ const functionRef = (name) => Object.freeze({
 });
 export const query = functionRef('query');
 export const mutate = functionRef('mutate');
-export const provision = functionRef('provision');
+export const register = functionRef('register');
 export const install = functionRef('install');
 export const introspect = functionRef('introspect');
 export const uninstall = functionRef('uninstall');
 export const journal = functionRef('journal');
-//# sourceMappingURL=functions.js.map
+export const upload = functionRef('upload');
+export const download = functionRef('download');

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

@@ -43,4 +43,12 @@ export declare const mint: Readonly<{
     }>;
     name: "mint";
 }>;
-//# sourceMappingURL=identity.d.ts.map
+export declare const impersonate: Readonly<{
+    kind: 'method';
+    owner: Readonly<{
+        origin: 'kernel.astrale.ai';
+        kind: 'class';
+        name: 'Identity';
+    }>;
+    name: "impersonate";
+}>;

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

@@ -9,4 +9,4 @@ export const can = methodRef('can');
 export const whoami = methodRef('whoami');
 export const whois = methodRef('whois');
 export const mint = methodRef('mint');
-//# sourceMappingURL=identity.js.map
+export const impersonate = methodRef('impersonate');

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

@@ -1,6 +1,6 @@
 export type { FunctionRef, SyscallRef } from './reference.js';
-export { install, introspect, journal, mutate, provision, query, uninstall } from './functions.js';
+export { download, install, introspect, journal, mutate, register, query, uninstall, upload, } from './functions.js';
+export * as execution from './execution.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

@@ -1,5 +1,5 @@
-export { install, introspect, journal, mutate, provision, query, uninstall } from './functions.js';
+export { download, install, introspect, journal, mutate, register, query, uninstall, upload, } from './functions.js';
+export * as execution from './execution.js';
 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

@@ -3,4 +3,3 @@ export type FunctionRef<Origin extends string = string, Name extends string = st
     readonly origin: Origin;
 };
 export type SyscallRef = FunctionRef | MethodAddress;
-//# sourceMappingURL=reference.d.ts.map

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

@@ -7,4 +7,3 @@ export declare const resolve: Readonly<{
     }>;
     name: 'resolve';
 }>;
-//# sourceMappingURL=view.d.ts.map

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

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

package/dist/schema/meta/created-by.d.ts

@@ -0,0 +1,32 @@
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const CreatedBy: builder.DirectedEdgeClass<{
+    readonly depth: 1;
+    readonly abstract: false;
+    readonly extends: readonly [builder.ClassReferenceProjection<"edge", {
+        readonly abstract: true;
+        readonly depth: 0;
+        readonly properties: never;
+        readonly source: {
+            readonly as: "source";
+            readonly outgoing: "0..*";
+        };
+        readonly target: {
+            readonly as: "target";
+            readonly incoming: "0..*";
+        };
+        readonly constraints: Record<never, never>;
+    }, never, never, never>];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "resource";
+        readonly outgoing: "0..1";
+    };
+    readonly target: {
+        readonly as: "creator";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: {
+        readonly noSelf: true;
+    };
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/meta/created-by.js

@@ -0,0 +1,17 @@
+import { edgeClass } from '@astrale-os/kernel-dsl/v1';
+import { Edge } from './edge.js';
+import { Node } from './node.js';
+// Identity composes meta, so meta names it by reference instead of importing it.
+const IdentityRef = {
+    origin: 'kernel.astrale.ai',
+    kind: 'class',
+    name: 'Identity',
+};
+export const CreatedBy = edgeClass.directed({
+    abstract: false,
+    source: { as: 'resource', accepts: [Node], outgoing: '0..1' },
+    target: { as: 'creator', accepts: [IdentityRef], incoming: '0..*' },
+    description: 'Kernel-authored attribution of a Node to the Identity whose call created it; it grants no authority by itself.',
+    extends: [Edge],
+    constraints: { noSelf: true },
+});

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

@@ -1,19 +1,20 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Descriptable: builder.NodeClass<{
+    readonly depth: 1;
     readonly abstract: true;
-    readonly extends: readonly [builder.NodeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
         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 depth: 0;
+        readonly properties: never;
+        readonly methods: Readonly<Record<never, never>>;
+    }, never, never, never>];
     readonly properties: {
-        description: builder.Property<Readonly<{
-            readonly type: 'string';
-            readonly minLength: 1;
-            readonly maxLength: 1000;
-        }>, {
-            readonly required: false;
-        }>;
+        readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
     };
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=descriptable.d.ts.map

package/dist/schema/meta/descriptable.js

@@ -8,4 +8,3 @@ export const Descriptable = nodeClass({
         description: property(metadata.description, { required: false }),
     },
 });
-//# sourceMappingURL=descriptable.js.map

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

@@ -1,22 +1,17 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Edge: builder.DirectedEdgeClass<{
+    readonly depth: 0;
     readonly abstract: true;
+    readonly extends: readonly [];
+    readonly properties: never;
     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.";
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
 }>;
-//# sourceMappingURL=edge.d.ts.map

package/dist/schema/meta/edge.js

@@ -6,4 +6,3 @@ export const Edge = edgeClass.directed({
     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,19 +1,20 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Iconable: builder.NodeClass<{
+    readonly depth: 1;
     readonly abstract: true;
-    readonly extends: readonly [builder.NodeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
         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 depth: 0;
+        readonly properties: never;
+        readonly methods: Readonly<Record<never, never>>;
+    }, never, never, never>];
     readonly properties: {
-        icon: builder.Property<Readonly<{
-            readonly type: 'string';
-            readonly minLength: 1;
-            readonly maxLength: 8000;
-        }>, {
-            readonly required: false;
-        }>;
+        readonly icon: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "icon", "self", never>;
     };
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "icon", "self", never>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=iconable.d.ts.map

package/dist/schema/meta/iconable.js

@@ -8,4 +8,3 @@ export const Iconable = nodeClass({
         icon: property(metadata.icon, { required: false }),
     },
 });
-//# sourceMappingURL=iconable.js.map

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

@@ -1,3 +1,4 @@
+export { CreatedBy } from './created-by.js';
 export { Descriptable } from './descriptable.js';
 export { Edge } from './edge.js';
 export { Iconable } from './iconable.js';
@@ -6,4 +7,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

@@ -1,3 +1,4 @@
+export { CreatedBy } from './created-by.js';
 export { Descriptable } from './descriptable.js';
 export { Edge } from './edge.js';
 export { Iconable } from './iconable.js';
@@ -6,4 +7,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,17 +1,20 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Named: builder.NodeClass<{
+    readonly depth: 1;
     readonly abstract: true;
-    readonly extends: readonly [builder.NodeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
         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 depth: 0;
+        readonly properties: never;
+        readonly methods: Readonly<Record<never, never>>;
+    }, never, never, never>];
     readonly properties: {
-        readonly name: {
-            readonly type: "string";
-            readonly minLength: 1;
-            readonly maxLength: 100;
-        };
+        readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
     };
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=named.d.ts.map

package/dist/schema/meta/named.js

@@ -8,4 +8,3 @@ export const Named = nodeClass({
         name: { type: 'string', minLength: 1, maxLength: 100 },
     },
 });
-//# sourceMappingURL=named.js.map

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

@@ -1,6 +1,13 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Node: builder.NodeClass<{
+    readonly depth: 0;
     readonly abstract: true;
-    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: never;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=node.d.ts.map

package/dist/schema/meta/node.js

@@ -3,4 +3,3 @@ 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,30 +1,22 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Remotable: builder.NodeClass<{
+    readonly depth: 1;
     readonly abstract: true;
-    readonly extends: readonly [builder.NodeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
         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 depth: 0;
+        readonly properties: never;
+        readonly methods: Readonly<Record<never, never>>;
+    }, never, never, never>];
     readonly properties: {
-        externalId: builder.Property<{
-            readonly type: "string";
-            readonly minLength: 1;
-            readonly maxLength: 512;
-        }, {
-            readonly required: false;
-        }>;
-        onConflict: builder.Property<{
-            readonly enum: readonly ["defaults", "error", "merge", "replace", "skip"];
-        }, {
-            readonly required: false;
-        }>;
-        updatedAt: builder.Property<Readonly<{
-            readonly type: 'string';
-            readonly 'x-astrale-value-kind': 'instant';
-        }>, {
-            readonly required: false;
-        }>;
+        readonly externalId: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "externalId", "self", never>;
+        readonly onConflict: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "onConflict", "self", never>;
+        readonly updatedAt: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "updatedAt", "self", never>;
     };
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "externalId", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "onConflict", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "updatedAt", "self", never>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=remotable.d.ts.map

package/dist/schema/meta/remotable.js

@@ -10,4 +10,3 @@ export const Remotable = nodeClass({
         updatedAt: property(schema.values.instant, { required: false }),
     },
 });
-//# sourceMappingURL=remotable.js.map

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

@@ -1,15 +1,20 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Statused: builder.NodeClass<{
+    readonly depth: 1;
     readonly abstract: true;
-    readonly extends: readonly [builder.NodeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
         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 depth: 0;
+        readonly properties: never;
+        readonly methods: Readonly<Record<never, never>>;
+    }, never, never, never>];
     readonly properties: {
-        readonly status: {
-            readonly enum: readonly ["active", "creating", "deleting", "error", "updating"];
-        };
+        readonly status: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "status", "self", undefined>;
     };
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "status", "self", undefined>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=statused.d.ts.map

package/dist/schema/meta/statused.js

@@ -8,4 +8,3 @@ export const Statused = nodeClass({
         status: { enum: ['active', 'creating', 'deleting', 'error', 'updating'] },
     },
 });
-//# sourceMappingURL=statused.js.map

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

@@ -1,20 +1,21 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Timestamped: builder.NodeClass<{
+    readonly depth: 1;
     readonly abstract: true;
-    readonly extends: readonly [builder.NodeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
         readonly abstract: true;
-        readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-    }>];
-    readonly description: "Explicit creation and update timestamp metadata.";
+        readonly depth: 0;
+        readonly properties: never;
+        readonly methods: Readonly<Record<never, never>>;
+    }, never, never, never>];
     readonly properties: {
-        createdAt: builder.AutoProperty<builder.Property<Readonly<{
-            readonly type: 'string';
-            readonly 'x-astrale-value-kind': 'instant';
-        }>, builder.PropertyOptions>>;
-        updatedAt: builder.AutoProperty<builder.Property<Readonly<{
-            readonly type: 'string';
-            readonly 'x-astrale-value-kind': 'instant';
-        }>, builder.PropertyOptions>>;
+        readonly createdAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", "self", undefined>;
+        readonly updatedAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", "self", undefined>;
     };
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", "self", undefined> | builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", "self", undefined>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=timestamped.d.ts.map

package/dist/schema/meta/timestamped.js

@@ -12,4 +12,3 @@ export const Timestamped = nodeClass({
         }),
     },
 });
-//# sourceMappingURL=timestamped.js.map