@astrale-os/kernel-core 0.9.0-beta.22 → 0.9.0-beta.23

package/CHANGELOG.md

@@ -6,6 +6,13 @@
 
 * remove endpoint, route, serving issuer, Publication ETag, and View placement properties from the
   Function and UI schema; graph projection now contains declaration meaning only
+## [0.9.0-beta.23](https://github.com/astrale-os/kernel/compare/kernel-core-v0.9.0-beta.22...kernel-core-v0.9.0-beta.23) (2026-08-29)
+
+
+### Features
+
+* **api:** carry view iframe requirements ([#531](https://github.com/astrale-os/kernel/issues/531)) ([4eedb0b](https://github.com/astrale-os/kernel/commit/4eedb0b3430f5f642942e913cf1c5806e09b7cf1))
+
 ## [0.9.0-beta.22](https://github.com/astrale-os/kernel/compare/kernel-core-v0.9.0-beta.21...kernel-core-v0.9.0-beta.22) (2026-08-29)
 
 

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

@@ -42,6 +42,10 @@ export declare const View: builder.NodeClass<{
                     };
                     href: string;
                     handshake: "none" | "shell";
+                    iframe?: {
+                        sandbox?: string[] | undefined;
+                        allow?: string[] | undefined;
+                    } | undefined;
                     issuer: string;
                     etag: string;
                     revision: string;
@@ -81,6 +85,10 @@ export declare const View: builder.NodeClass<{
                 };
                 href: string;
                 handshake: "none" | "shell";
+                iframe?: {
+                    sandbox?: string[] | undefined;
+                    allow?: string[] | undefined;
+                } | undefined;
                 issuer: string;
                 etag: string;
                 revision: string;

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

@@ -4269,6 +4269,10 @@ declare const KernelDefinitions: {
                             };
                             href: string;
                             handshake: "none" | "shell";
+                            iframe?: {
+                                sandbox?: string[] | undefined;
+                                allow?: string[] | undefined;
+                            } | undefined;
                             issuer: string;
                             etag: string;
                             revision: string;
@@ -4308,6 +4312,10 @@ declare const KernelDefinitions: {
                         };
                         href: string;
                         handshake: "none" | "shell";
+                        iframe?: {
+                            sandbox?: string[] | undefined;
+                            allow?: string[] | undefined;
+                        } | undefined;
                         issuer: string;
                         etag: string;
                         revision: string;
@@ -5614,6 +5622,41 @@ 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<{
+    kind: "bundle" | "inspect";
+    origin: string;
+}, {
+    readonly mode: 'binary';
+}, "authenticated", 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<"introspect"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.introspect";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     invocation?: {
         source: string;
         id: string;
@@ -5645,233 +5688,6 @@ 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<{
-    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";
-            } | 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;
-        };
-    };
-    expected?: {
-        origin: string;
-        revision: string;
-    }[] | undefined;
-    page: {
-        size: number;
-        after?: string | undefined;
-    };
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        result: {
-            kind: "graph";
-            graph: {
-                nodes: {
-                    id: string;
-                    class: string;
-                    props: Record<string, unknown>;
-                }[];
-                edges: {
-                    source: string;
-                    target: string;
-                    class: string;
-                    slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
-                    props: Record<string, unknown>;
-                }[];
-            };
-            selection: {
-                kind: "node";
-                ids: string[];
-            } | {
-                kind: "edge";
-                keys: {
-                    source: string;
-                    target: string;
-                    class: string;
-                }[];
-            };
-        } | {
-            kind: "nodes";
-            nodes: ({
-                kind: "reference";
-                value: {
-                    id: string;
-                    class: string;
-                };
-            } | {
-                kind: "value";
-                value: {
-                    id: string;
-                    class: string;
-                    props: Record<string, unknown>;
-                };
-            })[];
-        } | {
-            kind: "edges";
-            edges: {
-                edge: {
-                    kind: "reference";
-                    value: {
-                        source: string;
-                        target: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        source: string;
-                        target: string;
-                        class: string;
-                        slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
-                        props: Record<string, unknown>;
-                    };
-                };
-                source: {
-                    kind: "reference";
-                    value: {
-                        id: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        id: string;
-                        class: string;
-                        props: Record<string, unknown>;
-                    };
-                };
-                target: {
-                    kind: "reference";
-                    value: {
-                        id: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        id: string;
-                        class: string;
-                        props: Record<string, unknown>;
-                    };
-                };
-            }[];
-        };
-        page: {
-            next?: string | undefined;
-        };
-    };
-}, "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<"query"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.query";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     ast: {
         format: "astrale.graph.mutation";
@@ -6375,40 +6191,232 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     };
     readonly key: "kernel.astrale.ai:function.provision";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    operation: string;
-    domains: ({
-        artifact: {
-            digest: string;
-            mediaType: string;
-            size: number;
+    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;
+            };
         };
-        currentRevision?: string | null | undefined;
-    } | {
-        publication: {
-            url: string;
-            token?: string | undefined;
-            etag?: string | undefined;
+        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;
         };
-        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<{
-    kind: "bundle" | "inspect";
-    origin: string;
+    expected?: {
+        origin: string;
+        revision: string;
+    }[] | undefined;
+    page: {
+        size: number;
+        after?: string | undefined;
+    };
 }, {
-    readonly mode: 'binary';
-}, "authenticated", 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<"introspect"> & {
+    readonly mode: 'value';
+    readonly value: {
+        result: {
+            kind: "graph";
+            graph: {
+                nodes: {
+                    id: string;
+                    class: string;
+                    props: Record<string, unknown>;
+                }[];
+                edges: {
+                    source: string;
+                    target: string;
+                    class: string;
+                    slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
+                    props: Record<string, unknown>;
+                }[];
+            };
+            selection: {
+                kind: "node";
+                ids: string[];
+            } | {
+                kind: "edge";
+                keys: {
+                    source: string;
+                    target: string;
+                    class: string;
+                }[];
+            };
+        } | {
+            kind: "nodes";
+            nodes: ({
+                kind: "reference";
+                value: {
+                    id: string;
+                    class: string;
+                };
+            } | {
+                kind: "value";
+                value: {
+                    id: string;
+                    class: string;
+                    props: Record<string, unknown>;
+                };
+            })[];
+        } | {
+            kind: "edges";
+            edges: {
+                edge: {
+                    kind: "reference";
+                    value: {
+                        source: string;
+                        target: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        source: string;
+                        target: string;
+                        class: string;
+                        slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
+                        props: Record<string, unknown>;
+                    };
+                };
+                source: {
+                    kind: "reference";
+                    value: {
+                        id: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        id: string;
+                        class: string;
+                        props: Record<string, unknown>;
+                    };
+                };
+                target: {
+                    kind: "reference";
+                    value: {
+                        id: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        id: string;
+                        class: string;
+                        props: Record<string, unknown>;
+                    };
+                };
+            }[];
+        };
+        page: {
+            next?: string | undefined;
+        };
+    };
+}, "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<"query"> & {
         readonly origin: "kernel.astrale.ai";
     };
-    readonly key: "kernel.astrale.ai:function.introspect";
+    readonly key: "kernel.astrale.ai:function.query";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     operation: string;
     origin: string;
@@ -6508,6 +6516,10 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
             };
             href: string;
             handshake: "none" | "shell";
+            iframe?: {
+                sandbox?: string[] | undefined;
+                allow?: string[] | undefined;
+            } | undefined;
             issuer: string;
             etag: string;
             revision: string;

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

@@ -24,6 +24,10 @@ export declare const viewResolveOutput: z.ZodObject<{
             none: "none";
             shell: "shell";
         }>;
+        iframe: z.ZodOptional<z.ZodObject<{
+            sandbox: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
         issuer: z.ZodString;
         etag: z.ZodString;
         revision: z.ZodString;

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

@@ -13,6 +13,10 @@ const declaration = z.strictObject({
         z.strictObject({ kind: z.literal('definition'), definitions: z.array(definition).min(1) }),
     ]),
 });
+const iframeRequirements = z.strictObject({
+    sandbox: z.array(z.string()).optional(),
+    allow: z.array(z.string()).optional(),
+});
 export const viewResolveInput = z.strictObject({ target: z.string().min(1) });
 export const viewResolveOutput = z.strictObject({
     snapshot: z.string().min(1),
@@ -21,6 +25,7 @@ export const viewResolveOutput = z.strictObject({
         declaration,
         href: z.string().min(1),
         handshake: z.enum(['shell', 'none']),
+        iframe: iframeRequirements.optional(),
         issuer: z.string().min(1),
         etag: z.string().min(1),
         revision: z.string().min(1),

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

@@ -922,6 +922,10 @@ export declare const ViewMethods: Readonly<{
                 };
                 href: string;
                 handshake: "none" | "shell";
+                iframe?: {
+                    sandbox?: string[] | undefined;
+                    allow?: string[] | undefined;
+                } | undefined;
                 issuer: string;
                 etag: string;
                 revision: string;

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

@@ -22,6 +22,10 @@ export declare const ViewResolve: builder.Method<builder.CallableProjection<{
             };
             href: string;
             handshake: "none" | "shell";
+            iframe?: {
+                sandbox?: string[] | undefined;
+                allow?: string[] | undefined;
+            } | undefined;
             issuer: string;
             etag: string;
             revision: string;

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

@@ -6,10 +6,15 @@ export interface ResolvedView {
     readonly declaration: ViewDeclaration;
     readonly href: string;
     readonly handshake: 'shell' | 'none';
+    readonly iframe?: IframeRequirements;
     readonly issuer: IssuerId;
     readonly etag: `sha256:${string}`;
     readonly revision: Revision;
 }
+export interface IframeRequirements {
+    readonly sandbox?: readonly string[];
+    readonly allow?: readonly string[];
+}
 type ViewDeclaration = Omit<ViewDefinition, 'ref'>;
 export interface ViewResolution {
     readonly snapshot: `sha256:${string}`;

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

@@ -23,11 +23,13 @@ export function acceptViewResolution(input) {
         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);
         return Object.freeze({
             key,
             declaration,
             href: view.href,
             handshake: view.handshake,
+            ...(iframe === undefined ? {} : { iframe }),
             issuer: view.issuer,
             etag: digest(view.etag, `Resolved View ${index} ETag`),
             revision: digest(view.revision, `Resolved View ${index} revision`),
@@ -43,6 +45,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({

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

@@ -26,6 +26,10 @@ export declare const resolve: import("./model.js").MethodSyscall<Readonly<{
             };
             href: string;
             handshake: "none" | "shell";
+            iframe?: {
+                sandbox?: string[] | undefined;
+                allow?: string[] | undefined;
+            } | undefined;
             issuer: string;
             etag: string;
             revision: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-core",
-  "version": "0.9.0-beta.22",
+  "version": "0.9.0-beta.23",
   "description": "Astrale Kernel Core - Types, Invariants, and Pure Logic",
   "license": "Apache-2.0",
   "repository": {