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

package/dist/schema/kernel/schema.js

@@ -76,6 +76,7 @@ export const KernelRootFunctions = Object.freeze([
     K.functions.uninstall,
     K.functions.journal,
     K.classes.Identity.static.methods.whois,
+    K.classes.Identity.static.methods.impersonate,
     K.classes.View.static.methods.resolve,
 ].sort((left, right) => (left.key < right.key ? -1 : left.key > right.key ? 1 : 0)));
 export { AuthorityOperationOrder, AuthorityOperations, operationOf } from '../authority/index.js';

package/dist/schema/kernel/syscalls/contracts/impersonate.d.ts

@@ -0,0 +1,7 @@
+export declare const impersonateInput: import("zod").ZodObject<{
+    audience: import("zod").ZodOptional<import("zod").ZodString>;
+    ttlSeconds: import("zod").ZodNumber;
+    grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    identity: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const impersonateOutput: import("zod").ZodString;

package/dist/schema/kernel/syscalls/contracts/impersonate.js

@@ -0,0 +1,4 @@
+import { string } from 'zod';
+import { mintInput, mintOutput } from './mint.js';
+export const impersonateInput = mintInput.extend({ identity: string().min(1) });
+export const impersonateOutput = mintOutput;

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

@@ -4,6 +4,7 @@ export { delegateInput, delegateOutput } from './delegate.js';
 export { installInput, installReceipt, type DomainRequest, type InstallInput, type InstallReceipt, } from './install.js';
 export { introspectInput } from './introspect.js';
 export { journalInput, journalOutput } from './journal.js';
+export { impersonateInput, impersonateOutput } from './impersonate.js';
 export { mintInput, mintOutput } from './mint.js';
 export { mutateInput, mutateOutput } from './mutate.js';
 export { registerInput, registerOutput } from './register.js';

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

@@ -4,6 +4,7 @@ export { delegateInput, delegateOutput } from './delegate.js';
 export { installInput, installReceipt, } from './install.js';
 export { introspectInput } from './introspect.js';
 export { journalInput, journalOutput } from './journal.js';
+export { impersonateInput, impersonateOutput } from './impersonate.js';
 export { mintInput, mintOutput } from './mint.js';
 export { mutateInput, mutateOutput } from './mutate.js';
 export { registerInput, registerOutput } from './register.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/impersonate.d.ts

@@ -0,0 +1,10 @@
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Impersonate: builder.Method<builder.CallableProjection<{
+    audience?: string | undefined;
+    ttlSeconds: number;
+    grant?: unknown;
+    identity: string;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, "authorized", true, false>>;

package/dist/schema/kernel/syscalls/declarations/impersonate.js

@@ -0,0 +1,12 @@
+import { method } from '@astrale-os/kernel-dsl/v1';
+import { impersonateInput, impersonateOutput } from '../contracts/index.js';
+import { usePolicy } from './use-policy.js';
+export const Impersonate = method({
+    description: 'Issue a Kernel credential bounded by the active target Identity authority.',
+    auth: 'authorized',
+    policy: usePolicy(() => Impersonate),
+    input: impersonateInput,
+    output: impersonateOutput,
+    static: true,
+    abstract: false,
+});

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

@@ -379,29 +379,6 @@ export declare const Functions: Readonly<{
                 };
             })[];
             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;
@@ -429,6 +406,29 @@ export declare const Functions: Readonly<{
                 };
                 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: {
@@ -639,6 +639,15 @@ export declare const IdentityMethods: Readonly<{
         readonly mode: 'value';
         readonly value: string;
     }, "authenticated", true, false>>;
+    impersonate: builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>;
 }>;
 export declare const FunctionMethods: Readonly<{
     admit: builder.Method<builder.CallableProjection<{
@@ -687,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/index.js

@@ -1,6 +1,7 @@
 import { Admit } from './admit.js';
 import { Can } from './can.js';
 import { Delegate } from './delegate.js';
+import { Impersonate } from './impersonate.js';
 import { Install } from './install.js';
 import { Introspect } from './introspect.js';
 import { Journal } from './journal.js';
@@ -27,6 +28,7 @@ export const IdentityMethods = Object.freeze({
     whoami: Whoami,
     whois: Whois,
     mint: Mint,
+    impersonate: Impersonate,
 });
 export const FunctionMethods = Object.freeze({
     admit: Admit,

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/identity.d.ts

@@ -89,6 +89,22 @@ export declare const whois: import("./model.js").MethodSyscall<Readonly<{
     readonly name: "whois";
     readonly executable: true;
 }>;
+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;
+    grant?: unknown;
+    identity: 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 executable: true;
+}>;
 export declare const mint: import("./model.js").MethodSyscall<Readonly<{
     origin: 'kernel.astrale.ai';
     kind: 'class';

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

@@ -5,4 +5,5 @@ export const delegate = methodSyscall(references.delegate, K.classes.Identity.st
 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/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/dist/schema/kernel/syscalls/references/identity.d.ts

@@ -43,3 +43,12 @@ export declare const mint: Readonly<{
     }>;
     name: "mint";
 }>;
+export declare const impersonate: Readonly<{
+    kind: 'method';
+    owner: Readonly<{
+        origin: 'kernel.astrale.ai';
+        kind: 'class';
+        name: 'Identity';
+    }>;
+    name: "impersonate";
+}>;

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

@@ -9,3 +9,4 @@ export const can = methodRef('can');
 export const whoami = methodRef('whoami');
 export const whois = methodRef('whois');
 export const mint = methodRef('mint');
+export const impersonate = methodRef('impersonate');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-core",
-  "version": "0.9.0-beta.45",
+  "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"
   }
 }