@astrale-os/kernel-core 0.9.0-beta.46 → 0.9.0-beta.47

package/dist/schema/callables/view.d.ts

@@ -46,6 +46,13 @@ export declare const View: builder.NodeClass<{
                         sandbox?: string[] | undefined;
                         allow?: string[] | undefined;
                     } | undefined;
+                    host?: {
+                        navigation: {
+                            external: {
+                                origins: string[];
+                            };
+                        };
+                    } | undefined;
                     issuer: string;
                     etag: string;
                     revision: string;
@@ -91,6 +98,13 @@ export declare const View: builder.NodeClass<{
                     sandbox?: string[] | undefined;
                     allow?: string[] | undefined;
                 } | undefined;
+                host?: {
+                    navigation: {
+                        external: {
+                            origins: string[];
+                        };
+                    };
+                } | undefined;
                 issuer: string;
                 etag: string;
                 revision: string;

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

@@ -3786,6 +3786,13 @@ declare const KernelDefinitions: {
                                 sandbox?: string[] | undefined;
                                 allow?: string[] | undefined;
                             } | undefined;
+                            host?: {
+                                navigation: {
+                                    external: {
+                                        origins: string[];
+                                    };
+                                };
+                            } | undefined;
                             issuer: string;
                             etag: string;
                             revision: string;
@@ -3831,6 +3838,13 @@ declare const KernelDefinitions: {
                             sandbox?: string[] | undefined;
                             allow?: string[] | undefined;
                         } | undefined;
+                        host?: {
+                            navigation: {
+                                external: {
+                                    origins: string[];
+                                };
+                            };
+                        } | undefined;
                         issuer: string;
                         etag: string;
                         revision: string;
@@ -4421,29 +4435,6 @@ declare const KernelDefinitions: {
                     };
                 })[];
                 operations: ({
-                    op: "edge.update";
-                    edge: {
-                        source: string;
-                        target: string;
-                        class: string;
-                    };
-                    slug: unknown;
-                    props?: {
-                        set: Record<string, unknown>;
-                        unset: string[];
-                    } | undefined;
-                } | {
-                    op: "edge.update";
-                    edge: {
-                        source: string;
-                        target: string;
-                        class: string;
-                    };
-                    props: {
-                        set: Record<string, unknown>;
-                        unset: string[];
-                    };
-                } | {
                     op: "node.create";
                     as: string;
                     class: string;
@@ -4471,6 +4462,29 @@ declare const KernelDefinitions: {
                     };
                     slug?: unknown;
                     props: Record<string, unknown>;
+                } | {
+                    op: "edge.update";
+                    edge: {
+                        source: string;
+                        target: string;
+                        class: string;
+                    };
+                    slug: unknown;
+                    props?: {
+                        set: Record<string, unknown>;
+                        unset: string[];
+                    } | undefined;
+                } | {
+                    op: "edge.update";
+                    edge: {
+                        source: string;
+                        target: string;
+                        class: string;
+                    };
+                    props: {
+                        set: Record<string, unknown>;
+                        unset: string[];
+                    };
                 } | {
                     op: "edge.delete";
                     edge: {
@@ -4895,31 +4909,6 @@ export declare const AuthorityRelations: Readonly<{
 }>;
 /** Exact authorized Kernel Functions for which pristine Root receives direct can_use authority. */
 export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    operation: string;
-    domains: ({
-        artifact: {
-            digest: string;
-            mediaType: string;
-            size: number;
-        };
-        currentRevision?: string | null | undefined;
-    } | {
-        publication: {
-            url: string;
-            token?: string | undefined;
-            etag?: string | undefined;
-        };
-        revision?: string | undefined;
-        currentRevision?: string | null | undefined;
-    })[];
-}, {
-    readonly mode: 'binary';
-}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"install"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.install";
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     invocation?: {
         source: string;
         id: string;
@@ -4951,322 +4940,119 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
         readonly origin: "kernel.astrale.ai";
     };
     readonly key: "kernel.astrale.ai:function.journal";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    idempotencyKey: string;
+    identities: ({
+        id: string;
+        mode: "external";
+        credential: string;
+    } | {
+        id: string;
+        mode: "self";
+        publicKey: unknown;
+        credential: string;
+    })[];
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        identities: {
+            id: string;
+            iss: string;
+            sub: string;
+        }[];
+    };
+}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"register"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.register";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     ast: {
-        format: "astrale.graph.mutation";
-        version: "v3";
-        preconditions: ({
+        format: "astrale.graph.query";
+        version: "v6";
+        source: {
             kind: "node";
-            node: string;
-            class: string;
-            props?: {
-                equals: Record<string, unknown>;
-                absent?: string[] | undefined;
+            terms: ({
+                kind: "path";
+                path: string;
             } | {
-                absent: string[];
-            } | undefined;
+                kind: "class";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            })[];
+            binding: string;
         } | {
             kind: "edge";
-            edge: {
+            terms: {
+                kind: "class";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            }[];
+            bindings: {
                 source: string;
+                edge: string;
                 target: string;
-                class: string;
             };
-            slug?: unknown;
-            props?: {
-                equals: Record<string, unknown>;
-                absent?: string[] | undefined;
+        };
+        steps: ({
+            op: "filter";
+            binding: string;
+            predicate: {
+                kind: "class.satisfies";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
             } | {
-                absent: string[];
-            } | undefined;
-        } | {
-            kind: "query";
-            query: {
-                format: "astrale.graph.query";
-                version: "v6";
-                source: {
-                    kind: "node";
-                    terms: ({
-                        kind: "path";
-                        path: string;
-                    } | {
-                        kind: "class";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    })[];
-                    binding: string;
-                } | {
-                    kind: "edge";
-                    terms: {
-                        kind: "class";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    }[];
-                    bindings: {
-                        source: string;
-                        edge: string;
-                        target: string;
-                    };
-                };
-                steps: ({
-                    op: "filter";
-                    binding: string;
-                    predicate: {
-                        kind: "class.satisfies";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    } | {
-                        kind: "class.equal";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    } | {
-                        kind: "property.equal";
-                        property: string;
-                        value: unknown;
-                    } | {
-                        kind: "property.present";
-                        property: string;
-                    } | {
-                        kind: "identity.equal";
-                        identity: string | {
-                            source: string;
-                            target: string;
-                            class: string;
-                        };
-                    };
-                } | {
-                    op: "expand";
-                    from: string;
-                    via: {
-                        origin: string;
-                        kind: "class";
-                        name: string;
-                    }[];
-                    direction: "incident" | "incoming" | "outgoing";
-                    bindings: {
-                        edge: string;
-                        node: string;
-                    };
-                })[];
-                select: {
-                    kind: "graph";
-                    binding: string;
-                    order?: {
-                        property: string;
-                        direction: "asc" | "desc";
-                        unranked: "first" | "last";
-                    } | undefined;
-                } | {
-                    kind: "nodes";
-                    binding: string;
-                    projection: {
-                        kind: "reference" | "value";
-                    };
-                    order?: {
-                        property: string;
-                        direction: "asc" | "desc";
-                        unranked: "first" | "last";
-                    } | undefined;
-                } | {
-                    kind: "edges";
-                    binding: string;
-                    projection: {
-                        edge: "reference" | "value";
-                        source: "reference" | "value";
-                        target: "reference" | "value";
-                    };
-                    order?: {
-                        property: string;
-                        direction: "asc" | "desc";
-                        unranked: "first" | "last";
-                    } | undefined;
-                };
-            };
-            equals: {
-                kind: "node";
-                ids: string[];
-            } | {
-                kind: "edge";
-                keys: {
-                    source: string;
-                    target: string;
-                    class: string;
-                }[];
-            };
-        })[];
-        operations: ({
-            op: "edge.update";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
-            };
-            slug: unknown;
-            props?: {
-                set: Record<string, unknown>;
-                unset: string[];
-            } | undefined;
-        } | {
-            op: "edge.update";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
-            };
-            props: {
-                set: Record<string, unknown>;
-                unset: string[];
-            };
-        } | {
-            op: "node.create";
-            as: string;
-            class: string;
-            props: Record<string, unknown>;
-        } | {
-            op: "node.update";
-            node: string;
-            class: string;
-            props: {
-                set: Record<string, unknown>;
-                unset: string[];
-            };
-        } | {
-            op: "node.delete";
-            node: string;
-            class: string;
-        } | {
-            op: "edge.create";
-            class: string;
-            source: string | {
-                created: string;
-            };
-            target: string | {
-                created: string;
-            };
-            slug?: unknown;
-            props: Record<string, unknown>;
-        } | {
-            op: "edge.delete";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
-            };
-        })[];
-    };
-    expected?: {
-        origin: string;
-        revision: string;
-    }[] | undefined;
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        createdNodes: Record<string, string>;
-    };
-}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"mutate"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.mutate";
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    ast: {
-        format: "astrale.graph.query";
-        version: "v6";
-        source: {
-            kind: "node";
-            terms: ({
-                kind: "path";
-                path: string;
-            } | {
-                kind: "class";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            })[];
-            binding: string;
-        } | {
-            kind: "edge";
-            terms: {
-                kind: "class";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            }[];
-            bindings: {
-                source: string;
-                edge: string;
-                target: string;
-            };
-        };
-        steps: ({
-            op: "filter";
-            binding: string;
-            predicate: {
-                kind: "class.satisfies";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            } | {
-                kind: "class.equal";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            } | {
-                kind: "property.equal";
-                property: string;
-                value: unknown;
-            } | {
-                kind: "property.present";
-                property: string;
-            } | {
-                kind: "identity.equal";
-                identity: string | {
-                    source: string;
-                    target: string;
-                    class: string;
-                };
-            };
-        } | {
-            op: "expand";
-            from: string;
-            via: {
-                origin: string;
-                kind: "class";
-                name: string;
-            }[];
-            direction: "incident" | "incoming" | "outgoing";
-            bindings: {
-                edge: string;
-                node: string;
-            };
-        })[];
-        select: {
-            kind: "graph";
-            binding: string;
-            order?: {
-                property: string;
-                direction: "asc" | "desc";
-                unranked: "first" | "last";
+                kind: "class.equal";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            } | {
+                kind: "property.equal";
+                property: string;
+                value: unknown;
+            } | {
+                kind: "property.present";
+                property: string;
+            } | {
+                kind: "identity.equal";
+                identity: string | {
+                    source: string;
+                    target: string;
+                    class: string;
+                };
+            };
+        } | {
+            op: "expand";
+            from: string;
+            via: {
+                origin: string;
+                kind: "class";
+                name: string;
+            }[];
+            direction: "incident" | "incoming" | "outgoing";
+            bindings: {
+                edge: string;
+                node: string;
+            };
+        })[];
+        select: {
+            kind: "graph";
+            binding: string;
+            order?: {
+                property: string;
+                direction: "asc" | "desc";
+                unranked: "first" | "last";
             } | undefined;
         } | {
             kind: "nodes";
@@ -5408,33 +5194,261 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     };
     readonly key: "kernel.astrale.ai:function.query";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    idempotencyKey: string;
-    identities: ({
-        id: string;
-        mode: "external";
-        credential: string;
-    } | {
-        id: string;
-        mode: "self";
-        publicKey: unknown;
-        credential: string;
-    })[];
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        identities: {
-            id: string;
-            iss: string;
-            sub: string;
-        }[];
-    };
-}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"register"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.register";
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    operation: string;
+    ast: {
+        format: "astrale.graph.mutation";
+        version: "v3";
+        preconditions: ({
+            kind: "node";
+            node: string;
+            class: string;
+            props?: {
+                equals: Record<string, unknown>;
+                absent?: string[] | undefined;
+            } | {
+                absent: string[];
+            } | undefined;
+        } | {
+            kind: "edge";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+            slug?: unknown;
+            props?: {
+                equals: Record<string, unknown>;
+                absent?: string[] | undefined;
+            } | {
+                absent: string[];
+            } | undefined;
+        } | {
+            kind: "query";
+            query: {
+                format: "astrale.graph.query";
+                version: "v6";
+                source: {
+                    kind: "node";
+                    terms: ({
+                        kind: "path";
+                        path: string;
+                    } | {
+                        kind: "class";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    })[];
+                    binding: string;
+                } | {
+                    kind: "edge";
+                    terms: {
+                        kind: "class";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    }[];
+                    bindings: {
+                        source: string;
+                        edge: string;
+                        target: string;
+                    };
+                };
+                steps: ({
+                    op: "filter";
+                    binding: string;
+                    predicate: {
+                        kind: "class.satisfies";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    } | {
+                        kind: "class.equal";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    } | {
+                        kind: "property.equal";
+                        property: string;
+                        value: unknown;
+                    } | {
+                        kind: "property.present";
+                        property: string;
+                    } | {
+                        kind: "identity.equal";
+                        identity: string | {
+                            source: string;
+                            target: string;
+                            class: string;
+                        };
+                    };
+                } | {
+                    op: "expand";
+                    from: string;
+                    via: {
+                        origin: string;
+                        kind: "class";
+                        name: string;
+                    }[];
+                    direction: "incident" | "incoming" | "outgoing";
+                    bindings: {
+                        edge: string;
+                        node: string;
+                    };
+                })[];
+                select: {
+                    kind: "graph";
+                    binding: string;
+                    order?: {
+                        property: string;
+                        direction: "asc" | "desc";
+                        unranked: "first" | "last";
+                    } | undefined;
+                } | {
+                    kind: "nodes";
+                    binding: string;
+                    projection: {
+                        kind: "reference" | "value";
+                    };
+                    order?: {
+                        property: string;
+                        direction: "asc" | "desc";
+                        unranked: "first" | "last";
+                    } | undefined;
+                } | {
+                    kind: "edges";
+                    binding: string;
+                    projection: {
+                        edge: "reference" | "value";
+                        source: "reference" | "value";
+                        target: "reference" | "value";
+                    };
+                    order?: {
+                        property: string;
+                        direction: "asc" | "desc";
+                        unranked: "first" | "last";
+                    } | undefined;
+                };
+            };
+            equals: {
+                kind: "node";
+                ids: string[];
+            } | {
+                kind: "edge";
+                keys: {
+                    source: string;
+                    target: string;
+                    class: string;
+                }[];
+            };
+        })[];
+        operations: ({
+            op: "node.create";
+            as: string;
+            class: string;
+            props: Record<string, unknown>;
+        } | {
+            op: "node.update";
+            node: string;
+            class: string;
+            props: {
+                set: Record<string, unknown>;
+                unset: string[];
+            };
+        } | {
+            op: "node.delete";
+            node: string;
+            class: string;
+        } | {
+            op: "edge.create";
+            class: string;
+            source: string | {
+                created: string;
+            };
+            target: string | {
+                created: string;
+            };
+            slug?: unknown;
+            props: Record<string, unknown>;
+        } | {
+            op: "edge.update";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+            slug: unknown;
+            props?: {
+                set: Record<string, unknown>;
+                unset: string[];
+            } | undefined;
+        } | {
+            op: "edge.update";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+            props: {
+                set: Record<string, unknown>;
+                unset: string[];
+            };
+        } | {
+            op: "edge.delete";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+        })[];
+    };
+    expected?: {
+        origin: string;
+        revision: string;
+    }[] | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        createdNodes: Record<string, string>;
+    };
+}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"mutate"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.mutate";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    operation: string;
+    domains: ({
+        artifact: {
+            digest: string;
+            mediaType: string;
+            size: number;
+        };
+        currentRevision?: string | null | undefined;
+    } | {
+        publication: {
+            url: string;
+            token?: string | undefined;
+            etag?: string | undefined;
+        };
+        revision?: string | undefined;
+        currentRevision?: string | null | undefined;
+    })[];
+}, {
+    readonly mode: 'binary';
+}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"install"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.install";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    operation: string;
     domains: string[];
     data: {
         mode: "destructive" | "safe";
@@ -5479,30 +5493,15 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     };
     readonly key: "kernel.astrale.ai:function.uninstall";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
-    iss: string;
-    sub: string;
+    audience?: string | undefined;
+    ttlSeconds: number;
+    grant?: unknown;
+    identity: string;
 }, {
     readonly mode: 'value';
-    readonly value: {
-        id: string;
-        iss: string;
-        sub: string;
-        frozen: boolean;
-        requiredClaims: ({
-            claim: string;
-            op: "contains";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "eq";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "exists";
-        })[];
-    } | null;
-}, 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.Identity.method.whois"> & {
-    readonly name: "whois";
+    readonly value: 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.Identity.method.impersonate"> & {
+    readonly name: "impersonate";
     readonly executable: true;
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     target: string;
@@ -5531,6 +5530,13 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
                 sandbox?: string[] | undefined;
                 allow?: string[] | undefined;
             } | undefined;
+            host?: {
+                navigation: {
+                    external: {
+                        origins: string[];
+                    };
+                };
+            } | undefined;
             issuer: string;
             etag: string;
             revision: string;
@@ -5540,15 +5546,30 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     readonly name: "resolve";
     readonly executable: true;
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
-    audience?: string | undefined;
-    ttlSeconds: number;
-    grant?: unknown;
-    identity: string;
+    iss: string;
+    sub: string;
 }, {
     readonly mode: 'value';
-    readonly value: 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.Identity.method.impersonate"> & {
-    readonly name: "impersonate";
+    readonly value: {
+        id: string;
+        iss: string;
+        sub: string;
+        frozen: boolean;
+        requiredClaims: ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[];
+    } | null;
+}, 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.Identity.method.whois"> & {
+    readonly name: "whois";
     readonly executable: true;
 }))[];
 export { AuthorityOperationOrder, AuthorityOperations, operationOf } from '../authority/index.js';

package/dist/schema/kernel/syscalls/contracts/view-host-requirements.d.ts

@@ -0,0 +1,17 @@
+/** Browser effects required by a published Shell View. */
+export interface ViewHostRequirements {
+    readonly navigation: {
+        readonly external: {
+            readonly origins: readonly string[];
+        };
+    };
+}
+export declare const viewHostRequirements: import("zod").ZodObject<{
+    navigation: import("zod").ZodObject<{
+        external: import("zod").ZodObject<{
+            origins: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>;
+}, import("zod/v4/core").$strict>;
+/** Decode canonical wire requirements; construction also normalizes authored origins. */
+export declare function acceptViewHostRequirements(input: unknown, handshake: 'shell' | 'none', canonicalize?: boolean): ViewHostRequirements | undefined;

package/dist/schema/kernel/syscalls/contracts/view-host-requirements.js

@@ -0,0 +1,40 @@
+import * as portable from '@astrale-os/kernel-dsl/value';
+import { array, strictObject, string } from 'zod';
+export const viewHostRequirements = strictObject({
+    navigation: strictObject({
+        external: strictObject({ origins: array(string()).min(1) }),
+    }),
+});
+/** Decode canonical wire requirements; construction also normalizes authored origins. */
+export function acceptViewHostRequirements(input, handshake, canonicalize = false) {
+    if (input === undefined)
+        return undefined;
+    if (handshake !== 'shell')
+        throw new TypeError('Host requirements require a Shell handshake.');
+    const parsed = viewHostRequirements.safeParse(portable.accept(input));
+    if (!parsed.success)
+        throw new TypeError('View host requirements are invalid.');
+    const origins = parsed.data.navigation.external.origins.map((candidate) => {
+        const url = new URL(candidate);
+        if (url.protocol !== 'https:' ||
+            url.hostname.includes('*') ||
+            url.username !== '' ||
+            url.password !== '' ||
+            url.pathname !== '/' ||
+            url.search !== '' ||
+            url.hash !== '' ||
+            (!canonicalize && url.origin !== candidate))
+            throw new TypeError('External navigation requires an exact HTTPS origin.');
+        return url.origin;
+    });
+    const canonical = [...new Set(origins)].sort();
+    if (!canonicalize &&
+        (canonical.length !== origins.length ||
+            canonical.some((origin, index) => origin !== origins[index])))
+        throw new TypeError('External navigation origins are not canonical.');
+    return Object.freeze({
+        navigation: Object.freeze({
+            external: Object.freeze({ origins: Object.freeze(canonical) }),
+        }),
+    });
+}

package/dist/schema/kernel/syscalls/contracts/view-resolve.d.ts

@@ -27,6 +27,13 @@ export declare const viewResolveOutput: import("zod").ZodObject<{
             sandbox: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
             allow: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
         }, import("zod/v4/core").$strict>>;
+        host: import("zod").ZodOptional<import("zod").ZodObject<{
+            navigation: import("zod").ZodObject<{
+                external: import("zod").ZodObject<{
+                    origins: import("zod").ZodArray<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>>;
         issuer: import("zod").ZodString;
         etag: import("zod").ZodString;
         revision: import("zod").ZodString;

package/dist/schema/kernel/syscalls/contracts/view-resolve.js

@@ -1,6 +1,7 @@
 import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
 import { array, discriminatedUnion, enum as enumeration, literal, strictObject, string } from 'zod';
+import { viewHostRequirements } from './view-host-requirements.js';
 const definition = strictObject({
     origin: string().check(fullMatch(patterns.originFullMatch)),
     kind: literal('class'),
@@ -26,6 +27,7 @@ export const viewResolveOutput = strictObject({
         href: string().min(1),
         handshake: enumeration(['shell', 'none']),
         iframe: iframeRequirements.optional(),
+        host: viewHostRequirements.optional(),
         issuer: string().min(1),
         etag: string().min(1),
         revision: string().min(1),

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

@@ -696,6 +696,13 @@ export declare const ViewMethods: Readonly<{
                     sandbox?: string[] | undefined;
                     allow?: string[] | undefined;
                 } | undefined;
+                host?: {
+                    navigation: {
+                        external: {
+                            origins: string[];
+                        };
+                    };
+                } | undefined;
                 issuer: string;
                 etag: string;
                 revision: string;

package/dist/schema/kernel/syscalls/declarations/view-resolve.d.ts

@@ -26,6 +26,13 @@ export declare const ViewResolve: builder.Method<builder.CallableProjection<{
                 sandbox?: string[] | undefined;
                 allow?: string[] | undefined;
             } | undefined;
+            host?: {
+                navigation: {
+                    external: {
+                        origins: string[];
+                    };
+                };
+            } | undefined;
             issuer: string;
             etag: string;
             revision: string;

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

@@ -1,12 +1,15 @@
 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 iframe?: IframeRequirements;
+    readonly host?: ViewHostRequirements;
     readonly issuer: IssuerId;
     readonly etag: `sha256:${string}`;
     readonly revision: Revision;
@@ -22,4 +25,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

@@ -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);
@@ -24,12 +26,14 @@ export function acceptViewResolution(input) {
             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`),

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

@@ -30,6 +30,13 @@ export declare const resolve: import("./model.js").MethodSyscall<Readonly<{
                 sandbox?: string[] | undefined;
                 allow?: string[] | undefined;
             } | undefined;
+            host?: {
+                navigation: {
+                    external: {
+                        origins: string[];
+                    };
+                };
+            } | undefined;
             issuer: string;
             etag: string;
             revision: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-core",
-  "version": "0.9.0-beta.46",
+  "version": "0.9.0-beta.47",
   "description": "Astrale Kernel Core - Types, Invariants, and Pure Logic",
   "license": "Apache-2.0",
   "repository": {
@@ -186,6 +186,6 @@
     "test": "vitest run",
     "test:file": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.types.json && tsc --noEmit -p schema/.module/tsconfig.json"
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.types.json && tsc --noEmit -p schema/.module/tsconfig.json && tsc -p tsconfig.workers.json"
   }
 }