@inf-monkeys-tech/monkeys 1.1.0 → 1.1.2

package/lib/esm/schemas/index.mjs

@@ -7002,15 +7002,30 @@ var RenderScrollSchema = z6.object({
 });
 var RenderActivationSchema = z6.object({
   activationId: ContractIdentifierSchema,
-  mode: z6.enum(["navigate", "select", "drawer", "modal", "fullscreen", "inline"]),
+  mode: z6.enum([
+    "navigate",
+    "select",
+    "drawer",
+    "modal",
+    "fullscreen",
+    "inline"
+  ]),
   targetPath: z6.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.").optional(),
   history: z6.enum(["push", "replace"]).optional()
 }).strict().superRefine((activation, context) => {
   if (activation.mode === "navigate" && !activation.targetPath) {
-    context.addIssue({ code: "custom", path: ["targetPath"], message: "Navigate activation requires an application-relative targetPath." });
+    context.addIssue({
+      code: "custom",
+      path: ["targetPath"],
+      message: "Navigate activation requires an application-relative targetPath."
+    });
   }
   if (activation.mode !== "navigate" && activation.targetPath) {
-    context.addIssue({ code: "custom", path: ["targetPath"], message: "Only navigate activation may declare targetPath." });
+    context.addIssue({
+      code: "custom",
+      path: ["targetPath"],
+      message: "Only navigate activation may declare targetPath."
+    });
   }
 });
 var RenderLifecycleSchema = z6.object({
@@ -7029,13 +7044,25 @@ var RenderLayoutSchema = z6.object({
   gapTokenRef: EntityRefSchema.optional()
 }).strict().superRefine((layout, context) => {
   if (layout.direction && layout.mode !== "flex") {
-    context.addIssue({ code: "custom", path: ["direction"], message: "direction is only valid for flex layout." });
+    context.addIssue({
+      code: "custom",
+      path: ["direction"],
+      message: "direction is only valid for flex layout."
+    });
   }
   if (layout.columns && layout.mode !== "grid") {
-    context.addIssue({ code: "custom", path: ["columns"], message: "columns is only valid for grid layout." });
+    context.addIssue({
+      code: "custom",
+      path: ["columns"],
+      message: "columns is only valid for grid layout."
+    });
   }
   if (layout.gapTokenRef && layout.gapTokenRef.kind !== "design-token") {
-    context.addIssue({ code: "custom", path: ["gapTokenRef", "kind"], message: "gapTokenRef must reference design-token." });
+    context.addIssue({
+      code: "custom",
+      path: ["gapTokenRef", "kind"],
+      message: "gapTokenRef must reference design-token."
+    });
   }
 });
 var RenderResponsiveRuleSchema = z6.object({
@@ -7044,12 +7071,103 @@ var RenderResponsiveRuleSchema = z6.object({
   layout: RenderLayoutSchema
 }).strict().superRefine((rule, context) => {
   if (rule.minWidthPx === void 0 && rule.maxWidthPx === void 0) {
-    context.addIssue({ code: "custom", path: [], message: "Responsive rule must declare minWidthPx or maxWidthPx." });
+    context.addIssue({
+      code: "custom",
+      path: [],
+      message: "Responsive rule must declare minWidthPx or maxWidthPx."
+    });
   }
   if (rule.minWidthPx !== void 0 && rule.maxWidthPx !== void 0 && rule.minWidthPx > rule.maxWidthPx) {
-    context.addIssue({ code: "custom", path: ["maxWidthPx"], message: "maxWidthPx must be greater than or equal to minWidthPx." });
+    context.addIssue({
+      code: "custom",
+      path: ["maxWidthPx"],
+      message: "maxWidthPx must be greater than or equal to minWidthPx."
+    });
   }
 });
+var RenderStyleValueSchema = z6.union([
+  z6.number().finite(),
+  z6.string().trim().min(1).max(256).superRefine((value, context) => {
+    if (/[;{}]/.test(value) || /(?:url|expression|javascript|var)\s*\(/i.test(value)) {
+      context.addIssue({
+        code: "custom",
+        message: "Render style values must be bounded CSS values or $ Design Token references."
+      });
+    }
+  })
+]);
+var RenderStyleSchema = z6.object({
+  width: RenderStyleValueSchema.optional(),
+  height: RenderStyleValueSchema.optional(),
+  minWidth: RenderStyleValueSchema.optional(),
+  maxWidth: RenderStyleValueSchema.optional(),
+  minHeight: RenderStyleValueSchema.optional(),
+  maxHeight: RenderStyleValueSchema.optional(),
+  padding: RenderStyleValueSchema.optional(),
+  paddingBlock: RenderStyleValueSchema.optional(),
+  paddingInline: RenderStyleValueSchema.optional(),
+  margin: RenderStyleValueSchema.optional(),
+  marginBlockStart: RenderStyleValueSchema.optional(),
+  marginBlockEnd: RenderStyleValueSchema.optional(),
+  marginInlineStart: RenderStyleValueSchema.optional(),
+  marginInlineEnd: RenderStyleValueSchema.optional(),
+  display: z6.enum([
+    "none",
+    "block",
+    "inline",
+    "inline-block",
+    "flex",
+    "inline-flex",
+    "grid",
+    "contents"
+  ]).optional(),
+  gap: RenderStyleValueSchema.optional(),
+  rowGap: RenderStyleValueSchema.optional(),
+  columnGap: RenderStyleValueSchema.optional(),
+  background: RenderStyleValueSchema.optional(),
+  color: RenderStyleValueSchema.optional(),
+  borderColor: RenderStyleValueSchema.optional(),
+  borderWidth: RenderStyleValueSchema.optional(),
+  borderStyle: z6.enum(["none", "solid", "dashed", "dotted"]).optional(),
+  borderRadius: RenderStyleValueSchema.optional(),
+  boxShadow: RenderStyleValueSchema.optional(),
+  fontSize: RenderStyleValueSchema.optional(),
+  fontFamily: RenderStyleValueSchema.optional(),
+  fontWeight: RenderStyleValueSchema.optional(),
+  lineHeight: RenderStyleValueSchema.optional(),
+  textAlign: z6.enum(["start", "center", "end", "left", "right"]).optional(),
+  whiteSpace: z6.enum(["normal", "nowrap", "pre", "pre-wrap", "pre-line", "break-spaces"]).optional(),
+  overflow: z6.enum(["visible", "hidden", "auto", "scroll", "clip"]).optional(),
+  overflowX: z6.enum(["visible", "hidden", "auto", "scroll", "clip"]).optional(),
+  overflowY: z6.enum(["visible", "hidden", "auto", "scroll", "clip"]).optional(),
+  position: z6.enum(["static", "relative", "absolute", "sticky", "fixed"]).optional(),
+  inset: RenderStyleValueSchema.optional(),
+  top: RenderStyleValueSchema.optional(),
+  right: RenderStyleValueSchema.optional(),
+  bottom: RenderStyleValueSchema.optional(),
+  left: RenderStyleValueSchema.optional(),
+  gridTemplateColumns: RenderStyleValueSchema.optional(),
+  gridColumn: RenderStyleValueSchema.optional(),
+  gridRow: RenderStyleValueSchema.optional(),
+  flex: RenderStyleValueSchema.optional(),
+  flexDirection: z6.enum(["row", "row-reverse", "column", "column-reverse"]).optional(),
+  flexWrap: z6.enum(["nowrap", "wrap", "wrap-reverse"]).optional(),
+  alignItems: z6.enum(["start", "center", "end", "stretch", "baseline"]).optional(),
+  justifyContent: z6.enum([
+    "start",
+    "center",
+    "end",
+    "space-between",
+    "space-around",
+    "space-evenly"
+  ]).optional(),
+  flexGrow: z6.number().finite().nonnegative().optional(),
+  flexShrink: z6.number().finite().nonnegative().optional(),
+  alignSelf: z6.enum(["auto", "start", "center", "end", "stretch"]).optional(),
+  justifySelf: z6.enum(["auto", "start", "center", "end", "stretch"]).optional(),
+  objectFit: z6.enum(["contain", "cover", "fill", "none", "scale-down"]).optional(),
+  opacity: z6.number().finite().min(0).max(1).optional()
+}).strict();
 var requireRef = (reference, expectedKind, path, context) => {
   if (!reference) return;
   if (reference.kind !== expectedKind) {
@@ -7098,16 +7216,31 @@ var RenderNodeSchema = z6.object({
   activation: RenderActivationSchema,
   lifecycle: RenderLifecycleSchema,
   layout: RenderLayoutSchema,
+  style: RenderStyleSchema.optional(),
   responsive: z6.array(RenderResponsiveRuleSchema),
   accessRef: EntityRefSchema.optional(),
   evidenceRef: EntityRefSchema.optional(),
   state: RenderNodeStateSchema,
   renderModel: JsonObjectSchema,
-  repeat: z6.object({ source: PageExpressionSchema, keyPath: PageValuePathSchema.min(1), limit: z6.number().int().min(1).max(1e3).default(200) }).strict().optional()
+  repeat: z6.object({
+    source: PageExpressionSchema,
+    keyPath: PageValuePathSchema.min(1),
+    limit: z6.number().int().min(1).max(1e3).default(200)
+  }).strict().optional()
 }).strict().superRefine((node, context) => {
   requireRef(node.pageRef, "page", ["pageRef"], context);
-  requirePinnedOwnedRef(node.capabilityRef, "capability", ["capabilityRef"], context);
-  requirePinnedOwnedRef(node.providerRef, "view-provider", ["providerRef"], context);
+  requirePinnedOwnedRef(
+    node.capabilityRef,
+    "capability",
+    ["capabilityRef"],
+    context
+  );
+  requirePinnedOwnedRef(
+    node.providerRef,
+    "view-provider",
+    ["providerRef"],
+    context
+  );
   requireRef(node.accessRef, "access-policy", ["accessRef"], context);
   requireRef(node.evidenceRef, "evidence", ["evidenceRef"], context);
   if (node.parentNodeId === node.nodeId) {
@@ -7118,10 +7251,18 @@ var RenderNodeSchema = z6.object({
     });
   }
   if (new Set(node.children).size !== node.children.length) {
-    context.addIssue({ code: "custom", path: ["children"], message: "RenderNode children must be unique." });
+    context.addIssue({
+      code: "custom",
+      path: ["children"],
+      message: "RenderNode children must be unique."
+    });
   }
   if (node.children.includes(node.nodeId)) {
-    context.addIssue({ code: "custom", path: ["children"], message: "RenderNode cannot be its own child." });
+    context.addIssue({
+      code: "custom",
+      path: ["children"],
+      message: "RenderNode cannot be its own child."
+    });
   }
   if (node.surface.frameOwner === "provider" && !node.providerRef) {
     context.addIssue({
@@ -7241,9 +7382,28 @@ var ViewProviderDescriptorSchema = z6.object({
   loading: z6.enum(["eager", "lazy", "viewport", "on-activation"]),
   stateOwner: z6.enum(["host", "provider", "external"]),
   supportedPageTypes: z6.array(ContractIdentifierSchema).min(1),
-  supportedSurfaces: z6.array(z6.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"])).min(1),
+  supportedSurfaces: z6.array(
+    z6.enum([
+      "page",
+      "workspace",
+      "view",
+      "record",
+      "action",
+      "overlay",
+      "agent"
+    ])
+  ).min(1),
   frameOwner: z6.enum(["host", "provider", "none"]),
-  sideEffects: z6.array(z6.enum(["network", "storage", "navigation", "clipboard", "worker", "websocket"])),
+  sideEffects: z6.array(
+    z6.enum([
+      "network",
+      "storage",
+      "navigation",
+      "clipboard",
+      "worker",
+      "websocket"
+    ])
+  ),
   sideEffectAdapterRef: EntityRefSchema.optional(),
   lifecycle: z6.object({
     preserveMount: z6.boolean(),
@@ -7258,8 +7418,18 @@ var ViewProviderDescriptorSchema = z6.object({
   accessRef: EntityRefSchema.optional(),
   evidenceRef: EntityRefSchema.optional()
 }).strict().superRefine((provider, context) => {
-  requirePinnedOwnedRef(provider.capabilityRef, "capability", ["capabilityRef"], context);
-  requirePinnedOwnedRef(provider.sideEffectAdapterRef, "side-effect-adapter", ["sideEffectAdapterRef"], context);
+  requirePinnedOwnedRef(
+    provider.capabilityRef,
+    "capability",
+    ["capabilityRef"],
+    context
+  );
+  requirePinnedOwnedRef(
+    provider.sideEffectAdapterRef,
+    "side-effect-adapter",
+    ["sideEffectAdapterRef"],
+    context
+  );
   requireRef(provider.accessRef, "access-policy", ["accessRef"], context);
   requireRef(provider.evidenceRef, "evidence", ["evidenceRef"], context);
   if (provider.capabilityRef.version === void 0) {
@@ -7277,10 +7447,18 @@ var ViewProviderDescriptorSchema = z6.object({
     });
   }
   if (provider.sideEffects.length > 0 && !provider.sideEffectAdapterRef) {
-    context.addIssue({ code: "custom", path: ["sideEffectAdapterRef"], message: "Providers with side effects require a pinned side-effect adapter." });
+    context.addIssue({
+      code: "custom",
+      path: ["sideEffectAdapterRef"],
+      message: "Providers with side effects require a pinned side-effect adapter."
+    });
   }
   if (provider.sideEffects.length === 0 && provider.sideEffectAdapterRef) {
-    context.addIssue({ code: "custom", path: ["sideEffectAdapterRef"], message: "Pure providers cannot declare a side-effect adapter." });
+    context.addIssue({
+      code: "custom",
+      path: ["sideEffectAdapterRef"],
+      message: "Pure providers cannot declare a side-effect adapter."
+    });
   }
 });
 
@@ -9007,7 +9185,10 @@ var StableRefAliasMapSchema = z14.object({
   aliases: z14.array(StableRefAliasSchema),
   contentHash: Sha256Schema
 }).strict().superRefine((value, context) => {
-  const duplicate = uniqueArray(value.aliases, (entry) => stableRefIdentity(entry.aliasRef));
+  const duplicate = uniqueArray(
+    value.aliases,
+    (entry) => stableRefIdentity(entry.aliasRef)
+  );
   if (duplicate)
     context.addIssue({
       code: "custom",
@@ -9015,15 +9196,25 @@ var StableRefAliasMapSchema = z14.object({
       message: `Duplicate alias reference: ${duplicate}`
     });
 });
-var DeclarativeLifecycleSchema = z14.enum(["active", "deprecated", "retired"]);
-var ProductSurfaceSchema = z14.enum(["studio", "kernel"]);
-var DeclarativeShellHeaderChromeSchema = z14.discriminatedUnion("enabled", [
-  z14.object({ enabled: z14.literal(false) }).strict(),
-  z14.object({
-    enabled: z14.literal(true),
-    navigationPlacement: z14.enum(["studio.headbar.primary", "kernel.primary"])
-  }).strict()
+var DeclarativeLifecycleSchema = z14.enum([
+  "active",
+  "deprecated",
+  "retired"
 ]);
+var ProductSurfaceSchema = z14.enum(["studio", "kernel"]);
+var DeclarativeShellHeaderChromeSchema = z14.discriminatedUnion(
+  "enabled",
+  [
+    z14.object({ enabled: z14.literal(false) }).strict(),
+    z14.object({
+      enabled: z14.literal(true),
+      navigationPlacement: z14.enum([
+        "studio.headbar.primary",
+        "kernel.primary"
+      ])
+    }).strict()
+  ]
+);
 var DeclarativeShellSurfaceChromeSchema = z14.object({
   surface: ProductSurfaceSchema,
   header: DeclarativeShellHeaderChromeSchema
@@ -9058,15 +9249,17 @@ var GroupRefSchema = StableRefSchema.superRefine((value, context) => {
       message: "Access group references must use kind group."
     });
 });
-var AccessConditionRefSchema = RevisionRefSchema.superRefine((value, context) => {
-  if (value.kind !== "access-condition") {
-    context.addIssue({
-      code: "custom",
-      path: ["kind"],
-      message: "Access condition references must use kind access-condition."
-    });
+var AccessConditionRefSchema = RevisionRefSchema.superRefine(
+  (value, context) => {
+    if (value.kind !== "access-condition") {
+      context.addIssue({
+        code: "custom",
+        path: ["kind"],
+        message: "Access condition references must use kind access-condition."
+      });
+    }
   }
-});
+);
 var AccessPolicySchema = z14.object({
   authenticated: z14.boolean(),
   groupAllOf: z14.array(GroupRefSchema),
@@ -9076,8 +9269,16 @@ var AccessPolicySchema = z14.object({
   conditionAllOf: z14.array(AccessConditionRefSchema)
 }).strict().superRefine((value, context) => {
   const checks = [
-    ["groupAllOf", value.groupAllOf, (candidate) => stableRefIdentity(candidate)],
-    ["groupAnyOf", value.groupAnyOf, (candidate) => stableRefIdentity(candidate)],
+    [
+      "groupAllOf",
+      value.groupAllOf,
+      (candidate) => stableRefIdentity(candidate)
+    ],
+    [
+      "groupAnyOf",
+      value.groupAnyOf,
+      (candidate) => stableRefIdentity(candidate)
+    ],
     ["permissionAllOf", value.permissionAllOf, String],
     ["permissionAnyOf", value.permissionAnyOf, String],
     [
@@ -9243,14 +9444,19 @@ var validateReleaseRouteSurface = (target, context) => {
   const claimSurface = "surface" in target.routeClaim ? target.routeClaim.surface : void 0;
   const matcherSurface = "surface" in target.routeClaim.matcher ? target.routeClaim.matcher.surface : void 0;
   if (claimSurface === void 0 && matcherSurface === void 0) return;
-  if (claimSurface === target.surface && matcherSurface === target.surface) return;
+  if (claimSurface === target.surface && matcherSurface === target.surface)
+    return;
   context.addIssue({
     code: "custom",
     path: ["target", "routeClaim"],
     message: "A compiled Release route claim must either be fully legacy or bind both claim and matcher to the target surface."
   });
 };
-var ReleaseOperationSchema = z14.enum(["activate", "deactivate", "rollback"]);
+var ReleaseOperationSchema = z14.enum([
+  "activate",
+  "deactivate",
+  "rollback"
+]);
 var ReleaseDependencyRoleSchema = z14.enum([
   "route-space",
   "shell",
@@ -9341,8 +9547,16 @@ var ReleaseEvidenceSchema = z14.object({
 }).strict().superRefine((value, context) => {
   const expectedKinds = [
     ["publicationPlanRef", value.publicationPlanRef, "publication-plan"],
-    ["approvalPolicyRevisionRef", value.approvalPolicyRevisionRef, "approval-policy"],
-    ["approvalDecisionRevisionRef", value.approvalDecisionRevisionRef, "approval-decision"],
+    [
+      "approvalPolicyRevisionRef",
+      value.approvalPolicyRevisionRef,
+      "approval-policy"
+    ],
+    [
+      "approvalDecisionRevisionRef",
+      value.approvalDecisionRevisionRef,
+      "approval-decision"
+    ],
     ["actorRef", value.actorRef, "actor"]
   ];
   expectedKinds.forEach(([field, reference, expectedKind]) => {
@@ -9364,7 +9578,11 @@ var ReleaseEvidenceSchema = z14.object({
   });
 });
 var PublicationPlanOperationSchema = z14.object({
-  releaseKind: z14.enum(["page-release", "workbench-release", "navigation-release"]),
+  releaseKind: z14.enum([
+    "page-release",
+    "workbench-release",
+    "navigation-release"
+  ]),
   releaseSlotId: ContractIdentifierSchema,
   releaseRevisionRef: RevisionRefSchema,
   expectedHeadRevisionRef: RevisionRefSchema.nullable()
@@ -9405,10 +9623,23 @@ var PublicationPlanSchema = z14.object({
       path: ["environmentRef", "kind"],
       message: "Publication Plan requires an environment reference."
     });
-  validateTenantCompatibleReference(value.environmentRef, value.tenantScope, ["environmentRef"], context);
+  validateTenantCompatibleReference(
+    value.environmentRef,
+    value.tenantScope,
+    ["environmentRef"],
+    context
+  );
   const governedRefs = [
-    ["approvalPolicyRevisionRef", value.approvalPolicyRevisionRef, "approval-policy"],
-    ["approvalDecisionRevisionRef", value.approvalDecisionRevisionRef, "approval-decision"],
+    [
+      "approvalPolicyRevisionRef",
+      value.approvalPolicyRevisionRef,
+      "approval-policy"
+    ],
+    [
+      "approvalDecisionRevisionRef",
+      value.approvalDecisionRevisionRef,
+      "approval-decision"
+    ],
     ["actorRef", value.actorRef, "actor"]
   ];
   governedRefs.forEach(([field, reference, expectedKind]) => {
@@ -9418,19 +9649,26 @@ var PublicationPlanSchema = z14.object({
         path: [field, "kind"],
         message: `${field} must reference ${expectedKind}.`
       });
-    validateTenantCompatibleReference(reference, value.tenantScope, [field], context);
+    validateTenantCompatibleReference(
+      reference,
+      value.tenantScope,
+      [field],
+      context
+    );
   });
   value.operations.forEach((operation, index) => {
-    [operation.releaseRevisionRef, operation.expectedHeadRevisionRef].forEach((reference, referenceIndex) => {
-      if (reference?.tenantScope && tenantScopeKey(reference.tenantScope) !== tenantScopeKey(value.tenantScope)) {
-        const field = referenceIndex === 0 ? "releaseRevisionRef" : "expectedHeadRevisionRef";
-        context.addIssue({
-          code: "custom",
-          path: ["operations", index, field, "tenantScope"],
-          message: "Publication Plan operation belongs to another tenant scope."
-        });
+    [operation.releaseRevisionRef, operation.expectedHeadRevisionRef].forEach(
+      (reference, referenceIndex) => {
+        if (reference?.tenantScope && tenantScopeKey(reference.tenantScope) !== tenantScopeKey(value.tenantScope)) {
+          const field = referenceIndex === 0 ? "releaseRevisionRef" : "expectedHeadRevisionRef";
+          context.addIssue({
+            code: "custom",
+            path: ["operations", index, field, "tenantScope"],
+            message: "Publication Plan operation belongs to another tenant scope."
+          });
+        }
       }
-    });
+    );
   });
   value.evidenceRefs.forEach((reference, index) => {
     if (reference.kind !== "evidence")
@@ -9439,9 +9677,17 @@ var PublicationPlanSchema = z14.object({
         path: ["evidenceRefs", index, "kind"],
         message: "Publication Plan evidenceRefs must reference evidence revisions."
       });
-    validateTenantCompatibleReference(reference, value.tenantScope, ["evidenceRefs", index], context);
+    validateTenantCompatibleReference(
+      reference,
+      value.tenantScope,
+      ["evidenceRefs", index],
+      context
+    );
   });
-  if (uniqueArray(value.operations, (operation) => `${operation.releaseKind}:${operation.releaseSlotId}`)) {
+  if (uniqueArray(
+    value.operations,
+    (operation) => `${operation.releaseKind}:${operation.releaseSlotId}`
+  )) {
     context.addIssue({
       code: "custom",
       path: ["operations"],
@@ -9628,11 +9874,20 @@ var validateReleaseGovernanceScope = (value, expectedKind, context) => {
   }
   const governedEvidenceRefs = [
     [["evidence", "publicationPlanRef"], value.evidence.publicationPlanRef],
-    [["evidence", "approvalPolicyRevisionRef"], value.evidence.approvalPolicyRevisionRef],
-    [["evidence", "approvalDecisionRevisionRef"], value.evidence.approvalDecisionRevisionRef],
+    [
+      ["evidence", "approvalPolicyRevisionRef"],
+      value.evidence.approvalPolicyRevisionRef
+    ],
+    [
+      ["evidence", "approvalDecisionRevisionRef"],
+      value.evidence.approvalDecisionRevisionRef
+    ],
     [["evidence", "actorRef"], value.evidence.actorRef],
     ...value.evidence.validation.diagnosticRefs.map(
-      (reference, index) => [["evidence", "validation", "diagnosticRefs", index], reference]
+      (reference, index) => [
+        ["evidence", "validation", "diagnosticRefs", index],
+        reference
+      ]
     ),
     ...value.evidence.evidenceRefs.map(
       (reference, index) => [["evidence", "evidenceRefs", index], reference]
@@ -9643,15 +9898,31 @@ var validateReleaseGovernanceScope = (value, expectedKind, context) => {
         ["legacyRestoration", "legacyAdapterRevisionRef"],
         value.legacyRestoration.legacyAdapterRevisionRef
       ],
-      [["legacyRestoration", "sourceRevisionRef"], value.legacyRestoration.sourceRevisionRef]
+      [
+        ["legacyRestoration", "sourceRevisionRef"],
+        value.legacyRestoration.sourceRevisionRef
+      ]
     ] : []
   ];
   governedEvidenceRefs.forEach(
-    ([path, reference]) => validateTenantCompatibleReference(reference, value.tenantScope, [...path], context)
+    ([path, reference]) => validateTenantCompatibleReference(
+      reference,
+      value.tenantScope,
+      [...path],
+      context
+    )
   );
 };
 var BindingSourceSchema = z14.discriminatedUnion("kind", [
-  z14.object({ kind: z14.literal("scope-field"), path: z14.string().trim().min(1).max(4096).regex(/^[A-Za-z0-9_.-]+$/).refine((path) => path.split(".").length <= 16 && path.split(".").every((part) => part.length > 0 && !["__proto__", "prototype", "constructor"].includes(part)), "Scope paths require safe own members.") }).strict(),
+  z14.object({
+    kind: z14.literal("scope-field"),
+    path: z14.string().trim().min(1).max(4096).regex(/^[A-Za-z0-9_.-]+$/).refine(
+      (path) => path.split(".").length <= 16 && path.split(".").every(
+        (part) => part.length > 0 && !["__proto__", "prototype", "constructor"].includes(part)
+      ),
+      "Scope paths require safe own members."
+    )
+  }).strict(),
   z14.object({
     kind: z14.literal("binding-field"),
     bindingId: ContractIdentifierSchema,
@@ -9683,22 +9954,48 @@ var BindingSourceSchema = z14.discriminatedUnion("kind", [
   }).strict()
 ]);
 var ExpressionBindingSourceSchema = z14.object({ kind: z14.literal("expression"), expression: PageExpressionSchema }).strict().superRefine((value, context) => {
-  if (collectPageExpressionReads(value.expression).some((read) => read.root === "actions")) context.addIssue({ code: "custom", path: ["expression"], message: "Action runtime state is presentation-only and cannot influence an input or state transition." });
+  if (collectPageExpressionReads(value.expression).some(
+    (read) => read.root === "actions"
+  ))
+    context.addIssue({
+      code: "custom",
+      path: ["expression"],
+      message: "Action runtime state is presentation-only and cannot influence an input or state transition."
+    });
 });
-var FileFieldBindingSourceSchema = z14.object({ kind: z14.literal("file-field"), fileInputId: ContractIdentifierSchema, path: z14.enum(["fileName", "content", "canonicalUri"]) }).strict();
+var FileFieldBindingSourceSchema = z14.object({
+  kind: z14.literal("file-field"),
+  fileInputId: ContractIdentifierSchema,
+  path: z14.enum(["fileName", "content", "canonicalUri"])
+}).strict();
 var ActionFileInputSchema = z14.object({
   inputId: ContractIdentifierSchema,
   source: z14.discriminatedUnion("kind", [
-    z14.object({ kind: z14.literal("page-state"), stateId: ContractIdentifierSchema }).strict(),
-    z14.object({ kind: z14.literal("intent-field"), path: z14.string().trim().regex(/^[A-Za-z0-9_.-]+$/) }).strict()
+    z14.object({
+      kind: z14.literal("page-state"),
+      stateId: ContractIdentifierSchema
+    }).strict(),
+    z14.object({
+      kind: z14.literal("intent-field"),
+      path: z14.string().trim().regex(/^[A-Za-z0-9_.-]+$/)
+    }).strict()
   ]),
   maxBytes: z14.number().int().min(1).max(5368709120),
   upload: z14.object({ purpose: FilePurposeSchema }).strict().optional(),
   accept: z14.string().min(1).max(256).optional()
 }).strict().superRefine((value, context) => {
-  if (!value.upload && value.maxBytes > 1048576) context.addIssue({ code: "custom", path: ["maxBytes"], message: "Inline text files are limited to one MiB." });
+  if (!value.upload && value.maxBytes > 1048576)
+    context.addIssue({
+      code: "custom",
+      path: ["maxBytes"],
+      message: "Inline text files are limited to one MiB."
+    });
 });
-var ActionInputBindingSourceSchema = z14.discriminatedUnion("kind", [...BindingSourceSchema.options, ExpressionBindingSourceSchema, FileFieldBindingSourceSchema]);
+var ActionInputBindingSourceSchema = z14.discriminatedUnion("kind", [
+  ...BindingSourceSchema.options,
+  ExpressionBindingSourceSchema,
+  FileFieldBindingSourceSchema
+]);
 var InteractionBindingSourceSchema = z14.discriminatedUnion("kind", [
   ExpressionBindingSourceSchema,
   z14.object({
@@ -9718,7 +10015,12 @@ var InteractionBindingSourceSchema = z14.discriminatedUnion("kind", [
     stateId: ContractIdentifierSchema
   }).strict()
 ]);
-var PageStateComparableLiteralSchema = z14.union([z14.string(), z14.number().finite(), z14.boolean(), z14.null()]);
+var PageStateComparableLiteralSchema = z14.union([
+  z14.string(),
+  z14.number().finite(),
+  z14.boolean(),
+  z14.null()
+]);
 var PageStateConditionSchema = z14.discriminatedUnion("predicate", [
   z14.object({
     stateId: ContractIdentifierSchema,
@@ -9752,7 +10054,10 @@ var forEachPageStateCondition = (activation, visit, path = []) => {
   });
 };
 var PageRouteValueSourceSchema = z14.discriminatedUnion("kind", [
-  z14.object({ kind: z14.literal("route-parameter"), name: ContractIdentifierSchema }).strict(),
+  z14.object({
+    kind: z14.literal("route-parameter"),
+    name: ContractIdentifierSchema
+  }).strict(),
   z14.object({
     kind: z14.literal("constant"),
     value: z14.union([z14.string(), z14.number().finite(), z14.boolean()])
@@ -9764,11 +10069,17 @@ var PageRouteValueSourceSchema = z14.discriminatedUnion("kind", [
 ]);
 var PageEntryTransitionSchema = z14.object({
   browsingContext: z14.enum(["same", "new"]).optional(),
-  gestureSource: z14.object({ capabilityInstanceId: ContractIdentifierSchema, port: ContractIdentifierSchema }).strict().optional(),
+  gestureSource: z14.object({
+    capabilityInstanceId: ContractIdentifierSchema,
+    port: ContractIdentifierSchema
+  }).strict().optional(),
   transitionId: ContractIdentifierSchema,
   activation: PageStateActivationSchema,
   targetRef: StableRefSchema,
-  pathParameters: z14.record(ContractIdentifierSchema, PageRouteValueSourceSchema),
+  pathParameters: z14.record(
+    ContractIdentifierSchema,
+    PageRouteValueSourceSchema
+  ),
   query: z14.object({
     preserve: z14.boolean(),
     remove: z14.array(ContractIdentifierSchema),
@@ -9805,7 +10116,12 @@ var ResolvedPageEntryTransitionSchema = PageEntryTransitionSchema.safeExtend({
 }).strict();
 var LegacyBrowserPreferenceImportSchema = z14.object({
   storageKey: z14.string().trim().min(1).max(256),
-  jsonPath: z14.array(z14.union([z14.string().trim().min(1).max(128), z14.object({ stateId: ContractIdentifierSchema }).strict()])).min(1).max(16).optional(),
+  jsonPath: z14.array(
+    z14.union([
+      z14.string().trim().min(1).max(128),
+      z14.object({ stateId: ContractIdentifierSchema }).strict()
+    ])
+  ).min(1).max(16).optional(),
   valueType: z14.enum(["string", "number", "boolean-01", "json"])
 }).strict();
 var PageStateDefinitionSchema = z14.object({
@@ -9814,13 +10130,29 @@ var PageStateDefinitionSchema = z14.object({
   initialValue: PageExpressionSchema.optional(),
   schemaRevisionRef: RevisionRefSchema,
   defaultValue: JsonValueSchema.optional(),
-  persistence: z14.enum(["none", "session", "url", "tenant-preference", "url-with-tenant-preference"]),
+  persistence: z14.enum([
+    "none",
+    "session",
+    "url",
+    "tenant-preference",
+    "url-with-tenant-preference"
+  ]),
   urlWriteback: z14.enum(["synchronize", "never"]).optional(),
   preferencePartitionStateId: ContractIdentifierSchema.optional(),
   legacyBrowserPreferenceImport: LegacyBrowserPreferenceImportSchema.optional()
 }).strict().superRefine((value, context) => {
-  if (value.scopeNodeId && value.persistence !== "none") context.addIssue({ code: "custom", path: ["persistence"], message: "Repeated instance state must not persist outside its instance." });
-  if (value.initialValue && !value.scopeNodeId && (value.persistence !== "none" || value.initialValue.kind !== "read" || value.initialValue.root !== "state" || value.initialValue.path.length !== 1)) context.addIssue({ code: "custom", path: ["initialValue"], message: "Root initialization must directly read one persisted Page state into non-persistent state." });
+  if (value.scopeNodeId && value.persistence !== "none")
+    context.addIssue({
+      code: "custom",
+      path: ["persistence"],
+      message: "Repeated instance state must not persist outside its instance."
+    });
+  if (value.initialValue && !value.scopeNodeId && (value.persistence !== "none" || value.initialValue.kind !== "read" || value.initialValue.root !== "state" || value.initialValue.path.length !== 1))
+    context.addIssue({
+      code: "custom",
+      path: ["initialValue"],
+      message: "Root initialization must directly read one persisted Page state into non-persistent state."
+    });
   if (value.schemaRevisionRef.kind !== "schema") {
     context.addIssue({
       code: "custom",
@@ -9853,7 +10185,10 @@ var InteractionBindingSchema = z14.object({
   sourceResultSchemaRevisionRef: RevisionRefSchema.optional(),
   targetStateId: ContractIdentifierSchema,
   transition: z14.enum(["set", "merge", "toggle", "append", "remove", "reset"]),
-  inputMapping: z14.record(ContractIdentifierSchema, InteractionBindingSourceSchema)
+  inputMapping: z14.record(
+    ContractIdentifierSchema,
+    InteractionBindingSourceSchema
+  )
 }).strict().superRefine((value, context) => {
   if (value.sourceIntentSchemaRevisionRef.kind !== "schema") {
     context.addIssue({
@@ -9862,7 +10197,11 @@ var InteractionBindingSchema = z14.object({
       message: "Interaction source intents must pin a schema revision."
     });
   }
-  const mapsResult = Object.values(value.inputMapping).some((source) => source.kind === "result-field" || source.kind === "expression" && collectPageExpressionReads(source.expression).some((read) => read.root === "result"));
+  const mapsResult = Object.values(value.inputMapping).some(
+    (source) => source.kind === "result-field" || source.kind === "expression" && collectPageExpressionReads(source.expression).some(
+      (read) => read.root === "result"
+    )
+  );
   if (mapsResult && !value.sourceResultSchemaRevisionRef) {
     context.addIssue({
       code: "custom",
@@ -9900,7 +10239,11 @@ var InteractionBindingSchema = z14.object({
     });
   }
 });
-var GovernedCatalogResourceKindSchema = z14.enum(["tag", "tag-group", "feature-column"]);
+var GovernedCatalogResourceKindSchema = z14.enum([
+  "tag",
+  "tag-group",
+  "feature-column"
+]);
 var GovernedCatalogDomainQueryDataSourceSchema = z14.object({
   kind: z14.literal("governed-catalog"),
   resourceKind: GovernedCatalogResourceKindSchema
@@ -9982,9 +10325,21 @@ var DomainQueryDefinitionSchema = z14.object({
     });
   }
   const refs = [
-    ...sourceKind === "exact-view" && value.ontologyDefinitionRevisionRef ? [["ontologyDefinitionRevisionRef", value.ontologyDefinitionRevisionRef, "ontology-definition"]] : [],
+    ...sourceKind === "exact-view" && value.ontologyDefinitionRevisionRef ? [
+      [
+        "ontologyDefinitionRevisionRef",
+        value.ontologyDefinitionRevisionRef,
+        "ontology-definition"
+      ]
+    ] : [],
     ...sourceKind === "exact-view" && value.viewRevisionRef ? [["viewRevisionRef", value.viewRevisionRef, "view"]] : [],
-    ...sourceKind === "exact-view" && value.canonicalDataViewRevisionRef ? [["canonicalDataViewRevisionRef", value.canonicalDataViewRevisionRef, "view"]] : [],
+    ...sourceKind === "exact-view" && value.canonicalDataViewRevisionRef ? [
+      [
+        "canonicalDataViewRevisionRef",
+        value.canonicalDataViewRevisionRef,
+        "view"
+      ]
+    ] : [],
     ["inputSchemaRevisionRef", value.inputSchemaRevisionRef, "schema"],
     ["resultSchemaRevisionRef", value.resultSchemaRevisionRef, "schema"]
   ];
@@ -9996,10 +10351,23 @@ var DomainQueryDefinitionSchema = z14.object({
         message: `${field} must reference ${expectedKind}.`
       });
     }
-    validateTenantCompatibleReference(reference, value.tenantScope, [field], context);
+    validateTenantCompatibleReference(
+      reference,
+      value.tenantScope,
+      [field],
+      context
+    );
   });
-  [...value.accessPolicy.groupAllOf, ...value.accessPolicy.groupAnyOf].forEach(
-    (reference, index) => validateTenantCompatibleReference(reference, value.tenantScope, ["accessPolicy", "groups", index], context)
+  [
+    ...value.accessPolicy.groupAllOf,
+    ...value.accessPolicy.groupAnyOf
+  ].forEach(
+    (reference, index) => validateTenantCompatibleReference(
+      reference,
+      value.tenantScope,
+      ["accessPolicy", "groups", index],
+      context
+    )
   );
   value.accessPolicy.conditionAllOf.forEach(
     (reference, index) => validateTenantCompatibleReference(
@@ -10009,7 +10377,10 @@ var DomainQueryDefinitionSchema = z14.object({
       context
     )
   );
-  if (value.viewRevisionRef && value.canonicalDataViewRevisionRef && exactRevisionRef(value.viewRevisionRef, value.canonicalDataViewRevisionRef)) {
+  if (value.viewRevisionRef && value.canonicalDataViewRevisionRef && exactRevisionRef(
+    value.viewRevisionRef,
+    value.canonicalDataViewRevisionRef
+  )) {
     context.addIssue({
       code: "custom",
       path: ["canonicalDataViewRevisionRef"],
@@ -10052,9 +10423,21 @@ var QueryBindingSchema = z14.object({
     port: ContractIdentifierSchema
   }).strict(),
   renderModelSchemaRevisionRef: RevisionRefSchema,
-  targetProjection: z14.object({ expression: PageExpressionSchema, schemaRevisionRef: RevisionRefSchema }).strict().optional(),
-  streamTargetProjection: z14.object({ expression: PageExpressionSchema, schemaRevisionRef: RevisionRefSchema }).strict().optional(),
-  stateEffects: z14.array(z14.object({ targetStateId: ContractIdentifierSchema, value: PageExpressionSchema, when: PageExpressionSchema.optional() }).strict()).max(32).optional(),
+  targetProjection: z14.object({
+    expression: PageExpressionSchema,
+    schemaRevisionRef: RevisionRefSchema
+  }).strict().optional(),
+  streamTargetProjection: z14.object({
+    expression: PageExpressionSchema,
+    schemaRevisionRef: RevisionRefSchema
+  }).strict().optional(),
+  stateEffects: z14.array(
+    z14.object({
+      targetStateId: ContractIdentifierSchema,
+      value: PageExpressionSchema,
+      when: PageExpressionSchema.optional()
+    }).strict()
+  ).max(32).optional(),
   queryWhen: PageStateActivationSchema.optional(),
   accessFailure: z14.literal("render-forbidden").optional(),
   resultStateBindings: z14.array(QueryResultStateBindingSchema).max(32).optional(),
@@ -10063,27 +10446,88 @@ var QueryBindingSchema = z14.object({
   cursorWindow: CursorWindowBindingSchema.optional(),
   cache: z14.enum(["none", "identity-scoped", "tenant-scoped"]),
   cancelOnChange: z14.boolean(),
-  refreshPolicy: z14.object({ intervalMs: z14.number().int().min(1e3).max(3e5), when: PageExpressionSchema.optional() }).strict().optional()
+  refreshPolicy: z14.object({
+    intervalMs: z14.number().int().min(1e3).max(3e5),
+    when: PageExpressionSchema.optional()
+  }).strict().optional()
 }).strict().superRefine((value, context) => {
   if (value.targetProjection) {
-    if (value.targetProjection.schemaRevisionRef.kind !== "schema") context.addIssue({ code: "custom", path: ["targetProjection", "schemaRevisionRef"], message: "Query target projections require an exact target schema revision." });
-    for (const read of collectExternalPageExpressionReads(value.targetProjection.expression)) if (read.root !== "model") context.addIssue({ code: "custom", path: ["targetProjection", "expression"], message: "Query target projections may read only the validated raw model." });
+    if (value.targetProjection.schemaRevisionRef.kind !== "schema")
+      context.addIssue({
+        code: "custom",
+        path: ["targetProjection", "schemaRevisionRef"],
+        message: "Query target projections require an exact target schema revision."
+      });
+    for (const read of collectExternalPageExpressionReads(
+      value.targetProjection.expression
+    ))
+      if (read.root !== "model")
+        context.addIssue({
+          code: "custom",
+          path: ["targetProjection", "expression"],
+          message: "Query target projections may read only the validated raw model."
+        });
   }
   if (value.streamTargetProjection) {
     const projection = value.streamTargetProjection;
-    if (projection.schemaRevisionRef.kind !== "schema") context.addIssue({ code: "custom", path: ["streamTargetProjection", "schemaRevisionRef"], message: "Stream target projections require an exact target schema revision." });
-    for (const read of collectExternalPageExpressionReads(projection.expression)) if (read.root !== "model") context.addIssue({ code: "custom", path: ["streamTargetProjection", "expression"], message: "Stream target projections may read only the verified query and stream envelope." });
-    if (value.execution !== "server" || value.pagination !== "none") context.addIssue({ code: "custom", path: ["streamTargetProjection"], message: "Stream target projections require a non-paginated Server query." });
+    if (projection.schemaRevisionRef.kind !== "schema")
+      context.addIssue({
+        code: "custom",
+        path: ["streamTargetProjection", "schemaRevisionRef"],
+        message: "Stream target projections require an exact target schema revision."
+      });
+    for (const read of collectExternalPageExpressionReads(
+      projection.expression
+    ))
+      if (read.root !== "model")
+        context.addIssue({
+          code: "custom",
+          path: ["streamTargetProjection", "expression"],
+          message: "Stream target projections may read only the verified query and stream envelope."
+        });
+    if (value.execution !== "server" || value.pagination !== "none")
+      context.addIssue({
+        code: "custom",
+        path: ["streamTargetProjection"],
+        message: "Stream target projections require a non-paginated Server query."
+      });
   }
   const effects = value.stateEffects ?? [];
-  if (new Set(effects.map((effect) => effect.targetStateId)).size !== effects.length) context.addIssue({ code: "custom", path: ["stateEffects"], message: "A query completion may update each state only once." });
-  for (const [index, effect] of effects.entries()) for (const expression of [effect.value, ...effect.when ? [effect.when] : []]) {
-    for (const read of collectPageExpressionReads(expression)) if (!["model", "state", "scope"].includes(read.root)) context.addIssue({ code: "custom", path: ["stateEffects", index], message: "Query state effects may read only model, state, and scope." });
-  }
-  if (effects.length && (value.execution !== "server" || value.pagination !== "none")) context.addIssue({ code: "custom", path: ["stateEffects"], message: "Query state effects require a non-paginated Server query." });
+  if (new Set(effects.map((effect) => effect.targetStateId)).size !== effects.length)
+    context.addIssue({
+      code: "custom",
+      path: ["stateEffects"],
+      message: "A query completion may update each state only once."
+    });
+  for (const [index, effect] of effects.entries())
+    for (const expression of [
+      effect.value,
+      ...effect.when ? [effect.when] : []
+    ]) {
+      for (const read of collectPageExpressionReads(expression))
+        if (!["model", "state", "scope"].includes(read.root))
+          context.addIssue({
+            code: "custom",
+            path: ["stateEffects", index],
+            message: "Query state effects may read only model, state, and scope."
+          });
+    }
+  if (effects.length && (value.execution !== "server" || value.pagination !== "none"))
+    context.addIssue({
+      code: "custom",
+      path: ["stateEffects"],
+      message: "Query state effects require a non-paginated Server query."
+    });
   if (value.refreshPolicy?.when) {
-    for (const read of collectExternalPageExpressionReads(value.refreshPolicy.when)) {
-      if (read.root !== "model" && !(read.root === "actions" && read.path.length === 2 && read.path[1] === "pending")) context.addIssue({ code: "custom", path: ["refreshPolicy", "when"], message: "Automatic refresh conditions may read only the verified raw model and declared action pending state." });
+    for (const read of collectExternalPageExpressionReads(
+      value.refreshPolicy.when
+    )) {
+      if (read.root !== "model" && !(read.root === "actions" && read.path.length === 2 && read.path[1] === "pending"))
+        context.addIssue({
+          code: "custom",
+          path: ["refreshPolicy", "when"],
+          message: "Automatic refresh conditions may read only the verified raw model and declared action pending state."
+        });
     }
   }
   if (value.refreshPolicy && (value.execution !== "server" || value.pagination !== "none")) {
@@ -10159,15 +10603,31 @@ var CapabilityInstanceSchema = z14.object({
   propertySchemaRevisionRef: RevisionRefSchema,
   properties: JsonObjectSchema,
   propertyBindings: z14.array(PagePropertyBindingSchema).max(128).optional(),
-  eventPayloadBindings: z14.array(z14.object({ port: ContractIdentifierSchema, expression: PageExpressionSchema }).strict()).max(32).optional(),
-  eventEffects: z14.array(z14.object({
-    sourcePort: ContractIdentifierSchema,
-    sourceIntentSchemaRevisionRef: RevisionRefSchema,
-    refreshBindingIds: z14.array(ContractIdentifierSchema).min(1).max(128)
-  }).strict()).max(32).optional(),
+  eventPayloadBindings: z14.array(
+    z14.object({
+      port: ContractIdentifierSchema,
+      expression: PageExpressionSchema
+    }).strict()
+  ).max(32).optional(),
+  eventEffects: z14.array(
+    z14.object({
+      sourcePort: ContractIdentifierSchema,
+      sourceIntentSchemaRevisionRef: RevisionRefSchema,
+      refreshBindingIds: z14.array(ContractIdentifierSchema).min(1).max(128)
+    }).strict()
+  ).max(32).optional(),
   accessPolicy: AccessPolicySchema.optional(),
   activationWhen: PageStateActivationSchema.optional(),
-  allowedSideEffects: z14.array(z14.enum(["network", "storage", "navigation", "clipboard", "worker", "websocket"]))
+  allowedSideEffects: z14.array(
+    z14.enum([
+      "network",
+      "storage",
+      "navigation",
+      "clipboard",
+      "worker",
+      "websocket"
+    ])
+  )
 }).strict();
 var OntologyBindingSchema = z14.object({
   bindingId: ContractIdentifierSchema,
@@ -10199,7 +10659,10 @@ var OntologyBindingSchema = z14.object({
       message: "Ontology bindings require an exact canonical data.view revision."
     });
   }
-  if (exactRevisionRef(value.viewRevisionRef, value.canonicalDataViewRevisionRef)) {
+  if (exactRevisionRef(
+    value.viewRevisionRef,
+    value.canonicalDataViewRevisionRef
+  )) {
     context.addIssue({
       code: "custom",
       path: ["canonicalDataViewRevisionRef"],
@@ -10221,17 +10684,20 @@ var OntologyBindingSchema = z14.object({
     });
   }
 });
-var ActionResultBindingEffectSourceSchema = z14.discriminatedUnion("kind", [
-  z14.object({
-    kind: z14.literal("result-field"),
-    path: z14.string().trim().regex(/^[A-Za-z0-9_.-]+$/)
-  }).strict(),
-  z14.object({ kind: z14.literal("constant"), value: JsonValueSchema }).strict(),
-  z14.object({
-    kind: z14.literal("collection-length"),
-    offset: z14.number().int().min(-1e3).max(1e3)
-  }).strict()
-]);
+var ActionResultBindingEffectSourceSchema = z14.discriminatedUnion(
+  "kind",
+  [
+    z14.object({
+      kind: z14.literal("result-field"),
+      path: z14.string().trim().regex(/^[A-Za-z0-9_.-]+$/)
+    }).strict(),
+    z14.object({ kind: z14.literal("constant"), value: JsonValueSchema }).strict(),
+    z14.object({
+      kind: z14.literal("collection-length"),
+      offset: z14.number().int().min(-1e3).max(1e3)
+    }).strict()
+  ]
+);
 var ActionResultBindingEffectSchema = z14.object({
   bindingId: ContractIdentifierSchema,
   operation: z14.enum(["upsert-append", "remove-exact"]),
@@ -10244,7 +10710,9 @@ var ActionResultBindingEffectSchema = z14.object({
     }).strict()
   ).min(1).max(64)
 }).strict().superRefine((value, context) => {
-  const targetPaths = value.mappings.map(({ targetPath }) => targetPath.join("."));
+  const targetPaths = value.mappings.map(
+    ({ targetPath }) => targetPath.join(".")
+  );
   if (new Set(targetPaths).size !== targetPaths.length) {
     context.addIssue({
       code: "custom",
@@ -10306,17 +10774,30 @@ var ActionBindingSchema = z14.object({
   inputSchemaRevisionRef: RevisionRefSchema,
   when: PageExpressionSchema.optional(),
   fileInputs: z14.array(ActionFileInputSchema).min(1).max(4).optional(),
-  inputMapping: z14.record(ContractIdentifierSchema, ActionInputBindingSourceSchema),
+  inputMapping: z14.record(
+    ContractIdentifierSchema,
+    ActionInputBindingSourceSchema
+  ),
   sensitiveInputPaths: SensitiveResultPathsSchema.optional(),
   accessPolicy: AccessPolicySchema,
   confirmation: I18nTextSchema.optional(),
-  idempotencyKeySource: z14.enum(["interaction", "record-and-interaction", "caller-provided"]),
+  idempotencyKeySource: z14.enum([
+    "interaction",
+    "record-and-interaction",
+    "caller-provided"
+  ]),
   compensationCommandRevisionRef: RevisionRefSchema.optional(),
   resultSchemaRevisionRef: RevisionRefSchema,
   success: z14.object({
     download: z14.discriminatedUnion("kind", [
       z14.object({ kind: z14.literal("native") }).strict(),
-      z14.object({ kind: z14.literal("text-artifact"), fileNamePath: PageValuePathSchema.min(1), mimeTypePath: PageValuePathSchema.min(1), contentPath: PageValuePathSchema.min(1), maxBytes: z14.number().int().min(1).max(1048576) }).strict()
+      z14.object({
+        kind: z14.literal("text-artifact"),
+        fileNamePath: PageValuePathSchema.min(1),
+        mimeTypePath: PageValuePathSchema.min(1),
+        contentPath: PageValuePathSchema.min(1),
+        maxBytes: z14.number().int().min(1).max(1048576)
+      }).strict()
     ]).optional(),
     refreshBindingIds: z14.array(ContractIdentifierSchema),
     ephemeralResult: z14.object({
@@ -10338,19 +10819,55 @@ var ActionBindingSchema = z14.object({
 }).strict().superRefine((value, context) => {
   const fileIds = /* @__PURE__ */ new Set();
   for (const file of value.fileInputs ?? []) {
-    if (fileIds.has(file.inputId)) context.addIssue({ code: "custom", path: ["fileInputs"], message: "File input ids must be unique." });
+    if (fileIds.has(file.inputId))
+      context.addIssue({
+        code: "custom",
+        path: ["fileInputs"],
+        message: "File input ids must be unique."
+      });
     fileIds.add(file.inputId);
-    if (!Object.values(value.inputMapping).some((source) => source.kind === "file-field" && source.fileInputId === file.inputId)) context.addIssue({ code: "custom", path: ["fileInputs"], message: "File inputs require an explicit governed input mapping." });
-  }
-  for (const [name, source] of Object.entries(value.inputMapping)) if (source.kind === "file-field") {
-    const file = value.fileInputs?.find((file2) => file2.inputId === source.fileInputId);
-    if (source.path === "canonicalUri" && !file?.upload || source.path === "content" && file?.upload) context.addIssue({ code: "custom", path: ["inputMapping", name], message: "File field must match its declared transport mode." });
-    if (!fileIds.has(source.fileInputId)) context.addIssue({ code: "custom", path: ["inputMapping", name], message: "File fields must reference a declared file input." });
-    if (source.path === "content" && !value.sensitiveInputPaths?.includes(`/${name}`)) context.addIssue({ code: "custom", path: ["sensitiveInputPaths"], message: "File content must be declared as a sensitive command input." });
-  }
-  if (value.when) for (const read of collectPageExpressionReads(value.when)) {
-    if (!["intent", "state", "scope"].includes(read.root)) context.addIssue({ code: "custom", path: ["when"], message: "Action conditions may read only intent, declared Page state, and instance scope." });
+    if (!Object.values(value.inputMapping).some(
+      (source) => source.kind === "file-field" && source.fileInputId === file.inputId
+    ))
+      context.addIssue({
+        code: "custom",
+        path: ["fileInputs"],
+        message: "File inputs require an explicit governed input mapping."
+      });
   }
+  for (const [name, source] of Object.entries(value.inputMapping))
+    if (source.kind === "file-field") {
+      const file = value.fileInputs?.find(
+        (file2) => file2.inputId === source.fileInputId
+      );
+      if (source.path === "canonicalUri" && !file?.upload || source.path === "content" && file?.upload)
+        context.addIssue({
+          code: "custom",
+          path: ["inputMapping", name],
+          message: "File field must match its declared transport mode."
+        });
+      if (!fileIds.has(source.fileInputId))
+        context.addIssue({
+          code: "custom",
+          path: ["inputMapping", name],
+          message: "File fields must reference a declared file input."
+        });
+      if (source.path === "content" && !value.sensitiveInputPaths?.includes(`/${name}`))
+        context.addIssue({
+          code: "custom",
+          path: ["sensitiveInputPaths"],
+          message: "File content must be declared as a sensitive command input."
+        });
+    }
+  if (value.when)
+    for (const read of collectPageExpressionReads(value.when)) {
+      if (!["intent", "state", "scope"].includes(read.root))
+        context.addIssue({
+          code: "custom",
+          path: ["when"],
+          message: "Action conditions may read only intent, declared Page state, and instance scope."
+        });
+    }
   if (value.success.ephemeralResult) {
     const { valuePath, labelPath } = value.success.ephemeralResult;
     const segments = (path) => path.split("/").slice(1);
@@ -10480,7 +10997,9 @@ var PageMigrationEquivalenceSchema = z14.object({
       message: "Migration equivalence scenario identities must be unique."
     });
   }
-  const viewportIds = new Set(value.viewports.map((viewport) => viewport.viewportId));
+  const viewportIds = new Set(
+    value.viewports.map((viewport) => viewport.viewportId)
+  );
   value.scenarios.forEach((scenario, index) => {
     scenario.viewportIds.forEach((viewportId, viewportIndex) => {
       if (!viewportIds.has(viewportId)) {
@@ -10526,7 +11045,165 @@ var PageRouteStatePresentationSchema = z14.object({
     });
   });
 });
+var PageStateSchema = PageStateDefinitionSchema.omit({
+  schemaRevisionRef: true
+}).extend({
+  stateId: ContractIdentifierSchema,
+  schema: ContractIdentifierSchema
+}).strict();
+var PageEntryTargetSchema = z14.object({
+  kind: z14.enum(["page", "workbench"]),
+  id: ContractIdentifierSchema
+}).strict();
+var PageEntrySchema = PageEntryTransitionSchema.omit({
+  targetRef: true
+}).extend({
+  target: PageEntryTargetSchema
+}).strict();
+var PageInteractionSchema = InteractionBindingSchema.omit({
+  source: true,
+  sourceIntentSchemaRevisionRef: true,
+  sourceResultSchemaRevisionRef: true
+}).extend({
+  port: ContractIdentifierSchema
+}).strict();
+var PageCursorWindowSchema = CursorWindowBindingSchema.omit({
+  pageChangeIntentSchemaRevisionRef: true
+}).strict();
+var PageResultStateBindingSchema = QueryResultStateBindingSchema.omit({
+  targetStateSchemaRevisionRef: true
+}).strict();
+var PageDataSchema = QueryBindingSchema.omit({
+  queryDefinitionRevisionRef: true,
+  target: true,
+  renderModelSchemaRevisionRef: true,
+  targetProjection: true,
+  streamTargetProjection: true,
+  cursorWindow: true,
+  resultStateBindings: true
+}).extend({
+  query: ContractIdentifierSchema,
+  port: ContractIdentifierSchema,
+  targetProjection: z14.object({ expression: PageExpressionSchema }).strict().optional(),
+  streamTargetProjection: z14.object({ expression: PageExpressionSchema }).strict().optional(),
+  cursorWindow: PageCursorWindowSchema.optional(),
+  resultStateBindings: z14.array(PageResultStateBindingSchema).max(32).optional()
+}).strict();
+var PageActionSchema = ActionBindingSchema.omit({
+  commandRevisionRef: true,
+  source: true,
+  sourceIntentSchemaRevisionRef: true,
+  inputSchemaRevisionRef: true,
+  compensationCommandRevisionRef: true,
+  resultSchemaRevisionRef: true
+}).extend({
+  command: ContractIdentifierSchema,
+  port: ContractIdentifierSchema,
+  compensationCommand: ContractIdentifierSchema.optional()
+}).strict();
+var PageEventEffectSchema = z14.object({
+  port: ContractIdentifierSchema,
+  refresh: z14.array(ContractIdentifierSchema).min(1).max(128)
+}).strict();
+var PageNodeSchema = z14.lazy(
+  () => z14.object({
+    id: ContractIdentifierSchema,
+    component: ContractIdentifierSchema,
+    kind: RenderNodeKindSchema.optional(),
+    slot: ContractIdentifierSchema.optional(),
+    props: JsonObjectSchema.optional(),
+    bindings: z14.array(PagePropertyBindingSchema).max(128).optional(),
+    model: JsonObjectSchema.optional(),
+    style: RenderStyleSchema.optional(),
+    layout: RenderLayoutSchema.optional(),
+    responsive: z14.array(RenderResponsiveRuleSchema).optional(),
+    surface: RenderSurfaceSchema.optional(),
+    scroll: RenderScrollSchema.optional(),
+    activation: RenderActivationSchema.optional(),
+    lifecycle: RenderLifecycleSchema.optional(),
+    state: RenderNodeStateSchema.optional(),
+    access: AccessPolicySchema.optional(),
+    activeWhen: PageStateActivationSchema.optional(),
+    repeat: z14.object({
+      source: PageExpressionSchema,
+      keyPath: PageValuePathSchema.min(1),
+      limit: z14.number().int().min(1).max(1e3).optional()
+    }).strict().optional(),
+    data: z14.array(PageDataSchema).optional(),
+    actions: z14.array(PageActionSchema).optional(),
+    on: z14.array(PageInteractionSchema).optional(),
+    effects: z14.array(PageEventEffectSchema).optional(),
+    eventPayloads: z14.array(
+      z14.object({
+        port: ContractIdentifierSchema,
+        expression: PageExpressionSchema
+      }).strict()
+    ).optional(),
+    children: z14.array(PageNodeSchema).optional()
+  }).strict()
+);
 var PageSchema = z14.object({
+  contract: z14.literal("Page"),
+  schemaVersion: z14.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  pageId: ContractIdentifierSchema,
+  tenantScope: TenantScopeSchema,
+  identity: IdentitySchema,
+  surface: ProductSurfaceSchema,
+  route: RoutePathTemplateSchema,
+  routeSpace: ContractIdentifierSchema.optional(),
+  lifecycle: DeclarativeLifecycleSchema.default("active"),
+  routeStatePresentations: z14.array(PageRouteStatePresentationSchema).max(8).optional(),
+  shell: ContractIdentifierSchema.optional(),
+  body: PageNodeSchema,
+  state: z14.array(PageStateSchema).optional(),
+  entryTransitions: z14.array(PageEntrySchema).optional(),
+  access: AccessPolicySchema,
+  managementAccess: ManagementAccessSchema,
+  tokens: z14.array(ContractIdentifierSchema).optional(),
+  performanceBudget: ContractIdentifierSchema.optional(),
+  observationPolicy: ContractIdentifierSchema.optional(),
+  privacyClassification: z14.enum(["public", "internal", "confidential", "restricted"]).default("internal")
+}).strict().superRefine((page, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  const dataIds = /* @__PURE__ */ new Set();
+  const actionIds = /* @__PURE__ */ new Set();
+  const interactionIds = /* @__PURE__ */ new Set();
+  const visit = (node, path) => {
+    if (ids.has(node.id))
+      context.addIssue({
+        code: "custom",
+        path: [...path, "id"],
+        message: `Duplicate Page node id ${node.id}.`
+      });
+    ids.add(node.id);
+    for (const [field, values, target] of [
+      ["data", node.data ?? [], dataIds],
+      ["actions", node.actions ?? [], actionIds],
+      ["on", node.on ?? [], interactionIds]
+    ])
+      for (const [index, value] of values.entries()) {
+        if (target.has(value.bindingId))
+          context.addIssue({
+            code: "custom",
+            path: [...path, field, index, "bindingId"],
+            message: `Duplicate Page binding id ${value.bindingId}.`
+          });
+        target.add(value.bindingId);
+      }
+    (node.children ?? []).forEach(
+      (child, index) => visit(child, [...path, "children", index])
+    );
+  };
+  visit(page.body, ["body"]);
+  const stateIds = (page.state ?? []).map((entry) => entry.stateId);
+  if (new Set(stateIds).size !== stateIds.length)
+    context.addIssue({
+      code: "custom",
+      path: ["state"],
+      message: "Page state ids must be unique."
+    });
+});
+var ResolvedPageSchema = z14.object({
   contract: z14.literal("Page"),
   schemaVersion: z14.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
   pageId: ContractIdentifierSchema,
@@ -10537,7 +11214,12 @@ var PageSchema = z14.object({
   legacyRoutePolicy: LegacyRoutePolicySchema.optional(),
   migrationEquivalence: PageMigrationEquivalenceSchema.optional(),
   routeStatePresentations: z14.array(PageRouteStatePresentationSchema).max(8).optional(),
-  routeClaims: z14.array(z14.union([DeclarativeRouteClaimSchema, LegacyDeclarativeRouteClaimSchema])).min(1),
+  routeClaims: z14.array(
+    z14.union([
+      DeclarativeRouteClaimSchema,
+      LegacyDeclarativeRouteClaimSchema
+    ])
+  ).min(1),
   shellRevisionRef: RevisionRefSchema,
   renderTree: RenderTreeSchema,
   capabilityInstances: z14.array(CapabilityInstanceSchema).min(1),
@@ -10552,11 +11234,23 @@ var PageSchema = z14.object({
   tokenRevisionRefs: z14.array(RevisionRefSchema).min(1),
   performanceBudgetRef: RevisionRefSchema,
   observationPolicyRevisionRef: RevisionRefSchema,
-  privacyClassification: z14.enum(["public", "internal", "confidential", "restricted"])
+  privacyClassification: z14.enum([
+    "public",
+    "internal",
+    "confidential",
+    "restricted"
+  ])
 }).strict().superRefine((value, context) => {
-  validateDeclaredRouteSurfaces(value.supportedSurfaces, value.routeClaims, context);
+  validateDeclaredRouteSurfaces(
+    value.supportedSurfaces,
+    value.routeClaims,
+    context
+  );
   const routeStatePresentations = value.routeStatePresentations ?? [];
-  if (uniqueArray(routeStatePresentations, (candidate) => `${candidate.surface}:${candidate.state}`)) {
+  if (uniqueArray(
+    routeStatePresentations,
+    (candidate) => `${candidate.surface}:${candidate.state}`
+  )) {
     context.addIssue({
       code: "custom",
       path: ["routeStatePresentations"],
@@ -10578,18 +11272,27 @@ var PageSchema = z14.object({
   const queryBindings = value.queryBindings ?? [];
   stateDefinitions.forEach((definition, index) => {
     const partitionStateId = definition.preferencePartitionStateId;
-    const dynamicLegacySegments = definition.legacyBrowserPreferenceImport?.jsonPath?.filter((segment) => typeof segment !== "string") ?? [];
+    const dynamicLegacySegments = definition.legacyBrowserPreferenceImport?.jsonPath?.filter(
+      (segment) => typeof segment !== "string"
+    ) ?? [];
     if (!partitionStateId) {
       if (dynamicLegacySegments.length > 0) {
         context.addIssue({
           code: "custom",
-          path: ["stateDefinitions", index, "legacyBrowserPreferenceImport", "jsonPath"],
+          path: [
+            "stateDefinitions",
+            index,
+            "legacyBrowserPreferenceImport",
+            "jsonPath"
+          ],
           message: "A dynamic legacy preference path requires a declared preference partition state."
         });
       }
       return;
     }
-    const partitionDefinition = stateDefinitions.find((candidate) => candidate.stateId === partitionStateId);
+    const partitionDefinition = stateDefinitions.find(
+      (candidate) => candidate.stateId === partitionStateId
+    );
     if (partitionStateId === definition.stateId || !partitionDefinition || partitionDefinition.preferencePartitionStateId) {
       context.addIssue({
         code: "custom",
@@ -10597,24 +11300,60 @@ var PageSchema = z14.object({
         message: "Preference partitioning must reference a distinct, non-partitioned Page state."
       });
     }
-    definition.legacyBrowserPreferenceImport?.jsonPath?.forEach((segment, segmentIndex) => {
-      if (typeof segment !== "string" && segment.stateId !== partitionStateId) {
-        context.addIssue({
-          code: "custom",
-          path: ["stateDefinitions", index, "legacyBrowserPreferenceImport", "jsonPath", segmentIndex],
-          message: "A dynamic legacy preference path must use the declared preference partition state."
-        });
+    definition.legacyBrowserPreferenceImport?.jsonPath?.forEach(
+      (segment, segmentIndex) => {
+        if (typeof segment !== "string" && segment.stateId !== partitionStateId) {
+          context.addIssue({
+            code: "custom",
+            path: [
+              "stateDefinitions",
+              index,
+              "legacyBrowserPreferenceImport",
+              "jsonPath",
+              segmentIndex
+            ],
+            message: "A dynamic legacy preference path must use the declared preference partition state."
+          });
+        }
       }
-    });
+    );
   });
   const uniqueness = [
-    ["capabilityInstances", value.capabilityInstances, (candidate) => String(candidate.instanceId)],
-    ["stateDefinitions", stateDefinitions, (candidate) => String(candidate.stateId)],
-    ["entryTransitions", entryTransitions, (candidate) => String(candidate.transitionId)],
-    ["interactionBindings", interactionBindings, (candidate) => String(candidate.bindingId)],
-    ["ontologyBindings", value.ontologyBindings, (candidate) => String(candidate.bindingId)],
-    ["queryBindings", queryBindings, (candidate) => String(candidate.bindingId)],
-    ["actionBindings", value.actionBindings, (candidate) => String(candidate.bindingId)]
+    [
+      "capabilityInstances",
+      value.capabilityInstances,
+      (candidate) => String(candidate.instanceId)
+    ],
+    [
+      "stateDefinitions",
+      stateDefinitions,
+      (candidate) => String(candidate.stateId)
+    ],
+    [
+      "entryTransitions",
+      entryTransitions,
+      (candidate) => String(candidate.transitionId)
+    ],
+    [
+      "interactionBindings",
+      interactionBindings,
+      (candidate) => String(candidate.bindingId)
+    ],
+    [
+      "ontologyBindings",
+      value.ontologyBindings,
+      (candidate) => String(candidate.bindingId)
+    ],
+    [
+      "queryBindings",
+      queryBindings,
+      (candidate) => String(candidate.bindingId)
+    ],
+    [
+      "actionBindings",
+      value.actionBindings,
+      (candidate) => String(candidate.bindingId)
+    ]
   ];
   uniqueness.forEach(([field, values, identity]) => {
     if (uniqueArray(values, identity))
@@ -10624,49 +11363,132 @@ var PageSchema = z14.object({
         message: `${field} identities must be unique.`
       });
   });
-  const instanceIds = new Set(value.capabilityInstances.map((instance) => instance.instanceId));
+  const instanceIds = new Set(
+    value.capabilityInstances.map((instance) => instance.instanceId)
+  );
   const stateIds = new Set(stateDefinitions.map((state) => state.stateId));
   value.capabilityInstances.forEach((instance, index) => {
     const ports = /* @__PURE__ */ new Set();
     const payloadPorts = /* @__PURE__ */ new Set();
     instance.eventPayloadBindings?.forEach((binding, bindingIndex) => {
-      const path = ["capabilityInstances", index, "eventPayloadBindings", bindingIndex];
-      if (payloadPorts.has(binding.port)) context.addIssue({ code: "custom", path, message: "An event payload can have only one declarative projection." });
+      const path = [
+        "capabilityInstances",
+        index,
+        "eventPayloadBindings",
+        bindingIndex
+      ];
+      if (payloadPorts.has(binding.port))
+        context.addIssue({
+          code: "custom",
+          path,
+          message: "An event payload can have only one declarative projection."
+        });
       payloadPorts.add(binding.port);
       for (const read of collectPageExpressionReads(binding.expression)) {
-        if (read.root === "actions" || read.root === "result" || read.root === "state" && !stateIds.has(read.path[0] ?? "") || read.root === "bindings" && ![...value.ontologyBindings, ...queryBindings].some((candidate) => candidate.bindingId === read.path[0])) context.addIssue({ code: "custom", path, message: "Event payload projections require local event, model, scope, declared query results, or declared state." });
+        if (read.root === "actions" || read.root === "result" || read.root === "state" && !stateIds.has(read.path[0] ?? "") || read.root === "bindings" && ![...value.ontologyBindings, ...queryBindings].some(
+          (candidate) => candidate.bindingId === read.path[0]
+        ))
+          context.addIssue({
+            code: "custom",
+            path,
+            message: "Event payload projections require local event, model, scope, declared query results, or declared state."
+          });
       }
     });
     instance.eventEffects?.forEach((effect, effectIndex) => {
-      const path = ["capabilityInstances", index, "eventEffects", effectIndex];
-      if (effect.sourceIntentSchemaRevisionRef.kind !== "schema" || ports.has(effect.sourcePort)) context.addIssue({ code: "custom", path, message: "Event effects require one exact source schema per output port." });
+      const path = [
+        "capabilityInstances",
+        index,
+        "eventEffects",
+        effectIndex
+      ];
+      if (effect.sourceIntentSchemaRevisionRef.kind !== "schema" || ports.has(effect.sourcePort))
+        context.addIssue({
+          code: "custom",
+          path,
+          message: "Event effects require one exact source schema per output port."
+        });
       ports.add(effect.sourcePort);
-      if (value.actionBindings.some((binding) => binding.source.capabilityInstanceId === instance.instanceId && binding.source.port === effect.sourcePort)) context.addIssue({ code: "custom", path, message: "An Action output port must declare refresh effects through Action.success." });
-      for (const id of effect.refreshBindingIds) if (![...value.ontologyBindings, ...queryBindings].some((binding) => binding.bindingId === id)) context.addIssue({ code: "custom", path, message: "Event effect references an unknown query binding." });
+      if (value.actionBindings.some(
+        (binding) => binding.source.capabilityInstanceId === instance.instanceId && binding.source.port === effect.sourcePort
+      ))
+        context.addIssue({
+          code: "custom",
+          path,
+          message: "An Action output port must declare refresh effects through Action.success."
+        });
+      for (const id of effect.refreshBindingIds)
+        if (![...value.ontologyBindings, ...queryBindings].some(
+          (binding) => binding.bindingId === id
+        ))
+          context.addIssue({
+            code: "custom",
+            path,
+            message: "Event effect references an unknown query binding."
+          });
     });
   });
-  const repeatNodes = new Set(value.renderTree.nodes.filter((node) => node.repeat).map((node) => node.nodeId));
+  const repeatNodes = new Set(
+    value.renderTree.nodes.filter((node) => node.repeat).map((node) => node.nodeId)
+  );
   stateDefinitions.forEach((definition, index) => {
-    if (definition.scopeNodeId && !repeatNodes.has(definition.scopeNodeId)) context.addIssue({ code: "custom", path: ["stateDefinitions", index, "scopeNodeId"], message: "Instance state must reference an existing repeated RenderNode." });
+    if (definition.scopeNodeId && !repeatNodes.has(definition.scopeNodeId))
+      context.addIssue({
+        code: "custom",
+        path: ["stateDefinitions", index, "scopeNodeId"],
+        message: "Instance state must reference an existing repeated RenderNode."
+      });
     if (definition.initialValue && !definition.scopeNodeId) {
       const expression = definition.initialValue;
-      const source = expression.kind === "read" ? stateDefinitions.find((state) => state.stateId === expression.path[0] && !state.scopeNodeId) : void 0;
-      if (!source || source.initialValue || !["tenant-preference", "url-with-tenant-preference"].includes(source.persistence)) context.addIssue({ code: "custom", path: ["stateDefinitions", index, "initialValue"], message: "Root initialization requires an independently hydrated tenant preference; initialization chains are forbidden." });
+      const source = expression.kind === "read" ? stateDefinitions.find(
+        (state) => state.stateId === expression.path[0] && !state.scopeNodeId
+      ) : void 0;
+      if (!source || source.initialValue || !["tenant-preference", "url-with-tenant-preference"].includes(
+        source.persistence
+      ))
+        context.addIssue({
+          code: "custom",
+          path: ["stateDefinitions", index, "initialValue"],
+          message: "Root initialization requires an independently hydrated tenant preference; initialization chains are forbidden."
+        });
     }
     if (definition.initialValue) {
-      for (const read of collectPageExpressionReads(definition.initialValue)) {
-        if (!["scope", "state"].includes(read.root) || read.root === "state" && !stateDefinitions.some((state) => state.stateId === read.path[0] && !state.scopeNodeId)) context.addIssue({ code: "custom", path: ["stateDefinitions", index, "initialValue"], message: "Instance initial values can read only their item scope and declared Page state." });
+      for (const read of collectPageExpressionReads(
+        definition.initialValue
+      )) {
+        if (!["scope", "state"].includes(read.root) || read.root === "state" && !stateDefinitions.some(
+          (state) => state.stateId === read.path[0] && !state.scopeNodeId
+        ))
+          context.addIssue({
+            code: "custom",
+            path: ["stateDefinitions", index, "initialValue"],
+            message: "Instance initial values can read only their item scope and declared Page state."
+          });
       }
     }
   });
   value.renderTree.nodes.forEach((node, index) => {
     if (!node.repeat) return;
     for (const read of collectPageExpressionReads(node.repeat.source)) {
-      if (read.root === "actions" || read.root === "intent" || read.root === "result" || read.root === "model" || read.root === "state" && !stateIds.has(read.path[0] ?? "") || read.root === "bindings" && ![...value.ontologyBindings, ...queryBindings].some((binding) => binding.bindingId === read.path[0])) context.addIssue({ code: "custom", path: ["renderTree", "nodes", index, "repeat", "source"], message: "Repeated nodes require declared Page state, query results, or parent item scope." });
+      if (read.root === "actions" || read.root === "intent" || read.root === "result" || read.root === "model" || read.root === "state" && !stateIds.has(read.path[0] ?? "") || read.root === "bindings" && ![...value.ontologyBindings, ...queryBindings].some(
+        (binding) => binding.bindingId === read.path[0]
+      ))
+        context.addIssue({
+          code: "custom",
+          path: ["renderTree", "nodes", index, "repeat", "source"],
+          message: "Repeated nodes require declared Page state, query results, or parent item scope."
+        });
     }
   });
-  const renderNodesById = new Map(value.renderTree.nodes.map((node) => [node.nodeId, node]));
-  const instanceNodes = new Map(value.capabilityInstances.map((instance) => [instance.instanceId, instance.nodeId]));
+  const renderNodesById = new Map(
+    value.renderTree.nodes.map((node) => [node.nodeId, node])
+  );
+  const instanceNodes = new Map(
+    value.capabilityInstances.map((instance) => [
+      instance.instanceId,
+      instance.nodeId
+    ])
+  );
   const scopesForNode = (nodeId) => {
     const scopes = /* @__PURE__ */ new Set();
     const visited = /* @__PURE__ */ new Set();
@@ -10678,60 +11500,170 @@ var PageSchema = z14.object({
     }
     return scopes;
   };
-  const queryOwners = new Map([...value.ontologyBindings, ...queryBindings].map((binding) => [
-    binding.bindingId,
-    [...scopesForNode(instanceNodes.get(binding.target.capabilityInstanceId))][0]
-  ]));
-  const actionScopes = new Map(value.actionBindings.map((binding) => [binding.bindingId, scopesForNode(instanceNodes.get(binding.source.capabilityInstanceId))]));
-  const actionOwners = new Map([...actionScopes].map(([id, scopes]) => [id, [...scopes][0]]));
-  if (actionOwners.size !== value.actionBindings.length) context.addIssue({ code: "custom", path: ["actionBindings"], message: "Action binding identifiers must be unique." });
+  const queryOwners = new Map(
+    [...value.ontologyBindings, ...queryBindings].map((binding) => [
+      binding.bindingId,
+      [
+        ...scopesForNode(
+          instanceNodes.get(binding.target.capabilityInstanceId)
+        )
+      ][0]
+    ])
+  );
+  const actionScopes = new Map(
+    value.actionBindings.map((binding) => [
+      binding.bindingId,
+      scopesForNode(instanceNodes.get(binding.source.capabilityInstanceId))
+    ])
+  );
+  const actionOwners = new Map(
+    [...actionScopes].map(([id, scopes]) => [id, [...scopes][0]])
+  );
+  if (actionOwners.size !== value.actionBindings.length)
+    context.addIssue({
+      code: "custom",
+      path: ["actionBindings"],
+      message: "Action binding identifiers must be unique."
+    });
   const checkScopedReads = (reads, scopes, path) => {
     for (const read of reads) {
       const owner = read.root === "state" ? stateDefinitions.find((state) => state.stateId === read.path[0])?.scopeNodeId : read.root === "bindings" ? queryOwners.get(read.path[0]) : read.root === "actions" ? actionOwners.get(read.path[0]) : void 0;
-      const pendingAggregate = read.root === "actions" && read.path.length === 2 && read.path[1] === "pending" && actionScopes.has(read.path[0]) && [...scopes].every((scope) => actionScopes.get(read.path[0]).has(scope));
-      if (owner && !scopes.has(owner) && !pendingAggregate) context.addIssue({ code: "custom", path, message: "A binding cannot read state, query results, or individual action status from a sibling or descendant instance." });
+      const pendingAggregate = read.root === "actions" && read.path.length === 2 && read.path[1] === "pending" && actionScopes.has(read.path[0]) && [...scopes].every(
+        (scope) => actionScopes.get(read.path[0]).has(scope)
+      );
+      if (owner && !scopes.has(owner) && !pendingAggregate)
+        context.addIssue({
+          code: "custom",
+          path,
+          message: "A binding cannot read state, query results, or individual action status from a sibling or descendant instance."
+        });
     }
   };
   const checkScopedSources = (sources, scopes, path) => {
     Object.entries(sources).forEach(([name, source]) => {
-      if (source.kind === "expression") checkScopedReads(collectPageExpressionReads(source.expression), scopes, [...path, name]);
-      if (source.kind === "page-state") checkScopedReads([{ kind: "read", root: "state", path: [source.stateId] }], scopes, [...path, name]);
-      if (source.kind === "binding-field") checkScopedReads([{ kind: "read", root: "bindings", path: [source.bindingId] }], scopes, [...path, name]);
-      if (source.kind === "scope-field" && scopes.size === 0) context.addIssue({ code: "custom", path: [...path, name], message: "A scope field requires a repeated instance." });
+      if (source.kind === "expression")
+        checkScopedReads(
+          collectPageExpressionReads(source.expression),
+          scopes,
+          [...path, name]
+        );
+      if (source.kind === "page-state")
+        checkScopedReads(
+          [{ kind: "read", root: "state", path: [source.stateId] }],
+          scopes,
+          [...path, name]
+        );
+      if (source.kind === "binding-field")
+        checkScopedReads(
+          [{ kind: "read", root: "bindings", path: [source.bindingId] }],
+          scopes,
+          [...path, name]
+        );
+      if (source.kind === "scope-field" && scopes.size === 0)
+        context.addIssue({
+          code: "custom",
+          path: [...path, name],
+          message: "A scope field requires a repeated instance."
+        });
     });
   };
-  value.capabilityInstances.forEach((instance, index) => instance.eventPayloadBindings?.forEach((binding, bindingIndex) => checkScopedReads(collectPageExpressionReads(binding.expression), scopesForNode(instance.nodeId), ["capabilityInstances", index, "eventPayloadBindings", bindingIndex])));
-  value.capabilityInstances.forEach((instance, index) => instance.propertyBindings?.forEach((binding, bindingIndex) => {
-    checkScopedReads(collectPageExpressionReads(binding.expression), scopesForNode(instance.nodeId), ["capabilityInstances", index, "propertyBindings", bindingIndex]);
-  }));
-  for (const [collection, bindings] of [["ontologyBindings", value.ontologyBindings], ["queryBindings", queryBindings]]) {
-    bindings.forEach((binding, index) => checkScopedSources(binding.parameters, scopesForNode(instanceNodes.get(binding.target.capabilityInstanceId)), [collection, index, "parameters"]));
+  value.capabilityInstances.forEach(
+    (instance, index) => instance.eventPayloadBindings?.forEach(
+      (binding, bindingIndex) => checkScopedReads(
+        collectPageExpressionReads(binding.expression),
+        scopesForNode(instance.nodeId),
+        ["capabilityInstances", index, "eventPayloadBindings", bindingIndex]
+      )
+    )
+  );
+  value.capabilityInstances.forEach(
+    (instance, index) => instance.propertyBindings?.forEach((binding, bindingIndex) => {
+      checkScopedReads(
+        collectPageExpressionReads(binding.expression),
+        scopesForNode(instance.nodeId),
+        ["capabilityInstances", index, "propertyBindings", bindingIndex]
+      );
+    })
+  );
+  for (const [collection, bindings] of [
+    ["ontologyBindings", value.ontologyBindings],
+    ["queryBindings", queryBindings]
+  ]) {
+    bindings.forEach(
+      (binding, index) => checkScopedSources(
+        binding.parameters,
+        scopesForNode(instanceNodes.get(binding.target.capabilityInstanceId)),
+        [collection, index, "parameters"]
+      )
+    );
   }
   value.actionBindings.forEach((binding, index) => {
-    const scopes = scopesForNode(instanceNodes.get(binding.source.capabilityInstanceId));
-    checkScopedSources(binding.inputMapping, scopes, ["actionBindings", index, "inputMapping"]);
+    const scopes = scopesForNode(
+      instanceNodes.get(binding.source.capabilityInstanceId)
+    );
+    checkScopedSources(binding.inputMapping, scopes, [
+      "actionBindings",
+      index,
+      "inputMapping"
+    ]);
     for (const [fileIndex, file] of (binding.fileInputs ?? []).entries()) {
       if (file.source.kind === "page-state") {
         const stateId = file.source.stateId;
-        const state = stateDefinitions.find((candidate) => candidate.stateId === stateId);
-        if (!state || state.persistence !== "none") context.addIssue({ code: "custom", path: ["actionBindings", index, "fileInputs", fileIndex], message: "File handles require declared nonpersistent Page state." });
-        checkScopedSources({ file: file.source }, scopes, ["actionBindings", index, "fileInputs", fileIndex]);
+        const state = stateDefinitions.find(
+          (candidate) => candidate.stateId === stateId
+        );
+        if (!state || state.persistence !== "none")
+          context.addIssue({
+            code: "custom",
+            path: ["actionBindings", index, "fileInputs", fileIndex],
+            message: "File handles require declared nonpersistent Page state."
+          });
+        checkScopedSources({ file: file.source }, scopes, [
+          "actionBindings",
+          index,
+          "fileInputs",
+          fileIndex
+        ]);
       }
     }
     if (binding.when) {
       const reads = collectPageExpressionReads(binding.when);
       checkScopedReads(reads, scopes, ["actionBindings", index, "when"]);
-      for (const read of reads) if (read.root === "state" && !stateIds.has(read.path[0])) context.addIssue({ code: "custom", path: ["actionBindings", index, "when"], message: "Action condition references an unknown Page state." });
+      for (const read of reads)
+        if (read.root === "state" && !stateIds.has(read.path[0]))
+          context.addIssue({
+            code: "custom",
+            path: ["actionBindings", index, "when"],
+            message: "Action condition references an unknown Page state."
+          });
     }
   });
   interactionBindings.forEach((binding, index) => {
-    const sourceScopes = scopesForNode(instanceNodes.get(binding.source.capabilityInstanceId));
-    const targetScope = stateDefinitions.find((state) => state.stateId === binding.targetStateId)?.scopeNodeId;
-    if (targetScope && !sourceScopes.has(targetScope)) context.addIssue({ code: "custom", path: ["interactionBindings", index, "targetStateId"], message: "An interaction must target its own instance or an ancestor." });
-    checkScopedSources(binding.inputMapping, targetScope ? scopesForNode(targetScope) : /* @__PURE__ */ new Set(), ["interactionBindings", index, "inputMapping"]);
+    const sourceScopes = scopesForNode(
+      instanceNodes.get(binding.source.capabilityInstanceId)
+    );
+    const targetScope = stateDefinitions.find(
+      (state) => state.stateId === binding.targetStateId
+    )?.scopeNodeId;
+    if (targetScope && !sourceScopes.has(targetScope))
+      context.addIssue({
+        code: "custom",
+        path: ["interactionBindings", index, "targetStateId"],
+        message: "An interaction must target its own instance or an ancestor."
+      });
+    checkScopedSources(
+      binding.inputMapping,
+      targetScope ? scopesForNode(targetScope) : /* @__PURE__ */ new Set(),
+      ["interactionBindings", index, "inputMapping"]
+    );
   });
   value.renderTree.nodes.forEach((node, index) => {
-    if (node.repeat) checkScopedReads(collectPageExpressionReads(node.repeat.source), scopesForNode(node.parentNodeId), ["renderTree", "nodes", index, "repeat", "source"]);
+    if (node.repeat)
+      checkScopedReads(
+        collectPageExpressionReads(node.repeat.source),
+        scopesForNode(node.parentNodeId),
+        ["renderTree", "nodes", index, "repeat", "source"]
+      );
   });
   entryTransitions.forEach((transition, transitionIndex) => {
     if (transition.gestureSource && (!instanceIds.has(transition.gestureSource.capabilityInstanceId) || !interactionBindings.some(
@@ -10750,22 +11682,42 @@ var PageSchema = z14.object({
         message: "A Page cannot route into itself on entry."
       });
     }
-    forEachPageStateCondition(transition.activation, (condition, conditionPath) => {
-      if (!stateIds.has(condition.stateId)) {
+    forEachPageStateCondition(
+      transition.activation,
+      (condition, conditionPath) => {
+        if (!stateIds.has(condition.stateId)) {
+          context.addIssue({
+            code: "custom",
+            path: [
+              "entryTransitions",
+              transitionIndex,
+              "activation",
+              ...conditionPath,
+              "stateId"
+            ],
+            message: `Entry transition references unknown Page state ${condition.stateId}.`
+          });
+        }
+      }
+    );
+    const declaredRouteParameters = new Set(
+      value.routeClaims.flatMap(
+        (claim) => [...claim.pathTemplate.matchAll(/:([A-Za-z][A-Za-z0-9_-]*)/g)].map(
+          (match) => match[1]
+        )
+      )
+    );
+    for (const source of [
+      ...Object.values(transition.pathParameters),
+      ...Object.values(transition.query.set)
+    ]) {
+      if (source.kind === "route-parameter" && !declaredRouteParameters.has(source.name)) {
         context.addIssue({
           code: "custom",
-          path: ["entryTransitions", transitionIndex, "activation", ...conditionPath, "stateId"],
-          message: `Entry transition references unknown Page state ${condition.stateId}.`
+          path: ["entryTransitions", transitionIndex],
+          message: `Entry transition references unknown source route parameter ${source.name}.`
         });
       }
-    });
-    const declaredRouteParameters = new Set(value.routeClaims.flatMap(
-      (claim) => [...claim.pathTemplate.matchAll(/:([A-Za-z][A-Za-z0-9_-]*)/g)].map((match) => match[1])
-    ));
-    for (const source of [...Object.values(transition.pathParameters), ...Object.values(transition.query.set)]) {
-      if (source.kind === "route-parameter" && !declaredRouteParameters.has(source.name)) {
-        context.addIssue({ code: "custom", path: ["entryTransitions", transitionIndex], message: `Entry transition references unknown source route parameter ${source.name}.` });
-      }
     }
     const stateSources = [
       ...Object.values(transition.pathParameters).flatMap(
@@ -10790,7 +11742,11 @@ var PageSchema = z14.object({
       if (source.kind === "expression") {
         for (const read of collectPageExpressionReads(source.expression)) {
           if (read.root === "state" && (!read.path[0] || !stateIds.has(read.path[0])) || read.root === "model" || read.root === "bindings" || read.root === "result" && path[0] !== "interactionBindings") {
-            context.addIssue({ code: "custom", path: [...path, name, "expression"], message: "Expression references unavailable context or an undeclared Page state." });
+            context.addIssue({
+              code: "custom",
+              path: [...path, name, "expression"],
+              message: "Expression references unavailable context or an undeclared Page state."
+            });
           }
         }
       }
@@ -10807,7 +11763,12 @@ var PageSchema = z14.object({
     if (!instanceIds.has(binding.source.capabilityInstanceId)) {
       context.addIssue({
         code: "custom",
-        path: ["interactionBindings", index, "source", "capabilityInstanceId"],
+        path: [
+          "interactionBindings",
+          index,
+          "source",
+          "capabilityInstanceId"
+        ],
         message: "Interaction binding sources an unknown capability instance."
       });
     }
@@ -10818,8 +11779,16 @@ var PageSchema = z14.object({
         message: "Interaction binding targets an unknown Page state."
       });
     }
-    validatePageStateSources(binding.inputMapping, ["interactionBindings", index, "inputMapping"]);
-    if (Object.values(binding.inputMapping).some((source) => source.kind === "result-field" || source.kind === "expression" && collectPageExpressionReads(source.expression).some((read) => read.root === "result"))) {
+    validatePageStateSources(binding.inputMapping, [
+      "interactionBindings",
+      index,
+      "inputMapping"
+    ]);
+    if (Object.values(binding.inputMapping).some(
+      (source) => source.kind === "result-field" || source.kind === "expression" && collectPageExpressionReads(source.expression).some(
+        (read) => read.root === "result"
+      )
+    )) {
       const action = value.actionBindings.find(
         (candidate) => candidate.source.capabilityInstanceId === binding.source.capabilityInstanceId && candidate.source.port === binding.source.port
       );
@@ -10829,10 +11798,17 @@ var PageSchema = z14.object({
           path: ["interactionBindings", index, "source"],
           message: "Result-field interactions must source one declared Action binding."
         });
-      } else if (!binding.sourceResultSchemaRevisionRef || !exactRevisionRef(binding.sourceResultSchemaRevisionRef, action.resultSchemaRevisionRef)) {
+      } else if (!binding.sourceResultSchemaRevisionRef || !exactRevisionRef(
+        binding.sourceResultSchemaRevisionRef,
+        action.resultSchemaRevisionRef
+      )) {
         context.addIssue({
           code: "custom",
-          path: ["interactionBindings", index, "sourceResultSchemaRevisionRef"],
+          path: [
+            "interactionBindings",
+            index,
+            "sourceResultSchemaRevisionRef"
+          ],
           message: "Interaction result schema must exactly match the sourced Action result schema."
         });
       }
@@ -10841,45 +11817,90 @@ var PageSchema = z14.object({
   value.capabilityInstances.forEach((instance, index) => {
     const paths = [];
     instance.propertyBindings?.forEach((binding, bindingIndex) => {
-      const path = ["capabilityInstances", index, "propertyBindings", bindingIndex];
-      if (instance.capabilityRevisionRef.id.startsWith("monkeys.design.component.")) {
+      const path = [
+        "capabilityInstances",
+        index,
+        "propertyBindings",
+        bindingIndex
+      ];
+      if (instance.capabilityRevisionRef.id.startsWith(
+        "monkeys.design.component."
+      )) {
         const [group, member3, field] = binding.targetPath;
         const messages = instance.properties.messages;
         const message = messages && typeof messages === "object" && !Array.isArray(messages) ? messages[member3] : void 0;
         const declaredMessage = message && typeof message === "object" && !Array.isArray(message);
         const allowed = group === "props" && binding.targetPath.length >= 2 || group === "messages" && declaredMessage && (field === "values" && binding.targetPath.length >= 3 || binding.targetPath.length === 3 && (field === "key" || field === "textI18n") && Object.prototype.hasOwnProperty.call(message, field));
-        if (!allowed) context.addIssue({ code: "custom", path: [...path, "targetPath"], message: "Component expressions can update property values or declared message fields, never executable wiring." });
+        if (!allowed)
+          context.addIssue({
+            code: "custom",
+            path: [...path, "targetPath"],
+            message: "Component expressions can update property values or declared message fields, never executable wiring."
+          });
       }
-      if (paths.some((previous) => previous.slice(0, Math.min(previous.length, binding.targetPath.length)).every((key, i) => key === binding.targetPath[i]))) {
-        context.addIssue({ code: "custom", path: [...path, "targetPath"], message: "Dynamic property targets must not overlap." });
+      if (paths.some(
+        (previous) => previous.slice(0, Math.min(previous.length, binding.targetPath.length)).every((key, i) => key === binding.targetPath[i])
+      )) {
+        context.addIssue({
+          code: "custom",
+          path: [...path, "targetPath"],
+          message: "Dynamic property targets must not overlap."
+        });
       }
       paths.push(binding.targetPath);
       visitPageExpression(binding.expression, (expression) => {
         if (expression.kind !== "read") return;
         if (expression.root === "state" && (!expression.path[0] || !stateIds.has(expression.path[0]))) {
-          context.addIssue({ code: "custom", path: [...path, "expression"], message: "Property expressions must reference a declared Page state." });
+          context.addIssue({
+            code: "custom",
+            path: [...path, "expression"],
+            message: "Property expressions must reference a declared Page state."
+          });
         }
-        if (expression.root === "bindings" && ![...value.ontologyBindings, ...queryBindings].some((candidate) => candidate.bindingId === expression.path[0])) {
-          context.addIssue({ code: "custom", path: [...path, "expression"], message: "Property expressions must reference a declared Page query binding." });
+        if (expression.root === "bindings" && ![...value.ontologyBindings, ...queryBindings].some(
+          (candidate) => candidate.bindingId === expression.path[0]
+        )) {
+          context.addIssue({
+            code: "custom",
+            path: [...path, "expression"],
+            message: "Property expressions must reference a declared Page query binding."
+          });
         }
         if (expression.root === "actions" && (expression.path.length !== 2 || !actionOwners.has(expression.path[0]) || !["pending", "errorCode"].includes(expression.path[1]))) {
-          context.addIssue({ code: "custom", path: [...path, "expression"], message: "Property expressions may read only pending or errorCode from a declared Action binding." });
+          context.addIssue({
+            code: "custom",
+            path: [...path, "expression"],
+            message: "Property expressions may read only pending or errorCode from a declared Action binding."
+          });
         }
         if (expression.root === "intent" || expression.root === "result") {
-          context.addIssue({ code: "custom", path: [...path, "expression"], message: "Property expressions cannot read transient event or Action results." });
+          context.addIssue({
+            code: "custom",
+            path: [...path, "expression"],
+            message: "Property expressions cannot read transient event or Action results."
+          });
         }
       });
     });
     if (!instance.activationWhen) return;
-    forEachPageStateCondition(instance.activationWhen, (condition, conditionPath) => {
-      if (!stateIds.has(condition.stateId)) {
-        context.addIssue({
-          code: "custom",
-          path: ["capabilityInstances", index, "activationWhen", ...conditionPath, "stateId"],
-          message: "Capability activation condition references an unknown Page state."
-        });
+    forEachPageStateCondition(
+      instance.activationWhen,
+      (condition, conditionPath) => {
+        if (!stateIds.has(condition.stateId)) {
+          context.addIssue({
+            code: "custom",
+            path: [
+              "capabilityInstances",
+              index,
+              "activationWhen",
+              ...conditionPath,
+              "stateId"
+            ],
+            message: "Capability activation condition references an unknown Page state."
+          });
+        }
       }
-    });
+    );
   });
   value.ontologyBindings.forEach((binding, index) => {
     if (!instanceIds.has(binding.target.capabilityInstanceId)) {
@@ -10889,7 +11910,11 @@ var PageSchema = z14.object({
         message: "Ontology binding targets an unknown capability instance."
       });
     }
-    validatePageStateSources(binding.parameters, ["ontologyBindings", index, "parameters"]);
+    validatePageStateSources(binding.parameters, [
+      "ontologyBindings",
+      index,
+      "parameters"
+    ]);
   });
   queryBindings.forEach((binding, index) => {
     if (!instanceIds.has(binding.target.capabilityInstanceId)) {
@@ -10899,35 +11924,93 @@ var PageSchema = z14.object({
         message: "Query binding targets an unknown capability instance."
       });
     }
-    validatePageStateSources(binding.parameters, ["queryBindings", index, "parameters"]);
+    validatePageStateSources(binding.parameters, [
+      "queryBindings",
+      index,
+      "parameters"
+    ]);
     if (binding.queryWhen) {
-      forEachPageStateCondition(binding.queryWhen, (condition, conditionPath) => {
-        if (!stateIds.has(condition.stateId)) {
-          context.addIssue({
-            code: "custom",
-            path: ["queryBindings", index, "queryWhen", ...conditionPath, "stateId"],
-            message: "Query activation condition references an unknown Page state."
-          });
+      forEachPageStateCondition(
+        binding.queryWhen,
+        (condition, conditionPath) => {
+          if (!stateIds.has(condition.stateId)) {
+            context.addIssue({
+              code: "custom",
+              path: [
+                "queryBindings",
+                index,
+                "queryWhen",
+                ...conditionPath,
+                "stateId"
+              ],
+              message: "Query activation condition references an unknown Page state."
+            });
+          }
         }
-      });
+      );
     }
     if (binding.refreshPolicy?.when) {
       const path = ["queryBindings", index, "refreshPolicy", "when"];
-      const reads = collectExternalPageExpressionReads(binding.refreshPolicy.when);
-      checkScopedReads(reads, scopesForNode(instanceNodes.get(binding.target.capabilityInstanceId)), path);
-      for (const read of reads) if (read.root === "actions" && !actionScopes.has(read.path[0])) context.addIssue({ code: "custom", path, message: "Automatic refresh condition references an unknown action binding." });
+      const reads = collectExternalPageExpressionReads(
+        binding.refreshPolicy.when
+      );
+      checkScopedReads(
+        reads,
+        scopesForNode(instanceNodes.get(binding.target.capabilityInstanceId)),
+        path
+      );
+      for (const read of reads)
+        if (read.root === "actions" && !actionScopes.has(read.path[0]))
+          context.addIssue({
+            code: "custom",
+            path,
+            message: "Automatic refresh condition references an unknown action binding."
+          });
     }
-    const effectOwners = new Set(binding.stateEffects?.map((effect) => stateDefinitions.find((definition) => definition.stateId === effect.targetStateId)?.scopeNodeId ?? "") ?? []);
-    if (effectOwners.size > 1) context.addIssue({ code: "custom", path: ["queryBindings", index, "stateEffects"], message: "A query completion must update a single state owner atomically." });
+    const effectOwners = new Set(
+      binding.stateEffects?.map(
+        (effect) => stateDefinitions.find(
+          (definition) => definition.stateId === effect.targetStateId
+        )?.scopeNodeId ?? ""
+      ) ?? []
+    );
+    if (effectOwners.size > 1)
+      context.addIssue({
+        code: "custom",
+        path: ["queryBindings", index, "stateEffects"],
+        message: "A query completion must update a single state owner atomically."
+      });
     binding.stateEffects?.forEach((effect, effectIndex) => {
       const path = ["queryBindings", index, "stateEffects", effectIndex];
-      const state = stateDefinitions.find((definition) => definition.stateId === effect.targetStateId);
-      const scopes = scopesForNode(instanceNodes.get(binding.target.capabilityInstanceId));
-      if (!state || state.scopeNodeId && !scopes.has(state.scopeNodeId)) context.addIssue({ code: "custom", path: [...path, "targetStateId"], message: "A query effect must target declared state in its own scope or an ancestor." });
-      for (const expression of [effect.value, ...effect.when ? [effect.when] : []]) {
+      const state = stateDefinitions.find(
+        (definition) => definition.stateId === effect.targetStateId
+      );
+      const scopes = scopesForNode(
+        instanceNodes.get(binding.target.capabilityInstanceId)
+      );
+      if (!state || state.scopeNodeId && !scopes.has(state.scopeNodeId))
+        context.addIssue({
+          code: "custom",
+          path: [...path, "targetStateId"],
+          message: "A query effect must target declared state in its own scope or an ancestor."
+        });
+      for (const expression of [
+        effect.value,
+        ...effect.when ? [effect.when] : []
+      ]) {
         const reads = collectPageExpressionReads(expression);
-        checkScopedReads(reads, state?.scopeNodeId ? scopesForNode(state.scopeNodeId) : /* @__PURE__ */ new Set(), path);
-        for (const read of reads) if (read.root === "state" && !stateIds.has(read.path[0])) context.addIssue({ code: "custom", path, message: "Query effect references an unknown Page state." });
+        checkScopedReads(
+          reads,
+          state?.scopeNodeId ? scopesForNode(state.scopeNodeId) : /* @__PURE__ */ new Set(),
+          path
+        );
+        for (const read of reads)
+          if (read.root === "state" && !stateIds.has(read.path[0]))
+            context.addIssue({
+              code: "custom",
+              path,
+              message: "Query effect references an unknown Page state."
+            });
       }
     });
     binding.resultStateBindings?.forEach((resultBinding, resultIndex) => {
@@ -10937,41 +12020,78 @@ var PageSchema = z14.object({
       if (!stateDefinition) {
         context.addIssue({
           code: "custom",
-          path: ["queryBindings", index, "resultStateBindings", resultIndex, "targetStateId"],
+          path: [
+            "queryBindings",
+            index,
+            "resultStateBindings",
+            resultIndex,
+            "targetStateId"
+          ],
           message: "Query result binding targets an unknown Page state."
         });
         return;
       }
-      if (!exactRevisionRef(resultBinding.targetStateSchemaRevisionRef, stateDefinition.schemaRevisionRef)) {
+      if (!exactRevisionRef(
+        resultBinding.targetStateSchemaRevisionRef,
+        stateDefinition.schemaRevisionRef
+      )) {
         context.addIssue({
           code: "custom",
-          path: ["queryBindings", index, "resultStateBindings", resultIndex, "targetStateSchemaRevisionRef"],
+          path: [
+            "queryBindings",
+            index,
+            "resultStateBindings",
+            resultIndex,
+            "targetStateSchemaRevisionRef"
+          ],
           message: "Query result binding must pin the exact target Page-state schema revision."
         });
       }
       if (stateDefinition.persistence !== "none") {
         context.addIssue({
           code: "custom",
-          path: ["queryBindings", index, "resultStateBindings", resultIndex, "targetStateId"],
+          path: [
+            "queryBindings",
+            index,
+            "resultStateBindings",
+            resultIndex,
+            "targetStateId"
+          ],
           message: "Query result state projections must target non-persistent Page state."
         });
       }
     });
   });
   const dependencyBindings = [...value.ontologyBindings, ...queryBindings];
-  analyzePageBindingDependencies(dependencyBindings).errors.forEach((error) => {
-    const ontologyIndex = value.ontologyBindings.findIndex((binding) => binding.bindingId === error.bindingId);
-    const collection = ontologyIndex >= 0 ? "ontologyBindings" : "queryBindings";
-    const index = ontologyIndex >= 0 ? ontologyIndex : queryBindings.findIndex((binding) => binding.bindingId === error.bindingId);
-    context.addIssue({ code: "custom", path: [collection, index, "parameters"], message: `Page binding dependency ${error.code}: ${error.dependencyId ?? error.bindingId}` });
-  });
+  analyzePageBindingDependencies(dependencyBindings).errors.forEach(
+    (error) => {
+      const ontologyIndex = value.ontologyBindings.findIndex(
+        (binding) => binding.bindingId === error.bindingId
+      );
+      const collection = ontologyIndex >= 0 ? "ontologyBindings" : "queryBindings";
+      const index = ontologyIndex >= 0 ? ontologyIndex : queryBindings.findIndex(
+        (binding) => binding.bindingId === error.bindingId
+      );
+      context.addIssue({
+        code: "custom",
+        path: [collection, index, "parameters"],
+        message: `Page binding dependency ${error.code}: ${error.dependencyId ?? error.bindingId}`
+      });
+    }
+  );
   const projectedQueryStateIds = /* @__PURE__ */ new Set();
   queryBindings.forEach((binding, index) => {
     binding.resultStateBindings?.forEach((resultBinding, resultIndex) => {
       if (projectedQueryStateIds.has(resultBinding.targetStateId)) {
         context.addIssue({
           code: "custom",
-          path: ["queryBindings", index, "resultStateBindings", resultIndex, "targetStateId"],
+          path: [
+            "queryBindings",
+            index,
+            "resultStateBindings",
+            resultIndex,
+            "targetStateId"
+          ],
           message: "One Page state can have only one Server Query result owner."
         });
       }
@@ -10981,12 +12101,19 @@ var PageSchema = z14.object({
   queryBindings.forEach((binding, index) => {
     if (binding.execution !== "server") return;
     const readStateIds = new Set(
-      Object.values(binding.parameters).flatMap((source) => source.kind === "page-state" ? [source.stateId] : [])
+      Object.values(binding.parameters).flatMap(
+        (source) => source.kind === "page-state" ? [source.stateId] : []
+      )
     );
     if (binding.queryWhen) {
-      forEachPageStateCondition(binding.queryWhen, (condition) => readStateIds.add(condition.stateId));
+      forEachPageStateCondition(
+        binding.queryWhen,
+        (condition) => readStateIds.add(condition.stateId)
+      );
     }
-    const feedbackStateId = [...readStateIds].find((stateId) => projectedQueryStateIds.has(stateId));
+    const feedbackStateId = [...readStateIds].find(
+      (stateId) => projectedQueryStateIds.has(stateId)
+    );
     if (feedbackStateId) {
       context.addIssue({
         code: "custom",
@@ -11010,10 +12137,34 @@ var PageSchema = z14.object({
   const cursorWindowSources = /* @__PURE__ */ new Set();
   cursorWindowBindings.forEach(({ binding, index, collection }) => {
     const sourceId = binding.cursorWindow.sourceCapabilityInstanceId ?? binding.target.capabilityInstanceId;
-    if (!instanceIds.has(sourceId)) context.addIssue({ code: "custom", path: [collection, index, "cursorWindow", "sourceCapabilityInstanceId"], message: "Cursor-window source must reference a declared capability instance." });
+    if (!instanceIds.has(sourceId))
+      context.addIssue({
+        code: "custom",
+        path: [
+          collection,
+          index,
+          "cursorWindow",
+          "sourceCapabilityInstanceId"
+        ],
+        message: "Cursor-window source must reference a declared capability instance."
+      });
     const sourceScopes = [...scopesForNode(instanceNodes.get(sourceId))];
-    const targetScopes = [...scopesForNode(instanceNodes.get(binding.target.capabilityInstanceId))];
-    if (sourceScopes.length !== targetScopes.length || sourceScopes.some((id, index2) => id !== targetScopes[index2])) context.addIssue({ code: "custom", path: [collection, index, "cursorWindow", "sourceCapabilityInstanceId"], message: "Cursor-window source and query target must share the same repeated scope." });
+    const targetScopes = [
+      ...scopesForNode(
+        instanceNodes.get(binding.target.capabilityInstanceId)
+      )
+    ];
+    if (sourceScopes.length !== targetScopes.length || sourceScopes.some((id, index2) => id !== targetScopes[index2]))
+      context.addIssue({
+        code: "custom",
+        path: [
+          collection,
+          index,
+          "cursorWindow",
+          "sourceCapabilityInstanceId"
+        ],
+        message: "Cursor-window source and query target must share the same repeated scope."
+      });
     const sourceKey = `${sourceId}:${binding.cursorWindow.pageChangePort}`;
     if (cursorWindowSources.has(sourceKey)) {
       context.addIssue({
@@ -11045,9 +12196,15 @@ var PageSchema = z14.object({
         message: "Action binding sources an unknown capability instance."
       });
     }
-    validatePageStateSources(binding.inputMapping, ["actionBindings", index, "inputMapping"]);
+    validatePageStateSources(binding.inputMapping, [
+      "actionBindings",
+      index,
+      "inputMapping"
+    ]);
     binding.success.refreshBindingIds.forEach((bindingId) => {
-      if (!value.ontologyBindings.some((candidate) => candidate.bindingId === bindingId) && !queryBindings.some((candidate) => candidate.bindingId === bindingId)) {
+      if (!value.ontologyBindings.some(
+        (candidate) => candidate.bindingId === bindingId
+      ) && !queryBindings.some((candidate) => candidate.bindingId === bindingId)) {
         context.addIssue({
           code: "custom",
           path: ["actionBindings", index, "success", "refreshBindingIds"],
@@ -11055,7 +12212,9 @@ var PageSchema = z14.object({
         });
       }
     });
-    const effectBindingIds = binding.success.resultBindingEffects?.map((effect) => effect.bindingId) ?? [];
+    const effectBindingIds = binding.success.resultBindingEffects?.map(
+      (effect) => effect.bindingId
+    ) ?? [];
     if (new Set(effectBindingIds).size !== effectBindingIds.length) {
       context.addIssue({
         code: "custom",
@@ -11064,17 +12223,35 @@ var PageSchema = z14.object({
       });
     }
     binding.success.resultBindingEffects?.forEach((effect, effectIndex) => {
-      if (!value.ontologyBindings.some((candidate) => candidate.bindingId === effect.bindingId) && !queryBindings.some((candidate) => candidate.bindingId === effect.bindingId)) {
+      if (!value.ontologyBindings.some(
+        (candidate) => candidate.bindingId === effect.bindingId
+      ) && !queryBindings.some(
+        (candidate) => candidate.bindingId === effect.bindingId
+      )) {
         context.addIssue({
           code: "custom",
-          path: ["actionBindings", index, "success", "resultBindingEffects", effectIndex, "bindingId"],
+          path: [
+            "actionBindings",
+            index,
+            "success",
+            "resultBindingEffects",
+            effectIndex,
+            "bindingId"
+          ],
           message: `Unknown result effect binding: ${effect.bindingId}`
         });
       }
       if (binding.success.refreshBindingIds.includes(effect.bindingId)) {
         context.addIssue({
           code: "custom",
-          path: ["actionBindings", index, "success", "resultBindingEffects", effectIndex, "bindingId"],
+          path: [
+            "actionBindings",
+            index,
+            "success",
+            "resultBindingEffects",
+            effectIndex,
+            "bindingId"
+          ],
           message: "A result-projected binding cannot also be refreshed by the same Action."
         });
       }
@@ -11115,7 +12292,11 @@ var PageSchema = z14.object({
     const refs = [
       ["capabilityRevisionRef", instance.capabilityRevisionRef, "capability"],
       ["providerRevisionRef", instance.providerRevisionRef, "view-provider"],
-      ["propertySchemaRevisionRef", instance.propertySchemaRevisionRef, "schema"]
+      [
+        "propertySchemaRevisionRef",
+        instance.propertySchemaRevisionRef,
+        "schema"
+      ]
     ];
     refs.forEach(([field, reference, expectedKind]) => {
       if (reference.kind !== expectedKind)
@@ -11156,7 +12337,10 @@ var PageReleaseSchema = z14.object({
     surface: ProductSurfaceSchema,
     routeSpaceRevisionRef: RevisionRefSchema,
     normalizedPath: RoutePathTemplateSchema,
-    routeClaim: z14.union([CompiledRouteClaimSchema, LegacyCompiledRouteClaimSchema]),
+    routeClaim: z14.union([
+      CompiledRouteClaimSchema,
+      LegacyCompiledRouteClaimSchema
+    ]),
     legacyRouteTakeoverAuthorization: LegacyRouteTakeoverAuthorizationSchema.optional()
   }).strict()
 }).strict().superRefine((value, context) => {
@@ -11182,7 +12366,10 @@ var PageReleaseSchema = z14.object({
       message: "Page release target requires a route-space revision."
     });
   validateReleaseRouteSurface(value.target, context);
-  if (value.target.normalizedPath !== value.target.routeClaim.normalizedPath || !exactRevisionRef(value.target.routeSpaceRevisionRef, value.target.routeClaim.routeSpaceRevisionRef)) {
+  if (value.target.normalizedPath !== value.target.routeClaim.normalizedPath || !exactRevisionRef(
+    value.target.routeSpaceRevisionRef,
+    value.target.routeClaim.routeSpaceRevisionRef
+  )) {
     context.addIssue({
       code: "custom",
       path: ["target", "routeClaim"],
@@ -11190,7 +12377,10 @@ var PageReleaseSchema = z14.object({
     });
   }
   const takeover = value.target.legacyRouteTakeoverAuthorization;
-  if (takeover && (value.target.routeClaim.kind !== "canonical" || takeover.normalizedPath !== value.target.normalizedPath || !exactRevisionRef(takeover.routeSpaceRevisionRef, value.target.routeSpaceRevisionRef) || takeover.targetResourceRef.kind !== "page" || takeover.targetResourceRef.id !== value.pageRevisionRef.id || takeover.targetResourceRef.ownerRepo !== value.pageRevisionRef.ownerRepo)) {
+  if (takeover && (value.target.routeClaim.kind !== "canonical" || takeover.normalizedPath !== value.target.normalizedPath || !exactRevisionRef(
+    takeover.routeSpaceRevisionRef,
+    value.target.routeSpaceRevisionRef
+  ) || takeover.targetResourceRef.kind !== "page" || takeover.targetResourceRef.id !== value.pageRevisionRef.id || takeover.targetResourceRef.ownerRepo !== value.pageRevisionRef.ownerRepo)) {
     context.addIssue({
       code: "custom",
       path: ["target", "legacyRouteTakeoverAuthorization"],
@@ -11208,7 +12398,14 @@ var WorkbenchGroupSchema = z14.object({
 }).strict();
 var WorkbenchAppInstanceSchema = z14.object({
   instanceId: ContractIdentifierSchema,
-  kind: z14.enum(["built-in-application", "workflow-form", "workflow", "agent", "design", "capability"]),
+  kind: z14.enum([
+    "built-in-application",
+    "workflow-form",
+    "workflow",
+    "agent",
+    "design",
+    "capability"
+  ]),
   targetRevisionRef: RevisionRefSchema,
   providerRevisionRef: RevisionRefSchema,
   inputSchemaRevisionRef: RevisionRefSchema,
@@ -11231,7 +12428,12 @@ var WorkbenchSchema = z14.object({
   identity: WorkbenchIdentitySchema,
   supportedSurfaces: z14.array(ProductSurfaceSchema).min(1),
   lifecycle: DeclarativeLifecycleSchema,
-  routeClaims: z14.array(z14.union([DeclarativeRouteClaimSchema, LegacyDeclarativeRouteClaimSchema])).min(1),
+  routeClaims: z14.array(
+    z14.union([
+      DeclarativeRouteClaimSchema,
+      LegacyDeclarativeRouteClaimSchema
+    ])
+  ).min(1),
   groups: z14.array(WorkbenchGroupSchema).min(1),
   appInstances: z14.array(WorkbenchAppInstanceSchema).min(1),
   defaultEntry: z14.object({
@@ -11248,14 +12450,25 @@ var WorkbenchSchema = z14.object({
   workbenchAccessPolicy: AccessPolicySchema,
   managementAccess: ManagementAccessSchema,
   personalPreferencesPolicy: z14.object({
-    allowed: z14.array(z14.enum(["collapsed-groups", "recent-entry", "layout-density"])),
+    allowed: z14.array(
+      z14.enum(["collapsed-groups", "recent-entry", "layout-density"])
+    ),
     authority: z14.literal("identity-overlay")
   }).strict(),
   performanceBudgetRef: RevisionRefSchema,
   observationPolicyRevisionRef: RevisionRefSchema,
-  privacyClassification: z14.enum(["public", "internal", "confidential", "restricted"])
+  privacyClassification: z14.enum([
+    "public",
+    "internal",
+    "confidential",
+    "restricted"
+  ])
 }).strict().superRefine((value, context) => {
-  validateDeclaredRouteSurfaces(value.supportedSurfaces, value.routeClaims, context);
+  validateDeclaredRouteSurfaces(
+    value.supportedSurfaces,
+    value.routeClaims,
+    context
+  );
   if (value.purpose === "template" && value.sourceTemplateRevisionRef) {
     context.addIssue({
       code: "custom",
@@ -11270,7 +12483,10 @@ var WorkbenchSchema = z14.object({
       path: ["groups"],
       message: `Duplicate Workbench group: ${duplicateGroup}`
     });
-  const duplicateInstance = uniqueArray(value.appInstances, (instance) => instance.instanceId);
+  const duplicateInstance = uniqueArray(
+    value.appInstances,
+    (instance) => instance.instanceId
+  );
   if (duplicateInstance)
     context.addIssue({
       code: "custom",
@@ -11325,9 +12541,21 @@ var WorkbenchSchema = z14.object({
       });
   });
   const layoutRefs = [
-    ["hostCapabilityRevisionRef", value.layout.hostCapabilityRevisionRef, "capability"],
-    ["hostProviderRevisionRef", value.layout.hostProviderRevisionRef, "view-provider"],
-    ["layoutPolicyRevisionRef", value.layout.layoutPolicyRevisionRef, "layout-policy"]
+    [
+      "hostCapabilityRevisionRef",
+      value.layout.hostCapabilityRevisionRef,
+      "capability"
+    ],
+    [
+      "hostProviderRevisionRef",
+      value.layout.hostProviderRevisionRef,
+      "view-provider"
+    ],
+    [
+      "layoutPolicyRevisionRef",
+      value.layout.layoutPolicyRevisionRef,
+      "layout-policy"
+    ]
   ];
   layoutRefs.forEach(([field, reference, expectedKind]) => {
     if (reference.kind !== expectedKind)
@@ -11356,7 +12584,10 @@ var WorkbenchReleaseSchema = z14.object({
     workbenchId: ContractIdentifierSchema,
     routeSpaceRevisionRef: RevisionRefSchema,
     normalizedPath: RoutePathTemplateSchema,
-    routeClaim: z14.union([CompiledRouteClaimSchema, LegacyCompiledRouteClaimSchema]),
+    routeClaim: z14.union([
+      CompiledRouteClaimSchema,
+      LegacyCompiledRouteClaimSchema
+    ]),
     legacyRouteTakeoverAuthorization: LegacyRouteTakeoverAuthorizationSchema.optional(),
     order: z14.number().int(),
     isDefaultCandidate: z14.boolean()
@@ -11384,7 +12615,10 @@ var WorkbenchReleaseSchema = z14.object({
       message: "Workbench release target requires a route-space revision."
     });
   validateReleaseRouteSurface(value.target, context);
-  if (value.target.normalizedPath !== value.target.routeClaim.normalizedPath || !exactRevisionRef(value.target.routeSpaceRevisionRef, value.target.routeClaim.routeSpaceRevisionRef)) {
+  if (value.target.normalizedPath !== value.target.routeClaim.normalizedPath || !exactRevisionRef(
+    value.target.routeSpaceRevisionRef,
+    value.target.routeClaim.routeSpaceRevisionRef
+  )) {
     context.addIssue({
       code: "custom",
       path: ["target", "routeClaim"],
@@ -11392,7 +12626,10 @@ var WorkbenchReleaseSchema = z14.object({
     });
   }
   const takeover = value.target.legacyRouteTakeoverAuthorization;
-  if (takeover && (value.target.routeClaim.kind !== "canonical" || takeover.normalizedPath !== value.target.normalizedPath || !exactRevisionRef(takeover.routeSpaceRevisionRef, value.target.routeSpaceRevisionRef) || takeover.targetResourceRef.kind !== "workbench" || takeover.targetResourceRef.id !== value.workbenchRevisionRef.id || takeover.targetResourceRef.ownerRepo !== value.workbenchRevisionRef.ownerRepo)) {
+  if (takeover && (value.target.routeClaim.kind !== "canonical" || takeover.normalizedPath !== value.target.normalizedPath || !exactRevisionRef(
+    takeover.routeSpaceRevisionRef,
+    value.target.routeSpaceRevisionRef
+  ) || takeover.targetResourceRef.kind !== "workbench" || takeover.targetResourceRef.id !== value.workbenchRevisionRef.id || takeover.targetResourceRef.ownerRepo !== value.workbenchRevisionRef.ownerRepo)) {
     context.addIssue({
       code: "custom",
       path: ["target", "legacyRouteTakeoverAuthorization"],
@@ -11501,7 +12738,9 @@ var NavigationSchema = z14.object({
 }).strict().superRefine((value, context) => {
   validateNavigationTree(value.nodes, context);
   value.nodes.forEach((node, index) => {
-    if (node.kind === "target" && !["page", "workbench", "menu-action", "domain-command"].includes(node.targetRef.kind)) {
+    if (node.kind === "target" && !["page", "workbench", "menu-action", "domain-command"].includes(
+      node.targetRef.kind
+    )) {
       context.addIssue({
         code: "custom",
         path: ["nodes", index, "targetRef", "kind"],
@@ -11518,7 +12757,10 @@ var ResolvedNavigationTargetSchema = z14.object({
 }).strict();
 var UnavailableNavigationTargetSchema = z14.object({
   nodeId: ContractIdentifierSchema,
-  stableTargetRef: StableRefSchema.refine((reference) => reference.kind === "page", "Only missing Pages can be isolated."),
+  stableTargetRef: StableRefSchema.refine(
+    (reference) => reference.kind === "page",
+    "Only missing Pages can be isolated."
+  ),
   reason: z14.literal("page-missing"),
   accessPolicy: AccessPolicySchema.nullable()
 }).strict();
@@ -11555,8 +12797,15 @@ var NavigationReleaseSchema = z14.object({
       path: ["resolvedTargets"],
       message: "Resolved Navigation node IDs must be unique."
     });
-  if (uniqueArray([...value.resolvedTargets, ...value.unavailableTargets ?? []], (target) => target.nodeId)) {
-    context.addIssue({ code: "custom", path: ["unavailableTargets"], message: "Navigation target resolutions must have unique node IDs." });
+  if (uniqueArray(
+    [...value.resolvedTargets, ...value.unavailableTargets ?? []],
+    (target) => target.nodeId
+  )) {
+    context.addIssue({
+      code: "custom",
+      path: ["unavailableTargets"],
+      message: "Navigation target resolutions must have unique node IDs."
+    });
   }
 });
 var RuntimeDiagnosticSchema = z14.object({
@@ -11645,7 +12894,9 @@ var DeclarativeRouteOwnerIndexSchema = z14.object({
   contentHash: Sha256Schema,
   rebuildable: z14.literal(true)
 }).strict().superRefine((value, context) => {
-  const identities = value.entries.map((entry) => `${entry.resourceKind}:${entry.releaseSlotId}`);
+  const identities = value.entries.map(
+    (entry) => `${entry.resourceKind}:${entry.releaseSlotId}`
+  );
   if (new Set(identities).size !== identities.length) {
     context.addIssue({
       code: "custom",
@@ -11653,7 +12904,9 @@ var DeclarativeRouteOwnerIndexSchema = z14.object({
       message: "Route owner index entries must be unique by Release slot."
     });
   }
-  if (identities.some((identity, index) => index > 0 && identities[index - 1].localeCompare(identity) > 0)) {
+  if (identities.some(
+    (identity, index) => index > 0 && identities[index - 1].localeCompare(identity) > 0
+  )) {
     context.addIssue({
       code: "custom",
       path: ["entries"],
@@ -11735,7 +12988,9 @@ var DeclarativeWorkbenchCatalogSchema = z14.object({
       message: "Workbench catalog identities must be unique."
     });
   }
-  if (value.entries.filter((entry) => entry.authority !== "unavailable" && entry.isDefaultCandidate).length > 1) {
+  if (value.entries.filter(
+    (entry) => entry.authority !== "unavailable" && entry.isDefaultCandidate
+  ).length > 1) {
     context.addIssue({
       code: "custom",
       path: ["entries"],
@@ -11745,7 +13000,9 @@ var DeclarativeWorkbenchCatalogSchema = z14.object({
   const sorted = [...value.entries].sort(
     (left, right) => left.order - right.order || left.workbenchId.localeCompare(right.workbenchId)
   );
-  if (sorted.some((entry, index) => entry.workbenchId !== value.entries[index]?.workbenchId)) {
+  if (sorted.some(
+    (entry, index) => entry.workbenchId !== value.entries[index]?.workbenchId
+  )) {
     context.addIssue({
       code: "custom",
       path: ["entries"],
@@ -11777,9 +13034,16 @@ var PageRuntimeBundleSchema = z14.object({
   tokenRevisionRefs: z14.array(RevisionRefSchema),
   performanceBudgetRef: RevisionRefSchema,
   observationPolicyRevisionRef: RevisionRefSchema,
-  privacyClassification: z14.enum(["public", "internal", "confidential", "restricted"])
+  privacyClassification: z14.enum([
+    "public",
+    "internal",
+    "confidential",
+    "restricted"
+  ])
 }).strict().superRefine((value, context) => {
-  const instanceIds = new Set(value.capabilityInstances.map((instance) => instance.instanceId));
+  const instanceIds = new Set(
+    value.capabilityInstances.map((instance) => instance.instanceId)
+  );
   if (new Set(value.deniedCapabilityInstanceIds).size !== value.deniedCapabilityInstanceIds.length || value.deniedCapabilityInstanceIds.some((id) => !instanceIds.has(id))) {
     context.addIssue({
       code: "custom",
@@ -11842,7 +13106,12 @@ var WorkbenchRuntimeBundleSchema = z14.object({
   target: WorkbenchRuntimeTargetSchema,
   performanceBudgetRef: RevisionRefSchema,
   observationPolicyRevisionRef: RevisionRefSchema,
-  privacyClassification: z14.enum(["public", "internal", "confidential", "restricted"])
+  privacyClassification: z14.enum([
+    "public",
+    "internal",
+    "confidential",
+    "restricted"
+  ])
 }).strict().superRefine((value, context) => {
   validateRuntimeBundleBase(value, "workbench-release", context);
   value.routeClaims.forEach((claim, index) => {
@@ -11890,7 +13159,9 @@ var WorkbenchRuntimeBundleSchema = z14.object({
       message: "Workbench runtime default entry must reference a visible app in the declared group."
     });
   }
-  if (!value.groups.some((group) => group.groupId === value.defaultEntry?.groupId)) {
+  if (!value.groups.some(
+    (group) => group.groupId === value.defaultEntry?.groupId
+  )) {
     context.addIssue({
       code: "custom",
       path: ["defaultEntry", "groupId"],
@@ -11922,12 +13193,15 @@ var CompiledNavigationDomainCommandTargetSchema = ResolvedNavigationTargetSchema
   resultSchemaRevisionRef: RevisionRefSchema.optional(),
   input: JsonObjectSchema
 }).strict();
-var CompiledNavigationResolvedTargetSchema = z14.discriminatedUnion("kind", [
-  CompiledNavigationTargetSchema,
-  CompiledNavigationRegisteredMenuActionTargetSchema,
-  CompiledNavigationDomainCommandTargetSchema,
-  UnavailableNavigationTargetSchema.omit({ reason: true }).extend({ kind: z14.literal("unavailable") }).strict()
-]);
+var CompiledNavigationResolvedTargetSchema = z14.discriminatedUnion(
+  "kind",
+  [
+    CompiledNavigationTargetSchema,
+    CompiledNavigationRegisteredMenuActionTargetSchema,
+    CompiledNavigationDomainCommandTargetSchema,
+    UnavailableNavigationTargetSchema.omit({ reason: true }).extend({ kind: z14.literal("unavailable") }).strict()
+  ]
+);
 var CompiledNavigationGroupNodeSchema = NavigationGroupNodeSchema.extend({
   ancestorAccessPolicies: z14.array(AccessPolicySchema)
 }).strict();
@@ -11936,10 +13210,18 @@ var CompiledNavigationTargetNodeSchema = NavigationTargetNodeSchema.extend({
   resolvedTarget: CompiledNavigationResolvedTargetSchema
 }).strict().superRefine((node, context) => {
   if (node.resolvedTarget.nodeId !== node.nodeId || stableRefIdentity(node.resolvedTarget.stableTargetRef) !== stableRefIdentity(node.targetRef)) {
-    context.addIssue({ code: "custom", path: ["resolvedTarget"], message: "Resolved target identity must match the source node." });
+    context.addIssue({
+      code: "custom",
+      path: ["resolvedTarget"],
+      message: "Resolved target identity must match the source node."
+    });
   }
   if (node.resolvedTarget.kind === "unavailable" && (node.disabled !== true || Object.keys(node.parameterMapping).length > 0)) {
-    context.addIssue({ code: "custom", path: ["resolvedTarget"], message: "Unavailable targets must be disabled and contain no executable input." });
+    context.addIssue({
+      code: "custom",
+      path: ["resolvedTarget"],
+      message: "Unavailable targets must be disabled and contain no executable input."
+    });
   }
 });
 var CompiledNavigationSeparatorNodeSchema = NavigationSeparatorNodeSchema.extend({
@@ -12005,11 +13287,23 @@ var controlDefinition = (ontologyId, bodySchemaRef) => DeclarativeControlOntolog
 });
 var DECLARATIVE_CONTROL_ONTOLOGY_DEFINITIONS = Object.freeze([
   controlDefinition("monkeys.system.page", "monkeys.system.page/v1"),
-  controlDefinition("monkeys.system.page-release", "monkeys.system.page-release/v1"),
+  controlDefinition(
+    "monkeys.system.page-release",
+    "monkeys.system.page-release/v1"
+  ),
   controlDefinition("monkeys.system.workbench", "monkeys.system.workbench/v1"),
-  controlDefinition("monkeys.system.workbench-release", "monkeys.system.workbench-release/v1"),
-  controlDefinition("monkeys.system.navigation", "monkeys.system.navigation/v1"),
-  controlDefinition("monkeys.system.navigation-release", "monkeys.system.navigation-release/v1")
+  controlDefinition(
+    "monkeys.system.workbench-release",
+    "monkeys.system.workbench-release/v1"
+  ),
+  controlDefinition(
+    "monkeys.system.navigation",
+    "monkeys.system.navigation/v1"
+  ),
+  controlDefinition(
+    "monkeys.system.navigation-release",
+    "monkeys.system.navigation-release/v1"
+  )
 ]);
 
 // src/contracts/declarative-control-http.ts
@@ -12686,9 +13980,22 @@ var ChangeImpactGraphSchema = z17.object({
 }).strict();
 
 // src/contracts/declarative-control-http.ts
-var DeclarativeResourceKindSchema = z18.enum(["page", "navigation", "workbench"]);
-var DeclarativeAuthoringActionSchema = z18.enum(["validate", "preview", "publish", "rollback"]);
-var DeclarativeLegacyMigrationKindSchema = z18.enum(["page", "page-data-assets", "workbench"]);
+var DeclarativeResourceKindSchema = z18.enum([
+  "page",
+  "navigation",
+  "workbench"
+]);
+var DeclarativeAuthoringActionSchema = z18.enum([
+  "validate",
+  "preview",
+  "publish",
+  "rollback"
+]);
+var DeclarativeLegacyMigrationKindSchema = z18.enum([
+  "page",
+  "page-data-assets",
+  "workbench"
+]);
 var DeclarativeErrorEnvelopeSchema = z18.object({
   code: z18.string().trim().min(1),
   message: z18.string().trim().min(1),
@@ -12715,10 +14022,16 @@ var DeclarativeRuntimePageTargetSchema = z18.object({
     });
   }
 });
-var forbiddenRuntimeParameterKeys = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var forbiddenRuntimeParameterKeys = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
 var rejectRuntimePrototypeKeys = (value, context, path = []) => {
   if (Array.isArray(value)) {
-    value.forEach((child, index) => rejectRuntimePrototypeKeys(child, context, [...path, index]));
+    value.forEach(
+      (child, index) => rejectRuntimePrototypeKeys(child, context, [...path, index])
+    );
     return;
   }
   if (!value || typeof value !== "object") return;
@@ -12730,13 +14043,20 @@ var rejectRuntimePrototypeKeys = (value, context, path = []) => {
         message: "Prototype-mutating runtime parameter keys are forbidden."
       });
     }
-    rejectRuntimePrototypeKeys(value[key], context, [...path, key]);
+    rejectRuntimePrototypeKeys(
+      value[key],
+      context,
+      [...path, key]
+    );
   }
 };
 var runtimeParameterDepth = (value, depth = 0) => {
   if (value === null || typeof value !== "object") return depth;
   const values = Array.isArray(value) ? value : Object.values(value);
-  return values.reduce((maximum, child) => Math.max(maximum, runtimeParameterDepth(child, depth + 1)), depth);
+  return values.reduce(
+    (maximum, child) => Math.max(maximum, runtimeParameterDepth(child, depth + 1)),
+    depth
+  );
 };
 var DeclarativeRuntimeParametersSchema = z18.any().superRefine(rejectRuntimePrototypeKeys).pipe(
   JsonObjectSchema.superRefine((value, context) => {
@@ -12775,9 +14095,12 @@ var DeclarativeRuntimeParametersSchema = z18.any().superRefine(rejectRuntimeProt
           path,
           message: "Runtime parameter string values cannot exceed 2048 characters."
         });
-      else if (Array.isArray(entry)) entry.forEach((child, index) => visit(child, [...path, index]));
+      else if (Array.isArray(entry))
+        entry.forEach((child, index) => visit(child, [...path, index]));
       else if (entry && typeof entry === "object")
-        Object.entries(entry).forEach(([key, child]) => visit(child, [...path, key]));
+        Object.entries(entry).forEach(
+          ([key, child]) => visit(child, [...path, key])
+        );
     };
     visit(value, []);
   })
@@ -12812,17 +14135,36 @@ var DeclarativeRuntimeActionExecuteIntentSchema = DeclarativeRuntimePageTargetSc
   intent: JsonObjectSchema,
   recoveryOnly: z18.literal(true).optional(),
   pageState: DeclarativeRuntimeParametersSchema,
-  files: z18.record(z18.string().min(1).max(256), z18.union([
-    z18.object({ fileName: z18.string().min(1).max(255), content: z18.string().max(1048576) }).strict(),
-    z18.object({ fileName: z18.string().min(1).max(255), canonicalUri: z18.string().regex(/^file:\/\/[^\s/?#]+$/).max(1024) }).strict()
-  ])).superRefine((files, context) => {
-    if (Object.keys(files).length > 4 || Object.values(files).reduce((bytes, file) => bytes + ("content" in file ? new TextEncoder().encode(file.content).byteLength : 0), 0) > 1048576) context.addIssue({ code: "custom", message: "Action files exceed the transient input budget." });
+  files: z18.record(
+    z18.string().min(1).max(256),
+    z18.union([
+      z18.object({
+        fileName: z18.string().min(1).max(255),
+        content: z18.string().max(1048576)
+      }).strict(),
+      z18.object({
+        fileName: z18.string().min(1).max(255),
+        canonicalUri: z18.string().regex(/^file:\/\/[^\s/?#]+$/).max(1024)
+      }).strict()
+    ])
+  ).superRefine((files, context) => {
+    if (Object.keys(files).length > 4 || Object.values(files).reduce(
+      (bytes, file) => bytes + ("content" in file ? new TextEncoder().encode(file.content).byteLength : 0),
+      0
+    ) > 1048576)
+      context.addIssue({
+        code: "custom",
+        message: "Action files exceed the transient input budget."
+      });
   }).optional(),
   scope: z18.unknown().superRefine((value, context) => {
     try {
       assertPageValueBudget(value);
     } catch {
-      context.addIssue({ code: "custom", message: "Action instance scope exceeds the safe JSON budget." });
+      context.addIssue({
+        code: "custom",
+        message: "Action instance scope exceeds the safe JSON budget."
+      });
     }
   }).pipe(JsonObjectSchema).optional(),
   routePath: DeclarativeRuntimeActionRoutePathSchema.optional(),
@@ -12847,7 +14189,12 @@ var DeclarativeRuntimeActionExecuteResultSchema = z18.object({
   resultSchemaRevisionRef: RevisionRefSchema,
   result: JsonObjectSchema,
   download: DeclarativeNativeDownloadSchema.optional(),
-  downloadError: z18.object({ code: z18.enum(["DECLARATIVE_DOWNLOAD_FORBIDDEN", "DECLARATIVE_DOWNLOAD_UNAVAILABLE"]) }).strict().optional(),
+  downloadError: z18.object({
+    code: z18.enum([
+      "DECLARATIVE_DOWNLOAD_FORBIDDEN",
+      "DECLARATIVE_DOWNLOAD_UNAVAILABLE"
+    ])
+  }).strict().optional(),
   idempotentReplay: z18.boolean(),
   lineageRef: StableRefSchema,
   refreshBindingIds: z18.array(ContractIdentifierSchema),
@@ -13022,7 +14369,16 @@ var DeclarativeCapabilityAuthoringRegistrationSchema = z18.object({
   allowedChildCapabilityRefs: z18.array(StableRefSchema),
   inputPorts: z18.array(DeclarativeCapabilityPortSchema),
   outputPorts: z18.array(DeclarativeCapabilityPortSchema),
-  allowedSideEffects: z18.array(z18.enum(["network", "storage", "navigation", "clipboard", "worker", "websocket"])),
+  allowedSideEffects: z18.array(
+    z18.enum([
+      "network",
+      "storage",
+      "navigation",
+      "clipboard",
+      "worker",
+      "websocket"
+    ])
+  ),
   ontologyRequirements: z18.array(
     z18.object({
       inputPort: ContractIdentifierSchema,
@@ -13067,7 +14423,9 @@ var DeclarativeCapabilityAuthoringRegistrationSchema = z18.object({
     ...value.uiSchemaRevisionRef ? [value.uiSchemaRevisionRef] : [],
     ...value.inputPorts.map((port) => port.schemaRevisionRef),
     ...value.outputPorts.map((port) => port.schemaRevisionRef),
-    ...value.ontologyRequirements.map((requirement) => requirement.renderModelSchemaRevisionRef)
+    ...value.ontologyRequirements.map(
+      (requirement) => requirement.renderModelSchemaRevisionRef
+    )
   ];
   required.forEach((reference) => {
     const key = `${reference.ownerRepo}:${reference.id}@${reference.revision}:${reference.contentHash}`;
@@ -13179,7 +14537,9 @@ var ProductDeclarativeCapabilityRegistrationSchema = z18.object({
     }
   });
   const permissions = value.requiredPermissionCodes;
-  if (new Set(permissions).size !== permissions.length || permissions.some((permission, index) => index > 0 && permissions[index - 1].localeCompare(permission) > 0)) {
+  if (new Set(permissions).size !== permissions.length || permissions.some(
+    (permission, index) => index > 0 && permissions[index - 1].localeCompare(permission) > 0
+  )) {
     context.addIssue({
       code: "custom",
       path: ["requiredPermissionCodes"],
@@ -13333,7 +14693,9 @@ var DeclarativeProductResourceRegistrationSchema = z18.object({
     });
   }
   if (value.resourceKind === "shell") {
-    const parsed = DeclarativeShellResourceDocumentSchema.safeParse(value.document);
+    const parsed = DeclarativeShellResourceDocumentSchema.safeParse(
+      value.document
+    );
     if (!parsed.success)
       context.addIssue({
         code: "custom",
@@ -13341,7 +14703,9 @@ var DeclarativeProductResourceRegistrationSchema = z18.object({
         message: `Invalid shell declaration: ${parsed.error.message}`
       });
     if (parsed.success) {
-      const declaredSurfaces = new Set(parsed.data.surfaceChrome.map((entry) => entry.surface));
+      const declaredSurfaces = new Set(
+        parsed.data.surfaceChrome.map((entry) => entry.surface)
+      );
       const supportedSurfaces = new Set(value.supportedSurfaces);
       value.supportedSurfaces.forEach((surface) => {
         if (!declaredSurfaces.has(surface))
@@ -13362,7 +14726,9 @@ var DeclarativeProductResourceRegistrationSchema = z18.object({
     }
   }
   if (value.resourceKind === "layout-policy") {
-    const parsed = DeclarativeLayoutPolicyResourceDocumentSchema.safeParse(value.document);
+    const parsed = DeclarativeLayoutPolicyResourceDocumentSchema.safeParse(
+      value.document
+    );
     if (!parsed.success)
       context.addIssue({
         code: "custom",
@@ -13371,7 +14737,9 @@ var DeclarativeProductResourceRegistrationSchema = z18.object({
       });
   }
   if (value.resourceKind === "environment") {
-    const parsed = DeclarativeEnvironmentResourceDocumentSchema.safeParse(value.document);
+    const parsed = DeclarativeEnvironmentResourceDocumentSchema.safeParse(
+      value.document
+    );
     if (!parsed.success)
       context.addIssue({
         code: "custom",
@@ -13388,7 +14756,15 @@ var DeclarativeProductResourceRegistrationSchema = z18.object({
   }
 });
 var DeclarativeDefaultPolicyRegistrationSchema = z18.object({
-  role: z18.enum(["management", "access", "layout", "performance", "observability", "tokens", "environment"]),
+  role: z18.enum([
+    "management",
+    "access",
+    "layout",
+    "performance",
+    "observability",
+    "tokens",
+    "environment"
+  ]),
   resourceRevisionRef: RevisionRefSchema,
   supportedSurfaces: z18.array(ProductSurfaceSchema).min(1)
 }).strict();
@@ -13462,7 +14838,9 @@ var ProductDeclarativeAuthoringCatalogSchema = z18.object({
   applicationId: ContractIdentifierSchema,
   createTemplates: z18.array(DeclarativeCreateTemplateRegistrationSchema),
   routeSpaces: z18.array(DeclarativeRouteSpaceRegistrationSchema),
-  resourceRegistrations: z18.array(DeclarativeProductResourceRegistrationSchema),
+  resourceRegistrations: z18.array(
+    DeclarativeProductResourceRegistrationSchema
+  ),
   defaultPolicies: z18.array(DeclarativeDefaultPolicyRegistrationSchema),
   domainQueryDefinitions: z18.array(DeclarativeDomainQueryDefinitionRegistrationSchema).default([]),
   domainCommandDefinitions: z18.array(DeclarativeDomainCommandDefinitionRegistrationSchema).default([]),
@@ -13471,7 +14849,9 @@ var ProductDeclarativeAuthoringCatalogSchema = z18.object({
 }).strict().superRefine((value, context) => {
   const duplicates = (items) => items.find((item, index) => items.indexOf(item) !== index);
   const duplicateTemplate = duplicates(
-    value.createTemplates.map((item) => `${item.templateRevisionRef.id}@${item.templateRevisionRef.revision}`)
+    value.createTemplates.map(
+      (item) => `${item.templateRevisionRef.id}@${item.templateRevisionRef.revision}`
+    )
   );
   if (duplicateTemplate)
     context.addIssue({
@@ -13493,7 +14873,9 @@ var ProductDeclarativeAuthoringCatalogSchema = z18.object({
       message: `Duplicate legacy Page migration source ${duplicateMigrationSource}.`
     });
   const duplicateRouteSpace = duplicates(
-    value.routeSpaces.map((item) => `${item.routeSpaceRevisionRef.id}@${item.routeSpaceRevisionRef.revision}`)
+    value.routeSpaces.map(
+      (item) => `${item.routeSpaceRevisionRef.id}@${item.routeSpaceRevisionRef.revision}`
+    )
   );
   if (duplicateRouteSpace)
     context.addIssue({
@@ -13535,7 +14917,9 @@ var ProductDeclarativeAuthoringCatalogSchema = z18.object({
       message: `Duplicate Domain Command definition ${duplicateCommandDefinition}.`
     });
   const duplicateSchemaDefinition = duplicates(
-    value.schemaDefinitions.map((item) => `${item.definitionRevisionRef.id}@${item.definitionRevisionRef.revision}`)
+    value.schemaDefinitions.map(
+      (item) => `${item.definitionRevisionRef.id}@${item.definitionRevisionRef.revision}`
+    )
   );
   if (duplicateSchemaDefinition)
     context.addIssue({
@@ -13593,7 +14977,7 @@ var DeclarativeProductResourceChoiceSchema = DeclarativeAuthoringChoiceSchema.ex
 }).strict();
 var DeclarativeBindingAuthoringChoiceSchema = DeclarativeAuthoringChoiceSchema.extend({
   bindingTemplate: z18.object({
-    kind: z18.enum(["ontology", "view", "action"]),
+    kind: z18.enum(["ontology", "view", "query", "action"]),
     requiredRevisionRefs: z18.array(RevisionRefSchema),
     requiredPermissionCodes: z18.array(ContractIdentifierSchema),
     inputTemplate: z18.record(z18.string(), z18.unknown())
@@ -13609,7 +14993,14 @@ var DeclarativeWorkbenchTargetChoiceSchema = z18.object({
   targetRevisionRef: RevisionRefSchema,
   providerRevisionRef: RevisionRefSchema,
   inputSchemaRevisionRef: RevisionRefSchema,
-  kind: z18.enum(["built-in-application", "workflow-form", "workflow", "agent", "design", "capability"]),
+  kind: z18.enum([
+    "built-in-application",
+    "workflow-form",
+    "workflow",
+    "agent",
+    "design",
+    "capability"
+  ]),
   name: I18nTextSchema,
   targetAccessPolicy: AccessPolicySchema,
   supportedSurfaces: z18.array(ProductSurfaceSchema).min(1),
@@ -13660,7 +15051,11 @@ var DeclarativeCreateIntentSchema = z18.object({
     });
   }
 });
-var DeclarativeDocumentSchema = z18.union([PageSchema, NavigationSchema, WorkbenchSchema]);
+var DeclarativeDocumentSchema = z18.union([
+  PageSchema,
+  NavigationSchema,
+  WorkbenchSchema
+]);
 var DeclarativeSaveDraftIntentSchema = z18.object({
   document: DeclarativeDocumentSchema,
   expectedVersion: z18.number().int().nonnegative(),
@@ -13711,6 +15106,7 @@ var DeclarativeAuthoringChoiceKindSchema = z18.enum([
   "capability",
   "ontology",
   "view",
+  "query",
   "action",
   "access",
   "published-target",
@@ -13728,15 +15124,24 @@ var authoringChoicePage = (choiceKind, itemSchema) => z18.object({
       message: "PageInfo returned must match choice item count."
     });
 });
-var DeclarativeAuthoringChoicePageSchema = z18.discriminatedUnion("choiceKind", [
-  authoringChoicePage("capability", DeclarativeCapabilityAuthoringChoiceSchema),
-  authoringChoicePage("ontology", DeclarativeBindingAuthoringChoiceSchema),
-  authoringChoicePage("view", DeclarativeBindingAuthoringChoiceSchema),
-  authoringChoicePage("action", DeclarativeBindingAuthoringChoiceSchema),
-  authoringChoicePage("access", DeclarativeAuthoringChoiceSchema),
-  authoringChoicePage("published-target", DeclarativeAuthoringChoiceSchema),
-  authoringChoicePage("workbench-target", DeclarativeWorkbenchTargetChoiceSchema)
-]);
+var DeclarativeAuthoringChoicePageSchema = z18.discriminatedUnion(
+  "choiceKind",
+  [
+    authoringChoicePage(
+      "capability",
+      DeclarativeCapabilityAuthoringChoiceSchema
+    ),
+    authoringChoicePage("ontology", DeclarativeBindingAuthoringChoiceSchema),
+    authoringChoicePage("view", DeclarativeBindingAuthoringChoiceSchema),
+    authoringChoicePage("action", DeclarativeBindingAuthoringChoiceSchema),
+    authoringChoicePage("access", DeclarativeAuthoringChoiceSchema),
+    authoringChoicePage("published-target", DeclarativeAuthoringChoiceSchema),
+    authoringChoicePage(
+      "workbench-target",
+      DeclarativeWorkbenchTargetChoiceSchema
+    )
+  ]
+);
 var DeclarativeAuthoringResourcePageQuerySchema = z18.object({
   resourceKind: DeclarativeResourceKindSchema.optional(),
   resourceId: ContractIdentifierSchema.optional(),
@@ -13787,11 +15192,14 @@ var DeclarativeWorkbenchDocumentSummarySchema = z18.object({
   accessPolicy: AccessPolicySchema,
   managementAccess: ManagementAccessSchema
 }).strict();
-var DeclarativeDocumentSummarySchema = z18.discriminatedUnion("resourceKind", [
-  DeclarativePageDocumentSummarySchema,
-  DeclarativeNavigationDocumentSummarySchema,
-  DeclarativeWorkbenchDocumentSummarySchema
-]);
+var DeclarativeDocumentSummarySchema = z18.discriminatedUnion(
+  "resourceKind",
+  [
+    DeclarativePageDocumentSummarySchema,
+    DeclarativeNavigationDocumentSummarySchema,
+    DeclarativeWorkbenchDocumentSummarySchema
+  ]
+);
 var declarativeReferenceTenantScopeKey = (scope) => JSON.stringify(scope);
 var DeclarativeDefinitionKindByResourceKind = {
   page: "page",
@@ -13830,11 +15238,21 @@ var DeclarativeAuthoringResourceSummarySchema = z18.object({
 }).strict().superRefine((value, context) => {
   const expectedDefinitionKind = DeclarativeDefinitionKindByResourceKind[value.resourceKind];
   const expectedReleaseKind = DeclarativeReleaseKindByResourceKind[value.resourceKind];
-  const expectedTenantScope = declarativeReferenceTenantScopeKey(value.tenantScope);
+  const expectedTenantScope = declarativeReferenceTenantScopeKey(
+    value.tenantScope
+  );
   const seenReleaseRefs = /* @__PURE__ */ new Set();
   value.releasePlacements.forEach((placement, index) => {
-    const releasePath = ["releasePlacements", index, "releaseRevisionRef"];
-    const definitionPath = ["releasePlacements", index, "definitionRevisionRef"];
+    const releasePath = [
+      "releasePlacements",
+      index,
+      "releaseRevisionRef"
+    ];
+    const definitionPath = [
+      "releasePlacements",
+      index,
+      "definitionRevisionRef"
+    ];
     if (placement.releaseRevisionRef.kind !== expectedReleaseKind) {
       context.addIssue({
         code: "custom",
@@ -13842,7 +15260,9 @@ var DeclarativeAuthoringResourceSummarySchema = z18.object({
         message: `Release placement must reference ${expectedReleaseKind}.`
       });
     }
-    if (placement.releaseRevisionRef.visibility !== "tenant" || declarativeReferenceTenantScopeKey(placement.releaseRevisionRef.tenantScope) !== expectedTenantScope) {
+    if (placement.releaseRevisionRef.visibility !== "tenant" || declarativeReferenceTenantScopeKey(
+      placement.releaseRevisionRef.tenantScope
+    ) !== expectedTenantScope) {
       context.addIssue({
         code: "custom",
         path: [...releasePath, "tenantScope"],
@@ -13872,7 +15292,9 @@ var DeclarativeAuthoringResourceSummarySchema = z18.object({
         message: "Release placement definition must reference the summary resource."
       });
     }
-    if (placement.definitionRevisionRef.visibility !== "tenant" || declarativeReferenceTenantScopeKey(placement.definitionRevisionRef.tenantScope) !== expectedTenantScope) {
+    if (placement.definitionRevisionRef.visibility !== "tenant" || declarativeReferenceTenantScopeKey(
+      placement.definitionRevisionRef.tenantScope
+    ) !== expectedTenantScope) {
       context.addIssue({
         code: "custom",
         path: [...definitionPath, "tenantScope"],
@@ -13936,7 +15358,11 @@ var DeclarativePreviewResultSchema = z18.object({
   expiresAt: z18.string().datetime(),
   revision: z18.number().int().positive(),
   contentHash: Sha256Schema,
-  bundle: z18.union([PageRuntimeBundleSchema, NavigationRuntimeBundleSchema, WorkbenchRuntimeBundleSchema]),
+  bundle: z18.union([
+    PageRuntimeBundleSchema,
+    NavigationRuntimeBundleSchema,
+    WorkbenchRuntimeBundleSchema
+  ]),
   etag: z18.string().trim().min(1),
   sourceContentHash: Sha256Schema
 }).strict();
@@ -13944,8 +15370,16 @@ var DeclarativePublicationItemResultSchema = z18.object({
   resourceKind: DeclarativeResourceKindSchema,
   resourceId: ContractIdentifierSchema,
   releaseRevisionRef: RevisionRefSchema,
-  release: z18.union([PageReleaseSchema, NavigationReleaseSchema, WorkbenchReleaseSchema]),
-  bundle: z18.union([PageRuntimeBundleSchema, NavigationRuntimeBundleSchema, WorkbenchRuntimeBundleSchema]).optional()
+  release: z18.union([
+    PageReleaseSchema,
+    NavigationReleaseSchema,
+    WorkbenchReleaseSchema
+  ]),
+  bundle: z18.union([
+    PageRuntimeBundleSchema,
+    NavigationRuntimeBundleSchema,
+    WorkbenchRuntimeBundleSchema
+  ]).optional()
 }).strict().superRefine((value, context) => {
   const expectedReleaseKind = {
     page: "page-release",
@@ -13988,7 +15422,10 @@ var DeclarativePublicationItemResultSchema = z18.object({
   if (value.bundle) {
     const bundleDefinitionRef = value.bundle.contract === "PageRuntimeBundle" ? value.bundle.pageRevisionRef : value.bundle.contract === "NavigationRuntimeBundle" ? value.bundle.navigationRevisionRef : value.bundle.workbenchRevisionRef;
     const sameRevision = (left, right) => left.kind === right.kind && left.id === right.id && left.ownerRepo === right.ownerRepo && left.revision === right.revision && left.schemaVersion === right.schemaVersion && left.contentHash === right.contentHash;
-    if (value.bundle.contract !== expectedBundleContract || !sameRevision(value.bundle.releaseRevisionRef, value.releaseRevisionRef) || !sameRevision(bundleDefinitionRef, definitionRef)) {
+    if (value.bundle.contract !== expectedBundleContract || !sameRevision(
+      value.bundle.releaseRevisionRef,
+      value.releaseRevisionRef
+    ) || !sameRevision(bundleDefinitionRef, definitionRef)) {
       context.addIssue({
         code: "custom",
         path: ["bundle"],
@@ -14217,7 +15654,9 @@ var DeclarativeRuntimeResolvedSchema = z18.object({
   generation: z18.number().int().nonnegative(),
   contentHash: Sha256Schema
 }).strict().superRefine((value, context) => {
-  const outcomes = [value.page, value.workbench, value.redirect].filter(Boolean).length;
+  const outcomes = [value.page, value.workbench, value.redirect].filter(
+    Boolean
+  ).length;
   if (outcomes !== 1)
     context.addIssue({
       code: "custom",
@@ -14272,35 +15711,44 @@ var DeclarativeRuntimeDeniedOutcomeSchema = (outcome, code) => z18.object({
   ...DeclarativeRuntimeSafeBaseShape,
   code: z18.literal(code)
 }).strict();
-var DeclarativeRuntimeForbiddenOutcomeSchema = z18.discriminatedUnion("resourceKind", [
-  z18.object({
-    outcome: z18.literal("forbidden"),
-    ...DeclarativeRuntimeSafeBaseShape,
-    resourceKind: z18.literal("page"),
-    code: z18.literal("DECLARATIVE_PAGE_FORBIDDEN"),
-    presentation: PageRouteStatePresentationSchema.optional()
-  }).strict().superRefine((value, context) => {
-    if (value.presentation && value.presentation.surface !== value.surface) {
-      context.addIssue({
-        code: "custom",
-        path: ["presentation", "surface"],
-        message: "A forbidden Page presentation must match the resolved route surface."
-      });
-    }
-  }),
-  z18.object({
-    outcome: z18.literal("forbidden"),
-    ...DeclarativeRuntimeSafeBaseShape,
-    resourceKind: z18.literal("workbench"),
-    code: z18.literal("DECLARATIVE_WORKBENCH_FORBIDDEN")
-  }).strict()
-]);
+var DeclarativeRuntimeForbiddenOutcomeSchema = z18.discriminatedUnion(
+  "resourceKind",
+  [
+    z18.object({
+      outcome: z18.literal("forbidden"),
+      ...DeclarativeRuntimeSafeBaseShape,
+      resourceKind: z18.literal("page"),
+      code: z18.literal("DECLARATIVE_PAGE_FORBIDDEN"),
+      presentation: PageRouteStatePresentationSchema.optional()
+    }).strict().superRefine((value, context) => {
+      if (value.presentation && value.presentation.surface !== value.surface) {
+        context.addIssue({
+          code: "custom",
+          path: ["presentation", "surface"],
+          message: "A forbidden Page presentation must match the resolved route surface."
+        });
+      }
+    }),
+    z18.object({
+      outcome: z18.literal("forbidden"),
+      ...DeclarativeRuntimeSafeBaseShape,
+      resourceKind: z18.literal("workbench"),
+      code: z18.literal("DECLARATIVE_WORKBENCH_FORBIDDEN")
+    }).strict()
+  ]
+);
 var DeclarativeRuntimeResolveResultSchema = z18.union([
   DeclarativeRuntimeLegacyOutcomeSchema,
   DeclarativeRuntimeAuthorizedOutcomeSchema,
   DeclarativeRuntimeForbiddenOutcomeSchema,
-  DeclarativeRuntimeDeniedOutcomeSchema("unavailable", "DECLARATIVE_ROUTE_UNAVAILABLE"),
-  DeclarativeRuntimeDeniedOutcomeSchema("not-found", "DECLARATIVE_ROUTE_NOT_FOUND")
+  DeclarativeRuntimeDeniedOutcomeSchema(
+    "unavailable",
+    "DECLARATIVE_ROUTE_UNAVAILABLE"
+  ),
+  DeclarativeRuntimeDeniedOutcomeSchema(
+    "not-found",
+    "DECLARATIVE_ROUTE_NOT_FOUND"
+  )
 ]);
 var DeclarativeNavigationRuntimeBootstrapSchema = z18.object({
   placements: z18.array(
@@ -14366,7 +15814,9 @@ var DeclarativeNavigationRuntimeBootstrapSchema = z18.object({
   authDigest: Sha256Schema,
   etag: z18.string().trim().min(1)
 }).strict().superRefine((value, context) => {
-  const active = value.placements.filter((entry) => entry.authority === "declarative" && entry.state === "active");
+  const active = value.placements.filter(
+    (entry) => entry.authority === "declarative" && entry.state === "active"
+  );
   if (active.length !== value.bundles.length || active.length !== value.releaseSlotIds.length) {
     context.addIssue({
       code: "custom",
@@ -14519,7 +15969,10 @@ var DeclarativeRuntimeRouteOwnerSchema = z18.object({
   surface: ProductSurfaceSchema,
   normalizedPath: z18.string().trim().startsWith("/").max(2048),
   routeParameters: DeclarativeRuntimeRouteParametersSchema,
-  owner: z18.discriminatedUnion("authority", [DeclarativeLegacyRouteOwnerSchema, DeclarativeReleaseRouteOwnerSchema]),
+  owner: z18.discriminatedUnion("authority", [
+    DeclarativeLegacyRouteOwnerSchema,
+    DeclarativeReleaseRouteOwnerSchema
+  ]),
   contentHash: Sha256Schema
 }).strict();
 
@@ -18085,6 +19538,7 @@ var WorkflowParameterTypeOptionsSchema = z22.object({
   enableBooleanSwitchMode: z22.boolean().optional(),
   enableClear: z22.boolean().optional(),
   enableExpand: z22.boolean().optional(),
+  enableImageCrop: z22.boolean().optional(),
   enableImageMask: z22.boolean().optional(),
   enableImageOverlay: z22.boolean().optional(),
   enablePopupEditor: z22.boolean().optional(),
@@ -18672,14 +20126,14 @@ var canonicalContractSchemas = {
   "menu-definition": MenuDefinitionSchema,
   "menu-definition-set": MenuDefinitionSetSchema,
   "menu-runtime-bundle": MenuRuntimeBundleSchema,
-  "navigation": NavigationSchema,
+  navigation: NavigationSchema,
   "navigation-release": NavigationReleaseSchema,
   "navigation-runtime-bundle": NavigationRuntimeBundleSchema,
   "ontology-definition": OntologyDefinitionSchema,
   "overlay-node": OverlayNodeSchema,
   "output-record": OutputRecordSchema,
   "page-definition": PageDefinitionSchema,
-  "page": PageSchema,
+  page: PageSchema,
   "page-release": PageReleaseSchema,
   "page-runtime-bundle": PageRuntimeBundleSchema,
   "page-runtime-descriptor": PageRuntimeDescriptorSchema,
@@ -18713,7 +20167,7 @@ var canonicalContractSchemas = {
   "trend-metric-snapshot": TrendMetricSnapshotSchema,
   "trend-source-record": TrendSourceRecordSchema,
   "view-provider-descriptor": ViewProviderDescriptorSchema,
-  "workbench": WorkbenchSchema,
+  workbench: WorkbenchSchema,
   "workbench-release": WorkbenchReleaseSchema,
   "workbench-runtime-bundle": WorkbenchRuntimeBundleSchema,
   "workflow-definition": WorkflowDefinitionSchema,
@@ -18982,6 +20436,7 @@ export {
   RenderTreeSchema,
   RequestScopeSchema,
   ResolvedNavigationTargetSchema,
+  ResolvedPageSchema,
   ResolvedThemeTokensSchema,
   ResolvedWorkbenchAppInstanceSchema,
   RevisionRefSchema,