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

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

@@ -0,0 +1,303 @@
+export declare const status: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "status", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        function: string;
+        version: string;
+        state: "cancelled" | "completed" | "expired" | "failed" | "paused" | "pending" | "running" | "waiting";
+        createdAt: string;
+        detail?: {
+            phase: "activating" | "attempting" | "awaiting" | "cancelled" | "classifying" | "completed" | "draining" | "rejected" | "validating";
+            class?: "immediate" | "noop" | "revalidate" | undefined;
+            mode?: "maintenance" | "online" | undefined;
+            validation?: {
+                scope: "full" | "incremental";
+                counts: "exact" | "sample";
+            } | undefined;
+            progress?: {
+                pages: number;
+                interruptions: number;
+            } | undefined;
+            instance?: "attempt" | "draining" | "open" | "repair" | undefined;
+            command?: number | undefined;
+            expires?: number | undefined;
+            attempt?: {
+                number: number;
+                destination: "previous" | "target";
+            } | undefined;
+            report?: {
+                attempt: number;
+                destination: "previous" | "target";
+                result: "aborted" | "interrupted" | "migration-required";
+                reason?: string | undefined;
+                summary?: unknown;
+            } | undefined;
+            uncertified?: {
+                since: number;
+                session?: string | undefined;
+                operator?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        } | undefined;
+        outcome?: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        } | undefined;
+    } | {
+        id: string;
+        state: "deleted";
+        outcome: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        };
+    };
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Execution.method.status"> & {
+    readonly name: "status";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const result: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "result", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    waitMs?: number | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        kind: "completed";
+        value: unknown;
+    } | {
+        kind: "failed";
+        error: {
+            code: string;
+            message: string;
+            family?: string | undefined;
+            details?: unknown;
+        };
+    } | {
+        kind: "cancelled";
+    };
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Execution.method.result"> & {
+    readonly name: "result";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const cancel: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "cancel", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    force?: boolean | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        function: string;
+        version: string;
+        state: "cancelled" | "completed" | "expired" | "failed" | "paused" | "pending" | "running" | "waiting";
+        createdAt: string;
+        detail?: {
+            phase: "activating" | "attempting" | "awaiting" | "cancelled" | "classifying" | "completed" | "draining" | "rejected" | "validating";
+            class?: "immediate" | "noop" | "revalidate" | undefined;
+            mode?: "maintenance" | "online" | undefined;
+            validation?: {
+                scope: "full" | "incremental";
+                counts: "exact" | "sample";
+            } | undefined;
+            progress?: {
+                pages: number;
+                interruptions: number;
+            } | undefined;
+            instance?: "attempt" | "draining" | "open" | "repair" | undefined;
+            command?: number | undefined;
+            expires?: number | undefined;
+            attempt?: {
+                number: number;
+                destination: "previous" | "target";
+            } | undefined;
+            report?: {
+                attempt: number;
+                destination: "previous" | "target";
+                result: "aborted" | "interrupted" | "migration-required";
+                reason?: string | undefined;
+                summary?: unknown;
+            } | undefined;
+            uncertified?: {
+                since: number;
+                session?: string | undefined;
+                operator?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        } | undefined;
+        outcome?: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        } | undefined;
+    } | {
+        id: string;
+        state: "deleted";
+        outcome: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        };
+    };
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Execution.method.cancel"> & {
+    readonly name: "cancel";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const signal: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "signal", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    name: string;
+    value: unknown;
+}, {
+    readonly mode: 'value';
+    readonly value: Record<string, never>;
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Execution.method.signal"> & {
+    readonly name: "signal";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const resume: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "resume", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        function: string;
+        version: string;
+        state: "cancelled" | "completed" | "expired" | "failed" | "paused" | "pending" | "running" | "waiting";
+        createdAt: string;
+        detail?: {
+            phase: "activating" | "attempting" | "awaiting" | "cancelled" | "classifying" | "completed" | "draining" | "rejected" | "validating";
+            class?: "immediate" | "noop" | "revalidate" | undefined;
+            mode?: "maintenance" | "online" | undefined;
+            validation?: {
+                scope: "full" | "incremental";
+                counts: "exact" | "sample";
+            } | undefined;
+            progress?: {
+                pages: number;
+                interruptions: number;
+            } | undefined;
+            instance?: "attempt" | "draining" | "open" | "repair" | undefined;
+            command?: number | undefined;
+            expires?: number | undefined;
+            attempt?: {
+                number: number;
+                destination: "previous" | "target";
+            } | undefined;
+            report?: {
+                attempt: number;
+                destination: "previous" | "target";
+                result: "aborted" | "interrupted" | "migration-required";
+                reason?: string | undefined;
+                summary?: unknown;
+            } | undefined;
+            uncertified?: {
+                since: number;
+                session?: string | undefined;
+                operator?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        } | undefined;
+        outcome?: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        } | undefined;
+    } | {
+        id: string;
+        state: "deleted";
+        outcome: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        };
+    };
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Execution.method.resume"> & {
+    readonly name: "resume";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+declare const remove: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "delete", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: Record<string, never>;
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").CallablePolicy, "kernel.astrale.ai:class.Execution.method.delete"> & {
+    readonly name: "delete";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export { remove as delete };

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;