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

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

@@ -0,0 +1,11 @@
+import { K } from '../../index.js';
+import * as references from '../references/execution.js';
+import { methodSyscall } from './model.js';
+// Instance Methods: the handler receives the Execution receiver as `self`.
+export const status = methodSyscall(references.status, K.classes.Execution.methods.status);
+export const result = methodSyscall(references.result, K.classes.Execution.methods.result);
+export const cancel = methodSyscall(references.cancel, K.classes.Execution.methods.cancel);
+export const signal = methodSyscall(references.signal, K.classes.Execution.methods.signal);
+export const resume = methodSyscall(references.resume, K.classes.Execution.methods.resume);
+const remove = methodSyscall(references.delete, K.classes.Execution.methods.delete);
+export { remove as delete };

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

@@ -2,7 +2,11 @@ import type { ClassRef } from '@astrale-os/kernel-dsl/v1';
 import { type MethodSyscall } from './model.js';
 declare const Admit: import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     call: {
-        target: string;
+        target: string | {
+            callable: string;
+            instance?: string | undefined;
+            fingerprint?: string | undefined;
+        };
         input: unknown;
     };
     credential?: string | undefined;
@@ -12,8 +16,10 @@ declare const Admit: import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
         callable: string;
         receiver?: string | undefined;
     };
-}, true, "sealed", "authenticated", never, "kernel.astrale.ai:class.Function.method.admit"> & {
+}, true, false, "authenticated", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Function.method.admit"> & {
     readonly name: "admit";
+    readonly executable: true;
+    readonly execution: undefined;
 };
 export declare const admit: MethodSyscall<ClassRef<'Function'> & {
     readonly origin: 'kernel.astrale.ai';

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

@@ -2,8 +2,10 @@ import { K } from '../../index.js';
 import { type FunctionSyscall } from './model.js';
 export declare const query: FunctionSyscall<'kernel.astrale.ai', 'query', typeof K.functions.query>;
 export declare const mutate: FunctionSyscall<'kernel.astrale.ai', 'mutate', typeof K.functions.mutate>;
-export declare const provision: FunctionSyscall<'kernel.astrale.ai', 'provision', typeof K.functions.provision>;
+export declare const register: FunctionSyscall<'kernel.astrale.ai', 'register', typeof K.functions.register>;
 export declare const install: FunctionSyscall<'kernel.astrale.ai', 'install', typeof K.functions.install>;
 export declare const introspect: FunctionSyscall<'kernel.astrale.ai', 'introspect', typeof K.functions.introspect>;
 export declare const uninstall: FunctionSyscall<'kernel.astrale.ai', 'uninstall', typeof K.functions.uninstall>;
 export declare const journal: FunctionSyscall<'kernel.astrale.ai', 'journal', typeof K.functions.journal>;
+export declare const upload: FunctionSyscall<'kernel.astrale.ai', 'upload', typeof K.functions.upload>;
+export declare const download: FunctionSyscall<'kernel.astrale.ai', 'download', typeof K.functions.download>;

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

@@ -3,8 +3,10 @@ import * as references from '../references/functions.js';
 import { functionSyscall } from './model.js';
 export const query = functionSyscall(references.query, K.functions.query);
 export const mutate = functionSyscall(references.mutate, K.functions.mutate);
-export const provision = functionSyscall(references.provision, K.functions.provision);
+export const register = functionSyscall(references.register, K.functions.register);
 export const install = functionSyscall(references.install, K.functions.install);
 export const introspect = functionSyscall(references.introspect, K.functions.introspect);
 export const uninstall = functionSyscall(references.uninstall, K.functions.uninstall);
 export const journal = functionSyscall(references.journal, K.functions.journal);
+export const upload = functionSyscall(references.upload, K.functions.upload);
+export const download = functionSyscall(references.download, K.functions.download);

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

@@ -3,14 +3,16 @@ export declare const delegate: import("./model.js").MethodSyscall<Readonly<{
     kind: 'class';
     name: 'Identity';
 }>, "delegate", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    principal: string;
     audience: string;
     ttlSeconds: number;
-    attenuation: unknown;
 }, {
     readonly mode: 'value';
     readonly value: string;
-}, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+}, true, false, "authenticated", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Identity.method.delegate"> & {
     readonly name: "delegate";
+    readonly executable: true;
+    readonly execution: undefined;
 }>;
 export declare const can: import("./model.js").MethodSyscall<Readonly<{
     origin: 'kernel.astrale.ai';
@@ -19,13 +21,24 @@ export declare const can: import("./model.js").MethodSyscall<Readonly<{
 }>, "can", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     policy: string;
     object: string;
+} | {
+    checks: {
+        policy: string;
+        object: string;
+    }[];
 }, {
     readonly mode: 'value';
     readonly value: {
         allowed: boolean;
+    } | {
+        decisions: {
+            allowed: boolean;
+        }[];
     };
-}, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+}, true, false, "authenticated", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Identity.method.can"> & {
     readonly name: "can";
+    readonly executable: true;
+    readonly execution: undefined;
 }>;
 export declare const whoami: import("./model.js").MethodSyscall<Readonly<{
     origin: 'kernel.astrale.ai';
@@ -35,8 +48,8 @@ export declare const whoami: import("./model.js").MethodSyscall<Readonly<{
     readonly mode: 'value';
     readonly value: {
         id: string;
-        issuer: string;
-        subject: string;
+        iss: string;
+        sub: string;
         frozen: boolean;
         requiredClaims: ({
             claim: string;
@@ -51,22 +64,24 @@ export declare const whoami: import("./model.js").MethodSyscall<Readonly<{
             op: "exists";
         })[];
     };
-}, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+}, true, false, "authenticated", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Identity.method.whoami"> & {
     readonly name: "whoami";
+    readonly executable: true;
+    readonly execution: undefined;
 }>;
 export declare const whois: import("./model.js").MethodSyscall<Readonly<{
     origin: 'kernel.astrale.ai';
     kind: 'class';
     name: 'Identity';
 }>, "whois", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
-    issuer: string;
-    subject: string;
+    iss: string;
+    sub: string;
 }, {
     readonly mode: 'value';
     readonly value: {
         id: string;
-        issuer: string;
-        subject: string;
+        iss: string;
+        sub: string;
         frozen: boolean;
         requiredClaims: ({
             claim: string;
@@ -81,8 +96,26 @@ export declare const whois: import("./model.js").MethodSyscall<Readonly<{
             op: "exists";
         })[];
     } | null;
-}, true, "default", "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.Identity.method.whois"> & {
+}, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Identity.method.whois"> & {
     readonly name: "whois";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const impersonate: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Identity';
+}>, "impersonate", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    audience?: string | undefined;
+    ttlSeconds: number;
+    identity: string;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Identity.method.impersonate"> & {
+    readonly name: "impersonate";
+    readonly executable: true;
+    readonly execution: undefined;
 }>;
 export declare const mint: import("./model.js").MethodSyscall<Readonly<{
     origin: 'kernel.astrale.ai';
@@ -91,10 +124,11 @@ export declare const mint: import("./model.js").MethodSyscall<Readonly<{
 }>, "mint", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     audience?: string | undefined;
     ttlSeconds: number;
-    grant?: unknown;
 }, {
     readonly mode: 'value';
     readonly value: string;
-}, true, "default", "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.Identity.method.mint"> & {
+}, true, false, "authenticated", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Identity.method.mint"> & {
     readonly name: "mint";
+    readonly executable: true;
+    readonly execution: undefined;
 }>;

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

@@ -1,8 +1,9 @@
 import { K } from '../../index.js';
 import * as references from '../references/identity.js';
 import { methodSyscall } from './model.js';
-export const delegate = methodSyscall(references.delegate, K.classes.Identity.methods.delegate);
+export const delegate = methodSyscall(references.delegate, K.classes.Identity.static.methods.delegate);
 export const can = methodSyscall(references.can, K.classes.Identity.static.methods.can);
 export const whoami = methodSyscall(references.whoami, K.classes.Identity.static.methods.whoami);
 export const whois = methodSyscall(references.whois, K.classes.Identity.static.methods.whois);
+export const impersonate = methodSyscall(references.impersonate, K.classes.Identity.static.methods.impersonate);
 export const mint = methodSyscall(references.mint, K.classes.Identity.static.methods.mint);

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

@@ -1,5 +1,6 @@
 export type { FunctionSyscall, MethodSyscall, Syscall, SyscallRef } from './model.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';

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

@@ -1,4 +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';

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

@@ -1,13 +1,17 @@
 import type { Revision, ViewDefinition } from '@astrale-os/kernel-dsl/v1';
 import type { Key as KeyType } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { IssuerId } from '../../../../../auth/index.js';
+import { type ViewHostRequirements } from '../../contracts/view-host-requirements.js';
+export { acceptViewHostRequirements, type ViewHostRequirements, } from '../../contracts/view-host-requirements.js';
 export interface ResolvedView {
     readonly key: KeyType.View;
     readonly declaration: ViewDeclaration;
     readonly href: string;
     readonly handshake: 'shell' | 'none';
+    readonly host?: ViewHostRequirements;
     readonly issuer: IssuerId;
-    readonly etag: `sha256:${string}`;
+    /** Digest of the exact DomainRelease that owns this View. */
+    readonly release: `sha256:${string}`;
     readonly revision: Revision;
 }
 type ViewDeclaration = Omit<ViewDefinition, 'ref'>;
@@ -17,4 +21,3 @@ export interface ViewResolution {
 }
 /** Admit one detached, deeply immutable result of the Kernel View.resolve syscall. */
 export declare function acceptViewResolution(input: unknown): ViewResolution;
-export {};

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

@@ -1,7 +1,9 @@
-import { Key, patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { issuer } from '../../../../../auth/index.js';
 import { viewResolveOutput } from '../../contracts/index.js';
+import { acceptViewHostRequirements, } from '../../contracts/view-host-requirements.js';
+export { acceptViewHostRequirements, } from '../../contracts/view-host-requirements.js';
 /** Admit one detached, deeply immutable result of the Kernel View.resolve syscall. */
 export function acceptViewResolution(input) {
     const candidate = portable.accept(input);
@@ -23,13 +25,15 @@ export function acceptViewResolution(input) {
         if (!issuer.is(view.issuer))
             invalid(`Resolved View ${index} issuer is not canonical.`);
         const declaration = acceptDeclaration(view.declaration, index);
+        const host = acceptViewHostRequirements(view.host, view.handshake);
         return Object.freeze({
             key,
             declaration,
             href: view.href,
             handshake: view.handshake,
+            ...(host === undefined ? {} : { host }),
             issuer: view.issuer,
-            etag: digest(view.etag, `Resolved View ${index} ETag`),
+            release: digest(view.release, `Resolved View ${index} release`),
             revision: digest(view.revision, `Resolved View ${index} revision`),
         });
     });
@@ -43,51 +47,17 @@ export function acceptViewResolution(input) {
         views: Object.freeze(views),
     });
 }
-function acceptDeclaration(input, viewIndex) {
-    if (input.target.kind === 'domain') {
-        return Object.freeze({
-            ...(input.description === undefined ? {} : { description: input.description }),
-            target: Object.freeze({ kind: 'domain' }),
-        });
-    }
-    const definitions = input.target.definitions.map((definition, definitionIndex) => {
-        if (!patterns.origin.test(definition.origin) ||
-            definition.kind !== 'class' ||
-            !patterns.memberName.test(definition.name)) {
-            invalid(`Resolved View ${viewIndex} target definition ${definitionIndex} is invalid.`);
-        }
-        return Object.freeze({
-            origin: definition.origin,
-            kind: definition.kind,
-            name: definition.name,
-        });
-    });
-    for (let index = 1; index < definitions.length; index++) {
-        if (compareDefinitionRefs(definitions[index - 1], definitions[index]) >= 0) {
-            invalid(`Resolved View ${viewIndex} target definitions are not in strict canonical order.`);
-        }
-    }
+function acceptDeclaration(input, _viewIndex) {
     return Object.freeze({
         ...(input.description === undefined ? {} : { description: input.description }),
-        target: Object.freeze({
-            kind: 'definition',
-            definitions: Object.freeze(definitions),
-        }),
+        target: Object.freeze({ kind: 'domain' }),
     });
 }
-function compareDefinitionRefs(left, right) {
-    return (compare(left.origin, right.origin) ||
-        compare(left.kind, right.kind) ||
-        compare(left.name, right.name));
-}
 function digest(input, label) {
     if (!/^sha256:[0-9a-f]{64}$/u.test(input))
         invalid(`${label} is invalid.`);
     return input;
 }
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
 function invalid(message) {
     throw new TypeError(message);
 }

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

@@ -15,24 +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;

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

@@ -1,4 +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';
+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,3 +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';
+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/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,3 +33,13 @@ export declare const journal: Readonly<{
     kind: 'function';
     name: "journal";
 }>;
+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,8 +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');
+export const upload = functionRef('upload');
+export const download = functionRef('download');

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

@@ -43,3 +43,12 @@ export declare const mint: Readonly<{
     }>;
     name: "mint";
 }>;
+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,3 +9,4 @@ export const can = methodRef('can');
 export const whoami = methodRef('whoami');
 export const whois = methodRef('whois');
 export const mint = methodRef('mint');
+export const impersonate = methodRef('impersonate');

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

@@ -1,5 +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';

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

@@ -1,4 +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';

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,18 +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;
 }>;

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

@@ -1,21 +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;
 }>;