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

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

@@ -1,159 +1,66 @@
-import { z } from 'zod';
 import type { OperationId } from '../../../installation/operation-id.js';
 import type { TransitionReceipt } from './install.js';
-export declare const uninstallInput: z.ZodObject<{
-    operation: z.ZodString;
-    origin: z.ZodString;
-}, z.core.$strict>;
-export declare const uninstallOutput: z.ZodObject<{
-    operation: z.ZodString;
-    transition: z.ZodObject<{
-        intent: z.ZodObject<{
-            transition: z.ZodString;
-            operation: z.ZodString;
-            installation: z.ZodString;
-            origin: z.ZodString;
-            source: z.ZodNullable<z.ZodObject<{
-                origin: z.ZodString;
-                schemaRevision: z.ZodString;
-                schemaBundle: z.ZodString;
-                service: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"local">;
-                    artifact: z.ZodString;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"remote">;
-                    etag: z.ZodString;
-                }, z.core.$strict>], "kind">;
-                capabilities: z.ZodObject<{
-                    functions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                    classes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                        class: z.ZodObject<{
-                            origin: z.ZodString;
-                            kind: z.ZodLiteral<"class">;
-                            name: z.ZodString;
-                        }, z.core.$strict>;
-                        operations: z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            read: "read";
-                            traverse: "traverse";
-                            update: "update";
-                        }>>;
-                    }, z.core.$strict>>>;
-                    admin: z.ZodOptional<z.ZodObject<{
-                        grant: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            grant: "grant";
-                            read: "read";
-                            revoke: "revoke";
-                            traverse: "traverse";
-                            update: "update";
-                            use: "use";
-                        }>>>;
-                        revoke: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            grant: "grant";
-                            read: "read";
-                            revoke: "revoke";
-                            traverse: "traverse";
-                            update: "update";
-                            use: "use";
-                        }>>>;
-                    }, z.core.$strict>>;
-                }, z.core.$strict>;
-                dependencies: z.ZodArray<z.ZodObject<{
-                    origin: z.ZodString;
-                    installation: z.ZodString;
-                    target: z.ZodString;
-                    readinessReceipt: z.ZodString;
-                    meaningComparison: z.ZodString;
-                }, z.core.$strict>>;
-            }, z.core.$strict>>;
-            target: z.ZodNullable<z.ZodObject<{
-                origin: z.ZodString;
-                schemaRevision: z.ZodString;
-                schemaBundle: z.ZodString;
-                service: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"local">;
-                    artifact: z.ZodString;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"remote">;
-                    etag: z.ZodString;
-                }, z.core.$strict>], "kind">;
-                capabilities: z.ZodObject<{
-                    functions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                    classes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                        class: z.ZodObject<{
-                            origin: z.ZodString;
-                            kind: z.ZodLiteral<"class">;
-                            name: z.ZodString;
-                        }, z.core.$strict>;
-                        operations: z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            read: "read";
-                            traverse: "traverse";
-                            update: "update";
-                        }>>;
-                    }, z.core.$strict>>>;
-                    admin: z.ZodOptional<z.ZodObject<{
-                        grant: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            grant: "grant";
-                            read: "read";
-                            revoke: "revoke";
-                            traverse: "traverse";
-                            update: "update";
-                            use: "use";
-                        }>>>;
-                        revoke: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            grant: "grant";
-                            read: "read";
-                            revoke: "revoke";
-                            traverse: "traverse";
-                            update: "update";
-                            use: "use";
-                        }>>>;
-                    }, z.core.$strict>>;
-                }, z.core.$strict>;
-                dependencies: z.ZodArray<z.ZodObject<{
-                    origin: z.ZodString;
-                    installation: z.ZodString;
-                    target: z.ZodString;
-                    readinessReceipt: z.ZodString;
-                    meaningComparison: z.ZodString;
-                }, z.core.$strict>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        phase: z.ZodEnum<{
+export declare const uninstallInput: import("zod").ZodObject<{
+    operation: import("zod").ZodString;
+    domains: import("zod").ZodArray<import("zod").ZodString>;
+    data: import("zod").ZodObject<{
+        mode: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"safe">, import("zod").ZodLiteral<"destructive">]>;
+    }, import("zod/v4/core").$strict>;
+}, import("zod/v4/core").$strict>;
+/** What a completed uninstall ends with, the value its Execution's `result` yields. */
+export declare const uninstallOutput: import("zod").ZodObject<{
+    operation: import("zod").ZodString;
+    transitions: import("zod").ZodArray<import("zod").ZodObject<{
+        intent: import("zod").ZodObject<{
+            transition: import("zod").ZodString;
+            operation: import("zod").ZodString;
+            origin: import("zod").ZodString;
+            previous: import("zod").ZodNullable<import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                revision: import("zod").ZodString;
+                generation: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            generation: import("zod").ZodNullable<import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                revision: import("zod").ZodString;
+                generation: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            consent: import("zod").ZodOptional<import("zod").ZodObject<{
+                issuer: import("zod").ZodObject<{
+                    from: import("zod").ZodString;
+                    to: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                previous: import("zod").ZodEnum<{
+                    drain: "drain";
+                    revoke: "revoke";
+                }>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        phase: import("zod").ZodEnum<{
             converge: "converge";
             cutover: "cutover";
         }>;
-        state: z.ZodLiteral<"committed">;
-        readiness: z.ZodOptional<z.ZodObject<{
-            installation: z.ZodString;
-            target: z.ZodString;
-            transition: z.ZodString;
-            dependencies: z.ZodArray<z.ZodObject<{
-                origin: z.ZodString;
-                installation: z.ZodString;
-                target: z.ZodString;
-                readinessReceipt: z.ZodString;
-                meaningComparison: z.ZodString;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
+        state: import("zod").ZodLiteral<"committed">;
+        readiness: import("zod").ZodOptional<import("zod").ZodObject<{
+            generation: import("zod").ZodString;
+            transition: import("zod").ZodString;
+            dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                generation: import("zod").ZodString;
+                readiness: import("zod").ZodString;
+                meaning: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;
 export interface UninstallInput {
     readonly operation: OperationId;
-    readonly origin: string;
+    readonly domains: readonly [string, ...string[]];
+    readonly data: {
+        readonly mode: 'safe' | 'destructive';
+    };
 }
 export interface UninstallOutput {
     readonly operation: OperationId;
-    readonly transition: TransitionReceipt;
+    readonly transitions: readonly [TransitionReceipt, ...TransitionReceipt[]];
 }

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

@@ -1,10 +1,12 @@
-import { z } from 'zod';
+import { array, literal, strictObject, union } from 'zod';
 import { installationText, operationIdSchema, transitionReceipt } from './installation.js';
-export const uninstallInput = z.strictObject({
+export const uninstallInput = strictObject({
     operation: operationIdSchema,
-    origin: installationText,
+    domains: array(installationText).min(1),
+    data: strictObject({ mode: union([literal('safe'), literal('destructive')]) }),
 });
-export const uninstallOutput = z.strictObject({
+/** What a completed uninstall ends with, the value its Execution's `result` yields. */
+export const uninstallOutput = strictObject({
     operation: operationIdSchema,
-    transition: transitionReceipt,
+    transitions: array(transitionReceipt).min(1),
 });

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

@@ -1,31 +1,30 @@
-import { z } from 'zod';
-export declare const viewResolveInput: z.ZodObject<{
-    target: z.ZodString;
-}, z.core.$strict>;
-export declare const viewResolveOutput: z.ZodObject<{
-    snapshot: z.ZodString;
-    views: z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        declaration: z.ZodObject<{
-            description: z.ZodOptional<z.ZodString>;
-            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"domain">;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"definition">;
-                definitions: z.ZodArray<z.ZodObject<{
-                    origin: z.ZodString;
-                    kind: z.ZodLiteral<"class">;
-                    name: z.ZodString;
-                }, z.core.$strict>>;
-            }, z.core.$strict>], "kind">;
-        }, z.core.$strict>;
-        href: z.ZodString;
-        handshake: z.ZodEnum<{
+export declare const viewResolveInput: import("zod").ZodObject<{
+    target: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const viewResolveOutput: import("zod").ZodObject<{
+    snapshot: import("zod").ZodString;
+    views: import("zod").ZodArray<import("zod").ZodObject<{
+        key: import("zod").ZodString;
+        declaration: import("zod").ZodObject<{
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            target: import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"domain">;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>;
+        href: import("zod").ZodString;
+        handshake: import("zod").ZodEnum<{
             none: "none";
             shell: "shell";
         }>;
-        issuer: z.ZodString;
-        etag: z.ZodString;
-        revision: z.ZodString;
-    }, z.core.$strict>>;
-}, z.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;
+        release: import("zod").ZodString;
+        revision: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;

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

@@ -1,28 +1,20 @@
-import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
-import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
-import { z } from 'zod';
-const definition = z.strictObject({
-    origin: z.string().check(fullMatch(patterns.originFullMatch)),
-    kind: z.literal('class'),
-    name: z.string().check(fullMatch(patterns.memberNameFullMatch)),
+import { array, enum as enumeration, literal, strictObject, string } from 'zod';
+import { viewHostRequirements } from './view-host-requirements.js';
+const declaration = strictObject({
+    description: string().optional(),
+    target: strictObject({ kind: literal('domain') }),
 });
-const declaration = z.strictObject({
-    description: z.string().optional(),
-    target: z.discriminatedUnion('kind', [
-        z.strictObject({ kind: z.literal('domain') }),
-        z.strictObject({ kind: z.literal('definition'), definitions: z.array(definition).min(1) }),
-    ]),
-});
-export const viewResolveInput = z.strictObject({ target: z.string().min(1) });
-export const viewResolveOutput = z.strictObject({
-    snapshot: z.string().min(1),
-    views: z.array(z.strictObject({
-        key: z.string().min(1),
+export const viewResolveInput = strictObject({ target: string().min(1) });
+export const viewResolveOutput = strictObject({
+    snapshot: string().min(1),
+    views: array(strictObject({
+        key: string().min(1),
         declaration,
-        href: z.string().min(1),
-        handshake: z.enum(['shell', 'none']),
-        issuer: z.string().min(1),
-        etag: z.string().min(1),
-        revision: z.string().min(1),
+        href: string().min(1),
+        handshake: enumeration(['shell', 'none']),
+        host: viewHostRequirements.optional(),
+        issuer: string().min(1),
+        release: string().min(1),
+        revision: string().min(1),
     })),
 });

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

@@ -1,20 +1,19 @@
-import { z } from 'zod';
-export declare const whoamiInput: z.ZodObject<{}, z.core.$strict>;
-export declare const whoamiOutput: z.ZodObject<{
-    id: z.ZodString;
-    issuer: z.ZodString;
-    subject: z.ZodString;
-    frozen: z.ZodBoolean;
-    requiredClaims: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        claim: z.ZodString;
-        op: z.ZodLiteral<"contains">;
-        value: z.ZodNonOptional<z.ZodUnknown>;
-    }, z.core.$strict>, z.ZodObject<{
-        claim: z.ZodString;
-        op: z.ZodLiteral<"eq">;
-        value: z.ZodNonOptional<z.ZodUnknown>;
-    }, z.core.$strict>, z.ZodObject<{
-        claim: z.ZodString;
-        op: z.ZodLiteral<"exists">;
-    }, z.core.$strict>], "op">>;
-}, z.core.$strict>;
+export declare const whoamiInput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const whoamiOutput: import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    iss: import("zod").ZodString;
+    sub: import("zod").ZodString;
+    frozen: import("zod").ZodBoolean;
+    requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        claim: import("zod").ZodString;
+        op: import("zod").ZodLiteral<"contains">;
+        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        claim: import("zod").ZodString;
+        op: import("zod").ZodLiteral<"eq">;
+        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        claim: import("zod").ZodString;
+        op: import("zod").ZodLiteral<"exists">;
+    }, import("zod/v4/core").$strict>], "op">>;
+}, import("zod/v4/core").$strict>;

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { strictObject } from 'zod';
 import { identityOutput } from './identity.js';
-export const whoamiInput = z.strictObject({});
+export const whoamiInput = strictObject({});
 export const whoamiOutput = identityOutput;

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

@@ -1,23 +1,22 @@
-import { z } from 'zod';
-export declare const whoisInput: z.ZodObject<{
-    issuer: z.ZodString;
-    subject: z.ZodString;
-}, z.core.$strict>;
-export declare const whoisOutput: z.ZodNullable<z.ZodObject<{
-    id: z.ZodString;
-    issuer: z.ZodString;
-    subject: z.ZodString;
-    frozen: z.ZodBoolean;
-    requiredClaims: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        claim: z.ZodString;
-        op: z.ZodLiteral<"contains">;
-        value: z.ZodNonOptional<z.ZodUnknown>;
-    }, z.core.$strict>, z.ZodObject<{
-        claim: z.ZodString;
-        op: z.ZodLiteral<"eq">;
-        value: z.ZodNonOptional<z.ZodUnknown>;
-    }, z.core.$strict>, z.ZodObject<{
-        claim: z.ZodString;
-        op: z.ZodLiteral<"exists">;
-    }, z.core.$strict>], "op">>;
-}, z.core.$strict>>;
+export declare const whoisInput: import("zod").ZodObject<{
+    iss: import("zod").ZodString;
+    sub: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const whoisOutput: import("zod").ZodNullable<import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    iss: import("zod").ZodString;
+    sub: import("zod").ZodString;
+    frozen: import("zod").ZodBoolean;
+    requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        claim: import("zod").ZodString;
+        op: import("zod").ZodLiteral<"contains">;
+        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        claim: import("zod").ZodString;
+        op: import("zod").ZodLiteral<"eq">;
+        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        claim: import("zod").ZodString;
+        op: import("zod").ZodLiteral<"exists">;
+    }, import("zod/v4/core").$strict>], "op">>;
+}, import("zod/v4/core").$strict>>;

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

@@ -1,5 +1,5 @@
-import { z } from 'zod';
+import { strictObject, string } from 'zod';
 import { identityOutput } from './identity.js';
-const text = z.string().min(1);
-export const whoisInput = z.strictObject({ issuer: text, subject: text });
+const text = string().min(1);
+export const whoisInput = strictObject({ iss: text, sub: text });
 export const whoisOutput = identityOutput.nullable();

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

@@ -1,18 +1,18 @@
-import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Admit: builder.Method<{
-    readonly description: "Admit one remote path-only attempt and return its request-scoped execution target.";
-    readonly auth: "authenticated";
-    readonly input: import("zod").ZodObject<{
-        call: import("zod").ZodObject<{
-            target: import("zod").ZodString;
-            input: import("zod").ZodUnknown;
-        }, import("zod/v4/core").$strict>;
-        credential: import("zod").ZodOptional<import("zod").ZodString>;
-    }, import("zod/v4/core").$strict>;
-    readonly output: import("zod").ZodObject<{
-        callable: import("zod").ZodString;
-        receiver: import("zod").ZodOptional<import("zod").ZodString>;
-    }, import("zod/v4/core").$strict>;
-    readonly static: true;
-    readonly inheritance: "sealed";
-}>;
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Admit: builder.Method<builder.CallableProjection<{
+    call: {
+        target: string | {
+            callable: string;
+            instance?: string | undefined;
+            fingerprint?: string | undefined;
+        };
+        input: unknown;
+    };
+    credential?: string | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        callable: string;
+        receiver?: string | undefined;
+    };
+}, "authenticated", true, false, undefined>>;

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

@@ -1,10 +1,10 @@
+import { method } from '@astrale-os/kernel-dsl/v1';
 import { admitInput, admitOutput } from '../contracts/index.js';
-import { defineMethod } from './define.js';
-export const Admit = defineMethod({
+export const Admit = method({
     description: 'Admit one remote path-only attempt and return its request-scoped execution target.',
     auth: 'authenticated',
     input: admitInput,
     output: admitOutput,
     static: true,
-    inheritance: 'sealed',
+    abstract: false,
 });

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

@@ -1,14 +1,19 @@
-import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Can: builder.Method<{
-    readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-    readonly auth: "authenticated";
-    readonly input: import("zod").ZodObject<{
-        policy: import("zod").ZodString;
-        object: import("zod").ZodString;
-    }, import("zod/v4/core").$strict>;
-    readonly output: import("zod").ZodObject<{
-        allowed: import("zod").ZodBoolean;
-    }, import("zod/v4/core").$strict>;
-    readonly static: true;
-    readonly inheritance: "default";
-}>;
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Can: builder.Method<builder.CallableProjection<{
+    policy: string;
+    object: string;
+} | {
+    checks: {
+        policy: string;
+        object: string;
+    }[];
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        allowed: boolean;
+    } | {
+        decisions: {
+            allowed: boolean;
+        }[];
+    };
+}, "authenticated", true, false, undefined>>;

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

@@ -1,10 +1,10 @@
+import { method } from '@astrale-os/kernel-dsl/v1';
 import { canInput, canOutput } from '../contracts/index.js';
-import { defineMethod } from './define.js';
-export const Can = defineMethod({
-    description: 'Determine whether the current authenticated Identity satisfies one installed Policy for one object.',
+export const Can = method({
+    description: 'Determine whether the current authenticated Identity satisfies one installed Policy for one object, or each of an ordered batch of at most 256 Policy and object checks.',
     auth: 'authenticated',
     input: canInput,
     output: canOutput,
     static: true,
-    inheritance: 'default',
+    abstract: false,
 });