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

package/dist/schema/kernel/schema.js

@@ -1,12 +1,12 @@
 import { defineSchema, schema } from '@astrale-os/kernel-dsl/v1';
 import { AuthorityOperations, CanCreate, CanDelete, CanGrant, CanRead, CanRevoke, CanTraverse, CanUse, CanUpdate, GovernedBy, Operation, Policy, } from '../authority/index.js';
-import { Function as FunctionClass, MethodOf, View, ViewFor } from '../callables/index.js';
+import { Entrypoint, Execution, Function as FunctionClass, MethodOf, View, } from '../callables/index.js';
 import { OperationCore } from '../core/index.js';
 import { Class, Extends, InstanceOf } from '../definitions/index.js';
 import { Domain as DomainClass, OfDomain } from '../domain/index.js';
 import { ConstrainedBy, ExcludedFrom, ExtendsWith, Identity } from '../identity/index.js';
-import { Descriptable, Edge, Iconable, Named, Node, Remotable, Statused, Timestamped, } from '../meta/index.js';
-import { Functions } from './syscalls/declarations/index.js';
+import { CreatedBy, Descriptable, Edge, Iconable, Named, Node, Remotable, Statused, Timestamped, } from '../meta/index.js';
+import { Functions, CanUseSyscall } from './syscalls/declarations/index.js';
 const KernelDefinitions = {
     classes: {
         Descriptable,
@@ -20,6 +20,7 @@ const KernelDefinitions = {
         Timestamped,
         Class,
         Domain: DomainClass,
+        Execution,
         Function: FunctionClass,
         Operation,
         Policy,
@@ -33,6 +34,8 @@ const KernelDefinitions = {
         can_revoke: CanRevoke,
         can_use: CanUse,
         constrained_by: ConstrainedBy,
+        created_by: CreatedBy,
+        entrypoint: Entrypoint,
         excluded_from: ExcludedFrom,
         extends: Extends,
         extends_with: ExtendsWith,
@@ -40,9 +43,8 @@ const KernelDefinitions = {
         instance_of: InstanceOf,
         method_of: MethodOf,
         of_domain: OfDomain,
-        view_for: ViewFor,
     },
-    policies: {},
+    policies: { canUseSyscall: CanUseSyscall },
     functions: Functions,
 };
 const KernelCore = Object.freeze({
@@ -50,6 +52,7 @@ const KernelCore = Object.freeze({
     edges: OperationCore.edges,
 });
 const KernelSchemaInput = {
+    name: 'Kernel',
     ...KernelDefinitions,
     core: KernelCore,
 };
@@ -71,13 +74,14 @@ export const AuthorityRelations = Object.freeze({
 export const KernelRootFunctions = Object.freeze([
     K.functions.query,
     K.functions.mutate,
-    K.functions.provision,
+    K.functions.upload,
+    K.functions.download,
+    K.functions.register,
     K.functions.install,
-    K.functions.introspect,
     K.functions.uninstall,
     K.functions.journal,
     K.classes.Identity.static.methods.whois,
-    K.classes.Identity.static.methods.mint,
+    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/admit.d.ts

@@ -1,12 +1,15 @@
-import { z } from 'zod';
-export declare const admitInput: z.ZodObject<{
-    call: z.ZodObject<{
-        target: z.ZodString;
-        input: z.ZodUnknown;
-    }, z.core.$strict>;
-    credential: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const admitOutput: z.ZodObject<{
-    callable: z.ZodString;
-    receiver: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
+export declare const admitInput: import("zod").ZodObject<{
+    call: import("zod").ZodObject<{
+        target: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+            callable: import("zod").ZodString;
+            instance: import("zod").ZodOptional<import("zod").ZodString>;
+            fingerprint: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>]>;
+        input: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strict>;
+    credential: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;
+export declare const admitOutput: import("zod").ZodObject<{
+    callable: import("zod").ZodString;
+    receiver: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;

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

@@ -1,12 +1,19 @@
-import { z } from 'zod';
-export const admitInput = z.strictObject({
-    call: z.strictObject({
-        target: z.string().min(1),
-        input: z.unknown(),
+import { strictObject, string, union, unknown as unknownSchema } from 'zod';
+export const admitInput = strictObject({
+    call: strictObject({
+        target: union([
+            string().min(1),
+            strictObject({
+                callable: string().min(1),
+                instance: string().min(1).optional(),
+                fingerprint: string().min(1).optional(),
+            }),
+        ]),
+        input: unknownSchema(),
     }),
-    credential: z.string().optional(),
+    credential: string().optional(),
 });
-export const admitOutput = z.strictObject({
-    callable: z.string().min(1),
-    receiver: z.string().min(1).optional(),
+export const admitOutput = strictObject({
+    callable: string().min(1),
+    receiver: string().min(1).optional(),
 });

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

@@ -0,0 +1,31 @@
+export declare const MAXIMUM_BLOB_BYTES = 104857600;
+export declare const blobSlot: import("zod").ZodObject<{
+    node: import("zod").ZodString;
+    property: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const uploadInput: import("zod").ZodObject<{
+    mediaType: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const uploadOutput: import("zod").ZodObject<{
+    receipt: import("zod").ZodString;
+    ref: import("zod").ZodObject<{
+        digest: import("zod").ZodString;
+        mediaType: import("zod").ZodString;
+        size: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strict>;
+    expiresAt: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+/** Upper bound of one multi-slot download; a client splits larger slot lists. */
+export declare const MAXIMUM_DOWNLOAD_SLOTS = 256;
+/** Media type of a multi-slot download body: one length-prefixed part per slot, in slot order. */
+export declare const DOWNLOAD_PARTS_MEDIA_TYPE = "application/vnd.astrale.download-parts";
+/** One slot, the original contract, or an ordered slot list answered part by part. */
+export declare const downloadInput: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    node: import("zod").ZodString;
+    property: import("zod").ZodString;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    slots: import("zod").ZodArray<import("zod").ZodObject<{
+        node: import("zod").ZodString;
+        property: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>]>;

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

@@ -0,0 +1,24 @@
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
+import { array, strictObject, string, union } from 'zod';
+import { artifactRef } from './installation.js';
+export const MAXIMUM_BLOB_BYTES = 104_857_600;
+export const blobSlot = strictObject({
+    node: string().check(fullMatch('[A-Za-z0-9._-]{1,255}')),
+    property: string().check(fullMatch(patterns.propertyKeyFullMatch)),
+});
+export const uploadInput = strictObject({ mediaType: string().min(1) });
+export const uploadOutput = strictObject({
+    receipt: string().min(1),
+    ref: artifactRef,
+    expiresAt: string().min(1),
+});
+/** Upper bound of one multi-slot download; a client splits larger slot lists. */
+export const MAXIMUM_DOWNLOAD_SLOTS = 256;
+/** Media type of a multi-slot download body: one length-prefixed part per slot, in slot order. */
+export const DOWNLOAD_PARTS_MEDIA_TYPE = 'application/vnd.astrale.download-parts';
+/** One slot, the original contract, or an ordered slot list answered part by part. */
+export const downloadInput = union([
+    blobSlot,
+    strictObject({ slots: array(blobSlot).min(1).max(MAXIMUM_DOWNLOAD_SLOTS) }),
+]);

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

@@ -1,8 +1,19 @@
-import { z } from 'zod';
-export declare const canInput: z.ZodObject<{
-    policy: z.ZodString;
-    object: z.ZodString;
-}, z.core.$strict>;
-export declare const canOutput: z.ZodObject<{
-    allowed: z.ZodBoolean;
-}, z.core.$strict>;
+/** Upper bound of one Identity.can batch; a client splits larger check sets. */
+export declare const MAXIMUM_CHECKS = 256;
+/** One check, the original contract, or an ordered batch answered check by check. */
+export declare const canInput: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    policy: import("zod").ZodString;
+    object: import("zod").ZodString;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    checks: import("zod").ZodArray<import("zod").ZodObject<{
+        policy: import("zod").ZodString;
+        object: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>]>;
+export declare const canOutput: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    allowed: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    decisions: import("zod").ZodArray<import("zod").ZodObject<{
+        allowed: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>]>;

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

@@ -1,4 +1,12 @@
-import { z } from 'zod';
-const text = z.string().min(1);
-export const canInput = z.strictObject({ policy: text, object: text });
-export const canOutput = z.strictObject({ allowed: z.boolean() });
+import { array, boolean, strictObject, string, union } from 'zod';
+/** Upper bound of one Identity.can batch; a client splits larger check sets. */
+export const MAXIMUM_CHECKS = 256;
+const text = string().min(1);
+const check = strictObject({ policy: text, object: text });
+const decision = strictObject({ allowed: boolean() });
+/** One check, the original contract, or an ordered batch answered check by check. */
+export const canInput = union([
+    check,
+    strictObject({ checks: array(check).min(1).max(MAXIMUM_CHECKS) }),
+]);
+export const canOutput = union([decision, strictObject({ decisions: array(decision) })]);

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

@@ -1,7 +1,6 @@
-import { z } from 'zod';
-export declare const delegateInput: z.ZodObject<{
-    audience: z.ZodString;
-    ttlSeconds: z.ZodNumber;
-    attenuation: z.ZodUnknown;
-}, z.core.$strict>;
-export declare const delegateOutput: z.ZodString;
+export declare const delegateInput: import("zod").ZodObject<{
+    principal: import("zod").ZodString;
+    audience: import("zod").ZodString;
+    ttlSeconds: import("zod").ZodNumber;
+}, import("zod/v4/core").$strict>;
+export declare const delegateOutput: import("zod").ZodString;

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

@@ -1,8 +1,8 @@
-import { z } from 'zod';
-const text = z.string().min(1);
-export const delegateInput = z.strictObject({
+import { number, strictObject, string } from 'zod';
+const text = string().min(1);
+export const delegateInput = strictObject({
+    principal: text,
     audience: text,
-    ttlSeconds: z.number().int().min(1),
-    attenuation: z.unknown(),
+    ttlSeconds: number().int().min(1),
 });
 export const delegateOutput = text;

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

@@ -0,0 +1,60 @@
+/** Terminal outcome of one durable call; a handler failure is an outcome, not a call error. */
+export declare const executionOutcome: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"completed">;
+    value: import("zod").ZodUnknown;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"failed">;
+    error: import("zod").ZodObject<{
+        code: import("zod").ZodString;
+        message: import("zod").ZodString;
+        family: import("zod").ZodOptional<import("zod").ZodString>;
+        details: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"cancelled">;
+}, import("zod/v4/core").$strict>]>;
+export declare const executionStatus: import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    function: import("zod").ZodString;
+    version: import("zod").ZodString;
+    state: import("zod").ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        expired: "expired";
+        failed: "failed";
+        paused: "paused";
+        pending: "pending";
+        running: "running";
+        waiting: "waiting";
+    }>;
+    createdAt: import("zod").ZodString;
+    outcome: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"completed">;
+        value: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"failed">;
+        error: import("zod").ZodObject<{
+            code: import("zod").ZodString;
+            message: import("zod").ZodString;
+            family: import("zod").ZodOptional<import("zod").ZodString>;
+            details: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"cancelled">;
+    }, import("zod/v4/core").$strict>]>>;
+}, import("zod/v4/core").$strict>;
+export declare const executionStatusInput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionResultInput: import("zod").ZodObject<{
+    waitMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strict>;
+export declare const executionCancelInput: import("zod").ZodObject<{
+    force: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strict>;
+export declare const executionSignalInput: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    value: import("zod").ZodUnknown;
+}, import("zod/v4/core").$strict>;
+export declare const executionSignalOutput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionResumeInput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionDeleteInput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionDeleteOutput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;

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

@@ -0,0 +1,46 @@
+import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
+import { boolean, enum as enumeration, literal, number, strictObject, string, union, unknown as unknownSchema, } from 'zod';
+const nodeId = string().min(1).max(255).check(fullMatch('[A-Za-z0-9._-]+'));
+const empty = strictObject({});
+/** Engine-observed state; never persisted on the Execution. */
+const state = enumeration([
+    'pending',
+    'running',
+    'waiting',
+    'paused',
+    'completed',
+    'failed',
+    'cancelled',
+    'expired',
+]);
+const failure = strictObject({
+    code: string(),
+    message: string(),
+    family: string().optional(),
+    details: unknownSchema().optional(),
+});
+/** Terminal outcome of one durable call; a handler failure is an outcome, not a call error. */
+export const executionOutcome = union([
+    strictObject({ kind: literal('completed'), value: unknownSchema() }),
+    strictObject({ kind: literal('failed'), error: failure }),
+    strictObject({ kind: literal('cancelled') }),
+]);
+export const executionStatus = strictObject({
+    id: nodeId,
+    function: nodeId,
+    version: string().check(fullMatch('sha256:[0-9a-f]{64}')),
+    state,
+    createdAt: string().min(1),
+    outcome: executionOutcome.optional(),
+});
+export const executionStatusInput = empty;
+export const executionResultInput = strictObject({ waitMs: number().int().min(0).optional() });
+export const executionCancelInput = strictObject({ force: boolean().optional() });
+export const executionSignalInput = strictObject({
+    name: string().min(1).max(128),
+    value: unknownSchema(),
+});
+export const executionSignalOutput = empty;
+export const executionResumeInput = empty;
+export const executionDeleteInput = empty;
+export const executionDeleteOutput = empty;

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

@@ -0,0 +1,5 @@
+export declare const MAXIMUM_DOMAIN_EXPECTATIONS = 256;
+export declare const domainExpectations: import("zod").ZodArray<import("zod").ZodObject<{
+    origin: import("zod").ZodString;
+    revision: import("zod").ZodString;
+}, import("zod/v4/core").$strict>>;

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

@@ -0,0 +1,9 @@
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
+import { array, strictObject, string } from 'zod';
+export const MAXIMUM_DOMAIN_EXPECTATIONS = 256;
+const expectation = strictObject({
+    origin: string().check(fullMatch(patterns.originFullMatch)),
+    revision: string().check(fullMatch(patterns.revisionFullMatch)),
+});
+export const domainExpectations = array(expectation).max(MAXIMUM_DOMAIN_EXPECTATIONS);

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

@@ -1,19 +1,18 @@
-import { z } from 'zod';
-export declare const identityOutput: 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 identityOutput: 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/identity.js

@@ -1,10 +1,9 @@
-import { z } from 'zod';
+import { boolean, strictObject, string } from 'zod';
 import { requiredClaimsSchema } from '../../../authority/claims.js';
-const text = z.string().min(1);
-export const identityOutput = z.strictObject({
-    id: text,
-    issuer: text,
-    subject: text,
-    frozen: z.boolean(),
+export const identityOutput = strictObject({
+    id: string().min(1),
+    iss: string().min(1),
+    sub: string().min(1),
+    frozen: boolean(),
     requiredClaims: requiredClaimsSchema,
 });

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

@@ -0,0 +1,6 @@
+export declare const impersonateInput: import("zod").ZodObject<{
+    audience: import("zod").ZodOptional<import("zod").ZodString>;
+    ttlSeconds: import("zod").ZodNumber;
+    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

@@ -1,12 +1,15 @@
 export { admitInput, admitOutput } from './admit.js';
-export { canInput, canOutput } from './can.js';
+export { blobSlot, DOWNLOAD_PARTS_MEDIA_TYPE, downloadInput, MAXIMUM_BLOB_BYTES, MAXIMUM_DOWNLOAD_SLOTS, uploadInput, uploadOutput, } from './blob.js';
+export { MAXIMUM_CHECKS, canInput, canOutput } from './can.js';
 export { delegateInput, delegateOutput } from './delegate.js';
-export { installInput, installOutput, type DesiredInstallation, type InstallInput, type InstallOutput, } from './install.js';
+export { executionCancelInput, executionDeleteInput, executionDeleteOutput, executionOutcome, executionResultInput, executionResumeInput, executionSignalInput, executionSignalOutput, executionStatus, executionStatusInput, } from './execution.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 { provisionInput, provisionOutput } from './provision.js';
+export { registerInput, registerOutput } from './register.js';
 export { MAXIMUM_QUERY_EXPECTATIONS, queryInput, queryOutput } from './query.js';
 export { uninstallInput, uninstallOutput, type UninstallInput, type UninstallOutput, } from './uninstall.js';
 export { viewResolveInput, viewResolveOutput } from './view-resolve.js';

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

@@ -1,12 +1,15 @@
 export { admitInput, admitOutput } from './admit.js';
-export { canInput, canOutput } from './can.js';
+export { blobSlot, DOWNLOAD_PARTS_MEDIA_TYPE, downloadInput, MAXIMUM_BLOB_BYTES, MAXIMUM_DOWNLOAD_SLOTS, uploadInput, uploadOutput, } from './blob.js';
+export { MAXIMUM_CHECKS, canInput, canOutput } from './can.js';
 export { delegateInput, delegateOutput } from './delegate.js';
-export { installInput, installOutput, } from './install.js';
+export { executionCancelInput, executionDeleteInput, executionDeleteOutput, executionOutcome, executionResultInput, executionResumeInput, executionSignalInput, executionSignalOutput, executionStatus, executionStatusInput, } from './execution.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 { provisionInput, provisionOutput } from './provision.js';
+export { registerInput, registerOutput } from './register.js';
 export { MAXIMUM_QUERY_EXPECTATIONS, queryInput, queryOutput } from './query.js';
 export { uninstallInput, uninstallOutput, } from './uninstall.js';
 export { viewResolveInput, viewResolveOutput } from './view-resolve.js';