@astrale-os/kernel-core 0.9.0-beta.62 → 0.9.0-beta.64

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

@@ -1,4 +1,5 @@
 import type { OperationId } from '../../../installation/operation-id.js';
+import type { PublicationRequest } from './legacy/install.js';
 export declare const domainRequest: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
     artifact: import("zod").ZodObject<{
         digest: import("zod").ZodString;
@@ -6,6 +7,24 @@ export declare const domainRequest: import("zod").ZodUnion<readonly [import("zod
         size: import("zod").ZodNumber;
     }, import("zod/v4/core").$strict>;
     currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    release: import("zod").ZodObject<{
+        url: import("zod").ZodString;
+        token: import("zod").ZodOptional<import("zod").ZodString>;
+        digest: import("zod").ZodOptional<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").ZodOptional<import("zod").ZodEnum<{
+            drain: "drain";
+            revoke: "revoke";
+        }>>;
+    }, import("zod/v4/core").$strict>>;
+    revision: import("zod").ZodOptional<import("zod").ZodString>;
+    currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
 }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
     publication: import("zod").ZodObject<{
         url: import("zod").ZodString;
@@ -24,6 +43,24 @@ export declare const installInput: import("zod").ZodObject<{
             size: import("zod").ZodNumber;
         }, import("zod/v4/core").$strict>;
         currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        release: import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            token: import("zod").ZodOptional<import("zod").ZodString>;
+            digest: import("zod").ZodOptional<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").ZodOptional<import("zod").ZodEnum<{
+                drain: "drain";
+                revoke: "revoke";
+            }>>;
+        }, import("zod/v4/core").$strict>>;
+        revision: import("zod").ZodOptional<import("zod").ZodString>;
+        currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
     }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
         publication: import("zod").ZodObject<{
             url: import("zod").ZodString;
@@ -51,6 +88,16 @@ export declare const installReceipt: import("zod").ZodObject<{
                 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";
@@ -71,6 +118,7 @@ export declare const installReceipt: import("zod").ZodObject<{
 }, import("zod/v4/core").$strict>;
 type NonEmpty<Value> = readonly [Value, ...Value[]];
 export type InstallationDigest = `sha256:${string}`;
+export type ReleaseDigest = InstallationDigest;
 export interface ArtifactRef {
     readonly digest: InstallationDigest;
     readonly mediaType: string;
@@ -87,12 +135,35 @@ export interface DomainGeneration {
     readonly revision: string;
     readonly generation: InstallationDigest;
 }
+/**
+ * The operator's consent to replace the issuer an installation runs under (D7): a compare-and-swap
+ * of the exact installed issuer `from` for the exact issuer `to` the source serves.
+ */
+export interface IssuerConsent {
+    readonly issuer: {
+        readonly from: string;
+        readonly to: string;
+    };
+    /**
+     * What the replaced issuer keeps: `drain` (default) accepts it for a bounded time after the
+     * activation, then only for the steps of its durable runs; `revoke` cuts it at the activation.
+     */
+    readonly previous?: 'drain' | 'revoke';
+}
 export interface TransitionIntent {
     readonly transition: string;
     readonly operation: OperationId;
     readonly origin: string;
     readonly previous: DomainGeneration | null;
     readonly generation: DomainGeneration | null;
+    /** Present only on a replacement that changed its issuer under consent. */
+    readonly consent?: {
+        readonly issuer: {
+            readonly from: string;
+            readonly to: string;
+        };
+        readonly previous: 'drain' | 'revoke';
+    };
 }
 export interface ReadinessReceipt {
     readonly generation: InstallationDigest;
@@ -105,18 +176,26 @@ export interface TransitionReceipt {
     readonly state: 'committed';
     readonly readiness?: ReadinessReceipt;
 }
-export type DomainRequest = {
-    readonly artifact: ArtifactRef;
-    readonly currentRevision?: string | null;
-} | {
-    readonly publication: {
+/** Installs the document served by the URL, preferring release.json over domain.json. */
+export interface ReleaseRequest {
+    readonly release: {
         readonly url: string;
         readonly token?: string;
-        readonly etag?: InstallationDigest;
+        /** Requires an exact release digest. Omit to accept any served document, including a legacy Publication. */
+        readonly digest?: ReleaseDigest;
     };
+    /**
+     * Required when the source serves another issuer than the installed one, refused otherwise:
+     * `from` must be the installed issuer and `to` the served one, neither the Kernel issuer.
+     */
+    readonly consent?: IssuerConsent;
     readonly revision?: string;
     readonly currentRevision?: string | null;
-};
+}
+export type DomainRequest = {
+    readonly artifact: ArtifactRef;
+    readonly currentRevision?: string | null;
+} | ReleaseRequest | PublicationRequest;
 export interface InstallInput {
     readonly operation: OperationId;
     readonly domains: NonEmpty<DomainRequest>;

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

@@ -1,19 +1,22 @@
 import { array, strictObject, union } from 'zod';
-import { artifactRef, installationText, operationIdSchema, transitionReceipt, } from './installation.js';
+import { artifactRef, installationDigest, installationText, issuerConsent, operationIdSchema, transitionReceipt, } from './installation.js';
+import { publicationRequest } from './legacy/install.js';
 export const domainRequest = union([
     strictObject({
         artifact: artifactRef,
         currentRevision: installationText.nullable().optional(),
     }),
     strictObject({
-        publication: strictObject({
+        release: strictObject({
             url: installationText,
             token: installationText.optional(),
-            etag: installationText.optional(),
+            digest: installationDigest.optional(),
         }),
+        consent: issuerConsent.optional(),
         revision: installationText.optional(),
         currentRevision: installationText.nullable().optional(),
     }),
+    publicationRequest,
 ]);
 export const installInput = strictObject({
     operation: operationIdSchema,

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

@@ -18,6 +18,16 @@ export declare const domainGeneration: import("zod").ZodObject<{
     revision: import("zod").ZodString;
     generation: import("zod").ZodString;
 }, import("zod/v4/core").$strict>;
+export declare const issuerConsent: import("zod").ZodObject<{
+    issuer: import("zod").ZodObject<{
+        from: import("zod").ZodString;
+        to: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>;
+    previous: import("zod").ZodOptional<import("zod").ZodEnum<{
+        drain: "drain";
+        revoke: "revoke";
+    }>>;
+}, import("zod/v4/core").$strict>;
 export declare const transitionIntent: import("zod").ZodObject<{
     transition: import("zod").ZodString;
     operation: import("zod").ZodString;
@@ -32,6 +42,16 @@ export declare const transitionIntent: import("zod").ZodObject<{
         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>;
 export declare const readinessReceipt: import("zod").ZodObject<{
     generation: import("zod").ZodString;
@@ -58,6 +78,16 @@ export declare const transitionReceipt: import("zod").ZodObject<{
             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";

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

@@ -20,12 +20,21 @@ export const domainGeneration = strictObject({
     revision: installationText,
     generation: installationDigest,
 });
+const consentIssuers = strictObject({ from: installationText, to: installationText });
+export const issuerConsent = strictObject({
+    issuer: consentIssuers,
+    previous: enumeration(['drain', 'revoke']).optional(),
+});
 export const transitionIntent = strictObject({
     transition: installationText,
     operation: operationIdSchema,
     origin: installationText,
     previous: domainGeneration.nullable(),
     generation: domainGeneration.nullable(),
+    consent: strictObject({
+        issuer: consentIssuers,
+        previous: enumeration(['drain', 'revoke']),
+    }).optional(),
 });
 export const readinessReceipt = strictObject({
     generation: installationDigest,

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

@@ -1,8 +1,11 @@
-export declare const introspectInput: import("zod").ZodObject<{
+/** One ready Domain by origin, or the installed listing, which names no origin. */
+export declare const introspectInput: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
     kind: import("zod").ZodEnum<{
         bundle: "bundle";
         dependencies: "dependencies";
         inspect: "inspect";
     }>;
     origin: import("zod").ZodString;
-}, import("zod/v4/core").$strict>;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"installed">;
+}, import("zod/v4/core").$strict>]>;

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

@@ -1,5 +1,9 @@
-import { enum as enumeration, strictObject, string } from 'zod';
-export const introspectInput = strictObject({
-    kind: enumeration(['inspect', 'bundle', 'dependencies']),
-    origin: string().min(1),
-});
+import { enum as enumeration, literal, strictObject, string, union } from 'zod';
+/** One ready Domain by origin, or the installed listing, which names no origin. */
+export const introspectInput = union([
+    strictObject({
+        kind: enumeration(['inspect', 'bundle', 'dependencies']),
+        origin: string().min(1),
+    }),
+    strictObject({ kind: literal('installed') }),
+]);

package/dist/schema/kernel/syscalls/contracts/legacy/install.d.ts

@@ -0,0 +1,22 @@
+import type { InstallationDigest } from '../install.js';
+/** @deprecated Successor: the `release` request of `../install.ts`. */
+export declare const publicationRequest: import("zod").ZodObject<{
+    publication: import("zod").ZodObject<{
+        url: import("zod").ZodString;
+        token: import("zod").ZodOptional<import("zod").ZodString>;
+        etag: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>;
+    revision: import("zod").ZodOptional<import("zod").ZodString>;
+    currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}, import("zod/v4/core").$strict>;
+/** @deprecated Use `ReleaseRequest` to guard the release digest. */
+export interface PublicationRequest {
+    readonly publication: {
+        readonly url: string;
+        readonly token?: string;
+        /** ETag of the v3 document the source serves: its own, or the projection of a v4 release. */
+        readonly etag?: InstallationDigest;
+    };
+    readonly revision?: string;
+    readonly currentRevision?: string | null;
+}

package/dist/schema/kernel/syscalls/contracts/legacy/install.js

@@ -0,0 +1,31 @@
+/**
+ * The `publication` Domain request of `schema.install` keeps its v3 meaning: `etag` guards the
+ * ETag of the v3 document the source serves, including the frozen projection of a v4 release.
+ *
+ * @deprecated Use the `release` request of `../install.ts`, whose `digest` is the release digest.
+ *
+ * Short-term consumers: the Admin instance gateway and the CLI until they send `release`, the SDK
+ * e2e controller, and this repository's own callers (`__e2e__`, `host/e2e`,
+ * `host/qualification/falkor`) and tests. The 1Pact Host runs its own Kernel .117 and does not
+ * depend on this module.
+ *
+ * Removal, in a separate breaking release, once the Admin gateway and the CLI send `release` to
+ * every Kernel that accepts it and the SDK e2e controller has moved: move this repository's callers
+ * and tests first, then delete this folder, the `publication` branch of `domainRequest`, Runtime
+ * `PublicationDomainInput` with the `publication` branch of `installDomain`,
+ * `DesiredInstallation.targetEtag`, `InstallRoot.targetEtag` and
+ * `CUTOVER_PUBLICATION_ETAG_CONFLICT`. The legacy fingerprint keys stay frozen: retained operations
+ * store their digests.
+ */
+import { strictObject } from 'zod';
+import { installationText } from '../installation.js';
+/** @deprecated Successor: the `release` request of `../install.ts`. */
+export const publicationRequest = strictObject({
+    publication: strictObject({
+        url: installationText,
+        token: installationText.optional(),
+        etag: installationText.optional(),
+    }),
+    revision: installationText.optional(),
+    currentRevision: installationText.nullable().optional(),
+});

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

@@ -24,6 +24,16 @@ export declare const uninstallOutput: import("zod").ZodObject<{
                 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";

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

@@ -399,29 +399,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;
@@ -449,6 +426,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: {
@@ -493,6 +493,14 @@ export declare const Functions: Readonly<{
     install: builder.Function<builder.CallableProjection<{
         operation: string;
         domains: ({
+            publication: {
+                url: string;
+                token?: string | undefined;
+                etag?: string | undefined;
+            };
+            revision?: string | undefined;
+            currentRevision?: string | null | undefined;
+        } | {
             artifact: {
                 digest: string;
                 mediaType: string;
@@ -500,11 +508,18 @@ export declare const Functions: Readonly<{
             };
             currentRevision?: string | null | undefined;
         } | {
-            publication: {
+            release: {
                 url: string;
                 token?: string | undefined;
-                etag?: string | undefined;
+                digest?: string | undefined;
             };
+            consent?: {
+                issuer: {
+                    from: string;
+                    to: string;
+                };
+                previous?: "drain" | "revoke" | undefined;
+            } | undefined;
             revision?: string | undefined;
             currentRevision?: string | null | undefined;
         })[];
@@ -514,6 +529,8 @@ export declare const Functions: Readonly<{
     introspect: builder.Function<builder.CallableProjection<{
         kind: "bundle" | "dependencies" | "inspect";
         origin: string;
+    } | {
+        kind: "installed";
     }, {
         readonly mode: 'binary';
     }, "authenticated", false, false, undefined>>;
@@ -542,6 +559,13 @@ export declare const Functions: Readonly<{
                         revision: string;
                         generation: string;
                     } | null;
+                    consent?: {
+                        issuer: {
+                            from: string;
+                            to: string;
+                        };
+                        previous: "drain" | "revoke";
+                    } | undefined;
                 };
                 phase: "converge" | "cutover";
                 state: "committed";

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

@@ -2,6 +2,14 @@ import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Install: builder.Function<builder.CallableProjection<{
     operation: string;
     domains: ({
+        publication: {
+            url: string;
+            token?: string | undefined;
+            etag?: string | undefined;
+        };
+        revision?: string | undefined;
+        currentRevision?: string | null | undefined;
+    } | {
         artifact: {
             digest: string;
             mediaType: string;
@@ -9,11 +17,18 @@ export declare const Install: builder.Function<builder.CallableProjection<{
         };
         currentRevision?: string | null | undefined;
     } | {
-        publication: {
+        release: {
             url: string;
             token?: string | undefined;
-            etag?: string | undefined;
+            digest?: string | undefined;
         };
+        consent?: {
+            issuer: {
+                from: string;
+                to: string;
+            };
+            previous?: "drain" | "revoke" | undefined;
+        } | undefined;
         revision?: string | undefined;
         currentRevision?: string | null | undefined;
     })[];

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

@@ -2,6 +2,8 @@ import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Introspect: builder.Function<builder.CallableProjection<{
     kind: "bundle" | "dependencies" | "inspect";
     origin: string;
+} | {
+    kind: "installed";
 }, {
     readonly mode: 'binary';
 }, "authenticated", false, false, undefined>>;

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

@@ -155,29 +155,6 @@ export declare const Mutate: builder.Function<builder.CallableProjection<{
             };
         })[];
         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;
@@ -205,6 +182,29 @@ export declare const Mutate: builder.Function<builder.CallableProjection<{
             };
             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: {

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

@@ -24,6 +24,13 @@ export declare const Uninstall: builder.Function<builder.CallableProjection<{
                     revision: string;
                     generation: string;
                 } | null;
+                consent?: {
+                    issuer: {
+                        from: string;
+                        to: string;
+                    };
+                    previous: "drain" | "revoke";
+                } | undefined;
             };
             phase: "converge" | "cutover";
             state: "committed";

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

@@ -11,6 +11,13 @@ export interface ResolvedView {
     readonly iframe?: IframeRequirements;
     readonly host?: ViewHostRequirements;
     readonly issuer: IssuerId;
+    /**
+     * ETag of the v3 Publication that pins the View's Domain: its own for a legacy pin, the
+     * frozen projection's for a `DomainRelease` v4 pin.
+     *
+     * @deprecated Successor: `ResolvedView.release`, emitted by the breaking release (AM-1) as
+     * the release digest.
+     */
     readonly etag: `sha256:${string}`;
     readonly revision: Revision;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-core",
-  "version": "0.9.0-beta.62",
+  "version": "0.9.0-beta.64",
   "description": "Astrale Kernel Core - Types, Invariants, and Pure Logic",
   "license": "Apache-2.0",
   "repository": {
@@ -160,7 +160,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-dsl": "0.2.0-beta.44",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.46",
     "@noble/hashes": "2.3.0",
     "@types/json-schema": "^7.0.15",
     "dequal": "2.0.3"

package/dist/auth/authority/prepare-grant-body.d.ts

@@ -1,4 +0,0 @@
-import type { Grant } from '../grant/index.js';
-import type { AuthorityExpr, AuthorityPredicate } from './language/index.js';
-/** Prepare one body in a fresh Grant subject scope, independently of any concrete Grant. */
-export declare function prepareGrantBody(where: AuthorityExpr): (grant: Grant) => AuthorityPredicate;

package/dist/auth/authority/prepare-grant-body.js

@@ -1,27 +0,0 @@
-import * as portable from '@astrale-os/kernel-dsl/value';
-import { accept as acceptGrant, canonicalize as canonicalizeGrant } from '../grant/index.js';
-import { admitGrantBody } from './admission/index.js';
-import { AUTHORITY_PREDICATE_VERSION } from './language/index.js';
-import { normalizeGrantBodyAdmitted } from './normalization/index.js';
-import { ownCanonical } from './ownership.optimization.js';
-/** Prepare one body in a fresh Grant subject scope, independently of any concrete Grant. */
-export function prepareGrantBody(where) {
-    const admitted = admitGrantBody(portable.acceptForRead(where));
-    const body = portable.acceptImmutable(normalizeGrantBodyAdmitted(admitted));
-    return grantBinder(body);
-}
-// A distinct closure scope retains only the normalized body, never an initial Grant or caller input.
-function grantBinder(where) {
-    return (grant) => {
-        // Charge the entire expression on every binding, including the body and its outer container.
-        const value = portable.acceptForRead({ op: 'grant', grant, where });
-        return ownCanonical(Object.freeze({
-            version: AUTHORITY_PREDICATE_VERSION,
-            predicate: Object.freeze({
-                op: 'grant',
-                grant: canonicalizeGrant(acceptGrant(value.grant)),
-                where,
-            }),
-        }));
-    };
-}