@astrale-os/kernel-core 0.9.0-beta.6 → 0.9.0-beta.61

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

@@ -2,6 +2,8 @@ import { Key, patterns } 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);
@@ -17,16 +19,21 @@ 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.`);
         const declaration = acceptDeclaration(view.declaration, index);
+        const iframe = acceptIframeRequirements(view.iframe, view.handshake, index);
+        const host = acceptViewHostRequirements(view.host, view.handshake);
         return Object.freeze({
             key,
             declaration,
             href: view.href,
             handshake: view.handshake,
+            ...(iframe === undefined ? {} : { iframe }),
+            ...(host === undefined ? {} : { host }),
             issuer: view.issuer,
             etag: digest(view.etag, `Resolved View ${index} ETag`),
             revision: digest(view.revision, `Resolved View ${index} revision`),
@@ -42,6 +49,85 @@ export function acceptViewResolution(input) {
         views: Object.freeze(views),
     });
 }
+const IFRAME_TOKEN = /^[a-z][a-z0-9-]*$/u;
+function acceptIframeRequirements(input, handshake, viewIndex) {
+    if (input === undefined)
+        return undefined;
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        invalid(`Resolved View ${viewIndex} iframe requirements are invalid.`);
+    }
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== Object.prototype && prototype !== null) {
+        invalid(`Resolved View ${viewIndex} iframe requirements are invalid.`);
+    }
+    const value = input;
+    if (Reflect.ownKeys(value).some((key) => key !== 'sandbox' && key !== 'allow')) {
+        invalid(`Resolved View ${viewIndex} iframe requirements contain unknown fields.`);
+    }
+    const sandbox = acceptTokens(dataValue(value, 'sandbox', viewIndex), viewIndex, 'sandbox');
+    const allow = acceptTokens(dataValue(value, 'allow', viewIndex), viewIndex, 'allow');
+    const baselineSandbox = new Set(handshake === 'shell' ? ['allow-same-origin', 'allow-scripts'] : ['allow-scripts']);
+    const baselineAllow = new Set(handshake === 'shell' ? ['clipboard-write'] : []);
+    if (sandbox.some((token) => baselineSandbox.has(token)) ||
+        allow.some((token) => baselineAllow.has(token))) {
+        invalid(`Resolved View ${viewIndex} iframe requirements repeat a fixed handshake baseline.`);
+    }
+    const tokens = new Set(sandbox);
+    if (tokens.has('allow-popups-to-escape-sandbox') && !tokens.has('allow-popups')) {
+        invalid(`Resolved View ${viewIndex} popup escape requires popup authority.`);
+    }
+    if (tokens.has('allow-top-navigation') && tokens.has('allow-top-navigation-by-user-activation')) {
+        invalid(`Resolved View ${viewIndex} iframe navigation requirements are redundant.`);
+    }
+    if (tokens.has('allow-top-navigation-to-custom-protocols') &&
+        (tokens.has('allow-top-navigation') || tokens.has('allow-popups'))) {
+        invalid(`Resolved View ${viewIndex} custom-protocol requirements are redundant.`);
+    }
+    if (sandbox.length === 0 && allow.length === 0) {
+        invalid(`Resolved View ${viewIndex} empty iframe requirements must be omitted.`);
+    }
+    return Object.freeze({ sandbox: Object.freeze(sandbox), allow: Object.freeze(allow) });
+}
+function dataValue(input, key, viewIndex) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (descriptor === undefined)
+        return undefined;
+    if (!('value' in descriptor)) {
+        invalid(`Resolved View ${viewIndex} iframe requirements are invalid.`);
+    }
+    return descriptor.value;
+}
+function acceptTokens(input, viewIndex, field) {
+    if (input === undefined)
+        return [];
+    if (!Array.isArray(input))
+        invalid(`Resolved View ${viewIndex} iframe ${field} is invalid.`);
+    const descriptors = Object.getOwnPropertyDescriptors(input);
+    const values = [];
+    for (let index = 0; index < input.length; index += 1) {
+        const descriptor = descriptors[String(index)];
+        if (descriptor === undefined ||
+            !('value' in descriptor) ||
+            typeof descriptor.value !== 'string' ||
+            !IFRAME_TOKEN.test(descriptor.value)) {
+            invalid(`Resolved View ${viewIndex} iframe ${field} contains an invalid token.`);
+        }
+        values.push(descriptor.value);
+    }
+    for (const key of Reflect.ownKeys(descriptors)) {
+        if (key === 'length')
+            continue;
+        if (typeof key !== 'string' || !/^(0|[1-9][0-9]*)$/u.test(key) || Number(key) >= input.length) {
+            invalid(`Resolved View ${viewIndex} iframe ${field} is invalid.`);
+        }
+    }
+    for (let index = 1; index < values.length; index += 1) {
+        if (values[index - 1] >= values[index]) {
+            invalid(`Resolved View ${viewIndex} iframe ${field} is not in strict canonical order.`);
+        }
+    }
+    return values;
+}
 function acceptDeclaration(input, viewIndex) {
     if (input.target.kind === 'domain') {
         return Object.freeze({
@@ -51,7 +137,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 +176,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,51 @@
-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";
+            iframe?: {
+                sandbox?: string[] | undefined;
+                allow?: string[] | undefined;
+            } | undefined;
+            host?: {
+                navigation: {
+                    external: {
+                        origins: string[];
+                    };
+                };
+            } | undefined;
+            issuer: string;
+            etag: string;
+            revision: string;
+        }[];
+    };
+}, true, false, "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";
+    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

@@ -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
+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

@@ -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

@@ -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

@@ -1,41 +1,54 @@
 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
+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

@@ -1,12 +1,12 @@
 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
+export const impersonate = methodRef('impersonate');

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

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

@@ -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/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,15 +1,20 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Descriptable: builder.Interface<{
-    readonly family: "both";
-    readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
+export declare const Descriptable: builder.NodeClass<{
+    readonly depth: 1;
+    readonly abstract: true;
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
+        readonly abstract: true;
+        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

@@ -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,17 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Edge: builder.Interface<{
-    readonly family: "both";
-    readonly description: "Explicit kernel marker for Edge definitions; it carries no structural fields.";
+export declare const Edge: builder.DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: true;
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "source";
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "target";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
 }>;
-//# 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