@inf-monkeys-tech/monkeys 1.0.65 → 1.0.68

package/lib/esm/runtime/index.mjs

@@ -7012,7 +7012,8 @@ var CapabilitySourceTypeSchema = z3.enum([
   "plugin-manifest",
   "openapi",
   "workflow",
-  "comfyui"
+  "comfyui",
+  "design-view-provider"
 ]);
 var CapabilityRegistrySourceSchema = z3.object({
   sourceType: CapabilitySourceTypeSchema,
@@ -8680,7 +8681,7 @@ function toAgentSessionViewModel(projection, snapshot) {
 }
 
 // src/contracts/semantic.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/contracts/data.ts
 import { z as z6 } from "zod";
@@ -9306,39 +9307,996 @@ var MenuContributionResultSchema = z8.object({
   nodes: z8.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES)
 }).strict();
 
+// src/contracts/declarative-control.ts
+import { z as z9 } from "zod";
+var DECLARATIVE_CONTROL_SCHEMA_VERSION = 1;
+var uniqueArray = (values, identity) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const key = identity(value);
+    if (seen.has(key)) return key;
+    seen.add(key);
+  }
+  return void 0;
+};
+var I18nTextSchema = z9.object({
+  defaultLocale: LocaleIdentifierSchema,
+  values: z9.record(LocaleIdentifierSchema, z9.string().trim().min(1))
+}).strict().superRefine((value, context) => {
+  if (!Object.prototype.hasOwnProperty.call(value.values, value.defaultLocale)) {
+    context.addIssue({
+      code: "custom",
+      path: ["values", value.defaultLocale],
+      message: "I18nText values must contain the default locale."
+    });
+  }
+});
+var ScopedIdentityRefSchema = z9.object({
+  kind: ContractIdentifierSchema,
+  id: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema
+}).strict();
+var TenantScopeSchema = z9.object({
+  tenantRef: ScopedIdentityRefSchema,
+  dataSpaceRef: ScopedIdentityRefSchema,
+  teamRef: ScopedIdentityRefSchema.optional()
+}).strict().superRefine((value, context) => {
+  const expectedKinds = [
+    ["tenantRef", value.tenantRef, "tenant"],
+    ["dataSpaceRef", value.dataSpaceRef, "data-space"],
+    ["teamRef", value.teamRef, "team"]
+  ];
+  expectedKinds.forEach(([field, reference, expectedKind]) => {
+    if (reference && reference.kind !== expectedKind) {
+      context.addIssue({ code: "custom", path: [field, "kind"], message: `${field} must reference ${expectedKind}.` });
+    }
+  });
+});
+var ReferenceVisibilitySchema = z9.enum(["tenant", "global", "public"]);
+var StableRefShape = {
+  kind: ContractIdentifierSchema,
+  id: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  visibility: ReferenceVisibilitySchema,
+  tenantScope: TenantScopeSchema.optional()
+};
+var validateReferenceScope = (value, context) => {
+  if (value.visibility === "tenant" && !value.tenantScope) {
+    context.addIssue({ code: "custom", path: ["tenantScope"], message: "Tenant references require an explicit tenant scope." });
+  }
+  if (value.visibility !== "tenant" && value.tenantScope) {
+    context.addIssue({ code: "custom", path: ["tenantScope"], message: "Global and public references cannot carry a tenant scope." });
+  }
+};
+var StableRefSchema = z9.object(StableRefShape).strict().superRefine(validateReferenceScope);
+var RevisionRefSchema = z9.object({
+  ...StableRefShape,
+  revision: z9.number().int().positive(),
+  schemaVersion: ContractVersionSchema,
+  contentHash: Sha256Schema
+}).strict().superRefine(validateReferenceScope);
+var scopedIdentityKey = (reference) => `${reference.kind}:${reference.id}:${reference.ownerRepo}`;
+var tenantScopeKey = (scope) => `${scopedIdentityKey(scope.tenantRef)}:${scopedIdentityKey(scope.dataSpaceRef)}:${scope.teamRef ? scopedIdentityKey(scope.teamRef) : ""}`;
+var stableRefIdentity = (reference) => `${reference.visibility}:${reference.tenantScope ? tenantScopeKey(reference.tenantScope) : ""}:${reference.kind}:${reference.id}:${reference.ownerRepo}`;
+var exactRevisionRef = (left, right) => stableRefIdentity(left) === stableRefIdentity(right) && left.revision === right.revision && left.schemaVersion === right.schemaVersion && left.contentHash === right.contentHash;
+var StableRefAliasSchema = z9.object({
+  aliasRef: StableRefSchema,
+  canonicalRef: StableRefSchema,
+  validFrom: IsoDateTimeSchema,
+  validUntil: IsoDateTimeSchema.nullable(),
+  evidenceRef: RevisionRefSchema
+}).strict().superRefine((value, context) => {
+  if (value.aliasRef.kind !== value.canonicalRef.kind) {
+    context.addIssue({ code: "custom", path: ["canonicalRef", "kind"], message: "Alias and canonical references must have the same kind." });
+  }
+  if (value.validUntil && value.validUntil <= value.validFrom) {
+    context.addIssue({ code: "custom", path: ["validUntil"], message: "Alias validUntil must be later than validFrom." });
+  }
+});
+var StableRefAliasMapSchema = z9.object({
+  contract: z9.literal("StableRefAliasMap"),
+  schemaVersion: z9.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  tenantScope: TenantScopeSchema,
+  aliases: z9.array(StableRefAliasSchema),
+  contentHash: Sha256Schema
+}).strict().superRefine((value, context) => {
+  const duplicate = uniqueArray(value.aliases, (entry) => stableRefIdentity(entry.aliasRef));
+  if (duplicate) context.addIssue({ code: "custom", path: ["aliases"], message: `Duplicate alias reference: ${duplicate}` });
+});
+var DeclarativeLifecycleSchema = z9.enum(["active", "deprecated", "retired"]);
+var ProductSurfaceSchema = z9.enum(["studio", "kernel"]);
+var GroupRefSchema = StableRefSchema.superRefine((value, context) => {
+  if (value.kind !== "group") context.addIssue({ code: "custom", path: ["kind"], 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 AccessPolicySchema = z9.object({
+  authenticated: z9.boolean(),
+  groupAllOf: z9.array(GroupRefSchema),
+  groupAnyOf: z9.array(GroupRefSchema),
+  permissionAllOf: z9.array(ContractIdentifierSchema),
+  permissionAnyOf: z9.array(ContractIdentifierSchema),
+  conditionAllOf: z9.array(AccessConditionRefSchema)
+}).strict().superRefine((value, context) => {
+  const checks = [
+    ["groupAllOf", value.groupAllOf, (candidate) => stableRefIdentity(candidate)],
+    ["groupAnyOf", value.groupAnyOf, (candidate) => stableRefIdentity(candidate)],
+    ["permissionAllOf", value.permissionAllOf, String],
+    ["permissionAnyOf", value.permissionAnyOf, String],
+    ["conditionAllOf", value.conditionAllOf, (candidate) => `${stableRefIdentity(candidate)}@${candidate.revision}`]
+  ];
+  checks.forEach(([field, values, identity]) => {
+    if (uniqueArray(values, identity)) context.addIssue({ code: "custom", path: [field], message: `${field} entries must be unique.` });
+  });
+});
+var ManagementAccessSchema = z9.object({
+  edit: AccessPolicySchema,
+  preview: AccessPolicySchema,
+  publish: AccessPolicySchema,
+  deactivate: AccessPolicySchema,
+  rollback: AccessPolicySchema,
+  retire: AccessPolicySchema
+}).strict();
+var RoutePathTemplateSchema = z9.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.").superRefine((value, context) => {
+  if (value.includes("?") || value.includes("#") || value.includes("\\")) {
+    context.addIssue({ code: "custom", message: "Route paths cannot contain query strings, fragments, or backslashes." });
+  }
+  if (value.split("/").some((segment) => segment === "." || segment === "..")) {
+    context.addIssue({ code: "custom", message: "Route paths cannot contain traversal segments." });
+  }
+  if (/^[a-z][a-z0-9+.-]*:/i.test(value) || value.includes("://")) {
+    context.addIssue({ code: "custom", message: "Route paths cannot contain a scheme or host." });
+  }
+});
+var RouteSpaceParameterSchema = z9.object({
+  name: ContractIdentifierSchema,
+  type: z9.enum(["identifier", "integer", "slug", "uuid"]),
+  required: z9.boolean()
+}).strict();
+var RouteSpaceSchema = z9.object({
+  contract: z9.literal("RouteSpace"),
+  schemaVersion: z9.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  routeSpaceId: ContractIdentifierSchema,
+  supportedSurface: ProductSurfaceSchema,
+  basePath: RoutePathTemplateSchema,
+  caseSensitive: z9.boolean(),
+  trailingSlash: z9.enum(["preserve", "remove", "require"]),
+  reservedPaths: z9.array(RoutePathTemplateSchema),
+  parameters: z9.array(RouteSpaceParameterSchema)
+}).strict().superRefine((value, context) => {
+  if (uniqueArray(value.parameters, (parameter) => parameter.name)) {
+    context.addIssue({ code: "custom", path: ["parameters"], message: "RouteSpace parameter names must be unique." });
+  }
+  if (uniqueArray(value.reservedPaths, (path) => path)) {
+    context.addIssue({ code: "custom", path: ["reservedPaths"], message: "RouteSpace reserved paths must be unique." });
+  }
+});
+var RouteClaimBaseSchema = z9.object({
+  kind: z9.enum(["canonical", "alias", "redirect"]),
+  routeSpaceRevisionRef: RevisionRefSchema,
+  pathTemplate: RoutePathTemplateSchema,
+  redirectTargetRef: StableRefSchema.optional()
+}).strict().superRefine((value, context) => {
+  if (value.routeSpaceRevisionRef.kind !== "route-space") {
+    context.addIssue({ code: "custom", path: ["routeSpaceRevisionRef", "kind"], message: "Route claims must reference a route-space revision." });
+  }
+  if (value.kind === "redirect" && !value.redirectTargetRef) {
+    context.addIssue({ code: "custom", path: ["redirectTargetRef"], message: "Redirect claims require a governed target reference." });
+  }
+  if (value.kind !== "redirect" && value.redirectTargetRef) {
+    context.addIssue({ code: "custom", path: ["redirectTargetRef"], message: "Only redirect claims may declare redirectTargetRef." });
+  }
+});
+var LegacyRouteClaimSchema = RouteClaimBaseSchema;
+var RouteClaimSchema = RouteClaimBaseSchema.safeExtend({
+  surface: ProductSurfaceSchema
+}).strict();
+var DeclarativeRouteClaimSchema = RouteClaimSchema;
+var LegacyDeclarativeRouteClaimSchema = LegacyRouteClaimSchema;
+var LegacyCompiledRouteMatcherSchema = z9.object({
+  caseSensitive: z9.boolean(),
+  trailingSlash: z9.enum(["preserve", "remove", "require"]),
+  parameters: z9.array(RouteSpaceParameterSchema)
+}).strict();
+var CompiledRouteMatcherSchema = LegacyCompiledRouteMatcherSchema.safeExtend({
+  surface: ProductSurfaceSchema
+}).strict();
+var CompiledRouteClaimSchema = RouteClaimSchema.safeExtend({
+  normalizedPath: RoutePathTemplateSchema,
+  matcher: CompiledRouteMatcherSchema
+}).strict();
+var LegacyCompiledRouteClaimSchema = LegacyRouteClaimSchema.safeExtend({
+  normalizedPath: RoutePathTemplateSchema,
+  matcher: LegacyCompiledRouteMatcherSchema
+}).strict();
+var validateDeclaredRouteSurfaces = (supportedSurfaces, routeClaims, context) => {
+  if (uniqueArray(supportedSurfaces, (surface) => surface)) {
+    context.addIssue({ code: "custom", path: ["supportedSurfaces"], message: "Supported surfaces must be unique." });
+  }
+  const explicitClaims = routeClaims.filter((claim) => "surface" in claim);
+  if (explicitClaims.length > 0 && explicitClaims.length < routeClaims.length) {
+    context.addIssue({ code: "custom", path: ["routeClaims"], message: "Route claims must either all declare surface or all omit it for legacy compatibility." });
+    return;
+  }
+  routeClaims.forEach((claim, index) => {
+    if ("surface" in claim && !supportedSurfaces.includes(claim.surface)) {
+      context.addIssue({ code: "custom", path: ["routeClaims", index, "surface"], message: "Route claim surface must be declared by supportedSurfaces." });
+    }
+  });
+  if (explicitClaims.length !== routeClaims.length) return;
+  supportedSurfaces.forEach((surface) => {
+    const canonicalCount = explicitClaims.filter((claim) => claim.surface === surface && claim.kind === "canonical").length;
+    if (canonicalCount !== 1) {
+      context.addIssue({ code: "custom", path: ["routeClaims"], message: `Surface ${surface} requires exactly one canonical route claim.` });
+    }
+  });
+};
+var ReleaseOperationSchema = z9.enum(["activate", "deactivate", "rollback"]);
+var ReleaseDependencyRoleSchema = z9.enum([
+  "route-space",
+  "shell",
+  "page",
+  "page-release",
+  "workbench",
+  "workbench-release",
+  "navigation",
+  "navigation-release",
+  "menu-action",
+  "application-menu-catalog",
+  "capability",
+  "provider",
+  "ontology-definition",
+  "view",
+  "projection",
+  "action",
+  "token",
+  "schema",
+  "compiler",
+  "workflow",
+  "agent",
+  "built-in-application",
+  "design",
+  "layout-policy",
+  "performance-budget",
+  "observation-policy"
+]);
+var DependencyKindByRole = {
+  "route-space": "route-space",
+  shell: "shell",
+  page: "page",
+  "page-release": "page-release",
+  workbench: "workbench",
+  "workbench-release": "workbench-release",
+  navigation: "navigation",
+  "navigation-release": "navigation-release",
+  "menu-action": "menu-action",
+  "application-menu-catalog": "application-menu-catalog",
+  capability: "capability",
+  provider: "view-provider",
+  "ontology-definition": "ontology-definition",
+  view: "view",
+  projection: "projection",
+  action: "domain-command",
+  token: "design-token",
+  schema: "schema",
+  compiler: "compiler",
+  workflow: "workflow",
+  agent: "agent",
+  "built-in-application": "built-in-application",
+  design: "design",
+  "layout-policy": "layout-policy",
+  "performance-budget": "performance-budget",
+  "observation-policy": "observation-policy"
+};
+var ReleaseDependencySchema = z9.object({
+  role: ReleaseDependencyRoleSchema,
+  revisionRef: RevisionRefSchema
+}).strict().superRefine((value, context) => {
+  const expectedKind = DependencyKindByRole[value.role];
+  if (value.revisionRef.kind !== expectedKind) {
+    context.addIssue({
+      code: "custom",
+      path: ["revisionRef", "kind"],
+      message: `Dependency role ${value.role} requires reference kind ${expectedKind}.`
+    });
+  }
+});
+var ReleaseValidationSchema = z9.object({
+  result: z9.enum(["pass", "fail"]),
+  inputHash: Sha256Schema,
+  diagnosticRefs: z9.array(RevisionRefSchema)
+}).strict();
+var ReleaseEvidenceSchema = z9.object({
+  publicationPlanRef: StableRefSchema,
+  expectedHeadRevisionRef: RevisionRefSchema.nullable(),
+  validation: ReleaseValidationSchema,
+  approvalPolicyRevisionRef: RevisionRefSchema,
+  approvalDecisionRevisionRef: RevisionRefSchema,
+  actorRef: StableRefSchema,
+  reason: z9.string().trim().min(1).max(4096),
+  idempotencyKey: ContractIdentifierSchema,
+  occurredAt: IsoDateTimeSchema,
+  evidenceRefs: z9.array(RevisionRefSchema).min(1)
+}).strict().superRefine((value, context) => {
+  const expectedKinds = [
+    ["publicationPlanRef", value.publicationPlanRef, "publication-plan"],
+    ["approvalPolicyRevisionRef", value.approvalPolicyRevisionRef, "approval-policy"],
+    ["approvalDecisionRevisionRef", value.approvalDecisionRevisionRef, "approval-decision"],
+    ["actorRef", value.actorRef, "actor"]
+  ];
+  expectedKinds.forEach(([field, reference, expectedKind]) => {
+    if (reference.kind !== expectedKind) {
+      context.addIssue({ code: "custom", path: [field, "kind"], message: `${field} must reference ${expectedKind}.` });
+    }
+  });
+  value.evidenceRefs.forEach((reference, index) => {
+    if (reference.kind !== "evidence") context.addIssue({ code: "custom", path: ["evidenceRefs", index, "kind"], message: "Release evidenceRefs must reference evidence revisions." });
+  });
+});
+var PublicationPlanOperationSchema = z9.object({
+  releaseKind: z9.enum(["page-release", "workbench-release", "navigation-release"]),
+  releaseSlotId: ContractIdentifierSchema,
+  releaseRevisionRef: RevisionRefSchema,
+  expectedHeadRevisionRef: RevisionRefSchema.nullable()
+}).strict().superRefine((value, context) => {
+  if (value.releaseRevisionRef.kind !== value.releaseKind || value.releaseRevisionRef.id !== value.releaseSlotId) {
+    context.addIssue({ code: "custom", path: ["releaseRevisionRef"], message: "Publication Plan operation must pin the exact release slot revision." });
+  }
+  if (value.expectedHeadRevisionRef && (value.expectedHeadRevisionRef.kind !== value.releaseKind || value.expectedHeadRevisionRef.id !== value.releaseSlotId)) {
+    context.addIssue({ code: "custom", path: ["expectedHeadRevisionRef"], message: "Expected head must identify the same release slot." });
+  }
+});
+var PublicationPlanSchema = z9.object({
+  contract: z9.literal("PublicationPlan"),
+  schemaVersion: z9.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  planId: ContractIdentifierSchema,
+  tenantScope: TenantScopeSchema,
+  environmentRef: StableRefSchema,
+  operations: z9.array(PublicationPlanOperationSchema).min(1),
+  validation: ReleaseValidationSchema,
+  approvalPolicyRevisionRef: RevisionRefSchema,
+  approvalDecisionRevisionRef: RevisionRefSchema,
+  actorRef: StableRefSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  evidenceRefs: z9.array(RevisionRefSchema).min(1),
+  createdAt: IsoDateTimeSchema
+}).strict().superRefine((value, context) => {
+  if (value.environmentRef.kind !== "environment") context.addIssue({ code: "custom", path: ["environmentRef", "kind"], message: "Publication Plan requires an environment reference." });
+  const governedRefs = [
+    ["approvalPolicyRevisionRef", value.approvalPolicyRevisionRef, "approval-policy"],
+    ["approvalDecisionRevisionRef", value.approvalDecisionRevisionRef, "approval-decision"],
+    ["actorRef", value.actorRef, "actor"]
+  ];
+  governedRefs.forEach(([field, reference, expectedKind]) => {
+    if (reference.kind !== expectedKind) context.addIssue({ code: "custom", path: [field, "kind"], message: `${field} must reference ${expectedKind}.` });
+  });
+  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." });
+      }
+    });
+  });
+  value.evidenceRefs.forEach((reference, index) => {
+    if (reference.kind !== "evidence") context.addIssue({ code: "custom", path: ["evidenceRefs", index, "kind"], message: "Publication Plan evidenceRefs must reference evidence revisions." });
+  });
+  if (uniqueArray(value.operations, (operation) => `${operation.releaseKind}:${operation.releaseSlotId}`)) {
+    context.addIssue({ code: "custom", path: ["operations"], message: "Publication Plan release slots must be unique." });
+  }
+});
+var IdentitySchema = z9.object({
+  name: I18nTextSchema,
+  description: I18nTextSchema.optional(),
+  tags: z9.array(ContractIdentifierSchema).default([])
+}).strict();
+var WorkbenchIdentitySchema = IdentitySchema.extend({ iconRef: StableRefSchema.optional() }).strict();
+var ReleaseBaseShape = {
+  schemaVersion: z9.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  releaseSlotId: ContractIdentifierSchema,
+  tenantScope: TenantScopeSchema,
+  operation: ReleaseOperationSchema,
+  dependencySnapshot: z9.array(ReleaseDependencySchema),
+  evidence: ReleaseEvidenceSchema
+};
+var validateDependencySnapshot = (snapshot, context) => {
+  const duplicate = uniqueArray(snapshot, (dependency) => `${dependency.role}:${stableRefIdentity(dependency.revisionRef)}@${dependency.revisionRef.revision}`);
+  if (duplicate) context.addIssue({ code: "custom", path: ["dependencySnapshot"], message: `Duplicate dependency: ${duplicate}` });
+};
+var validateReleaseExpectedHead = (value, expectedKind, context) => {
+  const expectedHead = value.evidence.expectedHeadRevisionRef;
+  if (expectedHead && (expectedHead.kind !== expectedKind || expectedHead.id !== value.releaseSlotId)) {
+    context.addIssue({ code: "custom", path: ["evidence", "expectedHeadRevisionRef"], message: "Expected head must identify the same release slot." });
+  }
+  if (expectedHead?.tenantScope && tenantScopeKey(expectedHead.tenantScope) !== tenantScopeKey(value.tenantScope)) {
+    context.addIssue({ code: "custom", path: ["evidence", "expectedHeadRevisionRef", "tenantScope"], message: "Expected head belongs to another tenant scope." });
+  }
+};
+var BindingSourceSchema = z9.discriminatedUnion("kind", [
+  z9.object({ kind: z9.literal("constant"), value: z9.union([z9.string(), z9.number().finite(), z9.boolean(), z9.null()]) }).strict(),
+  z9.object({ kind: z9.literal("route-parameter"), name: ContractIdentifierSchema }).strict(),
+  z9.object({ kind: z9.literal("query-parameter"), name: ContractIdentifierSchema }).strict(),
+  z9.object({ kind: z9.literal("identity"), name: z9.enum(["tenantId", "teamId", "userId"]) }).strict(),
+  z9.object({ kind: z9.literal("intent-field"), path: z9.string().trim().regex(/^[A-Za-z0-9_.-]+$/) }).strict(),
+  z9.object({ kind: z9.literal("binding-field"), bindingId: ContractIdentifierSchema, path: z9.string().trim().regex(/^[A-Za-z0-9_.-]+$/) }).strict()
+]);
+var CapabilityInstanceSchema = z9.object({
+  instanceId: ContractIdentifierSchema,
+  nodeId: ContractIdentifierSchema,
+  capabilityRevisionRef: RevisionRefSchema,
+  providerRevisionRef: RevisionRefSchema,
+  propertySchemaRevisionRef: RevisionRefSchema,
+  properties: JsonObjectSchema,
+  allowedSideEffects: z9.array(z9.enum(["network", "storage", "navigation", "worker", "websocket"]))
+}).strict();
+var OntologyBindingSchema = z9.object({
+  bindingId: ContractIdentifierSchema,
+  ontologyDefinitionRevisionRef: RevisionRefSchema,
+  viewRevisionRef: RevisionRefSchema.optional(),
+  projectionRevisionRef: RevisionRefSchema.optional(),
+  parameters: z9.record(ContractIdentifierSchema, BindingSourceSchema),
+  target: z9.object({ capabilityInstanceId: ContractIdentifierSchema, port: ContractIdentifierSchema }).strict(),
+  renderModelSchemaRevisionRef: RevisionRefSchema,
+  pagination: z9.enum(["none", "cursor", "offset"]),
+  cache: z9.enum(["none", "identity-scoped", "tenant-scoped"]),
+  cancelOnChange: z9.boolean()
+}).strict().superRefine((value, context) => {
+  if ((value.viewRevisionRef ? 1 : 0) + (value.projectionRevisionRef ? 1 : 0) !== 1) {
+    context.addIssue({ code: "custom", path: ["viewRevisionRef"], message: "Ontology bindings require exactly one View or Projection revision." });
+  }
+  if (value.ontologyDefinitionRevisionRef.kind !== "ontology-definition") {
+    context.addIssue({ code: "custom", path: ["ontologyDefinitionRevisionRef", "kind"], message: "Expected an ontology-definition revision." });
+  }
+});
+var ActionBindingSchema = z9.object({
+  bindingId: ContractIdentifierSchema,
+  commandRevisionRef: RevisionRefSchema,
+  source: z9.object({ capabilityInstanceId: ContractIdentifierSchema, port: ContractIdentifierSchema }).strict(),
+  sourceIntentSchemaRevisionRef: RevisionRefSchema,
+  inputSchemaRevisionRef: RevisionRefSchema,
+  inputMapping: z9.record(ContractIdentifierSchema, BindingSourceSchema),
+  accessPolicy: AccessPolicySchema,
+  confirmation: I18nTextSchema.optional(),
+  idempotencyKeySource: z9.enum(["interaction", "record-and-interaction", "caller-provided"]),
+  compensationCommandRevisionRef: RevisionRefSchema.optional(),
+  resultSchemaRevisionRef: RevisionRefSchema,
+  success: z9.object({
+    refreshBindingIds: z9.array(ContractIdentifierSchema),
+    navigationTargetRef: StableRefSchema.optional()
+  }).strict(),
+  recovery: z9.enum(["retry-safe", "compensating-command", "manual-review"]),
+  lineageRequired: z9.literal(true)
+}).strict().superRefine((value, context) => {
+  if (value.commandRevisionRef.kind !== "domain-command") {
+    context.addIssue({ code: "custom", path: ["commandRevisionRef", "kind"], message: "Action bindings must reference a domain-command revision." });
+  }
+  if (value.sourceIntentSchemaRevisionRef.kind !== "schema") {
+    context.addIssue({ code: "custom", path: ["sourceIntentSchemaRevisionRef", "kind"], message: "Action source intents must pin a schema revision." });
+  }
+  if (value.inputSchemaRevisionRef.kind !== "schema") {
+    context.addIssue({ code: "custom", path: ["inputSchemaRevisionRef", "kind"], message: "Action command inputs must pin a schema revision." });
+  }
+  if (value.recovery === "compensating-command" && !value.compensationCommandRevisionRef) {
+    context.addIssue({ code: "custom", path: ["compensationCommandRevisionRef"], message: "Compensating recovery requires a compensation command." });
+  }
+});
+var PageSchema = z9.object({
+  contract: z9.literal("Page"),
+  schemaVersion: z9.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  pageId: ContractIdentifierSchema,
+  tenantScope: TenantScopeSchema,
+  identity: IdentitySchema,
+  supportedSurfaces: z9.array(ProductSurfaceSchema).min(1),
+  lifecycle: DeclarativeLifecycleSchema,
+  routeClaims: z9.array(z9.union([DeclarativeRouteClaimSchema, LegacyDeclarativeRouteClaimSchema])).min(1),
+  shellRevisionRef: RevisionRefSchema,
+  renderTree: RenderTreeSchema,
+  capabilityInstances: z9.array(CapabilityInstanceSchema).min(1),
+  ontologyBindings: z9.array(OntologyBindingSchema),
+  actionBindings: z9.array(ActionBindingSchema),
+  pageAccessPolicy: AccessPolicySchema,
+  managementAccess: ManagementAccessSchema,
+  tokenRevisionRefs: z9.array(RevisionRefSchema).min(1),
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema,
+  privacyClassification: z9.enum(["public", "internal", "confidential", "restricted"])
+}).strict().superRefine((value, context) => {
+  validateDeclaredRouteSurfaces(value.supportedSurfaces, value.routeClaims, context);
+  const uniqueness = [
+    ["capabilityInstances", value.capabilityInstances, (candidate) => String(candidate.instanceId)],
+    ["ontologyBindings", value.ontologyBindings, (candidate) => String(candidate.bindingId)],
+    ["actionBindings", value.actionBindings, (candidate) => String(candidate.bindingId)]
+  ];
+  uniqueness.forEach(([field, values, identity]) => {
+    if (uniqueArray(values, identity)) context.addIssue({ code: "custom", path: [field], message: `${field} identities must be unique.` });
+  });
+  const instanceIds = new Set(value.capabilityInstances.map((instance) => instance.instanceId));
+  value.ontologyBindings.forEach((binding, index) => {
+    if (!instanceIds.has(binding.target.capabilityInstanceId)) {
+      context.addIssue({ code: "custom", path: ["ontologyBindings", index, "target", "capabilityInstanceId"], message: "Ontology binding targets an unknown capability instance." });
+    }
+  });
+  value.actionBindings.forEach((binding, index) => {
+    if (!instanceIds.has(binding.source.capabilityInstanceId)) {
+      context.addIssue({ code: "custom", path: ["actionBindings", index, "source", "capabilityInstanceId"], message: "Action binding sources an unknown capability instance." });
+    }
+    binding.success.refreshBindingIds.forEach((bindingId) => {
+      if (!value.ontologyBindings.some((candidate) => candidate.bindingId === bindingId)) {
+        context.addIssue({ code: "custom", path: ["actionBindings", index, "success", "refreshBindingIds"], message: `Unknown refresh binding: ${bindingId}` });
+      }
+    });
+  });
+  if (value.shellRevisionRef.kind !== "shell") context.addIssue({ code: "custom", path: ["shellRevisionRef", "kind"], message: "Page shellRevisionRef must reference a shell." });
+  value.capabilityInstances.forEach((instance, index) => {
+    const refs = [
+      ["capabilityRevisionRef", instance.capabilityRevisionRef, "capability"],
+      ["providerRevisionRef", instance.providerRevisionRef, "view-provider"],
+      ["propertySchemaRevisionRef", instance.propertySchemaRevisionRef, "schema"]
+    ];
+    refs.forEach(([field, reference, expectedKind]) => {
+      if (reference.kind !== expectedKind) context.addIssue({ code: "custom", path: ["capabilityInstances", index, field, "kind"], message: `${field} must reference ${expectedKind}.` });
+    });
+  });
+  value.tokenRevisionRefs.forEach((reference, index) => {
+    if (reference.kind !== "design-token") context.addIssue({ code: "custom", path: ["tokenRevisionRefs", index, "kind"], message: "Page token references must use kind design-token." });
+  });
+  if (value.performanceBudgetRef.kind !== "performance-budget") context.addIssue({ code: "custom", path: ["performanceBudgetRef", "kind"], message: "Page requires a performance-budget revision." });
+  if (value.observationPolicyRevisionRef.kind !== "observation-policy") context.addIssue({ code: "custom", path: ["observationPolicyRevisionRef", "kind"], message: "Page requires an observation-policy revision." });
+});
+var PageReleaseSchema = z9.object({
+  contract: z9.literal("PageRelease"),
+  ...ReleaseBaseShape,
+  pageRevisionRef: RevisionRefSchema,
+  target: z9.object({
+    environmentRef: StableRefSchema,
+    surface: ProductSurfaceSchema,
+    routeSpaceRevisionRef: RevisionRefSchema,
+    normalizedPath: RoutePathTemplateSchema,
+    routeClaim: z9.union([CompiledRouteClaimSchema, LegacyCompiledRouteClaimSchema])
+  }).strict()
+}).strict().superRefine((value, context) => {
+  validateDependencySnapshot(value.dependencySnapshot, context);
+  validateReleaseExpectedHead(value, "page-release", context);
+  if (value.pageRevisionRef.kind !== "page") context.addIssue({ code: "custom", path: ["pageRevisionRef", "kind"], message: "Expected a page revision." });
+  if (value.target.environmentRef.kind !== "environment") context.addIssue({ code: "custom", path: ["target", "environmentRef", "kind"], message: "Page release target requires an environment reference." });
+  if (value.target.routeSpaceRevisionRef.kind !== "route-space") context.addIssue({ code: "custom", path: ["target", "routeSpaceRevisionRef", "kind"], message: "Page release target requires a route-space revision." });
+  if (value.target.normalizedPath !== value.target.routeClaim.normalizedPath || !exactRevisionRef(value.target.routeSpaceRevisionRef, value.target.routeClaim.routeSpaceRevisionRef)) {
+    context.addIssue({ code: "custom", path: ["target", "routeClaim"], message: "Page Release route authority must pin the exact compiled claim and normalized path." });
+  }
+  if ("surface" in value.target.routeClaim && value.target.routeClaim.surface !== value.target.surface) {
+    context.addIssue({ code: "custom", path: ["target", "routeClaim", "surface"], message: "Page Release route claim must match the target surface." });
+  }
+});
+var WorkbenchGroupSchema = z9.object({
+  groupId: ContractIdentifierSchema,
+  label: I18nTextSchema,
+  iconRef: StableRefSchema.optional(),
+  order: z9.number().int(),
+  collapsedByDefault: z9.boolean(),
+  accessPolicy: AccessPolicySchema.optional()
+}).strict();
+var WorkbenchAppInstanceSchema = z9.object({
+  instanceId: ContractIdentifierSchema,
+  kind: z9.enum(["built-in-application", "workflow-form", "workflow", "agent", "design", "capability"]),
+  targetRevisionRef: RevisionRefSchema,
+  providerRevisionRef: RevisionRefSchema,
+  inputSchemaRevisionRef: RevisionRefSchema,
+  input: JsonObjectSchema,
+  groupId: ContractIdentifierSchema,
+  order: z9.number().int(),
+  display: z9.object({ name: I18nTextSchema.optional(), iconRef: StableRefSchema.optional() }).strict(),
+  accessPolicy: AccessPolicySchema
+}).strict();
+var WorkbenchSchema = z9.object({
+  contract: z9.literal("Workbench"),
+  schemaVersion: z9.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  workbenchId: ContractIdentifierSchema,
+  tenantScope: TenantScopeSchema,
+  purpose: z9.enum(["instance", "template"]),
+  sourceTemplateRevisionRef: RevisionRefSchema.optional(),
+  identity: WorkbenchIdentitySchema,
+  supportedSurfaces: z9.array(ProductSurfaceSchema).min(1),
+  lifecycle: DeclarativeLifecycleSchema,
+  routeClaims: z9.array(z9.union([DeclarativeRouteClaimSchema, LegacyDeclarativeRouteClaimSchema])).min(1),
+  groups: z9.array(WorkbenchGroupSchema).min(1),
+  appInstances: z9.array(WorkbenchAppInstanceSchema).min(1),
+  defaultEntry: z9.object({ groupId: ContractIdentifierSchema, instanceId: ContractIdentifierSchema, showDefaultGroup: z9.boolean() }).strict(),
+  layout: z9.object({
+    hostCapabilityRevisionRef: RevisionRefSchema,
+    hostProviderRevisionRef: RevisionRefSchema,
+    layoutPolicyRevisionRef: RevisionRefSchema,
+    tokenRevisionRefs: z9.array(RevisionRefSchema).min(1)
+  }).strict(),
+  workbenchAccessPolicy: AccessPolicySchema,
+  managementAccess: ManagementAccessSchema,
+  personalPreferencesPolicy: z9.object({
+    allowed: z9.array(z9.enum(["collapsed-groups", "recent-entry", "layout-density"])),
+    authority: z9.literal("identity-overlay")
+  }).strict(),
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema,
+  privacyClassification: z9.enum(["public", "internal", "confidential", "restricted"])
+}).strict().superRefine((value, context) => {
+  validateDeclaredRouteSurfaces(value.supportedSurfaces, value.routeClaims, context);
+  if (value.purpose === "template" && value.sourceTemplateRevisionRef) {
+    context.addIssue({ code: "custom", path: ["sourceTemplateRevisionRef"], message: "Templates cannot derive from another template at runtime." });
+  }
+  const duplicateGroup = uniqueArray(value.groups, (group) => group.groupId);
+  if (duplicateGroup) context.addIssue({ code: "custom", path: ["groups"], message: `Duplicate Workbench group: ${duplicateGroup}` });
+  const duplicateInstance = uniqueArray(value.appInstances, (instance) => instance.instanceId);
+  if (duplicateInstance) context.addIssue({ code: "custom", path: ["appInstances"], message: `Duplicate Workbench instance: ${duplicateInstance}` });
+  const groupIds = new Set(value.groups.map((group) => group.groupId));
+  value.appInstances.forEach((instance, index) => {
+    if (!groupIds.has(instance.groupId)) context.addIssue({ code: "custom", path: ["appInstances", index, "groupId"], message: "Workbench app references an unknown group." });
+  });
+  const defaultInstance = value.appInstances.find((instance) => instance.instanceId === value.defaultEntry.instanceId);
+  if (!defaultInstance || defaultInstance.groupId !== value.defaultEntry.groupId) {
+    context.addIssue({ code: "custom", path: ["defaultEntry"], message: "Workbench default entry must reference an app in the declared group." });
+  }
+  const targetKindByInstanceKind = {
+    "built-in-application": "built-in-application",
+    "workflow-form": "workflow",
+    workflow: "workflow",
+    agent: "agent",
+    design: "design",
+    capability: "capability"
+  };
+  value.appInstances.forEach((instance, index) => {
+    if (instance.targetRevisionRef.kind !== targetKindByInstanceKind[instance.kind]) context.addIssue({ code: "custom", path: ["appInstances", index, "targetRevisionRef", "kind"], message: `Workbench ${instance.kind} target has an incompatible reference kind.` });
+    if (instance.providerRevisionRef.kind !== "view-provider") context.addIssue({ code: "custom", path: ["appInstances", index, "providerRevisionRef", "kind"], message: "Workbench app provider must use kind view-provider." });
+    if (instance.inputSchemaRevisionRef.kind !== "schema") context.addIssue({ code: "custom", path: ["appInstances", index, "inputSchemaRevisionRef", "kind"], message: "Workbench app input must pin a schema revision." });
+  });
+  const layoutRefs = [
+    ["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) context.addIssue({ code: "custom", path: ["layout", field, "kind"], message: `${field} must reference ${expectedKind}.` });
+  });
+  value.layout.tokenRevisionRefs.forEach((reference, index) => {
+    if (reference.kind !== "design-token") context.addIssue({ code: "custom", path: ["layout", "tokenRevisionRefs", index, "kind"], message: "Workbench token references must use kind design-token." });
+  });
+});
+var WorkbenchReleaseSchema = z9.object({
+  contract: z9.literal("WorkbenchRelease"),
+  ...ReleaseBaseShape,
+  workbenchRevisionRef: RevisionRefSchema,
+  target: z9.object({
+    environmentRef: StableRefSchema,
+    surface: ProductSurfaceSchema,
+    workbenchId: ContractIdentifierSchema,
+    routeSpaceRevisionRef: RevisionRefSchema,
+    normalizedPath: RoutePathTemplateSchema,
+    routeClaim: z9.union([CompiledRouteClaimSchema, LegacyCompiledRouteClaimSchema]),
+    order: z9.number().int(),
+    isDefaultCandidate: z9.boolean()
+  }).strict()
+}).strict().superRefine((value, context) => {
+  validateDependencySnapshot(value.dependencySnapshot, context);
+  validateReleaseExpectedHead(value, "workbench-release", context);
+  if (value.workbenchRevisionRef.kind !== "workbench") context.addIssue({ code: "custom", path: ["workbenchRevisionRef", "kind"], message: "Expected a workbench revision." });
+  if (value.target.environmentRef.kind !== "environment") context.addIssue({ code: "custom", path: ["target", "environmentRef", "kind"], message: "Workbench release target requires an environment reference." });
+  if (value.target.routeSpaceRevisionRef.kind !== "route-space") context.addIssue({ code: "custom", path: ["target", "routeSpaceRevisionRef", "kind"], message: "Workbench release target requires a route-space revision." });
+  if (value.target.normalizedPath !== value.target.routeClaim.normalizedPath || !exactRevisionRef(value.target.routeSpaceRevisionRef, value.target.routeClaim.routeSpaceRevisionRef)) {
+    context.addIssue({ code: "custom", path: ["target", "routeClaim"], message: "Workbench Release route authority must pin the exact compiled claim and normalized path." });
+  }
+  if ("surface" in value.target.routeClaim && value.target.routeClaim.surface !== value.target.surface) {
+    context.addIssue({ code: "custom", path: ["target", "routeClaim", "surface"], message: "Workbench Release route claim must match the target surface." });
+  }
+});
+var NavigationNodeBaseShape = {
+  nodeId: ContractIdentifierSchema,
+  parentNodeId: ContractIdentifierSchema.nullable(),
+  order: z9.number().int(),
+  disabled: z9.boolean().optional()
+};
+var NavigationGroupNodeSchema = z9.object({
+  ...NavigationNodeBaseShape,
+  kind: z9.literal("group"),
+  label: I18nTextSchema,
+  iconRef: StableRefSchema.optional(),
+  collapsedByDefault: z9.boolean(),
+  audience: AccessPolicySchema
+}).strict();
+var NavigationTargetNodeSchema = z9.object({
+  ...NavigationNodeBaseShape,
+  kind: z9.literal("target"),
+  label: I18nTextSchema,
+  iconRef: StableRefSchema.optional(),
+  tone: z9.enum(["default", "danger"]).optional(),
+  targetRef: StableRefSchema,
+  parameterMapping: z9.record(ContractIdentifierSchema, BindingSourceSchema),
+  audience: AccessPolicySchema
+}).strict();
+var NavigationSeparatorNodeSchema = z9.object({
+  ...NavigationNodeBaseShape,
+  kind: z9.literal("separator")
+}).strict();
+var NavigationNodeSchema = z9.discriminatedUnion("kind", [
+  NavigationGroupNodeSchema,
+  NavigationTargetNodeSchema,
+  NavigationSeparatorNodeSchema
+]);
+var validateNavigationTree = (nodes, context) => {
+  const byId = /* @__PURE__ */ new Map();
+  nodes.forEach((node, index) => {
+    if (byId.has(node.nodeId)) context.addIssue({ code: "custom", path: ["nodes", index, "nodeId"], message: `Duplicate Navigation node: ${node.nodeId}` });
+    else byId.set(node.nodeId, { node, index });
+  });
+  const siblingOrders = /* @__PURE__ */ new Set();
+  nodes.forEach((node, index) => {
+    const orderKey = `${node.parentNodeId ?? ""}:${node.order}`;
+    if (siblingOrders.has(orderKey)) context.addIssue({ code: "custom", path: ["nodes", index, "order"], message: "Sibling Navigation order values must be unique." });
+    siblingOrders.add(orderKey);
+    if (node.parentNodeId) {
+      const parent = byId.get(node.parentNodeId)?.node;
+      if (!parent) context.addIssue({ code: "custom", path: ["nodes", index, "parentNodeId"], message: "Navigation node has an unknown parent." });
+      else if (parent.kind !== "group") context.addIssue({ code: "custom", path: ["nodes", index, "parentNodeId"], message: "Navigation parents must be groups." });
+    }
+    const ancestors = /* @__PURE__ */ new Set([node.nodeId]);
+    let parentId = node.parentNodeId;
+    while (parentId) {
+      if (ancestors.has(parentId)) {
+        context.addIssue({ code: "custom", path: ["nodes", index, "parentNodeId"], message: `Navigation cycle contains ${node.nodeId}.` });
+        break;
+      }
+      ancestors.add(parentId);
+      parentId = byId.get(parentId)?.node.parentNodeId ?? null;
+    }
+  });
+};
+var NavigationSchema = z9.object({
+  contract: z9.literal("Navigation"),
+  schemaVersion: z9.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  navigationId: ContractIdentifierSchema,
+  tenantScope: TenantScopeSchema,
+  identity: IdentitySchema,
+  supportedSurfaces: z9.array(ProductSurfaceSchema).min(1),
+  placements: z9.array(ContractIdentifierSchema).min(1),
+  lifecycle: DeclarativeLifecycleSchema,
+  nodes: z9.array(NavigationNodeSchema),
+  managementAccess: ManagementAccessSchema,
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema
+}).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)) {
+      context.addIssue({ code: "custom", path: ["nodes", index, "targetRef", "kind"], message: "Navigation targets must reference Page, Workbench, registered Menu Action, or DomainCommand identities." });
+    }
+  });
+});
+var ResolvedNavigationTargetSchema = z9.object({
+  nodeId: ContractIdentifierSchema,
+  stableTargetRef: StableRefSchema,
+  targetRevisionRef: RevisionRefSchema,
+  releaseRevisionRef: RevisionRefSchema.optional()
+}).strict();
+var NavigationReleaseSchema = z9.object({
+  contract: z9.literal("NavigationRelease"),
+  ...ReleaseBaseShape,
+  navigationRevisionRef: RevisionRefSchema,
+  target: z9.object({
+    environmentRef: StableRefSchema,
+    surface: ProductSurfaceSchema,
+    placement: ContractIdentifierSchema
+  }).strict(),
+  resolvedTargets: z9.array(ResolvedNavigationTargetSchema)
+}).strict().superRefine((value, context) => {
+  validateDependencySnapshot(value.dependencySnapshot, context);
+  validateReleaseExpectedHead(value, "navigation-release", context);
+  if (value.navigationRevisionRef.kind !== "navigation") context.addIssue({ code: "custom", path: ["navigationRevisionRef", "kind"], message: "Expected a navigation revision." });
+  if (value.target.environmentRef.kind !== "environment") context.addIssue({ code: "custom", path: ["target", "environmentRef", "kind"], message: "Navigation release target requires an environment reference." });
+  if (uniqueArray(value.resolvedTargets, (target) => target.nodeId)) context.addIssue({ code: "custom", path: ["resolvedTargets"], message: "Resolved Navigation node IDs must be unique." });
+});
+var RuntimeDiagnosticSchema = z9.object({
+  code: ContractIdentifierSchema,
+  severity: z9.enum(["info", "warning", "error"]),
+  path: z9.string().trim().min(1),
+  message: z9.string().trim().min(1)
+}).strict();
+var RuntimeBundleBaseShape = {
+  schemaVersion: z9.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  tenantScope: TenantScopeSchema,
+  releaseRevisionRef: RevisionRefSchema,
+  compilerRevisionRef: RevisionRefSchema,
+  generation: z9.number().int().nonnegative(),
+  dependencySnapshot: z9.array(ReleaseDependencySchema),
+  contentHash: Sha256Schema,
+  rebuildable: z9.literal(true),
+  diagnostics: z9.array(RuntimeDiagnosticSchema)
+};
+var PageRuntimeBundleSchema = z9.object({
+  contract: z9.literal("PageRuntimeBundle"),
+  ...RuntimeBundleBaseShape,
+  pageId: ContractIdentifierSchema,
+  pageRevisionRef: RevisionRefSchema,
+  surface: ProductSurfaceSchema,
+  routeClaims: z9.array(CompiledRouteClaimSchema),
+  shellRevisionRef: RevisionRefSchema,
+  renderTree: RenderTreeSchema,
+  capabilityInstances: z9.array(CapabilityInstanceSchema),
+  ontologyBindings: z9.array(OntologyBindingSchema),
+  actionBindings: z9.array(ActionBindingSchema),
+  pageAccessPolicy: AccessPolicySchema,
+  tokenRevisionRefs: z9.array(RevisionRefSchema),
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema,
+  privacyClassification: z9.enum(["public", "internal", "confidential", "restricted"])
+}).strict();
+var ResolvedWorkbenchAppInstanceSchema = WorkbenchAppInstanceSchema.extend({
+  targetAccessPolicy: AccessPolicySchema
+}).strict();
+var WorkbenchRuntimeTargetSchema = WorkbenchReleaseSchema.shape.target.safeExtend({
+  routeClaim: CompiledRouteClaimSchema
+}).strict();
+var WorkbenchRuntimeBundleSchema = z9.object({
+  contract: z9.literal("WorkbenchRuntimeBundle"),
+  ...RuntimeBundleBaseShape,
+  workbenchId: ContractIdentifierSchema,
+  workbenchRevisionRef: RevisionRefSchema,
+  surface: ProductSurfaceSchema,
+  routeClaims: z9.array(CompiledRouteClaimSchema),
+  groups: z9.array(WorkbenchGroupSchema),
+  appInstances: z9.array(ResolvedWorkbenchAppInstanceSchema),
+  defaultEntry: WorkbenchSchema.shape.defaultEntry,
+  layout: WorkbenchSchema.shape.layout,
+  workbenchAccessPolicy: AccessPolicySchema,
+  personalPreferencesPolicy: WorkbenchSchema.shape.personalPreferencesPolicy,
+  target: WorkbenchRuntimeTargetSchema,
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema,
+  privacyClassification: z9.enum(["public", "internal", "confidential", "restricted"])
+}).strict();
+var CompiledNavigationTargetSchema = ResolvedNavigationTargetSchema.extend({
+  kind: z9.literal("route"),
+  accessPolicy: AccessPolicySchema,
+  routeClaim: CompiledRouteClaimSchema
+}).strict();
+var CompiledNavigationRegisteredMenuActionTargetSchema = ResolvedNavigationTargetSchema.extend({
+  kind: z9.literal("registered-menu-action"),
+  accessPolicy: AccessPolicySchema,
+  execution: z9.literal("client"),
+  applicationId: ContractIdentifierSchema,
+  actionRef: ContractIdentifierSchema,
+  inputSchemaRef: ContractIdentifierSchema.optional(),
+  input: JsonObjectSchema,
+  sourceCatalogRevisionRef: RevisionRefSchema
+}).strict();
+var CompiledNavigationDomainCommandTargetSchema = ResolvedNavigationTargetSchema.extend({
+  kind: z9.literal("governed-domain-command"),
+  accessPolicy: AccessPolicySchema,
+  execution: z9.literal("server"),
+  commandRevisionRef: RevisionRefSchema,
+  inputSchemaRevisionRef: RevisionRefSchema,
+  resultSchemaRevisionRef: RevisionRefSchema.optional(),
+  input: JsonObjectSchema
+}).strict();
+var CompiledNavigationResolvedTargetSchema = z9.discriminatedUnion("kind", [
+  CompiledNavigationTargetSchema,
+  CompiledNavigationRegisteredMenuActionTargetSchema,
+  CompiledNavigationDomainCommandTargetSchema
+]);
+var CompiledNavigationGroupNodeSchema = NavigationGroupNodeSchema.extend({
+  ancestorAccessPolicies: z9.array(AccessPolicySchema)
+}).strict();
+var CompiledNavigationTargetNodeSchema = NavigationTargetNodeSchema.extend({
+  ancestorAccessPolicies: z9.array(AccessPolicySchema),
+  resolvedTarget: CompiledNavigationResolvedTargetSchema
+}).strict();
+var CompiledNavigationSeparatorNodeSchema = NavigationSeparatorNodeSchema.extend({
+  ancestorAccessPolicies: z9.array(AccessPolicySchema)
+}).strict();
+var CompiledNavigationNodeSchema = z9.discriminatedUnion("kind", [
+  CompiledNavigationGroupNodeSchema,
+  CompiledNavigationTargetNodeSchema,
+  CompiledNavigationSeparatorNodeSchema
+]);
+var NavigationRuntimeBundleSchema = z9.object({
+  contract: z9.literal("NavigationRuntimeBundle"),
+  ...RuntimeBundleBaseShape,
+  navigationId: ContractIdentifierSchema,
+  navigationRevisionRef: RevisionRefSchema,
+  surface: ProductSurfaceSchema,
+  placement: ContractIdentifierSchema,
+  nodes: z9.array(CompiledNavigationNodeSchema),
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema
+}).strict();
+var DeclarativeControlOntologyDefinitionSchema = OntologyDefinitionSchema.extend({
+  classification: z9.literal("control"),
+  discovery: z9.object({
+    ordinaryDataBrowser: z9.literal(false),
+    businessSearch: z9.literal(false),
+    businessStatistics: z9.literal(false),
+    ordinaryExport: z9.literal(false),
+    genericWrite: z9.literal(false)
+  }).strict()
+}).strict();
+var controlDefinition = (ontologyId, bodySchemaRef) => DeclarativeControlOntologyDefinitionSchema.parse({
+  contract: "OntologyDefinition",
+  ontologyId,
+  dataSpaceId: "monkeys.control",
+  ownerRepo: "monkeys-js-sdk",
+  bodySchemaRef,
+  authority: { service: "monkeys-data-server", storage: "domain-record", scope: "tenant" },
+  relationKinds: [],
+  metricKinds: [],
+  classification: "control",
+  discovery: {
+    ordinaryDataBrowser: false,
+    businessSearch: false,
+    businessStatistics: false,
+    ordinaryExport: false,
+    genericWrite: false
+  }
+});
+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.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")
+]);
+
 // src/contracts/semantic.ts
-var ConceptRelationshipSchema = z9.object({
+var ExactRefKindSchema = (kind) => RevisionRefSchema.superRefine((value, context) => {
+  if (value.kind !== kind) context.addIssue({ code: "custom", path: ["kind"], message: `Reference must use kind ${kind}.` });
+});
+var SchemaDefinitionSchema = z10.object({
+  contract: z10.literal("Schema"),
+  schemaVersion: z10.literal(1),
+  schemaId: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  dialect: z10.literal("https://json-schema.org/draft/2020-12/schema"),
+  document: JsonObjectSchema
+}).strict();
+var OntologyViewDefinitionSchema = z10.object({
+  contract: z10.literal("View"),
+  schemaVersion: z10.literal(1),
+  viewId: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  ontologyDefinitionRevisionRef: ExactRefKindSchema("ontology-definition"),
+  renderModelSchemaRevisionRef: ExactRefKindSchema("schema"),
+  requiredPermissionCodes: z10.array(ContractIdentifierSchema).default([])
+}).strict();
+var ConceptRelationshipSchema = z10.object({
   kind: ContractIdentifierSchema,
   targetConceptId: ContractIdentifierSchema,
-  cardinality: z9.enum(["one", "optional", "many"])
+  cardinality: z10.enum(["one", "optional", "many"])
 }).strict();
-var ConceptDefinitionSchema = z9.object({
-  contract: z9.literal("ConceptDefinition"),
+var ConceptDefinitionSchema = z10.object({
+  contract: z10.literal("ConceptDefinition"),
   conceptId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z9.string().trim().min(1),
-  description: z9.string().optional(),
+  displayName: z10.string().trim().min(1),
+  description: z10.string().optional(),
   schemaRef: ContractIdentifierSchema,
   ontologyId: ContractIdentifierSchema.optional(),
-  capabilityIds: z9.array(ContractIdentifierSchema).default([]),
-  commandNames: z9.array(ContractIdentifierSchema).default([]),
-  relationships: z9.array(ConceptRelationshipSchema).default([])
+  capabilityIds: z10.array(ContractIdentifierSchema).default([]),
+  commandNames: z10.array(ContractIdentifierSchema).default([]),
+  relationships: z10.array(ConceptRelationshipSchema).default([])
 }).strict();
-var DomainCommandDefinitionSchema = z9.object({
-  contract: z9.literal("DomainCommandDefinition"),
+var DomainCommandDefinitionSchema = z10.object({
+  contract: z10.literal("DomainCommandDefinition"),
   commandName: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z9.string().trim().min(1),
-  description: z9.string().optional(),
-  targetKinds: z9.array(ContractIdentifierSchema).min(1),
+  displayName: z10.string().trim().min(1),
+  description: z10.string().optional(),
+  targetKinds: z10.array(ContractIdentifierSchema).min(1),
   inputSchemaRef: ContractIdentifierSchema,
   outputSchemaRef: ContractIdentifierSchema.optional(),
-  requiredPermissionCodes: z9.array(ContractIdentifierSchema).default([]),
+  requiredPermissionCodes: z10.array(ContractIdentifierSchema).default([]),
   handlerRef: EntityRefSchema,
-  sideEffects: z9.array(z9.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
+  sideEffects: z10.array(z10.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
 }).strict();
-var DomainCommandSchema = z9.object({
-  contract: z9.literal("DomainCommand"),
+var DomainCommandSchema = z10.object({
+  contract: z10.literal("DomainCommand"),
   commandId: ContractIdentifierSchema,
   commandName: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
@@ -9346,30 +10304,30 @@ var DomainCommandSchema = z9.object({
   idempotencyKey: ContractIdentifierSchema,
   targetRef: EntityRefSchema,
   actorRef: EntityRefSchema,
-  source: z9.object({
-    product: z9.enum(["studio", "kernel", "agent", "mcp", "service"]),
+  source: z10.object({
+    product: z10.enum(["studio", "kernel", "agent", "mcp", "service"]),
     pageId: ContractIdentifierSchema.optional(),
     capabilityId: ContractIdentifierSchema.optional()
   }).strict(),
   payload: JsonObjectSchema,
   issuedAt: IsoDateTimeSchema
 }).strict();
-var ProductDeclarationSchema = z9.object({
-  contract: z9.literal("ProductDeclaration"),
+var ProductDeclarationSchema = z10.object({
+  contract: z10.literal("ProductDeclaration"),
   declarationId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  concepts: z9.array(ConceptDefinitionSchema).default([]),
-  ontologies: z9.array(OntologyDefinitionSchema).default([]),
-  projections: z9.array(ProjectionSpecSchema).default([]),
-  commands: z9.array(DomainCommandDefinitionSchema).default([]),
-  capabilities: z9.array(CapabilityManifestSchema).default([]),
-  pages: z9.array(PageDefinitionSchema).default([]),
-  menus: z9.array(MenuDefinitionSchema).default([])
-}).strict();
-var DeclarationGraphEdgeSchema = z9.object({
+  concepts: z10.array(ConceptDefinitionSchema).default([]),
+  ontologies: z10.array(OntologyDefinitionSchema).default([]),
+  projections: z10.array(ProjectionSpecSchema).default([]),
+  commands: z10.array(DomainCommandDefinitionSchema).default([]),
+  capabilities: z10.array(CapabilityManifestSchema).default([]),
+  pages: z10.array(PageDefinitionSchema).default([]),
+  menus: z10.array(MenuDefinitionSchema).default([])
+}).strict();
+var DeclarationGraphEdgeSchema = z10.object({
   from: EntityRefSchema,
   to: EntityRefSchema,
-  relation: z9.enum([
+  relation: z10.enum([
     "uses-ontology",
     "uses-projection",
     "uses-capability",
@@ -9377,17 +10335,17 @@ var DeclarationGraphEdgeSchema = z9.object({
     "relates-to-concept"
   ])
 }).strict();
-var ChangeImpactSchema = z9.object({
+var ChangeImpactSchema = z10.object({
   changedRef: EntityRefSchema,
-  affectedRefs: z9.array(EntityRefSchema),
-  reasons: z9.array(ContractIdentifierSchema).min(1)
+  affectedRefs: z10.array(EntityRefSchema),
+  reasons: z10.array(ContractIdentifierSchema).min(1)
 }).strict();
-var ChangeImpactGraphSchema = z9.object({
-  contract: z9.literal("ChangeImpactGraph"),
+var ChangeImpactGraphSchema = z10.object({
+  contract: z10.literal("ChangeImpactGraph"),
   declarationId: ContractIdentifierSchema,
-  nodes: z9.array(EntityRefSchema),
-  edges: z9.array(DeclarationGraphEdgeSchema),
-  impacts: z9.array(ChangeImpactSchema),
+  nodes: z10.array(EntityRefSchema),
+  edges: z10.array(DeclarationGraphEdgeSchema),
+  impacts: z10.array(ChangeImpactSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
 
@@ -9546,132 +10504,1051 @@ var compileProductDeclaration = (input) => {
       if (!ontologiesById.has(ontologyId)) throw new Error(`Projection ${projection.projectionId} references unknown ontology ${ontologyId}.`);
       addEdge(ref("projection", projection.projectionId), ref("ontology", ontologyId), "uses-ontology");
     }
-  }
-  for (const command of declaration.commands) addNode("command", command.commandName);
-  for (const capability of declaration.capabilities) addNode("capability", capability.id);
-  for (const menu of declaration.menus) addNode("menu", `${menu.applicationId}/${menu.surface}/${menu.menuId}`);
-  for (const concept of declaration.concepts) {
-    addNode("concept", concept.conceptId);
-    if (concept.ontologyId) {
-      if (!ontologiesById.has(concept.ontologyId)) throw new Error(`Concept ${concept.conceptId} references unknown ontology ${concept.ontologyId}.`);
-      addEdge(ref("concept", concept.conceptId), ref("ontology", concept.ontologyId), "uses-ontology");
+  }
+  for (const command of declaration.commands) addNode("command", command.commandName);
+  for (const capability of declaration.capabilities) addNode("capability", capability.id);
+  for (const menu of declaration.menus) addNode("menu", `${menu.applicationId}/${menu.surface}/${menu.menuId}`);
+  for (const concept of declaration.concepts) {
+    addNode("concept", concept.conceptId);
+    if (concept.ontologyId) {
+      if (!ontologiesById.has(concept.ontologyId)) throw new Error(`Concept ${concept.conceptId} references unknown ontology ${concept.ontologyId}.`);
+      addEdge(ref("concept", concept.conceptId), ref("ontology", concept.ontologyId), "uses-ontology");
+    }
+    for (const capabilityId of concept.capabilityIds) {
+      if (!capabilitiesById.has(capabilityId)) throw new Error(`Concept ${concept.conceptId} references unknown capability ${capabilityId}.`);
+      addEdge(ref("concept", concept.conceptId), ref("capability", capabilityId), "uses-capability");
+    }
+    for (const commandName of concept.commandNames) {
+      if (!commandsByName.has(commandName)) throw new Error(`Concept ${concept.conceptId} references unknown command ${commandName}.`);
+      addEdge(ref("concept", concept.conceptId), ref("command", commandName), "uses-command");
+    }
+    for (const relationship of concept.relationships) {
+      if (!conceptsById.has(relationship.targetConceptId)) {
+        throw new Error(`Concept ${concept.conceptId} references unknown concept ${relationship.targetConceptId}.`);
+      }
+      addEdge(ref("concept", concept.conceptId), ref("concept", relationship.targetConceptId), "relates-to-concept");
+    }
+  }
+  for (const page of declaration.pages) {
+    addNode("page", page.pageId);
+    if (page.binding.ontologyId) {
+      if (!ontologiesById.has(page.binding.ontologyId)) throw new Error(`Page ${page.pageId} references unknown ontology ${page.binding.ontologyId}.`);
+      addEdge(ref("page", page.pageId), ref("ontology", page.binding.ontologyId), "uses-ontology");
+    }
+    if (page.binding.projectionRef) {
+      if (!projectionsById.has(page.binding.projectionRef)) throw new Error(`Page ${page.pageId} references unknown projection ${page.binding.projectionRef}.`);
+      addEdge(ref("page", page.pageId), ref("projection", page.binding.projectionRef), "uses-projection");
+    }
+    for (const capabilityRef of [page.capabilityRef, ...page.capabilityRefs].filter(Boolean)) {
+      if (!capabilitiesById.has(capabilityRef.id)) throw new Error(`Page ${page.pageId} references unknown capability ${capabilityRef.id}.`);
+      addEdge(ref("page", page.pageId), ref("capability", capabilityRef.id), "uses-capability");
+    }
+  }
+  uniqueIndex(nodes, refKey, "declaration node");
+  return Object.freeze({
+    declaration: Object.freeze(declaration),
+    conceptsById,
+    ontologiesById,
+    projectionsById,
+    commandsByName,
+    capabilitiesById,
+    pagesById,
+    menusByKey,
+    nodes: Object.freeze(nodes),
+    edges: Object.freeze(edges)
+  });
+};
+var validateDomainCommand = (input, definitions, permissionCodes) => {
+  const command = DomainCommandSchema.parse(input);
+  const commandsByName = uniqueIndex(
+    definitions.map((definition2) => DomainCommandDefinitionSchema.parse(definition2)),
+    (definition2) => definition2.commandName,
+    "command name"
+  );
+  const definition = commandsByName.get(command.commandName);
+  if (!definition) throw new Error(`Unknown domain command: ${command.commandName}`);
+  if (!definition.targetKinds.includes(command.targetRef.kind)) {
+    throw new Error(`Command ${command.commandName} does not accept target kind ${command.targetRef.kind}.`);
+  }
+  const granted = new Set(permissionCodes);
+  const missing = definition.requiredPermissionCodes.filter((permission) => !granted.has(permission));
+  if (missing.length) throw new Error(`Command ${command.commandName} requires permissions: ${missing.join(", ")}`);
+  return Object.freeze(command);
+};
+var declarationValuesByRef = (compiled) => {
+  const values = /* @__PURE__ */ new Map();
+  for (const value of compiled.declaration.ontologies) values.set(refKey(ref("ontology", value.ontologyId)), value);
+  for (const value of compiled.declaration.projections) values.set(refKey(ref("projection", value.projectionId)), value);
+  for (const value of compiled.declaration.commands) values.set(refKey(ref("command", value.commandName)), value);
+  for (const value of compiled.declaration.capabilities) values.set(refKey(ref("capability", value.id)), value);
+  for (const value of compiled.declaration.concepts) values.set(refKey(ref("concept", value.conceptId)), value);
+  for (const value of compiled.declaration.pages) values.set(refKey(ref("page", value.pageId)), value);
+  return values;
+};
+var buildChangeImpactGraph = (previousInput, nextInput, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) => {
+  const previous = compileProductDeclaration(previousInput);
+  const next = compileProductDeclaration(nextInput);
+  const previousValues = declarationValuesByRef(previous);
+  const nextValues = declarationValuesByRef(next);
+  const changedKeys = /* @__PURE__ */ new Set();
+  for (const key of /* @__PURE__ */ new Set([...previousValues.keys(), ...nextValues.keys()])) {
+    if (JSON.stringify(previousValues.get(key)) !== JSON.stringify(nextValues.get(key))) changedKeys.add(key);
+  }
+  const reverse = /* @__PURE__ */ new Map();
+  for (const edge of [...previous.edges, ...next.edges]) {
+    const dependency = refKey(edge.to);
+    const dependent = refKey(edge.from);
+    const values = reverse.get(dependency) ?? /* @__PURE__ */ new Set();
+    values.add(dependent);
+    reverse.set(dependency, values);
+  }
+  const refs = /* @__PURE__ */ new Map();
+  for (const node of [...previous.nodes, ...next.nodes]) refs.set(refKey(node), node);
+  const impacts = Array.from(changedKeys).sort().map((changedKey) => {
+    const affected = /* @__PURE__ */ new Set();
+    const queue = [...reverse.get(changedKey) ?? []];
+    while (queue.length) {
+      const current = queue.shift();
+      if (affected.has(current)) continue;
+      affected.add(current);
+      queue.push(...reverse.get(current) ?? []);
+    }
+    return {
+      changedRef: refs.get(changedKey) ?? (() => {
+        const separator = changedKey.indexOf(":");
+        return ref(changedKey.slice(0, separator), changedKey.slice(separator + 1));
+      })(),
+      affectedRefs: Array.from(affected).sort().map((key) => refs.get(key)),
+      reasons: affected.size ? ["dependency"] : ["direct-change"]
+    };
+  });
+  return ChangeImpactGraphSchema.parse({
+    contract: "ChangeImpactGraph",
+    declarationId: next.declaration.declarationId,
+    nodes: Array.from(refs.values()).sort((left, right) => refKey(left).localeCompare(refKey(right))),
+    edges: next.edges,
+    impacts,
+    generatedAt
+  });
+};
+
+// src/runtime/render-tree-compiler.ts
+var compileRenderTree = (input) => {
+  const tree = RenderTreeSchema.parse(input);
+  const nodesById = /* @__PURE__ */ new Map();
+  for (const node of tree.nodes) {
+    if (nodesById.has(node.nodeId)) throw new Error(`Duplicate render node id: ${node.nodeId}`);
+    nodesById.set(node.nodeId, node);
+  }
+  const root = nodesById.get(tree.rootNodeId);
+  if (!root) throw new Error(`Render tree ${tree.treeId} has no root node ${tree.rootNodeId}.`);
+  if (root.parentNodeId !== void 0) throw new Error(`Render tree root ${root.nodeId} cannot declare a parent.`);
+  for (const node of tree.nodes) {
+    if (node.nodeId !== root.nodeId && node.parentNodeId === void 0) {
+      throw new Error(`Render node ${node.nodeId} is disconnected from root ${root.nodeId}.`);
+    }
+    if (node.parentNodeId !== void 0) {
+      const parent = nodesById.get(node.parentNodeId);
+      if (!parent) throw new Error(`Render node ${node.nodeId} references missing parent ${node.parentNodeId}.`);
+      if (!parent.children.includes(node.nodeId)) {
+        throw new Error(`Render node ${node.nodeId} is not declared by parent ${parent.nodeId}.`);
+      }
+    }
+    for (const childId of node.children) {
+      const child = nodesById.get(childId);
+      if (!child) throw new Error(`Render node ${node.nodeId} references missing child ${childId}.`);
+      if (child.parentNodeId !== node.nodeId) {
+        throw new Error(`Render child ${childId} does not point back to parent ${node.nodeId}.`);
+      }
+    }
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const traversal = [];
+  const visit = (node) => {
+    if (visiting.has(node.nodeId)) throw new Error(`Render tree ${tree.treeId} contains a cycle at ${node.nodeId}.`);
+    if (visited.has(node.nodeId)) return;
+    visiting.add(node.nodeId);
+    traversal.push(node);
+    node.children.forEach((childId) => visit(nodesById.get(childId)));
+    visiting.delete(node.nodeId);
+    visited.add(node.nodeId);
+  };
+  visit(root);
+  if (visited.size !== nodesById.size) {
+    const disconnected = tree.nodes.find((node) => !visited.has(node.nodeId));
+    throw new Error(`Render node ${disconnected.nodeId} is not reachable from root ${root.nodeId}.`);
+  }
+  const childrenOf = (nodeId) => {
+    const node = nodesById.get(nodeId);
+    if (!node) throw new Error(`Unknown render node: ${nodeId}`);
+    return Object.freeze(node.children.map((childId) => nodesById.get(childId)));
+  };
+  const ancestorsOf = (nodeId) => {
+    let node = nodesById.get(nodeId);
+    if (!node) throw new Error(`Unknown render node: ${nodeId}`);
+    const ancestors = [];
+    while (node.parentNodeId !== void 0) {
+      node = nodesById.get(node.parentNodeId);
+      ancestors.push(node);
+    }
+    return Object.freeze(ancestors);
+  };
+  return Object.freeze({
+    tree,
+    root,
+    nodesById,
+    traversal: Object.freeze(traversal),
+    childrenOf,
+    ancestorsOf
+  });
+};
+
+// src/runtime/declarative-control-compiler.ts
+var DeclarativeControlCompilationError = class extends Error {
+  constructor(code, path, message) {
+    super(`${code} at ${path}: ${message}`);
+    this.code = code;
+    this.path = path;
+    this.name = "DeclarativeControlCompilationError";
+  }
+};
+var scopedIdentityKey2 = (reference) => `${reference.kind}:${reference.id}:${reference.ownerRepo}`;
+var scopeKey = (scope) => `${scopedIdentityKey2(scope.tenantRef)}:${scopedIdentityKey2(scope.dataSpaceRef)}:${scope.teamRef ? scopedIdentityKey2(scope.teamRef) : ""}`;
+var stableRefKey = (reference) => `${reference.visibility}:${reference.tenantScope ? scopeKey(reference.tenantScope) : ""}:${reference.kind}:${reference.id}:${reference.ownerRepo}`;
+var revisionRefKey = (reference) => `${stableRefKey(reference)}@${reference.revision}:v${reference.schemaVersion}:${reference.contentHash.toLowerCase()}`;
+var sameStableRef = (left, right) => stableRefKey(left) === stableRefKey(right);
+var sameRevisionRef = (left, right) => revisionRefKey(left) === revisionRefKey(right);
+var assertUniqueRegistryKeys = (keys, path) => {
+  const seen = /* @__PURE__ */ new Set();
+  keys.forEach((key, index) => {
+    if (seen.has(key)) {
+      throw new DeclarativeControlCompilationError("REGISTRY_CONFLICT", `${path}[${index}]`, `Duplicate registry identity: ${key}`);
+    }
+    seen.add(key);
+  });
+};
+var stableSerialize = (value) => {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
+  const record = value;
+  return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${stableSerialize(record[key])}`).join(",")}}`;
+};
+var SHA256_INITIAL = [
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+];
+var SHA256_ROUND = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+var rotateRight = (value, amount) => value >>> amount | value << 32 - amount;
+var sha256Hex = (value) => {
+  const source = [...new TextEncoder().encode(value)];
+  const bitLength = source.length * 8;
+  source.push(128);
+  while (source.length % 64 !== 56) source.push(0);
+  const high = Math.floor(bitLength / 4294967296);
+  const low = bitLength >>> 0;
+  for (let shift = 24; shift >= 0; shift -= 8) source.push(high >>> shift & 255);
+  for (let shift = 24; shift >= 0; shift -= 8) source.push(low >>> shift & 255);
+  const hash = [...SHA256_INITIAL];
+  const words = new Array(64).fill(0);
+  for (let offset = 0; offset < source.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const start = offset + index * 4;
+      words[index] = (source[start] << 24 | source[start + 1] << 16 | source[start + 2] << 8 | source[start + 3]) >>> 0;
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const previous = words[index - 15];
+      const recent = words[index - 2];
+      const small0 = rotateRight(previous, 7) ^ rotateRight(previous, 18) ^ previous >>> 3;
+      const small1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ recent >>> 10;
+      words[index] = words[index - 16] + small0 + words[index - 7] + small1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let index = 0; index < 64; index += 1) {
+      const big1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const choice = e & f ^ ~e & g;
+      const temp1 = h + big1 + choice + SHA256_ROUND[index] + words[index] >>> 0;
+      const big0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const majority = a & b ^ a & c ^ b & c;
+      const temp2 = big0 + majority >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    hash[0] = hash[0] + a >>> 0;
+    hash[1] = hash[1] + b >>> 0;
+    hash[2] = hash[2] + c >>> 0;
+    hash[3] = hash[3] + d >>> 0;
+    hash[4] = hash[4] + e >>> 0;
+    hash[5] = hash[5] + f >>> 0;
+    hash[6] = hash[6] + g >>> 0;
+    hash[7] = hash[7] + h >>> 0;
+  }
+  return hash.map((part) => part.toString(16).padStart(8, "0")).join("");
+};
+var canonicalContentHash = (value) => sha256Hex(stableSerialize(value));
+var declarativeCreateTemplateSourceHash = (document) => canonicalContentHash(document);
+var declarativeCreateTemplateRevisionHash = (registration) => canonicalContentHash(registration.document);
+var declarativeRouteSpaceSourceHash = (routeSpace) => canonicalContentHash(routeSpace);
+var declarativeRouteSpaceRevisionHash = (registration) => canonicalContentHash(registration.routeSpace);
+var declarativeProductResourceSourceHash = (document) => canonicalContentHash(document);
+var declarativeProductResourceRevisionHash = (registration) => canonicalContentHash(registration.document);
+var deepFreeze = (value) => {
+  if (value === null || typeof value !== "object" || Object.isFrozen(value)) return value;
+  Object.values(value).forEach((child) => deepFreeze(child));
+  return Object.freeze(value);
+};
+var assertTenantCompatible = (reference, scope, path) => {
+  if (reference.visibility === "tenant" && scopeKey(reference.tenantScope) !== scopeKey(scope)) {
+    throw new DeclarativeControlCompilationError("CROSS_TENANT_REFERENCE", path, `Reference ${reference.kind}/${reference.id} belongs to another tenant scope.`);
+  }
+};
+var assertSameTenantScope = (candidate, expected, path) => {
+  if (scopeKey(candidate) !== scopeKey(expected)) {
+    throw new DeclarativeControlCompilationError("CROSS_TENANT_REFERENCE", path, "Record and release tenant scopes do not match.");
+  }
+};
+var stableFromRevision = (reference) => StableRefSchema.parse({
+  kind: reference.kind,
+  id: reference.id,
+  ownerRepo: reference.ownerRepo,
+  visibility: reference.visibility,
+  ...reference.tenantScope ? { tenantScope: reference.tenantScope } : {}
+});
+var assertRevisionIdentity = (reference, expectedKind, expectedId, scope, path) => {
+  if (reference.kind !== expectedKind || reference.id !== expectedId) {
+    throw new DeclarativeControlCompilationError("REVISION_MISMATCH", path, `Expected ${expectedKind}/${expectedId}, received ${reference.kind}/${reference.id}.`);
+  }
+  assertTenantCompatible(reference, scope, path);
+};
+var dependencyKey = (role, reference) => `${role}:${revisionRefKey(reference)}`;
+var requireDependencies = (snapshot, required) => {
+  const available = new Set(snapshot.map((dependency) => dependencyKey(dependency.role, dependency.revisionRef)));
+  for (const dependency of required) {
+    const key = dependencyKey(dependency.role, dependency.revisionRef);
+    if (!available.has(key)) {
+      throw new DeclarativeControlCompilationError("DEPENDENCY_MISSING", "dependencySnapshot", `Missing exact ${dependency.role} dependency ${revisionRefKey(dependency.revisionRef)}.`);
+    }
+  }
+};
+var assertDependencyScopes = (snapshot, scope) => snapshot.forEach((dependency, index) => assertTenantCompatible(dependency.revisionRef, scope, `dependencySnapshot[${index}].revisionRef`));
+var requireReleaseReady = (release) => {
+  if (release.evidence.validation.result !== "pass") {
+    throw new DeclarativeControlCompilationError("RELEASE_VALIDATION_FAILED", "evidence.validation.result", "Runtime bundles require a passing release validation result.");
+  }
+};
+var refSet = (values) => new Set(values.map(stableRefKey));
+var chainRequiresAll = (policies, field) => {
+  if (field === "permissionAllOf") return new Set(policies.flatMap((policy) => policy.permissionAllOf));
+  if (field === "groupAllOf") return refSet(policies.flatMap((policy) => policy.groupAllOf));
+  return new Set(policies.flatMap((policy) => policy.conditionAllOf.map(revisionRefKey)));
+};
+var chainImpliesAny = (policies, targetAny, allValues, anyValues) => {
+  if (targetAny.size === 0) return true;
+  if ([...allValues].some((value) => targetAny.has(value))) return true;
+  return policies.some((policy) => {
+    const values = anyValues(policy);
+    return values.length > 0 && values.every((value) => targetAny.has(value));
+  });
+};
+var accessPolicyChainImplies = (policyInputs, targetInput) => {
+  const policies = policyInputs.map((policy) => AccessPolicySchema.parse(policy));
+  const target = AccessPolicySchema.parse(targetInput);
+  if (target.authenticated && !policies.some((policy) => policy.authenticated)) return false;
+  const permissionAll = chainRequiresAll(policies, "permissionAllOf");
+  if (target.permissionAllOf.some((permission) => !permissionAll.has(permission))) return false;
+  if (!chainImpliesAny(policies, new Set(target.permissionAnyOf), permissionAll, (policy) => policy.permissionAnyOf)) return false;
+  const groupAll = chainRequiresAll(policies, "groupAllOf");
+  if (target.groupAllOf.some((group) => !groupAll.has(stableRefKey(group)))) return false;
+  if (!chainImpliesAny(
+    policies,
+    refSet(target.groupAnyOf),
+    groupAll,
+    (policy) => policy.groupAnyOf.map(stableRefKey)
+  )) return false;
+  const conditionAll = chainRequiresAll(policies, "conditionAllOf");
+  if (target.conditionAllOf.some((condition) => !conditionAll.has(revisionRefKey(condition)))) return false;
+  return true;
+};
+var normalizePath = (path, routeSpace) => {
+  let normalized = path;
+  if (!routeSpace.caseSensitive) {
+    normalized = normalized.split("/").map((segment) => segment.startsWith(":") ? segment : segment.toLowerCase()).join("/");
+  }
+  if (routeSpace.trailingSlash === "remove" && normalized.length > 1) normalized = normalized.replace(/\/+$/, "");
+  if (routeSpace.trailingSlash === "require" && normalized.length > 1 && !normalized.endsWith("/")) normalized += "/";
+  return normalized;
+};
+var compileRouteClaims = (input) => {
+  const registrations = input.routeSpaces.map((entry, index) => {
+    const revisionRef = RevisionRefSchema.parse(entry.revisionRef);
+    const routeSpace = RouteSpaceSchema.parse(entry.routeSpace);
+    if (revisionRef.kind !== "route-space" || revisionRef.id !== routeSpace.routeSpaceId) {
+      throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `routeSpaces[${index}]`, "RouteSpace registration identity does not match its pinned revision.");
+    }
+    return { revisionRef, routeSpace };
+  });
+  assertUniqueRegistryKeys(registrations.map((entry) => revisionRefKey(entry.revisionRef)), "routeSpaces");
+  const routeSpacesByRevision = new Map(registrations.map((entry) => [revisionRefKey(entry.revisionRef), entry.routeSpace]));
+  const normalizedPaths = /* @__PURE__ */ new Set();
+  const compiled = [];
+  input.claims.forEach((inputClaim, index) => {
+    const parsedClaim = "surface" in inputClaim ? RouteClaimSchema.parse(inputClaim) : LegacyRouteClaimSchema.parse(inputClaim);
+    const routeSpace = routeSpacesByRevision.get(revisionRefKey(parsedClaim.routeSpaceRevisionRef));
+    if (!routeSpace) throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISSING", `routeClaims[${index}].routeSpaceRevisionRef`, "No exact RouteSpace registration exists.");
+    const claim = RouteClaimSchema.parse({
+      ...parsedClaim,
+      surface: "surface" in parsedClaim ? parsedClaim.surface : routeSpace.supportedSurface
+    });
+    if (routeSpace.supportedSurface !== claim.surface) {
+      throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `routeClaims[${index}].surface`, `Route claim surface ${claim.surface} does not match RouteSpace ${routeSpace.routeSpaceId}.`);
+    }
+    if (claim.surface !== input.surface) return;
+    const normalizedPath = normalizePath(claim.pathTemplate, routeSpace);
+    const knownParameters = new Set(routeSpace.parameters.map((parameter) => parameter.name));
+    const pathParameters = [...normalizedPath.matchAll(/:([A-Za-z][A-Za-z0-9_-]*)/g)].map((match) => match[1]);
+    if (new Set(pathParameters).size !== pathParameters.length) {
+      throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `routeClaims[${index}].pathTemplate`, "Route parameters must be unique within a path.");
+    }
+    const unknownParameter = pathParameters.find((parameter) => !knownParameters.has(parameter));
+    if (unknownParameter) {
+      throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `routeClaims[${index}].pathTemplate`, `Route parameter ${unknownParameter} is not declared by ${routeSpace.routeSpaceId}.`);
+    }
+    const reserved = routeSpace.reservedPaths.some((candidate) => {
+      const normalizedReserved = normalizePath(candidate, routeSpace);
+      return normalizedPath === normalizedReserved || normalizedPath.startsWith(`${normalizedReserved}/`);
+    });
+    if (reserved) throw new DeclarativeControlCompilationError("ROUTE_RESERVED", `routeClaims[${index}].pathTemplate`, `Route ${normalizedPath} is reserved by ${routeSpace.routeSpaceId}.`);
+    const routeIdentity = `${revisionRefKey(claim.routeSpaceRevisionRef)}:${normalizedPath}`;
+    if (normalizedPaths.has(routeIdentity)) throw new DeclarativeControlCompilationError("ROUTE_CONFLICT", `routeClaims[${index}].pathTemplate`, `Duplicate normalized route ${normalizedPath}.`);
+    normalizedPaths.add(routeIdentity);
+    compiled.push(CompiledRouteClaimSchema.parse({
+      ...claim,
+      normalizedPath,
+      matcher: {
+        surface: claim.surface,
+        caseSensitive: routeSpace.caseSensitive,
+        trailingSlash: routeSpace.trailingSlash,
+        parameters: routeSpace.parameters
+      }
+    }));
+  });
+  if (!compiled.some((claim) => claim.kind === "canonical")) {
+    throw new DeclarativeControlCompilationError("ROUTE_CONFLICT", "routeClaims", "At least one canonical route claim is required.");
+  }
+  return Object.freeze(compiled);
+};
+var routeParameterPattern = (type) => {
+  if (type === "integer") return /^-?\d+$/;
+  if (type === "uuid") return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  if (type === "slug") return /^[A-Za-z0-9]+(?:[._-][A-Za-z0-9]+)*$/;
+  return /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+};
+var materializeRouteSpacePath = (input) => {
+  const routeSpace = RouteSpaceSchema.parse(input.routeSpace);
+  const applicationPath = RoutePathTemplateSchema.parse(input.applicationPath);
+  const basePath = routeSpace.basePath === "/" ? "" : routeSpace.basePath.replace(/\/+$/, "");
+  let browserTemplate = normalizePath(`${basePath}${applicationPath === "/" ? "/" : applicationPath}` || "/", routeSpace);
+  const parameters = input.parameters || {};
+  const declared = new Map(routeSpace.parameters.map((parameter) => [parameter.name, parameter]));
+  const referenced = [...browserTemplate.matchAll(/:([A-Za-z][A-Za-z0-9_-]*)/g)].map((match) => match[1]);
+  for (const name of referenced) {
+    const definition = declared.get(name);
+    const raw = parameters[name];
+    if (!definition || raw === void 0 || raw === null || String(raw).trim() === "") {
+      throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", "parameters", `Route parameter ${name} is not resolved by ${routeSpace.routeSpaceId}.`);
+    }
+    const value = String(raw);
+    if (!routeParameterPattern(definition.type).test(value)) {
+      throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `parameters.${name}`, `Route parameter ${name} does not satisfy ${definition.type}.`);
+    }
+    browserTemplate = browserTemplate.replace(`:${name}`, encodeURIComponent(value));
+  }
+  const unknown = Object.keys(parameters).find((name) => !declared.has(name));
+  if (unknown) throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `parameters.${unknown}`, `RouteSpace ${routeSpace.routeSpaceId} does not declare ${unknown}.`);
+  return browserTemplate;
+};
+var renderTreeDepth = (tree) => {
+  const byId = new Map(tree.nodes.map((node) => [node.nodeId, node]));
+  let maximum = 0;
+  tree.nodes.forEach((node) => {
+    let depth = 1;
+    let parentId = node.parentNodeId;
+    while (parentId) {
+      depth += 1;
+      parentId = byId.get(parentId)?.parentNodeId;
+    }
+    maximum = Math.max(maximum, depth);
+  });
+  return maximum;
+};
+var compareLegacyEntityRef = (reference, revision) => reference.kind === revision.kind && reference.id === revision.id && String(reference.version) === String(revision.revision) && reference.ownerRepo === revision.ownerRepo;
+var pageDependencies = (page, compilerRevisionRef) => [
+  ...page.routeClaims.map((claim) => ({ role: "route-space", revisionRef: claim.routeSpaceRevisionRef })),
+  { role: "shell", revisionRef: page.shellRevisionRef },
+  ...page.capabilityInstances.flatMap((instance) => [
+    { role: "capability", revisionRef: instance.capabilityRevisionRef },
+    { role: "provider", revisionRef: instance.providerRevisionRef },
+    { role: "schema", revisionRef: instance.propertySchemaRevisionRef }
+  ]),
+  ...page.ontologyBindings.flatMap((binding) => [
+    { role: "ontology-definition", revisionRef: binding.ontologyDefinitionRevisionRef },
+    ...binding.viewRevisionRef ? [{ role: "view", revisionRef: binding.viewRevisionRef }] : [],
+    ...binding.projectionRevisionRef ? [{ role: "projection", revisionRef: binding.projectionRevisionRef }] : [],
+    { role: "schema", revisionRef: binding.renderModelSchemaRevisionRef }
+  ]),
+  ...page.actionBindings.flatMap((binding) => [
+    { role: "action", revisionRef: binding.commandRevisionRef },
+    { role: "schema", revisionRef: binding.sourceIntentSchemaRevisionRef },
+    { role: "schema", revisionRef: binding.inputSchemaRevisionRef },
+    { role: "schema", revisionRef: binding.resultSchemaRevisionRef },
+    ...binding.compensationCommandRevisionRef ? [{ role: "action", revisionRef: binding.compensationCommandRevisionRef }] : []
+  ]),
+  ...page.tokenRevisionRefs.map((revisionRef) => ({ role: "token", revisionRef })),
+  { role: "performance-budget", revisionRef: page.performanceBudgetRef },
+  { role: "observation-policy", revisionRef: page.observationPolicyRevisionRef },
+  { role: "compiler", revisionRef: compilerRevisionRef }
+];
+var compilePageRuntimeBundle = (input) => {
+  const page = PageSchema.parse(input.page);
+  const pageRevisionRef = RevisionRefSchema.parse(input.pageRevisionRef);
+  const release = PageReleaseSchema.parse(input.release);
+  const releaseRevisionRef = RevisionRefSchema.parse(input.releaseRevisionRef);
+  const compilerRevisionRef = RevisionRefSchema.parse(input.compilerRevisionRef);
+  const scope = TenantScopeSchema.parse(page.tenantScope);
+  assertSameTenantScope(release.tenantScope, scope, "release.tenantScope");
+  assertRevisionIdentity(pageRevisionRef, "page", page.pageId, scope, "pageRevisionRef");
+  assertRevisionIdentity(release.pageRevisionRef, "page", page.pageId, scope, "release.pageRevisionRef");
+  if (!sameRevisionRef(pageRevisionRef, release.pageRevisionRef)) throw new DeclarativeControlCompilationError("REVISION_MISMATCH", "release.pageRevisionRef", "Release does not pin the supplied Page revision.");
+  assertRevisionIdentity(releaseRevisionRef, "page-release", release.releaseSlotId, scope, "releaseRevisionRef");
+  requireReleaseReady(release);
+  requireDependencies(release.dependencySnapshot, pageDependencies(page, compilerRevisionRef));
+  assertDependencyScopes(release.dependencySnapshot, scope);
+  if (page.renderTree.nodes.length > input.limits.maxRenderNodes) throw new DeclarativeControlCompilationError("RENDER_NODE_LIMIT_EXCEEDED", "page.renderTree.nodes", "RenderTree exceeds the caller-approved node limit.");
+  if (renderTreeDepth(page.renderTree) > input.limits.maxRenderDepth) throw new DeclarativeControlCompilationError("RENDER_DEPTH_EXCEEDED", "page.renderTree.nodes", "RenderTree exceeds the caller-approved depth limit.");
+  const renderTree = compileRenderTree(page.renderTree).tree;
+  const instancesByNode = new Map(page.capabilityInstances.map((instance) => [instance.nodeId, instance]));
+  const registrations = input.capabilityRegistry.map((registration, registrationIndex) => ({
+    ...registration,
+    capabilityRevisionRef: RevisionRefSchema.parse(registration.capabilityRevisionRef),
+    providerRevisionRef: RevisionRefSchema.parse(registration.providerRevisionRef),
+    inputPorts: registration.inputPorts.map((port, portIndex) => {
+      const schemaRevisionRef = RevisionRefSchema.parse(port.schemaRevisionRef);
+      if (schemaRevisionRef.kind !== "schema") {
+        throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `capabilityRegistry[${registrationIndex}].inputPorts[${portIndex}].schemaRevisionRef`, "Capability ports must pin schema revisions.");
+      }
+      return { ...port, schemaRevisionRef };
+    }),
+    outputPorts: registration.outputPorts.map((port, portIndex) => {
+      const schemaRevisionRef = RevisionRefSchema.parse(port.schemaRevisionRef);
+      if (schemaRevisionRef.kind !== "schema") {
+        throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `capabilityRegistry[${registrationIndex}].outputPorts[${portIndex}].schemaRevisionRef`, "Capability ports must pin schema revisions.");
+      }
+      return { ...port, schemaRevisionRef };
+    })
+  }));
+  assertUniqueRegistryKeys(registrations.map((registration) => `${revisionRefKey(registration.capabilityRevisionRef)}:${revisionRefKey(registration.providerRevisionRef)}`), "capabilityRegistry");
+  const registrationsByPair = new Map(registrations.map((registration) => [
+    `${revisionRefKey(registration.capabilityRevisionRef)}:${revisionRefKey(registration.providerRevisionRef)}`,
+    registration
+  ]));
+  page.capabilityInstances.forEach((instance, index) => {
+    const node = renderTree.nodes.find((candidate) => candidate.nodeId === instance.nodeId);
+    if (!node || !compareLegacyEntityRef(node.capabilityRef, instance.capabilityRevisionRef) || !node.providerRef || !compareLegacyEntityRef(node.providerRef, instance.providerRevisionRef) || node.pageRef.id !== page.pageId) {
+      throw new DeclarativeControlCompilationError("CAPABILITY_BINDING_MISMATCH", `capabilityInstances[${index}]`, "RenderTree node identity does not match the declared capability/provider instance.");
+    }
+    const registration = registrationsByPair.get(`${revisionRefKey(instance.capabilityRevisionRef)}:${revisionRefKey(instance.providerRevisionRef)}`);
+    if (!registration?.editorEligible) {
+      throw new DeclarativeControlCompilationError("CAPABILITY_NOT_EDITOR_ELIGIBLE", `capabilityInstances[${index}]`, "Capability/provider pair is not editor-eligible.");
+    }
+    if (instance.allowedSideEffects.some((sideEffect) => !registration.allowedSideEffects.includes(sideEffect))) {
+      throw new DeclarativeControlCompilationError("CAPABILITY_BINDING_MISMATCH", `capabilityInstances[${index}].allowedSideEffects`, "Page requests undeclared provider side effects.");
+    }
+  });
+  page.ontologyBindings.forEach((binding, index) => {
+    const instance = page.capabilityInstances.find((candidate) => candidate.instanceId === binding.target.capabilityInstanceId);
+    const registration = instance && registrationsByPair.get(`${revisionRefKey(instance.capabilityRevisionRef)}:${revisionRefKey(instance.providerRevisionRef)}`);
+    const port = registration?.inputPorts.find((candidate) => candidate.name === binding.target.port);
+    if (!port || !sameRevisionRef(port.schemaRevisionRef, binding.renderModelSchemaRevisionRef)) {
+      throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `ontologyBindings[${index}].target.port`, "Ontology render model does not match the registered capability input port.");
+    }
+  });
+  page.actionBindings.forEach((binding, index) => {
+    const instance = page.capabilityInstances.find((candidate) => candidate.instanceId === binding.source.capabilityInstanceId);
+    const registration = instance && registrationsByPair.get(`${revisionRefKey(instance.capabilityRevisionRef)}:${revisionRefKey(instance.providerRevisionRef)}`);
+    const port = registration?.outputPorts.find((candidate) => candidate.name === binding.source.port);
+    if (!port || !sameRevisionRef(port.schemaRevisionRef, binding.sourceIntentSchemaRevisionRef)) {
+      throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `actionBindings[${index}].sourceIntentSchemaRevisionRef`, "Action source intent does not match the registered capability output port.");
+    }
+  });
+  const routeClaims = compileRouteClaims({ claims: page.routeClaims, routeSpaces: input.routeSpaces, surface: release.target.surface });
+  const releaseRoute = routeClaims.find((claim) => claim.kind === "canonical" && claim.normalizedPath === release.target.normalizedPath);
+  if (!releaseRoute || !sameRevisionRef(releaseRoute.routeSpaceRevisionRef, release.target.routeSpaceRevisionRef)) {
+    throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", "release.target", "Release target does not match a canonical Page route claim.");
+  }
+  if (!page.supportedSurfaces.includes(release.target.surface)) {
+    throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", "release.target.surface", "Page does not support the release surface.");
+  }
+  const unsigned = {
+    contract: "PageRuntimeBundle",
+    schemaVersion: 1,
+    tenantScope: scope,
+    releaseRevisionRef,
+    compilerRevisionRef,
+    generation: input.generation,
+    dependencySnapshot: release.dependencySnapshot,
+    rebuildable: true,
+    diagnostics: [],
+    pageId: page.pageId,
+    pageRevisionRef,
+    surface: release.target.surface,
+    routeClaims,
+    shellRevisionRef: page.shellRevisionRef,
+    renderTree,
+    capabilityInstances: page.capabilityInstances,
+    ontologyBindings: page.ontologyBindings,
+    actionBindings: page.actionBindings,
+    pageAccessPolicy: page.pageAccessPolicy,
+    tokenRevisionRefs: page.tokenRevisionRefs,
+    performanceBudgetRef: page.performanceBudgetRef,
+    observationPolicyRevisionRef: page.observationPolicyRevisionRef,
+    privacyClassification: page.privacyClassification
+  };
+  return deepFreeze(PageRuntimeBundleSchema.parse({ ...unsigned, contentHash: canonicalContentHash(unsigned) }));
+};
+var workbenchDependencyRole = (kind) => {
+  switch (kind) {
+    case "workflow":
+      return "workflow";
+    case "agent":
+      return "agent";
+    case "capability":
+      return "capability";
+    case "design":
+      return "design";
+    case "built-in-application":
+      return "built-in-application";
+    default:
+      return "workflow";
+  }
+};
+var workbenchDependencies = (workbench, compilerRevisionRef) => [
+  ...workbench.routeClaims.map((claim) => ({ role: "route-space", revisionRef: claim.routeSpaceRevisionRef })),
+  ...workbench.appInstances.flatMap((instance) => [
+    { role: workbenchDependencyRole(instance.targetRevisionRef.kind), revisionRef: instance.targetRevisionRef },
+    { role: "provider", revisionRef: instance.providerRevisionRef },
+    { role: "schema", revisionRef: instance.inputSchemaRevisionRef }
+  ]),
+  { role: "capability", revisionRef: workbench.layout.hostCapabilityRevisionRef },
+  { role: "provider", revisionRef: workbench.layout.hostProviderRevisionRef },
+  { role: "layout-policy", revisionRef: workbench.layout.layoutPolicyRevisionRef },
+  ...workbench.layout.tokenRevisionRefs.map((revisionRef) => ({ role: "token", revisionRef })),
+  { role: "performance-budget", revisionRef: workbench.performanceBudgetRef },
+  { role: "observation-policy", revisionRef: workbench.observationPolicyRevisionRef },
+  { role: "compiler", revisionRef: compilerRevisionRef }
+];
+var compileWorkbenchRuntimeBundle = (input) => {
+  const workbench = WorkbenchSchema.parse(input.workbench);
+  const workbenchRevisionRef = RevisionRefSchema.parse(input.workbenchRevisionRef);
+  const release = WorkbenchReleaseSchema.parse(input.release);
+  const releaseRevisionRef = RevisionRefSchema.parse(input.releaseRevisionRef);
+  const compilerRevisionRef = RevisionRefSchema.parse(input.compilerRevisionRef);
+  const scope = TenantScopeSchema.parse(workbench.tenantScope);
+  assertSameTenantScope(release.tenantScope, scope, "release.tenantScope");
+  if (workbench.purpose === "template") throw new DeclarativeControlCompilationError("WORKBENCH_TEMPLATE_UNRELEASABLE", "workbench.purpose", "Workbench templates cannot be activated.");
+  if (workbench.groups.length > input.limits.maxWorkbenchGroups || workbench.appInstances.length > input.limits.maxWorkbenchInstances) {
+    throw new DeclarativeControlCompilationError("WORKBENCH_INSTANCE_LIMIT_EXCEEDED", "workbench", "Workbench exceeds caller-approved compilation limits.");
+  }
+  assertRevisionIdentity(workbenchRevisionRef, "workbench", workbench.workbenchId, scope, "workbenchRevisionRef");
+  assertRevisionIdentity(release.workbenchRevisionRef, "workbench", workbench.workbenchId, scope, "release.workbenchRevisionRef");
+  if (!sameRevisionRef(workbenchRevisionRef, release.workbenchRevisionRef)) throw new DeclarativeControlCompilationError("REVISION_MISMATCH", "release.workbenchRevisionRef", "Release does not pin the supplied Workbench revision.");
+  assertRevisionIdentity(releaseRevisionRef, "workbench-release", release.releaseSlotId, scope, "releaseRevisionRef");
+  if (release.target.workbenchId !== workbench.workbenchId) throw new DeclarativeControlCompilationError("REVISION_MISMATCH", "release.target.workbenchId", "Release target does not match Workbench identity.");
+  requireReleaseReady(release);
+  requireDependencies(release.dependencySnapshot, workbenchDependencies(workbench, compilerRevisionRef));
+  assertDependencyScopes(release.dependencySnapshot, scope);
+  const routeClaims = compileRouteClaims({ claims: workbench.routeClaims, routeSpaces: input.routeSpaces, surface: release.target.surface });
+  const releaseRoute = routeClaims.find((claim) => claim.kind === "canonical" && claim.normalizedPath === release.target.normalizedPath);
+  if (!releaseRoute || !sameRevisionRef(releaseRoute.routeSpaceRevisionRef, release.target.routeSpaceRevisionRef)) {
+    throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", "release.target", "Release target does not match a canonical Workbench route claim.");
+  }
+  const targetRegistry = input.targetRegistry.map((registration) => ({
+    stableTargetRef: StableRefSchema.parse(registration.stableTargetRef),
+    targetRevisionRef: RevisionRefSchema.parse(registration.targetRevisionRef),
+    accessPolicy: AccessPolicySchema.parse(registration.accessPolicy)
+  }));
+  assertUniqueRegistryKeys(targetRegistry.map((registration) => stableRefKey(registration.stableTargetRef)), "targetRegistry");
+  const targetsByStableRef = new Map(targetRegistry.map((registration) => [stableRefKey(registration.stableTargetRef), registration]));
+  const groupsById = new Map(workbench.groups.map((group) => [group.groupId, group]));
+  const appInstances = workbench.appInstances.map((instance, index) => {
+    const stableTarget = StableRefSchema.parse({
+      kind: instance.targetRevisionRef.kind,
+      id: instance.targetRevisionRef.id,
+      ownerRepo: instance.targetRevisionRef.ownerRepo,
+      visibility: instance.targetRevisionRef.visibility,
+      ...instance.targetRevisionRef.tenantScope ? { tenantScope: instance.targetRevisionRef.tenantScope } : {}
+    });
+    const registration = targetsByStableRef.get(stableRefKey(stableTarget));
+    if (!registration || !sameStableRef(registration.stableTargetRef, stableFromRevision(registration.targetRevisionRef)) || !sameRevisionRef(registration.targetRevisionRef, instance.targetRevisionRef)) {
+      throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `appInstances[${index}].targetRevisionRef`, "Workbench app target is not present at the exact registered revision.");
+    }
+    assertTenantCompatible(instance.targetRevisionRef, scope, `appInstances[${index}].targetRevisionRef`);
+    const group = groupsById.get(instance.groupId);
+    const chain = [workbench.workbenchAccessPolicy, ...group?.accessPolicy ? [group.accessPolicy] : [], instance.accessPolicy];
+    if (!accessPolicyChainImplies(chain, registration.accessPolicy)) {
+      throw new DeclarativeControlCompilationError("AUDIENCE_WIDER_THAN_TARGET", `appInstances[${index}].accessPolicy`, "Workbench and instance audience is wider than the target audience.");
+    }
+    return { ...instance, targetAccessPolicy: registration.accessPolicy };
+  });
+  const unsigned = {
+    contract: "WorkbenchRuntimeBundle",
+    schemaVersion: 1,
+    tenantScope: scope,
+    releaseRevisionRef,
+    compilerRevisionRef,
+    generation: input.generation,
+    dependencySnapshot: release.dependencySnapshot,
+    rebuildable: true,
+    diagnostics: [],
+    workbenchId: workbench.workbenchId,
+    workbenchRevisionRef,
+    surface: release.target.surface,
+    routeClaims,
+    groups: workbench.groups,
+    appInstances,
+    defaultEntry: workbench.defaultEntry,
+    layout: workbench.layout,
+    workbenchAccessPolicy: workbench.workbenchAccessPolicy,
+    personalPreferencesPolicy: workbench.personalPreferencesPolicy,
+    target: { ...release.target, routeClaim: releaseRoute },
+    performanceBudgetRef: workbench.performanceBudgetRef,
+    observationPolicyRevisionRef: workbench.observationPolicyRevisionRef,
+    privacyClassification: workbench.privacyClassification
+  };
+  return deepFreeze(WorkbenchRuntimeBundleSchema.parse({ ...unsigned, contentHash: canonicalContentHash(unsigned) }));
+};
+var navigationDepth = (navigation) => {
+  const byId = new Map(navigation.nodes.map((node) => [node.nodeId, node]));
+  let maximum = 0;
+  navigation.nodes.forEach((node) => {
+    let depth = 1;
+    let parentId = node.parentNodeId;
+    while (parentId) {
+      depth += 1;
+      parentId = byId.get(parentId)?.parentNodeId ?? null;
+    }
+    maximum = Math.max(maximum, depth);
+  });
+  return maximum;
+};
+var orderedNavigationNodes = (navigation) => {
+  const children = /* @__PURE__ */ new Map();
+  navigation.nodes.forEach((node) => {
+    const parent = node.parentNodeId ?? "";
+    const siblings = children.get(parent) ?? [];
+    children.set(parent, [...siblings, node]);
+  });
+  children.forEach((siblings) => siblings.sort((left, right) => left.order - right.order || left.nodeId.localeCompare(right.nodeId)));
+  const ordered = [];
+  const append = (parentId) => {
+    for (const node of children.get(parentId) ?? []) {
+      ordered.push(node);
+      append(node.nodeId);
+    }
+  };
+  append("");
+  return ordered;
+};
+var navigationDependencies = (navigation, release, compilerRevisionRef) => [
+  ...release.resolvedTargets.flatMap((target) => [
+    { role: target.targetRevisionRef.kind === "domain-command" ? "action" : target.targetRevisionRef.kind, revisionRef: target.targetRevisionRef },
+    ...target.releaseRevisionRef ? [{ role: target.releaseRevisionRef.kind, revisionRef: target.releaseRevisionRef }] : []
+  ]),
+  { role: "performance-budget", revisionRef: navigation.performanceBudgetRef },
+  { role: "observation-policy", revisionRef: navigation.observationPolicyRevisionRef },
+  { role: "compiler", revisionRef: compilerRevisionRef }
+];
+var compileNavigationRuntimeBundle = (input) => {
+  const navigation = NavigationSchema.parse(input.navigation);
+  const navigationRevisionRef = RevisionRefSchema.parse(input.navigationRevisionRef);
+  const release = NavigationReleaseSchema.parse(input.release);
+  const releaseRevisionRef = RevisionRefSchema.parse(input.releaseRevisionRef);
+  const compilerRevisionRef = RevisionRefSchema.parse(input.compilerRevisionRef);
+  const scope = TenantScopeSchema.parse(navigation.tenantScope);
+  assertSameTenantScope(release.tenantScope, scope, "release.tenantScope");
+  if (navigation.nodes.length > input.limits.maxNavigationNodes) throw new DeclarativeControlCompilationError("NAV_NODE_LIMIT_EXCEEDED", "navigation.nodes", "Navigation exceeds the caller-approved node limit.");
+  if (navigationDepth(navigation) > input.limits.maxNavigationDepth) throw new DeclarativeControlCompilationError("NAV_DEPTH_EXCEEDED", "navigation.nodes", "Navigation exceeds the caller-approved depth limit.");
+  assertRevisionIdentity(navigationRevisionRef, "navigation", navigation.navigationId, scope, "navigationRevisionRef");
+  assertRevisionIdentity(release.navigationRevisionRef, "navigation", navigation.navigationId, scope, "release.navigationRevisionRef");
+  if (!sameRevisionRef(navigationRevisionRef, release.navigationRevisionRef)) throw new DeclarativeControlCompilationError("REVISION_MISMATCH", "release.navigationRevisionRef", "Release does not pin the supplied Navigation revision.");
+  assertRevisionIdentity(releaseRevisionRef, "navigation-release", release.releaseSlotId, scope, "releaseRevisionRef");
+  if (release.target.surface !== navigation.supportedSurfaces.find((surface) => surface === release.target.surface) || !navigation.placements.includes(release.target.placement)) {
+    throw new DeclarativeControlCompilationError("REVISION_MISMATCH", "release.target", "Navigation release target is not declared by the Navigation record.");
+  }
+  requireReleaseReady(release);
+  requireDependencies(release.dependencySnapshot, navigationDependencies(navigation, release, compilerRevisionRef));
+  assertDependencyScopes(release.dependencySnapshot, scope);
+  const targetRegistry = input.targetRegistry.map((registration, index) => {
+    const common = {
+      stableTargetRef: StableRefSchema.parse(registration.stableTargetRef),
+      targetRevisionRef: RevisionRefSchema.parse(registration.targetRevisionRef),
+      surface: ProductSurfaceSchema.parse(registration.surface),
+      accessPolicy: AccessPolicySchema.parse(registration.accessPolicy)
+    };
+    if (registration.kind === "route") {
+      const routeClaim = CompiledRouteClaimSchema.parse(registration.routeClaim);
+      if (routeClaim.surface !== common.surface) {
+        throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `targetRegistry[${index}].routeClaim.surface`, "Navigation route claim must match its registered surface.");
+      }
+      return {
+        ...common,
+        kind: "route",
+        releaseRevisionRef: registration.releaseRevisionRef ? RevisionRefSchema.parse(registration.releaseRevisionRef) : void 0,
+        routeClaim
+      };
+    }
+    if (registration.kind === "registered-menu-action") {
+      const sourceCatalogRevisionRef = RevisionRefSchema.parse(registration.sourceCatalogRevisionRef);
+      if (sourceCatalogRevisionRef.kind !== "application-menu-catalog" || registration.targetRevisionRef.kind !== "menu-action") {
+        throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", "targetRegistry", "Registered Menu Actions require exact menu-action and application-menu-catalog revisions.");
+      }
+      if (registration.inputSchemaRef && !registration.validateInput) {
+        throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", "targetRegistry", "Registered Menu Actions with input schemas require the active catalog validator.");
+      }
+      return { ...common, kind: "registered-menu-action", applicationId: registration.applicationId, actionRef: registration.actionRef, inputSchemaRef: registration.inputSchemaRef, validateInput: registration.validateInput, sourceCatalogRevisionRef };
+    }
+    if (registration.targetRevisionRef.kind !== "domain-command") {
+      throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", "targetRegistry", "Governed DomainCommand actions require an exact domain-command revision.");
     }
-    for (const capabilityId of concept.capabilityIds) {
-      if (!capabilitiesById.has(capabilityId)) throw new Error(`Concept ${concept.conceptId} references unknown capability ${capabilityId}.`);
-      addEdge(ref("concept", concept.conceptId), ref("capability", capabilityId), "uses-capability");
+    const inputSchemaRevisionRef = RevisionRefSchema.parse(registration.inputSchemaRevisionRef);
+    const resultSchemaRevisionRef = registration.resultSchemaRevisionRef ? RevisionRefSchema.parse(registration.resultSchemaRevisionRef) : void 0;
+    if (inputSchemaRevisionRef.kind !== "schema" || resultSchemaRevisionRef && resultSchemaRevisionRef.kind !== "schema") {
+      throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", "targetRegistry", "Governed DomainCommand actions require exact input and output Schema revisions.");
     }
-    for (const commandName of concept.commandNames) {
-      if (!commandsByName.has(commandName)) throw new Error(`Concept ${concept.conceptId} references unknown command ${commandName}.`);
-      addEdge(ref("concept", concept.conceptId), ref("command", commandName), "uses-command");
+    return { ...common, kind: "governed-domain-command", inputSchemaRevisionRef, resultSchemaRevisionRef };
+  });
+  assertUniqueRegistryKeys(targetRegistry.map((registration) => stableRefKey(registration.stableTargetRef)), "targetRegistry");
+  const targetsByStableRef = new Map(targetRegistry.map((registration) => [stableRefKey(registration.stableTargetRef), registration]));
+  const releasedByNodeId = new Map(release.resolvedTargets.map((target) => [target.nodeId, target]));
+  const nodesById = new Map(navigation.nodes.map((node) => [node.nodeId, node]));
+  const nodes = orderedNavigationNodes(navigation).map((node, index) => {
+    const ancestors = [];
+    let parentId = node.parentNodeId;
+    while (parentId) {
+      const parent = nodesById.get(parentId);
+      if (parent?.kind === "group") ancestors.unshift(parent.audience);
+      parentId = parent?.parentNodeId ?? null;
     }
-    for (const relationship of concept.relationships) {
-      if (!conceptsById.has(relationship.targetConceptId)) {
-        throw new Error(`Concept ${concept.conceptId} references unknown concept ${relationship.targetConceptId}.`);
-      }
-      addEdge(ref("concept", concept.conceptId), ref("concept", relationship.targetConceptId), "relates-to-concept");
+    if (node.kind !== "target") return { ...node, ancestorAccessPolicies: ancestors };
+    if (!["page", "workbench", "menu-action", "domain-command"].includes(node.targetRef.kind)) {
+      throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `nodes[${index}].targetRef.kind`, "Navigation targets may reference only Page, Workbench, registered Menu Action, or DomainCommand identities.");
     }
-  }
-  for (const page of declaration.pages) {
-    addNode("page", page.pageId);
-    if (page.binding.ontologyId) {
-      if (!ontologiesById.has(page.binding.ontologyId)) throw new Error(`Page ${page.pageId} references unknown ontology ${page.binding.ontologyId}.`);
-      addEdge(ref("page", page.pageId), ref("ontology", page.binding.ontologyId), "uses-ontology");
+    const registration = targetsByStableRef.get(stableRefKey(node.targetRef));
+    const released = releasedByNodeId.get(node.nodeId);
+    if (!registration || !released || !sameStableRef(registration.stableTargetRef, stableFromRevision(registration.targetRevisionRef)) || !sameStableRef(registration.stableTargetRef, released.stableTargetRef) || !sameRevisionRef(registration.targetRevisionRef, released.targetRevisionRef) || registration.kind === "route" && (Boolean(registration.releaseRevisionRef) !== Boolean(released.releaseRevisionRef) || registration.releaseRevisionRef && released.releaseRevisionRef && !sameRevisionRef(registration.releaseRevisionRef, released.releaseRevisionRef))) {
+      throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `nodes[${index}].targetRef`, "Navigation target is not resolved to the exact active release recorded by NavigationRelease.");
     }
-    if (page.binding.projectionRef) {
-      if (!projectionsById.has(page.binding.projectionRef)) throw new Error(`Page ${page.pageId} references unknown projection ${page.binding.projectionRef}.`);
-      addEdge(ref("page", page.pageId), ref("projection", page.binding.projectionRef), "uses-projection");
+    if (registration.surface !== release.target.surface) {
+      throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `nodes[${index}].targetRef`, "Navigation target is active on another surface.");
     }
-    for (const capabilityRef of [page.capabilityRef, ...page.capabilityRefs].filter(Boolean)) {
-      if (!capabilitiesById.has(capabilityRef.id)) throw new Error(`Page ${page.pageId} references unknown capability ${capabilityRef.id}.`);
-      addEdge(ref("page", page.pageId), ref("capability", capabilityRef.id), "uses-capability");
+    assertTenantCompatible(registration.targetRevisionRef, scope, `nodes[${index}].targetRef`);
+    if (!accessPolicyChainImplies([...ancestors, node.audience], registration.accessPolicy)) {
+      throw new DeclarativeControlCompilationError("AUDIENCE_WIDER_THAN_TARGET", `nodes[${index}].audience`, "Effective Navigation audience is wider than the target audience.");
     }
-  }
-  uniqueIndex(nodes, refKey, "declaration node");
-  return Object.freeze({
-    declaration: Object.freeze(declaration),
-    conceptsById,
-    ontologiesById,
-    projectionsById,
-    commandsByName,
-    capabilitiesById,
-    pagesById,
-    menusByKey,
-    nodes: Object.freeze(nodes),
-    edges: Object.freeze(edges)
-  });
-};
-var validateDomainCommand = (input, definitions, permissionCodes) => {
-  const command = DomainCommandSchema.parse(input);
-  const commandsByName = uniqueIndex(
-    definitions.map((definition2) => DomainCommandDefinitionSchema.parse(definition2)),
-    (definition2) => definition2.commandName,
-    "command name"
-  );
-  const definition = commandsByName.get(command.commandName);
-  if (!definition) throw new Error(`Unknown domain command: ${command.commandName}`);
-  if (!definition.targetKinds.includes(command.targetRef.kind)) {
-    throw new Error(`Command ${command.commandName} does not accept target kind ${command.targetRef.kind}.`);
-  }
-  const granted = new Set(permissionCodes);
-  const missing = definition.requiredPermissionCodes.filter((permission) => !granted.has(permission));
-  if (missing.length) throw new Error(`Command ${command.commandName} requires permissions: ${missing.join(", ")}`);
-  return Object.freeze(command);
-};
-var declarationValuesByRef = (compiled) => {
-  const values = /* @__PURE__ */ new Map();
-  for (const value of compiled.declaration.ontologies) values.set(refKey(ref("ontology", value.ontologyId)), value);
-  for (const value of compiled.declaration.projections) values.set(refKey(ref("projection", value.projectionId)), value);
-  for (const value of compiled.declaration.commands) values.set(refKey(ref("command", value.commandName)), value);
-  for (const value of compiled.declaration.capabilities) values.set(refKey(ref("capability", value.id)), value);
-  for (const value of compiled.declaration.concepts) values.set(refKey(ref("concept", value.conceptId)), value);
-  for (const value of compiled.declaration.pages) values.set(refKey(ref("page", value.pageId)), value);
-  return values;
-};
-var buildChangeImpactGraph = (previousInput, nextInput, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) => {
-  const previous = compileProductDeclaration(previousInput);
-  const next = compileProductDeclaration(nextInput);
-  const previousValues = declarationValuesByRef(previous);
-  const nextValues = declarationValuesByRef(next);
-  const changedKeys = /* @__PURE__ */ new Set();
-  for (const key of /* @__PURE__ */ new Set([...previousValues.keys(), ...nextValues.keys()])) {
-    if (JSON.stringify(previousValues.get(key)) !== JSON.stringify(nextValues.get(key))) changedKeys.add(key);
-  }
-  const reverse = /* @__PURE__ */ new Map();
-  for (const edge of [...previous.edges, ...next.edges]) {
-    const dependency = refKey(edge.to);
-    const dependent = refKey(edge.from);
-    const values = reverse.get(dependency) ?? /* @__PURE__ */ new Set();
-    values.add(dependent);
-    reverse.set(dependency, values);
-  }
-  const refs = /* @__PURE__ */ new Map();
-  for (const node of [...previous.nodes, ...next.nodes]) refs.set(refKey(node), node);
-  const impacts = Array.from(changedKeys).sort().map((changedKey) => {
-    const affected = /* @__PURE__ */ new Set();
-    const queue = [...reverse.get(changedKey) ?? []];
-    while (queue.length) {
-      const current = queue.shift();
-      if (affected.has(current)) continue;
-      affected.add(current);
-      queue.push(...reverse.get(current) ?? []);
+    const mappedInput = Object.fromEntries(Object.entries(node.parameterMapping).map(([name, source]) => {
+      if (source.kind !== "constant") {
+        throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `nodes[${index}].parameterMapping.${name}`, "Navigation actions accept only publication-time constant input.");
+      }
+      return [name, source.value];
+    }));
+    let resolvedTarget;
+    if (registration.kind === "route") {
+      resolvedTarget = { ...released, kind: "route", accessPolicy: registration.accessPolicy, routeClaim: registration.routeClaim };
+    } else if (registration.kind === "registered-menu-action") {
+      if (!registration.inputSchemaRef && Object.keys(mappedInput).length > 0) {
+        throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `nodes[${index}].parameterMapping`, "The registered Menu Action does not accept input.");
+      }
+      let input2;
+      try {
+        input2 = JsonObjectSchema.parse(registration.validateInput ? registration.validateInput(mappedInput) : mappedInput);
+      } catch (error) {
+        throw new DeclarativeControlCompilationError(
+          "NAV_ACTION_INPUT_INVALID",
+          `nodes[${index}].parameterMapping`,
+          `Registered Menu Action input failed its active catalog schema: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      const sourceDependency = release.dependencySnapshot.find((dependency) => dependency.role === "application-menu-catalog" && sameRevisionRef(dependency.revisionRef, registration.sourceCatalogRevisionRef));
+      if (!sourceDependency) throw new DeclarativeControlCompilationError("DEPENDENCY_MISSING", `nodes[${index}].targetRef`, "Registered Menu Action source catalog is not pinned by NavigationRelease.");
+      resolvedTarget = {
+        ...released,
+        kind: "registered-menu-action",
+        accessPolicy: registration.accessPolicy,
+        execution: "client",
+        applicationId: registration.applicationId,
+        actionRef: registration.actionRef,
+        ...registration.inputSchemaRef ? { inputSchemaRef: registration.inputSchemaRef } : {},
+        input: input2,
+        sourceCatalogRevisionRef: registration.sourceCatalogRevisionRef
+      };
+    } else {
+      const inputDependency = release.dependencySnapshot.find(
+        (dependency) => dependency.role === "schema" && sameRevisionRef(dependency.revisionRef, registration.inputSchemaRevisionRef)
+      );
+      const resultDependency = registration.resultSchemaRevisionRef ? release.dependencySnapshot.find(
+        (dependency) => dependency.role === "schema" && sameRevisionRef(dependency.revisionRef, registration.resultSchemaRevisionRef)
+      ) : void 0;
+      if (!inputDependency || registration.resultSchemaRevisionRef && !resultDependency) {
+        throw new DeclarativeControlCompilationError("DEPENDENCY_MISSING", `nodes[${index}].targetRef`, "Governed DomainCommand schemas are not pinned by NavigationRelease.");
+      }
+      resolvedTarget = {
+        ...released,
+        kind: "governed-domain-command",
+        accessPolicy: registration.accessPolicy,
+        execution: "server",
+        commandRevisionRef: registration.targetRevisionRef,
+        inputSchemaRevisionRef: registration.inputSchemaRevisionRef,
+        ...registration.resultSchemaRevisionRef ? { resultSchemaRevisionRef: registration.resultSchemaRevisionRef } : {},
+        input: JsonObjectSchema.parse(mappedInput)
+      };
     }
     return {
-      changedRef: refs.get(changedKey) ?? (() => {
-        const separator = changedKey.indexOf(":");
-        return ref(changedKey.slice(0, separator), changedKey.slice(separator + 1));
-      })(),
-      affectedRefs: Array.from(affected).sort().map((key) => refs.get(key)),
-      reasons: affected.size ? ["dependency"] : ["direct-change"]
+      ...node,
+      ancestorAccessPolicies: ancestors,
+      resolvedTarget
     };
   });
-  return ChangeImpactGraphSchema.parse({
-    contract: "ChangeImpactGraph",
-    declarationId: next.declaration.declarationId,
-    nodes: Array.from(refs.values()).sort((left, right) => refKey(left).localeCompare(refKey(right))),
-    edges: next.edges,
-    impacts,
-    generatedAt
+  const unsigned = {
+    contract: "NavigationRuntimeBundle",
+    schemaVersion: 1,
+    tenantScope: scope,
+    releaseRevisionRef,
+    compilerRevisionRef,
+    generation: input.generation,
+    dependencySnapshot: release.dependencySnapshot,
+    rebuildable: true,
+    diagnostics: [],
+    navigationId: navigation.navigationId,
+    navigationRevisionRef,
+    surface: release.target.surface,
+    placement: release.target.placement,
+    nodes,
+    performanceBudgetRef: navigation.performanceBudgetRef,
+    observationPolicyRevisionRef: navigation.observationPolicyRevisionRef
+  };
+  return deepFreeze(NavigationRuntimeBundleSchema.parse({ ...unsigned, contentHash: canonicalContentHash(unsigned) }));
+};
+var validateWorkbenchRuntimeSet = (bundleInputs) => {
+  const bundles = bundleInputs.map((bundle) => WorkbenchRuntimeBundleSchema.parse(bundle));
+  if (bundles.length === 0) {
+    throw new DeclarativeControlCompilationError("WORKBENCH_RELEASE_SET_INVALID", "bundles", "An active Workbench release set must retain at least one Workbench.");
+  }
+  const first = bundles[0];
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenOrders = /* @__PURE__ */ new Set();
+  let defaultCount = 0;
+  bundles.forEach((bundle, index) => {
+    if (scopeKey(bundle.tenantScope) !== scopeKey(first.tenantScope) || bundle.surface !== first.surface || !sameStableRef(bundle.target.environmentRef, first.target.environmentRef)) {
+      throw new DeclarativeControlCompilationError("WORKBENCH_RELEASE_SET_INVALID", `bundles[${index}]`, "Workbench release set entries must share tenant, environment, and surface.");
+    }
+    if (seenIds.has(bundle.workbenchId)) throw new DeclarativeControlCompilationError("WORKBENCH_RELEASE_SET_INVALID", `bundles[${index}].workbenchId`, "Workbench identities must be unique in an active release set.");
+    if (seenOrders.has(bundle.target.order)) throw new DeclarativeControlCompilationError("WORKBENCH_RELEASE_SET_INVALID", `bundles[${index}].target.order`, "Workbench order values must be unique in an active release set.");
+    seenIds.add(bundle.workbenchId);
+    seenOrders.add(bundle.target.order);
+    if (bundle.target.isDefaultCandidate) defaultCount += 1;
   });
+  if (defaultCount > 1) throw new DeclarativeControlCompilationError("WORKBENCH_RELEASE_SET_INVALID", "bundles", "An active Workbench release set may have at most one default candidate.");
+  return Object.freeze([...bundles].sort((left, right) => left.target.order - right.target.order || left.workbenchId.localeCompare(right.workbenchId)));
+};
+var resolveWorkbenchEntry = (input) => {
+  if (input.requestedWorkbenchId) {
+    const requested = input.bundles.find((bundle) => bundle.workbenchId === input.requestedWorkbenchId);
+    if (!requested) return { status: "not-found", workbenchId: input.requestedWorkbenchId };
+    if (!input.isAllowed(requested)) return { status: "forbidden", workbenchId: input.requestedWorkbenchId };
+    return { status: "resolved", bundle: requested, source: "explicit" };
+  }
+  const allowed = input.bundles.filter(input.isAllowed).sort((left, right) => left.target.order - right.target.order || left.workbenchId.localeCompare(right.workbenchId));
+  const defaultBundle = allowed.find((bundle) => bundle.target.isDefaultCandidate);
+  if (defaultBundle) return { status: "resolved", bundle: defaultBundle, source: "default" };
+  if (allowed[0]) return { status: "resolved", bundle: allowed[0], source: "first-accessible" };
+  return { status: "forbidden", workbenchId: "" };
 };
 
 // src/runtime/menu-compiler.ts
@@ -9688,19 +11565,19 @@ var pageKey = (page) => `${page.applicationId}\0${page.pageId}`;
 var targetKey = (page, activationId) => `${page.applicationId}\0${page.pageId}\0${activationId}`;
 var actionKey = (applicationId, actionRef) => `${applicationId}\0${actionRef}`;
 var providerKey = (applicationId, providerId) => `${applicationId}\0${providerId}`;
-var stableSerialize = (value) => {
+var stableSerialize2 = (value) => {
   if (value === void 0) return "null";
   if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
-  if (Array.isArray(value)) return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
+  if (Array.isArray(value)) return `[${value.map((item) => stableSerialize2(item)).join(",")}]`;
   const record = value;
-  return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${stableSerialize(record[key])}`).join(",")}}`;
+  return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${stableSerialize2(record[key])}`).join(",")}}`;
 };
-var deepFreeze = (value) => {
+var deepFreeze2 = (value) => {
   if (value === null || typeof value !== "object" || Object.isFrozen(value)) return value;
-  Object.values(value).forEach((child) => deepFreeze(child));
+  Object.values(value).forEach((child) => deepFreeze2(child));
   return Object.freeze(value);
 };
-var SHA256_INITIAL = [
+var SHA256_INITIAL2 = [
   1779033703,
   3144134277,
   1013904242,
@@ -9710,7 +11587,7 @@ var SHA256_INITIAL = [
   528734635,
   1541459225
 ];
-var SHA256_ROUND = [
+var SHA256_ROUND2 = [
   1116352408,
   1899447441,
   3049323471,
@@ -9776,8 +11653,8 @@ var SHA256_ROUND = [
   3204031479,
   3329325298
 ];
-var rotateRight = (value, amount) => value >>> amount | value << 32 - amount;
-var sha256Hex = (value) => {
+var rotateRight2 = (value, amount) => value >>> amount | value << 32 - amount;
+var sha256Hex2 = (value) => {
   const source = [...new TextEncoder().encode(value)];
   const bitLength = source.length * 8;
   source.push(128);
@@ -9786,7 +11663,7 @@ var sha256Hex = (value) => {
   const low = bitLength >>> 0;
   for (let shift = 24; shift >= 0; shift -= 8) source.push(high >>> shift & 255);
   for (let shift = 24; shift >= 0; shift -= 8) source.push(low >>> shift & 255);
-  const hash = [...SHA256_INITIAL];
+  const hash = [...SHA256_INITIAL2];
   const words = new Array(64).fill(0);
   for (let offset = 0; offset < source.length; offset += 64) {
     for (let index = 0; index < 16; index += 1) {
@@ -9796,16 +11673,16 @@ var sha256Hex = (value) => {
     for (let index = 16; index < 64; index += 1) {
       const previous = words[index - 15];
       const recent = words[index - 2];
-      const small0 = rotateRight(previous, 7) ^ rotateRight(previous, 18) ^ previous >>> 3;
-      const small1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ recent >>> 10;
+      const small0 = rotateRight2(previous, 7) ^ rotateRight2(previous, 18) ^ previous >>> 3;
+      const small1 = rotateRight2(recent, 17) ^ rotateRight2(recent, 19) ^ recent >>> 10;
       words[index] = words[index - 16] + small0 + words[index - 7] + small1 >>> 0;
     }
     let [a, b, c, d, e, f, g, h] = hash;
     for (let index = 0; index < 64; index += 1) {
-      const big1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const big1 = rotateRight2(e, 6) ^ rotateRight2(e, 11) ^ rotateRight2(e, 25);
       const choice = e & f ^ ~e & g;
-      const temp1 = h + big1 + choice + SHA256_ROUND[index] + words[index] >>> 0;
-      const big0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const temp1 = h + big1 + choice + SHA256_ROUND2[index] + words[index] >>> 0;
+      const big0 = rotateRight2(a, 2) ^ rotateRight2(a, 13) ^ rotateRight2(a, 22);
       const majority = a & b ^ a & c ^ b & c;
       const temp2 = big0 + majority >>> 0;
       h = g;
@@ -10033,10 +11910,10 @@ var compileMenuRuntimeBundle = (input) => {
           normalizedSourceInput = { exposure: node.behavior.input.exposure, value: normalized };
           runtimeInput = node.behavior.input.exposure === "client" ? { exposure: "client", value: normalized } : { exposure: "server" };
           if (node.behavior.input.exposure === "server" && definition.applicationId === applicationId) {
-            serverInputByTargetKey.set(identity, deepFreeze(normalized));
+            serverInputByTargetKey.set(identity, deepFreeze2(normalized));
           }
         }
-        const signature = stableSerialize({
+        const signature = stableSerialize2({
           kind: "navigate",
           page: node.behavior.page,
           activationId,
@@ -10144,7 +12021,7 @@ var compileMenuRuntimeBundle = (input) => {
   };
   const document = MenuRuntimeBundleSchema.parse({
     ...unsignedDocument,
-    contentHash: sha256Hex(stableSerialize(unsignedDocument))
+    contentHash: sha256Hex2(stableSerialize2(unsignedDocument))
   });
   const menusByKey = new Map(document.menus.map((menu) => [
     menuKey(menu.applicationId, menu.surface, menu.menuId),
@@ -10171,7 +12048,7 @@ var compileMenuRuntimeBundle = (input) => {
     return target ? Object.freeze({ status: "resolved", target }) : Object.freeze({ status: "unmatched" });
   };
   return Object.freeze({
-    document: deepFreeze(document),
+    document: deepFreeze2(document),
     menusByKey,
     navigationTargetsByKey: documentTargetsByKey,
     serverInputByTargetKey,
@@ -10586,83 +12463,11 @@ var buildApplicationHandoffUrl = (targetPath, handoff) => {
   return isRelative ? `${url.pathname}${url.search}${url.hash}` : url.toString();
 };
 
-// src/runtime/render-tree-compiler.ts
-var compileRenderTree = (input) => {
-  const tree = RenderTreeSchema.parse(input);
-  const nodesById = /* @__PURE__ */ new Map();
-  for (const node of tree.nodes) {
-    if (nodesById.has(node.nodeId)) throw new Error(`Duplicate render node id: ${node.nodeId}`);
-    nodesById.set(node.nodeId, node);
-  }
-  const root = nodesById.get(tree.rootNodeId);
-  if (!root) throw new Error(`Render tree ${tree.treeId} has no root node ${tree.rootNodeId}.`);
-  if (root.parentNodeId !== void 0) throw new Error(`Render tree root ${root.nodeId} cannot declare a parent.`);
-  for (const node of tree.nodes) {
-    if (node.nodeId !== root.nodeId && node.parentNodeId === void 0) {
-      throw new Error(`Render node ${node.nodeId} is disconnected from root ${root.nodeId}.`);
-    }
-    if (node.parentNodeId !== void 0) {
-      const parent = nodesById.get(node.parentNodeId);
-      if (!parent) throw new Error(`Render node ${node.nodeId} references missing parent ${node.parentNodeId}.`);
-      if (!parent.children.includes(node.nodeId)) {
-        throw new Error(`Render node ${node.nodeId} is not declared by parent ${parent.nodeId}.`);
-      }
-    }
-    for (const childId of node.children) {
-      const child = nodesById.get(childId);
-      if (!child) throw new Error(`Render node ${node.nodeId} references missing child ${childId}.`);
-      if (child.parentNodeId !== node.nodeId) {
-        throw new Error(`Render child ${childId} does not point back to parent ${node.nodeId}.`);
-      }
-    }
-  }
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const traversal = [];
-  const visit = (node) => {
-    if (visiting.has(node.nodeId)) throw new Error(`Render tree ${tree.treeId} contains a cycle at ${node.nodeId}.`);
-    if (visited.has(node.nodeId)) return;
-    visiting.add(node.nodeId);
-    traversal.push(node);
-    node.children.forEach((childId) => visit(nodesById.get(childId)));
-    visiting.delete(node.nodeId);
-    visited.add(node.nodeId);
-  };
-  visit(root);
-  if (visited.size !== nodesById.size) {
-    const disconnected = tree.nodes.find((node) => !visited.has(node.nodeId));
-    throw new Error(`Render node ${disconnected.nodeId} is not reachable from root ${root.nodeId}.`);
-  }
-  const childrenOf = (nodeId) => {
-    const node = nodesById.get(nodeId);
-    if (!node) throw new Error(`Unknown render node: ${nodeId}`);
-    return Object.freeze(node.children.map((childId) => nodesById.get(childId)));
-  };
-  const ancestorsOf = (nodeId) => {
-    let node = nodesById.get(nodeId);
-    if (!node) throw new Error(`Unknown render node: ${nodeId}`);
-    const ancestors = [];
-    while (node.parentNodeId !== void 0) {
-      node = nodesById.get(node.parentNodeId);
-      ancestors.push(node);
-    }
-    return Object.freeze(ancestors);
-  };
-  return Object.freeze({
-    tree,
-    root,
-    nodesById,
-    traversal: Object.freeze(traversal),
-    childrenOf,
-    ancestorsOf
-  });
-};
-
 // src/contracts/tenant.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/contracts/theme.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/theme-tokens/core.ts
 var import_ajv = __toESM(require_ajv());
@@ -12889,20 +14694,20 @@ function assertMonkeysThemeTokensComplete(input) {
 }
 
 // src/contracts/theme.ts
-var ThemeTokenTypeSchema = z10.enum(THEME_TOKEN_TYPES);
-var ThemeTokenSchema = z10.record(z10.string(), z10.unknown()).superRefine((input, context) => {
+var ThemeTokenTypeSchema = z11.enum(THEME_TOKEN_TYPES);
+var ThemeTokenSchema = z11.record(z11.string(), z11.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocumentStructure({ token: input });
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
   }
 });
-var ThemeTokenGroupSchema = z10.record(z10.string(), z10.unknown()).superRefine((input, context) => {
+var ThemeTokenGroupSchema = z11.record(z11.string(), z11.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocumentStructure(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
   }
 });
-var ThemeTokensSchema = z10.record(z10.string(), z10.unknown()).superRefine((input, context) => {
+var ThemeTokensSchema = z11.record(z11.string(), z11.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocument(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
@@ -12929,9 +14734,9 @@ var ResolvedThemeTokensSchema = ThemeTokensSchema.superRefine((input, context) =
 });
 
 // src/contracts/tenant.ts
-var DesignTokenFileSourceSchema = z11.object({
-  type: z11.literal("file"),
-  path: z11.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenFileSourceSchema = z12.object({
+  type: z12.literal("file"),
+  path: z12.string().trim().min(1).superRefine((source, context) => {
     const isWindowsDrivePath = /^[a-z]:[\\/]/i.test(source);
     if (!isWindowsDrivePath && /^[a-z][a-z\d+.-]*:/i.test(source)) {
       context.addIssue({
@@ -12941,9 +14746,9 @@ var DesignTokenFileSourceSchema = z11.object({
     }
   })
 }).strict();
-var DesignTokenUrlSourceSchema = z11.object({
-  type: z11.literal("url"),
-  url: z11.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenUrlSourceSchema = z12.object({
+  type: z12.literal("url"),
+  url: z12.string().trim().min(1).superRefine((source, context) => {
     if (!/^https?:\/\//i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -12952,55 +14757,45 @@ var DesignTokenUrlSourceSchema = z11.object({
     }
   })
 }).strict();
-var DesignTokenInlineSourceSchema = z11.object({
-  type: z11.literal("inline"),
+var DesignTokenInlineSourceSchema = z12.object({
+  type: z12.literal("inline"),
   document: ThemeTokensSchema
 }).strict();
-var DesignTokenSourceSchema = z11.discriminatedUnion("type", [
-  DesignTokenFileSourceSchema,
-  DesignTokenUrlSourceSchema,
-  DesignTokenInlineSourceSchema
-]);
-var TenantDesignTokensConfigSchema = z11.object({
+var DesignTokenSourceSchema = z12.discriminatedUnion("type", [DesignTokenFileSourceSchema, DesignTokenUrlSourceSchema, DesignTokenInlineSourceSchema]);
+var TenantDesignTokensConfigSchema = z12.object({
   /** Ordered tenant overrides. The backend always applies the product default first. */
-  tokenSources: z11.array(DesignTokenSourceSchema)
+  tokenSources: z12.array(DesignTokenSourceSchema)
 }).strict();
-var TenantAuthBindingSchema = z11.object({
-  kind: z11.literal("auth-provider"),
+var TenantAuthBindingSchema = z12.object({
+  kind: z12.literal("auth-provider"),
   providerId: ContractIdentifierSchema,
   policyRef: ContractIdentifierSchema.optional()
 }).strict();
-var TenantDataBindingSchema = z11.discriminatedUnion("kind", [
-  z11.object({
-    kind: z11.literal("data-provider"),
+var TenantDataBindingSchema = z12.discriminatedUnion("kind", [
+  z12.object({
+    kind: z12.literal("data-provider"),
     providerId: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict(),
-  z11.object({
-    kind: z11.literal("projection"),
+  z12.object({
+    kind: z12.literal("projection"),
     projectionRef: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict()
 ]);
-var TenantAuthBindingsSchema = z11.record(
-  ContractIdentifierSchema,
-  TenantAuthBindingSchema
-);
-var TenantDataBindingsSchema = z11.record(
-  ContractIdentifierSchema,
-  TenantDataBindingSchema
-);
-var TenantTrendRadarSourceSchema = z11.object({
+var TenantAuthBindingsSchema = z12.record(ContractIdentifierSchema, TenantAuthBindingSchema);
+var TenantDataBindingsSchema = z12.record(ContractIdentifierSchema, TenantDataBindingSchema);
+var TenantTrendRadarSourceSchema = z12.object({
   ontologyId: ContractIdentifierSchema,
   viewId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarCollectionTargetSchema = z11.object({
+var TenantTrendRadarCollectionTargetSchema = z12.object({
   ontologyId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarEvaluationSchema = z11.object({
+var TenantTrendRadarEvaluationSchema = z12.object({
   workflowId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarDerivedMetricsSchema = z11.object({
+var TenantTrendRadarDerivedMetricsSchema = z12.object({
   productCountFieldKey: ContractIdentifierSchema,
   salesValueCountFieldKey: ContractIdentifierSchema,
   salesSumFieldKey: ContractIdentifierSchema
@@ -13008,7 +14803,7 @@ var TenantTrendRadarDerivedMetricsSchema = z11.object({
   ({ productCountFieldKey, salesValueCountFieldKey, salesSumFieldKey }) => (/* @__PURE__ */ new Set([productCountFieldKey, salesValueCountFieldKey, salesSumFieldKey])).size === 3,
   { message: "Trend Radar derived metric Field Keys must be distinct." }
 );
-var TenantTrendRadarSourcesSchema = z11.object({
+var TenantTrendRadarSourcesSchema = z12.object({
   products: TenantTrendRadarSourceSchema.optional(),
   hotwords: TenantTrendRadarSourceSchema.optional(),
   brands: TenantTrendRadarSourceSchema.optional(),
@@ -13016,58 +14811,54 @@ var TenantTrendRadarSourcesSchema = z11.object({
   derivedMetrics: TenantTrendRadarDerivedMetricsSchema.optional(),
   evaluation: TenantTrendRadarEvaluationSchema.optional()
 }).strict();
-var AssetVariantsSchema = z11.object({
-  light: z11.string().optional(),
-  dark: z11.string().optional()
+var AssetVariantsSchema = z12.object({
+  light: z12.string().optional(),
+  dark: z12.string().optional()
 }).strict();
-var TenantAgentThemeConfigSchema = z11.object({
+var TenantAgentThemeConfigSchema = z12.object({
   logo: AssetVariantsSchema.optional(),
-  brandDisplayMode: z11.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
-  density: z11.enum(["compact", "default", "comfortable"]).optional(),
+  brandDisplayMode: z12.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
+  density: z12.enum(["compact", "default", "comfortable"]).optional(),
   sidebar: AgentWorkbenchSidebarConfigSchema.optional(),
   /** @deprecated Use sidebar.navigationMode. */
-  navigationMode: z11.enum(["default", "session", "trend"]).optional(),
+  navigationMode: z12.enum(["default", "session", "trend"]).optional(),
   /** @deprecated Use sidebar.quickStartEnabled. */
-  quickStartEnabled: z11.boolean().optional()
+  quickStartEnabled: z12.boolean().optional()
 }).strict();
 var LEGACY_CURRENT_USER_MENU_ITEM_IDS = ["dark-mode", "language", "settings", "logout"];
 var CURRENT_USER_MENU_CONTROL_REFS = ["dark-mode", "language"];
 var CURRENT_USER_MENU_ACTION_REFS = ["logout"];
-var CurrentUserMenuIdentifierSchema = z11.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/, "Expected a stable current-user menu identifier.");
-var CurrentUserMenuDisplayTextSchema = z11.union([
-  z11.string().trim().min(1),
-  z11.record(z11.string().trim().min(1), z11.string().trim().min(1)).refine((value) => Object.keys(value).length > 0, "Localized menu text must contain at least one locale.")
+var CurrentUserMenuIdentifierSchema = z12.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/, "Expected a stable current-user menu identifier.");
+var CurrentUserMenuDisplayTextSchema = z12.union([
+  z12.string().trim().min(1),
+  z12.record(z12.string().trim().min(1), z12.string().trim().min(1)).refine((value) => Object.keys(value).length > 0, "Localized menu text must contain at least one locale.")
 ]);
-var CurrentUserMenuNavigationItemSchema = z11.object({
+var CurrentUserMenuNavigationItemSchema = z12.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z11.literal("navigation"),
+  kind: z12.literal("navigation"),
   ref: CurrentUserMenuIdentifierSchema
 }).strict();
-var CurrentUserMenuControlItemSchema = z11.object({
+var CurrentUserMenuControlItemSchema = z12.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z11.literal("control"),
-  ref: z11.enum(CURRENT_USER_MENU_CONTROL_REFS)
+  kind: z12.literal("control"),
+  ref: z12.enum(CURRENT_USER_MENU_CONTROL_REFS)
 }).strict();
-var CurrentUserMenuActionItemSchema = z11.object({
+var CurrentUserMenuActionItemSchema = z12.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z11.literal("action"),
-  ref: z11.enum(CURRENT_USER_MENU_ACTION_REFS),
-  tone: z11.enum(["default", "danger"]).optional()
-}).strict();
-var CurrentUserMenuItemSchema = z11.discriminatedUnion("kind", [
-  CurrentUserMenuNavigationItemSchema,
-  CurrentUserMenuControlItemSchema,
-  CurrentUserMenuActionItemSchema
-]);
-var CurrentUserMenuSectionSchema = z11.object({
+  kind: z12.literal("action"),
+  ref: z12.enum(CURRENT_USER_MENU_ACTION_REFS),
+  tone: z12.enum(["default", "danger"]).optional()
+}).strict();
+var CurrentUserMenuItemSchema = z12.discriminatedUnion("kind", [CurrentUserMenuNavigationItemSchema, CurrentUserMenuControlItemSchema, CurrentUserMenuActionItemSchema]);
+var CurrentUserMenuSectionSchema = z12.object({
   id: CurrentUserMenuIdentifierSchema,
   label: CurrentUserMenuDisplayTextSchema.optional(),
-  dividerBefore: z11.boolean().optional(),
-  items: z11.array(CurrentUserMenuItemSchema)
+  dividerBefore: z12.boolean().optional(),
+  items: z12.array(CurrentUserMenuItemSchema)
 }).strict();
-var CurrentUserMenuConfigSchema = z11.object({
-  version: z11.literal(1),
-  sections: z11.array(CurrentUserMenuSectionSchema).max(20)
+var CurrentUserMenuConfigSchema = z12.object({
+  version: z12.literal(1),
+  sections: z12.array(CurrentUserMenuSectionSchema).max(20)
 }).strict().superRefine((value, context) => {
   const sectionIds = /* @__PURE__ */ new Set();
   const itemIds = /* @__PURE__ */ new Set();
@@ -13101,7 +14892,7 @@ var CurrentUserMenuConfigSchema = z11.object({
     });
   }
 });
-var LegacyCurrentUserMenuProfileSchema = z11.array(z11.enum(LEGACY_CURRENT_USER_MENU_ITEM_IDS)).superRefine((value, context) => {
+var LegacyCurrentUserMenuProfileSchema = z12.array(z12.enum(LEGACY_CURRENT_USER_MENU_ITEM_IDS)).superRefine((value, context) => {
   const seen = /* @__PURE__ */ new Set();
   value.forEach((item, index) => {
     if (seen.has(item)) {
@@ -13114,73 +14905,69 @@ var LegacyCurrentUserMenuProfileSchema = z11.array(z11.enum(LEGACY_CURRENT_USER_
     seen.add(item);
   });
 });
-var CurrentUserMenuProfileSchema = z11.union([
-  z11.literal("*"),
-  LegacyCurrentUserMenuProfileSchema,
-  CurrentUserMenuConfigSchema
-]);
-var ThemeHeadbarSchema = z11.object({
-  theme: z11.enum(["card", "glassy", "ghost"]).optional(),
-  navPosition: z11.enum(["left", "center", "right"]).optional(),
-  actions: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional(),
+var CurrentUserMenuProfileSchema = z12.union([z12.literal("*"), LegacyCurrentUserMenuProfileSchema, CurrentUserMenuConfigSchema]);
+var ThemeHeadbarSchema = z12.object({
+  theme: z12.enum(["card", "glassy", "ghost"]).optional(),
+  navPosition: z12.enum(["left", "center", "right"]).optional(),
+  actions: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]).optional(),
   profile: CurrentUserMenuProfileSchema.optional(),
-  showTeamQuota: z11.boolean().optional()
+  showTeamQuota: z12.boolean().optional()
 }).strict();
-var TenantHeadbarModuleLeafSchema = z11.object({
+var TenantHeadbarModuleLeafSchema = z12.object({
   id: ContractIdentifierSchema,
-  extraInfo: z11.boolean().optional(),
-  displayName: z11.union([z11.string(), z11.record(LocaleIdentifierSchema, z11.string())]).optional(),
-  visible: z11.boolean().optional(),
-  disabled: z11.boolean().optional(),
-  icon: z11.string().optional(),
-  showQuickSwitcher: z11.boolean().optional(),
-  showSidebar: z11.boolean().optional(),
-  showContentFrame: z11.boolean().optional()
+  extraInfo: z12.boolean().optional(),
+  displayName: z12.union([z12.string(), z12.record(LocaleIdentifierSchema, z12.string())]).optional(),
+  visible: z12.boolean().optional(),
+  disabled: z12.boolean().optional(),
+  icon: z12.string().optional(),
+  showQuickSwitcher: z12.boolean().optional(),
+  showSidebar: z12.boolean().optional(),
+  showContentFrame: z12.boolean().optional()
 }).strict();
 var TenantHeadbarModuleItemSchema = TenantHeadbarModuleLeafSchema.extend({
-  children: z11.array(TenantHeadbarModuleLeafSchema).optional()
-}).strict();
-var KernelHeadbarSchema = z11.object({
-  theme: z11.literal("card").optional(),
-  layoutMode: z11.enum(["boxed", "full-bleed"]).optional(),
-  heightPx: z11.number().positive().optional(),
-  navPosition: z11.enum(["left", "center", "right"]).optional(),
-  brandTitle: z11.string().optional(),
-  menuRadius: z11.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
-}).strict();
-var CustomIconSchema = z11.object({
-  color: z11.string().optional(),
-  url: z11.string().optional(),
-  type: z11.enum(["svg", "image"]).optional(),
-  hintTextColor: z11.string().optional()
-}).strict();
-var WorkbenchCustomerToolSchema = z11.object({
+  children: z12.array(TenantHeadbarModuleLeafSchema).optional()
+}).strict();
+var KernelHeadbarSchema = z12.object({
+  theme: z12.literal("card").optional(),
+  layoutMode: z12.enum(["boxed", "full-bleed"]).optional(),
+  heightPx: z12.number().positive().optional(),
+  navPosition: z12.enum(["left", "center", "right"]).optional(),
+  brandTitle: z12.string().optional(),
+  menuRadius: z12.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
+}).strict();
+var CustomIconSchema = z12.object({
+  color: z12.string().optional(),
+  url: z12.string().optional(),
+  type: z12.enum(["svg", "image"]).optional(),
+  hintTextColor: z12.string().optional()
+}).strict();
+var WorkbenchCustomerToolSchema = z12.object({
   id: ContractIdentifierSchema,
-  label: z11.union([z11.string(), z11.record(LocaleIdentifierSchema, z11.string())]).optional(),
-  fixed: z11.boolean().optional()
+  label: z12.union([z12.string(), z12.record(LocaleIdentifierSchema, z12.string())]).optional(),
+  fixed: z12.boolean().optional()
 }).strict();
-var WorkbenchStudioOverrideSchema = z11.object({
-  studioName: z11.string().trim().min(1),
-  dropdownToolsDefault: z11.array(ContractIdentifierSchema).optional(),
-  existingToolsDefault: z11.array(ContractIdentifierSchema).optional(),
-  historyColumnsDefault: z11.number().int().min(1).max(6).optional()
+var WorkbenchStudioOverrideSchema = z12.object({
+  studioName: z12.string().trim().min(1),
+  dropdownToolsDefault: z12.array(ContractIdentifierSchema).optional(),
+  existingToolsDefault: z12.array(ContractIdentifierSchema).optional(),
+  historyColumnsDefault: z12.number().int().min(1).max(6).optional()
 }).strict();
-var TenantWorkbenchPageContextSchema = z11.object({
+var TenantWorkbenchPageContextSchema = z12.object({
   workflow: JsonObjectSchema.optional(),
   agent: JsonObjectSchema.optional(),
   agentId: ContractIdentifierSchema.optional(),
   designProject: JsonObjectSchema.optional(),
   designMetadataId: ContractIdentifierSchema.optional(),
-  iframeUrl: z11.string().trim().min(1).optional(),
-  info: z11.object({
+  iframeUrl: z12.string().trim().min(1).optional(),
+  info: z12.object({
     displayName: LocalizedTextSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    iconUrl: z11.string().trim().min(1).optional()
+    iconUrl: z12.string().trim().min(1).optional()
   }).strict().optional(),
-  isBuiltinPinned: z11.boolean().optional(),
-  isBuiltinReadonly: z11.boolean().optional()
+  isBuiltinPinned: z12.boolean().optional(),
+  isBuiltinReadonly: z12.boolean().optional()
 }).strict();
-var TenantWorkbenchPageEnvelopeSchema = z11.object({
+var TenantWorkbenchPageEnvelopeSchema = z12.object({
   definition: PageDefinitionSchema,
   context: TenantWorkbenchPageContextSchema
 }).strict().superRefine(({ definition }, context) => {
@@ -13213,66 +15000,77 @@ var TenantWorkbenchPageEnvelopeSchema = z11.object({
     });
   }
 });
-var TenantWorkbenchPageGroupSchema = z11.object({
+var TenantWorkbenchPageGroupSchema = z12.object({
   id: ContractIdentifierSchema,
-  pageIds: z11.array(ContractIdentifierSchema),
+  pageIds: z12.array(ContractIdentifierSchema),
   displayName: LocalizedTextSchema,
-  isBuiltIn: z11.boolean(),
-  iconUrl: z11.string().optional(),
-  sortIndex: z11.number().int().nullable().optional(),
+  isBuiltIn: z12.boolean(),
+  iconUrl: z12.string().optional(),
+  sortIndex: z12.number().int().nullable().optional(),
   presetRelationId: ContractIdentifierSchema.optional(),
   relationKey: ContractIdentifierSchema.nullable().optional(),
   studioId: ContractIdentifierSchema.optional()
 }).strict();
-var TenantWorkbenchConfigSchema = z11.object({
-  pages: z11.array(TenantWorkbenchPageEnvelopeSchema),
-  pageGroups: z11.array(TenantWorkbenchPageGroupSchema),
-  catalog: z11.object({ enabled: z11.boolean().optional(), defaultEntry: z11.boolean().optional() }).strict().optional(),
-  quickSwitcherMaxItems: z11.number().int().nonnegative().optional(),
-  defaultOrder: z11.object({
-    groups: z11.array(ContractIdentifierSchema),
-    pages: z11.record(ContractIdentifierSchema, z11.array(ContractIdentifierSchema))
+var TenantWorkbenchConfigSchema = z12.object({
+  pages: z12.array(TenantWorkbenchPageEnvelopeSchema),
+  pageGroups: z12.array(TenantWorkbenchPageGroupSchema),
+  catalog: z12.object({
+    enabled: z12.boolean().optional(),
+    defaultEntry: z12.boolean().optional()
   }).strict().optional(),
-  customers: z11.object({
-    dropdownToolsDefault: z11.array(ContractIdentifierSchema).optional(),
-    layoutManagerTools: z11.array(WorkbenchCustomerToolSchema).optional(),
-    studioTabsMode: z11.enum(["dropdown", "tabs"]).optional(),
-    historyWatermark: z11.object({
-      svgUrl: z11.string().optional(),
-      coverage: z11.array(z11.enum(["list", "detail", "download"])).optional(),
-      maxLongEdgeRatio: z11.number().positive().optional(),
-      sizing: z11.object({
+  quickSwitcherMaxItems: z12.number().int().nonnegative().optional(),
+  defaultOrder: z12.object({
+    groups: z12.array(ContractIdentifierSchema),
+    pages: z12.record(ContractIdentifierSchema, z12.array(ContractIdentifierSchema))
+  }).strict().optional(),
+  customers: z12.object({
+    dropdownToolsDefault: z12.array(ContractIdentifierSchema).optional(),
+    layoutManagerTools: z12.array(WorkbenchCustomerToolSchema).optional(),
+    studioTabsMode: z12.enum(["dropdown", "tabs"]).optional(),
+    historyWatermark: z12.object({
+      svgUrl: z12.string().optional(),
+      coverage: z12.array(z12.enum(["list", "detail", "download"])).optional(),
+      maxLongEdgeRatio: z12.number().positive().optional(),
+      sizing: z12.object({
         mode: ContractIdentifierSchema,
-        heightRatio: z11.number().positive().optional(),
-        minHeightPx: z11.number().nonnegative().optional(),
-        maxHeightPx: z11.number().nonnegative().optional()
+        heightRatio: z12.number().positive().optional(),
+        minHeightPx: z12.number().nonnegative().optional(),
+        maxHeightPx: z12.number().nonnegative().optional()
       }).strict().optional(),
-      enhance: z11.object({
-        enabled: z11.boolean().optional(),
-        backgroundLumaThreshold: z11.number().min(0).max(1).optional(),
-        stroke: z11.object({
-          color: z11.string().optional(),
-          opacity: z11.number().min(0).max(1).optional(),
-          widthRatio: z11.number().nonnegative().optional(),
-          blurRatio: z11.number().nonnegative().optional(),
-          steps: z11.number().int().positive().optional()
+      enhance: z12.object({
+        enabled: z12.boolean().optional(),
+        backgroundLumaThreshold: z12.number().min(0).max(1).optional(),
+        stroke: z12.object({
+          color: z12.string().optional(),
+          opacity: z12.number().min(0).max(1).optional(),
+          widthRatio: z12.number().nonnegative().optional(),
+          blurRatio: z12.number().nonnegative().optional(),
+          steps: z12.number().int().positive().optional()
         }).strict().optional()
       }).strict().optional()
     }).strict().optional(),
-    layoutManagerEnabled: z11.boolean().optional(),
-    existingToolsDefault: z11.array(ContractIdentifierSchema).optional(),
-    historyColumnsDefault: z11.number().int().min(1).max(6).optional(),
-    studioOverrides: z11.array(WorkbenchStudioOverrideSchema).optional()
+    layoutManagerEnabled: z12.boolean().optional(),
+    existingToolsDefault: z12.array(ContractIdentifierSchema).optional(),
+    historyColumnsDefault: z12.number().int().min(1).max(6).optional(),
+    studioOverrides: z12.array(WorkbenchStudioOverrideSchema).optional()
   }).strict().optional()
 }).strict().superRefine(({ pages, pageGroups }, context) => {
   const pageIds = pages.map(({ definition }) => definition.pageId);
   const pageIdSet = new Set(pageIds);
   if (pageIdSet.size !== pageIds.length) {
-    context.addIssue({ code: "custom", path: ["pages"], message: "Tenant workbench page ids must be unique." });
+    context.addIssue({
+      code: "custom",
+      path: ["pages"],
+      message: "Tenant workbench page ids must be unique."
+    });
   }
   const groupIds = pageGroups.map(({ id }) => id);
   if (new Set(groupIds).size !== groupIds.length) {
-    context.addIssue({ code: "custom", path: ["pageGroups"], message: "Tenant workbench page group ids must be unique." });
+    context.addIssue({
+      code: "custom",
+      path: ["pageGroups"],
+      message: "Tenant workbench page group ids must be unique."
+    });
   }
   pageGroups.forEach((group, groupIndex) => {
     group.pageIds.forEach((pageId, pageIndex) => {
@@ -13286,38 +15084,41 @@ var TenantWorkbenchConfigSchema = z11.object({
     });
   });
 });
-var LoginPageSchema = z11.object({
-  background: z11.object({ imageUrl: z11.string().optional(), gradient: z11.string().optional() }).strict().optional(),
-  logo: z11.object({
-    url: z11.string().optional(),
-    lightUrl: z11.string().optional(),
-    darkUrl: z11.string().optional(),
-    position: z11.enum(["top", "middle", "bottom"]).optional(),
-    scale: z11.number().positive().optional()
+var LoginPageSchema = z12.object({
+  background: z12.object({
+    imageUrl: z12.string().optional(),
+    gradient: z12.string().optional()
+  }).strict().optional(),
+  logo: z12.object({
+    url: z12.string().optional(),
+    lightUrl: z12.string().optional(),
+    darkUrl: z12.string().optional(),
+    position: z12.enum(["top", "middle", "bottom"]).optional(),
+    scale: z12.number().positive().optional()
   }).strict().optional(),
-  customCss: z11.string().optional()
+  customCss: z12.string().optional()
 }).strict();
 var LandingPageHeadbarConfigShape = {
-  headbarMode: z11.enum(["shared", "hidden"]).optional()
+  headbarMode: z12.enum(["shared", "hidden"]).optional()
 };
-var LandingPageDefaultConfigSchema = z11.object({
-  mode: z11.literal("default"),
+var LandingPageDefaultConfigSchema = z12.object({
+  mode: z12.literal("default"),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageMarkdownConfigSchema = z11.object({
-  mode: z11.literal("markdown"),
-  content: z11.string(),
+var LandingPageMarkdownConfigSchema = z12.object({
+  mode: z12.literal("markdown"),
+  content: z12.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageHtmlConfigSchema = z11.object({
-  mode: z11.literal("html"),
-  content: z11.string(),
+var LandingPageHtmlConfigSchema = z12.object({
+  mode: z12.literal("html"),
+  content: z12.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageIframeConfigSchema = z11.object({
-  mode: z11.literal("iframe"),
+var LandingPageIframeConfigSchema = z12.object({
+  mode: z12.literal("iframe"),
   ...LandingPageHeadbarConfigShape,
-  url: z11.string().refine((value) => {
+  url: z12.string().refine((value) => {
     if (/^\/(?!\/)/.test(value)) {
       return !value.includes("\\");
     }
@@ -13329,13 +15130,13 @@ var LandingPageIframeConfigSchema = z11.object({
     }
   }, "Landing page iframe URL must use a root-relative path or HTTP(S) without embedded credentials.")
 }).strict();
-var TenantLandingPageConfigSchema = z11.discriminatedUnion("mode", [
+var TenantLandingPageConfigSchema = z12.discriminatedUnion("mode", [
   LandingPageDefaultConfigSchema,
   LandingPageMarkdownConfigSchema,
   LandingPageHtmlConfigSchema,
   LandingPageIframeConfigSchema
 ]);
-var ListFooterPageSizeOptionsSchema = z11.array(z11.number().int().positive().max(1e3)).min(1).max(10).superRefine((options, context) => {
+var ListFooterPageSizeOptionsSchema = z12.array(z12.number().int().positive().max(1e3)).min(1).max(10).superRefine((options, context) => {
   const seen = /* @__PURE__ */ new Set();
   options.forEach((option, index) => {
     if (seen.has(option)) {
@@ -13348,263 +15149,339 @@ var ListFooterPageSizeOptionsSchema = z11.array(z11.number().int().positive().ma
     seen.add(option);
   });
 });
-var TenantListFooterConfigSchema = z11.object({
-  showTotal: z11.boolean().optional(),
-  showPageSize: z11.boolean().optional(),
+var TenantListFooterConfigSchema = z12.object({
+  showTotal: z12.boolean().optional(),
+  showPageSize: z12.boolean().optional(),
   pageSizeOptions: ListFooterPageSizeOptionsSchema.optional(),
-  paginationMode: z11.enum(["auto", "pages", "compact"]).optional(),
-  alignment: z11.enum(["start", "end", "space-between"]).optional(),
-  density: z11.enum(["compact", "default", "comfortable"]).optional()
-}).strict();
-var TenantApplicationConfigSchema = z11.object({
-  theme: z11.object({
-    id: z11.string().optional(),
-    name: z11.string().optional(),
-    title: z11.string().optional(),
+  paginationMode: z12.enum(["auto", "pages", "compact"]).optional(),
+  alignment: z12.enum(["start", "end", "space-between"]).optional(),
+  density: z12.enum(["compact", "default", "comfortable"]).optional()
+}).strict();
+var TenantApplicationConfigSchema = z12.object({
+  theme: z12.object({
+    id: z12.string().optional(),
+    name: z12.string().optional(),
+    title: z12.string().optional(),
     favicon: AssetVariantsSchema.optional(),
     logo: AssetVariantsSchema.optional(),
-    pwaIcon: z11.string().optional(),
-    form: z11.object({ variant: z11.enum(["bento", "ghost"]) }).strict().optional(),
-    toast: z11.object({
-      position: z11.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
+    pwaIcon: z12.string().optional(),
+    form: z12.object({ variant: z12.enum(["bento", "ghost"]) }).strict().optional(),
+    toast: z12.object({
+      position: z12.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
+    }).strict().optional(),
+    icons: z12.object({
+      error: CustomIconSchema.optional(),
+      empty: CustomIconSchema.optional()
     }).strict().optional(),
-    icons: z11.object({ error: CustomIconSchema.optional(), empty: CustomIconSchema.optional() }).strict().optional(),
-    views: z11.object({
-      form: z11.object({
-        toast: z11.object({ afterCreate: z11.boolean(), afterDelete: z11.boolean() }).strict(),
-        progress: z11.enum(["estimate", "infinite"]),
-        onlyResult: z11.boolean(),
-        tabular: z11.object({ theme: z11.enum(["default", "tentiary", "primary"]) }).strict()
+    views: z12.object({
+      form: z12.object({
+        toast: z12.object({
+          afterCreate: z12.boolean(),
+          afterDelete: z12.boolean()
+        }).strict(),
+        progress: z12.enum(["estimate", "infinite"]),
+        onlyResult: z12.boolean(),
+        tabular: z12.object({ theme: z12.enum(["default", "tentiary", "primary"]) }).strict()
       }).strict()
     }).strict().optional(),
     loginPage: LoginPageSchema.optional(),
-    extraLanguageURL: z11.record(z11.string(), z11.string()).optional(),
-    hideSpaceHeader: z11.boolean().optional(),
-    showSidebarTeamSelector: z11.boolean().optional(),
-    showWorkbenchSidebar: z11.boolean().optional(),
-    workbenchViewTheme: z11.enum(["default", "bsd-blue"]).optional(),
-    defaults: z11.object({
-      showFormInImageDetail: z11.boolean().optional(),
-      darkMode: z11.enum(["light", "dark", "auto"]).optional(),
-      language: z11.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
-      showDarkModeToggle: z11.boolean().optional(),
-      showLanguageToggle: z11.boolean().optional()
+    extraLanguageURL: z12.record(z12.string(), z12.string()).optional(),
+    hideSpaceHeader: z12.boolean().optional(),
+    showSidebarTeamSelector: z12.boolean().optional(),
+    showWorkbenchSidebar: z12.boolean().optional(),
+    workbenchViewTheme: z12.enum(["default", "bsd-blue"]).optional(),
+    defaults: z12.object({
+      showFormInImageDetail: z12.boolean().optional(),
+      darkMode: z12.enum(["light", "dark", "auto"]).optional(),
+      language: z12.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
+      showDarkModeToggle: z12.boolean().optional(),
+      showLanguageToggle: z12.boolean().optional()
     }).strict().optional(),
-    modules: z11.object({
-      monkeysSpaceSidebar: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional(),
-      monkeysSpaceHeadbar: z11.union([
-        z11.literal("*"),
-        z11.array(TenantHeadbarModuleItemSchema)
-      ]).optional(),
-      settingsSidebar: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional()
+    modules: z12.object({
+      monkeysSpaceSidebar: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]).optional(),
+      monkeysSpaceHeadbar: z12.union([z12.literal("*"), z12.array(TenantHeadbarModuleItemSchema)]).optional(),
+      settingsSidebar: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]).optional()
     }).strict().optional(),
     headbar: ThemeHeadbarSchema.optional(),
-    kernelLayout: z11.object({
-      navigationMode: z11.enum(["sidebar", "topbar"]).optional(),
-      allowNavigationModeSwitch: z11.boolean().optional(),
+    kernelLayout: z12.object({
+      navigationMode: z12.enum(["sidebar", "topbar"]).optional(),
+      allowNavigationModeSwitch: z12.boolean().optional(),
       headbar: KernelHeadbarSchema.optional()
     }).strict().optional(),
-    paginationPosition: z11.enum(["left", "right"]).optional(),
+    paginationPosition: z12.enum(["left", "right"]).optional(),
     listFooter: TenantListFooterConfigSchema.optional(),
-    ugcViewIconOnlyMode: z11.boolean().optional(),
-    workflowPreviewExecutionGrid: z11.object({
-      selectionModeDisplayType: z11.enum(["operation-button", "dropdown-menu"]).optional(),
-      clickBehavior: z11.enum(["preview", "select", "fill-form", "none"]).optional(),
-      showErrorFilter: z11.boolean().optional(),
-      displayType: z11.enum(["grid", "masonry"]).optional(),
-      showDetailButton: z11.boolean().optional(),
-      aspectRatio: z11.enum(["1:1", "4:3", "3:4", "16:9", "9:16"]).optional()
+    ugcViewIconOnlyMode: z12.boolean().optional(),
+    workflowPreviewExecutionGrid: z12.object({
+      selectionModeDisplayType: z12.enum(["operation-button", "dropdown-menu"]).optional(),
+      clickBehavior: z12.enum(["preview", "select", "fill-form", "none"]).optional(),
+      showErrorFilter: z12.boolean().optional(),
+      displayType: z12.enum(["grid", "masonry"]).optional(),
+      showDetailButton: z12.boolean().optional(),
+      aspectRatio: z12.enum(["1:1", "4:3", "3:4", "16:9", "9:16"]).optional()
     }).strict().optional(),
-    workbenchSidebarDefaultOpen: z11.boolean().optional(),
-    workbenchSidebarMoreAction: z11.boolean().optional(),
-    workbenchSidebarApart: z11.boolean().optional(),
-    workbenchSidebarToggleGroupDetail: z11.boolean().optional(),
-    workbenchSidebarViewType: z11.boolean().optional(),
-    workbenchSidebarFormViewEmbed: z11.boolean().optional(),
-    workbenchSidebarModernMode: z11.boolean().optional(),
-    ugc: z11.object({ onItemClick: z11.boolean(), subtitle: z11.boolean().optional() }).strict().optional(),
-    uniImagePreview: z11.boolean().optional(),
-    imagePreviewStyle: z11.union([z11.literal(false), z11.enum(["simple", "normal", "uni"])]).optional(),
-    teamAsUser: z11.boolean().optional(),
-    themeMode: z11.enum(["shadow", "border"]).optional(),
-    density: z11.enum(["compact", "default", "comfortable"]).optional(),
-    statusStates: z11.object({
-      loading: z11.object({ variant: z11.enum(["spinner", "skeleton"]).optional() }).strict().optional(),
-      empty: z11.object({ variant: z11.enum(["default", "compact"]).optional() }).strict().optional(),
-      error: z11.object({ showRetry: z11.boolean().optional() }).strict().optional(),
-      permission: z11.object({ showRequestAccess: z11.boolean().optional() }).strict().optional(),
-      density: z11.enum(["compact", "default", "comfortable"]).optional()
+    workbenchSidebarDefaultOpen: z12.boolean().optional(),
+    workbenchSidebarMoreAction: z12.boolean().optional(),
+    workbenchSidebarApart: z12.boolean().optional(),
+    workbenchSidebarToggleGroupDetail: z12.boolean().optional(),
+    workbenchSidebarViewType: z12.boolean().optional(),
+    workbenchSidebarFormViewEmbed: z12.boolean().optional(),
+    workbenchSidebarModernMode: z12.boolean().optional(),
+    ugc: z12.object({
+      onItemClick: z12.boolean(),
+      subtitle: z12.boolean().optional()
     }).strict().optional(),
-    pageZoom: z11.number().positive().optional(),
-    miniMode: z11.object({ showPreviewViewExecutionResultGrid: z11.boolean() }).strict().optional(),
-    workflow: z11.object({ allowConcurrentRuns: z11.boolean() }).strict().optional(),
-    historyResult: z11.object({ display: z11.boolean() }).strict().optional(),
-    uploader: z11.object({
-      orientation: z11.enum(["vertical", "horizontal"]),
-      pasteButton: z11.boolean(),
-      statusText: z11.boolean()
+    uniImagePreview: z12.boolean().optional(),
+    imagePreviewStyle: z12.union([z12.literal(false), z12.enum(["simple", "normal", "uni"])]).optional(),
+    teamAsUser: z12.boolean().optional(),
+    themeMode: z12.enum(["shadow", "border"]).optional(),
+    density: z12.enum(["compact", "default", "comfortable"]).optional(),
+    statusStates: z12.object({
+      loading: z12.object({ variant: z12.enum(["spinner", "skeleton"]).optional() }).strict().optional(),
+      empty: z12.object({ variant: z12.enum(["default", "compact"]).optional() }).strict().optional(),
+      error: z12.object({ showRetry: z12.boolean().optional() }).strict().optional(),
+      permission: z12.object({ showRequestAccess: z12.boolean().optional() }).strict().optional(),
+      density: z12.enum(["compact", "default", "comfortable"]).optional()
     }).strict().optional(),
-    designProjects: z11.object({
-      oneOnOne: z11.boolean(),
-      newTabOpenBoard: z11.boolean(),
-      defaultShowGrid: z11.boolean().optional(),
-      createDefaultFrame: z11.boolean(),
-      showPageMenu: z11.boolean(),
-      showMainMenu: z11.boolean(),
-      showStylePanel: z11.boolean(),
-      showToolbar: z11.boolean(),
-      toolbarPosition: z11.enum(["bottom", "left"]).optional(),
-      showContextMenu: z11.boolean(),
-      showActionsMenu: z11.boolean(),
-      showPageAndLayerSidebar: z11.boolean().optional(),
-      showBoardOperationSidebar: z11.boolean().optional(),
-      showMiniToolsToolbar: z11.boolean().optional(),
-      showRightSidebar: z11.boolean().optional(),
-      showRealtimeDrawing: z11.boolean().optional(),
-      showWorkflow: z11.boolean().optional(),
-      showVersionManager: z11.boolean().optional(),
-      showAgent: z11.boolean().optional(),
-      AgentTools: z11.array(ContractIdentifierSchema).optional()
+    pageZoom: z12.number().positive().optional(),
+    miniMode: z12.object({ showPreviewViewExecutionResultGrid: z12.boolean() }).strict().optional(),
+    workflow: z12.object({ allowConcurrentRuns: z12.boolean() }).strict().optional(),
+    historyResult: z12.object({ display: z12.boolean() }).strict().optional(),
+    uploader: z12.object({
+      orientation: z12.enum(["vertical", "horizontal"]),
+      pasteButton: z12.boolean(),
+      statusText: z12.boolean()
+    }).strict().optional(),
+    designProjects: z12.object({
+      oneOnOne: z12.boolean(),
+      newTabOpenBoard: z12.boolean(),
+      defaultShowGrid: z12.boolean().optional(),
+      createDefaultFrame: z12.boolean(),
+      showPageMenu: z12.boolean(),
+      showMainMenu: z12.boolean(),
+      showStylePanel: z12.boolean(),
+      showToolbar: z12.boolean(),
+      toolbarPosition: z12.enum(["bottom", "left"]).optional(),
+      showContextMenu: z12.boolean(),
+      showActionsMenu: z12.boolean(),
+      showPageAndLayerSidebar: z12.boolean().optional(),
+      showBoardOperationSidebar: z12.boolean().optional(),
+      showMiniToolsToolbar: z12.boolean().optional(),
+      showRightSidebar: z12.boolean().optional(),
+      showRealtimeDrawing: z12.boolean().optional(),
+      showWorkflow: z12.boolean().optional(),
+      showVersionManager: z12.boolean().optional(),
+      showAgent: z12.boolean().optional(),
+      AgentTools: z12.array(ContractIdentifierSchema).optional()
     }).strict().optional(),
     workbench: TenantWorkbenchConfigSchema.optional(),
-    visionProWorkflows: z11.array(ContractIdentifierSchema).optional(),
-    initTeam: z11.boolean().optional(),
-    imageThumbnail: z11.boolean().optional(),
-    pages: z11.object({
-      allowPageKeys: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]),
+    visionProWorkflows: z12.array(ContractIdentifierSchema).optional(),
+    initTeam: z12.boolean().optional(),
+    imageThumbnail: z12.boolean().optional(),
+    pages: z12.object({
+      allowPageKeys: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]),
       defaultPageKey: ContractIdentifierSchema.optional(),
-      homeEntryEnabled: z11.boolean().optional()
+      homeEntryEnabled: z12.boolean().optional()
     }).strict().optional(),
     agent: TenantAgentThemeConfigSchema.optional()
   }).strict(),
   landingPage: TenantLandingPageConfigSchema.optional(),
-  auth: z11.object({
-    enabled: z11.array(ContractIdentifierSchema).default([]),
-    oidc: z11.object({ buttonText: z11.string().optional(), autoSignin: z11.boolean().optional() }).strict().optional(),
-    password: z11.object({
-      registrationEnabled: z11.boolean().optional(),
-      disableAutoRegister: z11.boolean().optional()
+  auth: z12.object({
+    enabled: z12.array(ContractIdentifierSchema).default([]),
+    oidc: z12.object({
+      buttonText: z12.string().optional(),
+      autoSignin: z12.boolean().optional()
+    }).strict().optional(),
+    password: z12.object({
+      registrationEnabled: z12.boolean().optional(),
+      disableAutoRegister: z12.boolean().optional()
     }).strict().optional(),
-    registrationApproval: z11.object({
-      enabled: z11.boolean().optional()
+    registrationApproval: z12.object({
+      enabled: z12.boolean().optional()
     }).strict().optional(),
-    hideAuthToast: z11.boolean().optional(),
-    autoReload: z11.boolean().optional(),
-    defaultOtherTeam: z11.boolean().optional()
+    hideAuthToast: z12.boolean().optional(),
+    autoReload: z12.boolean().optional(),
+    defaultOtherTeam: z12.boolean().optional()
   }).strict(),
-  endpoints: z11.record(ContractIdentifierSchema, z11.string()),
-  module: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]),
-  behavior: z11.object({
-    clearWorkflowFormStorageAfterUpdate: z11.boolean().optional(),
-    autoApproveOAuth: z11.boolean().optional(),
-    rememberWorkflowModelSelection: z11.boolean().optional()
+  endpoints: z12.record(ContractIdentifierSchema, z12.string()),
+  module: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]),
+  behavior: z12.object({
+    clearWorkflowFormStorageAfterUpdate: z12.boolean().optional(),
+    autoApproveOAuth: z12.boolean().optional(),
+    rememberWorkflowModelSelection: z12.boolean().optional()
   }).strict(),
-  dataManagement: z11.object({
-    favoriteOntologyId: z11.string().optional(),
-    pairedOntologyId: z11.string().optional(),
-    galleryOntologyIds: z11.array(ContractIdentifierSchema).max(20).optional(),
-    galleryOntologyId: z11.string().optional(),
-    dataBrowserDefaultOntologyId: z11.string().optional(),
-    workflowResultOntologyId: z11.string().optional(),
-    homeAdvertisement: z11.object({
+  dataManagement: z12.object({
+    favoriteOntologyId: z12.string().optional(),
+    pairedOntologyId: z12.string().optional(),
+    galleryOntologyIds: z12.array(ContractIdentifierSchema).max(20).optional(),
+    galleryOntologyId: z12.string().optional(),
+    dataBrowserDefaultOntologyId: z12.string().optional(),
+    workflowResultOntologyId: z12.string().optional(),
+    homeAdvertisement: z12.object({
+      ontologyId: ContractIdentifierSchema,
+      viewId: ContractIdentifierSchema.optional(),
+      viewType: z12.enum(["filter", "container", "share_link"]).optional(),
+      teamId: ContractIdentifierSchema.optional(),
+      teamOnly: z12.boolean().optional(),
+      pageSize: z12.number().int().positive().optional(),
+      sortBy: z12.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
+      sortOrder: z12.enum(["asc", "desc"]).optional(),
+      fieldMap: z12.record(z12.string(), z12.string()).optional(),
+      columnIds: z12.record(z12.string(), z12.string()).optional()
+    }).strict().optional(),
+    homeShortcutBackground: z12.object({
       ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
-      viewType: z11.enum(["filter", "container", "share_link"]).optional(),
+      viewType: z12.enum(["filter", "container", "share_link"]).optional(),
       teamId: ContractIdentifierSchema.optional(),
-      teamOnly: z11.boolean().optional(),
-      pageSize: z11.number().int().positive().optional(),
-      sortBy: z11.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
-      sortOrder: z11.enum(["asc", "desc"]).optional(),
-      fieldMap: z11.record(z11.string(), z11.string()).optional(),
-      columnIds: z11.record(z11.string(), z11.string()).optional()
+      teamOnly: z12.boolean().optional(),
+      pageSize: z12.number().int().positive().optional(),
+      sortBy: z12.enum(["pin_order", "asset_id", "updated_timestamp"]).optional(),
+      sortOrder: z12.enum(["asc", "desc"]).optional(),
+      fieldMap: z12.record(z12.string(), z12.string()).optional(),
+      columnIds: z12.record(z12.string(), z12.string()).optional()
     }).strict().optional(),
-    homeTrendAssistant: z11.object({
+    homeTrendAssistant: z12.object({
       ontologyId: ContractIdentifierSchema.optional(),
       viewId: ContractIdentifierSchema.optional(),
       viewInstanceId: ContractIdentifierSchema.optional(),
-      viewName: z11.string().optional(),
+      viewName: z12.string().optional(),
       teamId: ContractIdentifierSchema.optional(),
       designOptionsWorkflowId: ContractIdentifierSchema.optional(),
-      tep: z11.object({ baseUrl: z11.string().optional(), timeoutMs: z11.number().int().positive().optional() }).strict().optional(),
-      runtime: z11.object({ appId: ContractIdentifierSchema, tepBaseUrlConfigured: z11.boolean(), tepAuthorizationConfigured: z11.boolean(), tepCookieConfigured: z11.boolean() }).strict().optional()
+      tep: z12.object({
+        baseUrl: z12.string().optional(),
+        timeoutMs: z12.number().int().positive().optional()
+      }).strict().optional(),
+      runtime: z12.object({
+        appId: ContractIdentifierSchema,
+        tepBaseUrlConfigured: z12.boolean(),
+        tepAuthorizationConfigured: z12.boolean(),
+        tepCookieConfigured: z12.boolean()
+      }).strict().optional()
     }).strict().optional(),
-    staticTrendReport: z11.object({
+    staticTrendReport: z12.object({
       ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
       teamId: ContractIdentifierSchema.optional()
     }).strict().optional(),
     trendRadar: TenantTrendRadarSourcesSchema.optional(),
-    sharing: z11.object({
-      silentViewLinks: z11.object({ enabled: z11.boolean().optional(), placement: z11.object({ mode: z11.enum(["sourceOntology", "ontology"]).optional(), ontologyId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
-      shareAccess: z11.object({ publicLinksEnabled: z11.boolean().optional(), passwordGateEnabled: z11.boolean().optional(), passwordAccessTtlSeconds: z11.number().int().positive().optional(), defaultViewTreeDelivery: z11.enum(["manual", "auto"]).optional() }).strict().optional(),
-      shareDialog: z11.object({
-        audience: z11.object({ enabled: z11.boolean().optional(), allowed: z11.array(z11.enum(["user", "team", "public"])).optional(), default: z11.enum(["user", "team", "public"]).optional() }).strict().optional(),
-        accessLevel: z11.object({ enabled: z11.boolean().optional(), allowed: z11.array(z11.enum(["read", "write"])).optional(), default: z11.enum(["read", "write"]).optional() }).strict().optional(),
-        viewTreeDelivery: z11.object({ enabled: z11.boolean().optional(), allowed: z11.array(z11.enum(["manual", "auto"])).optional(), default: z11.enum(["manual", "auto"]).optional() }).strict().optional()
+    sharing: z12.object({
+      silentViewLinks: z12.object({
+        enabled: z12.boolean().optional(),
+        placement: z12.object({
+          mode: z12.enum(["sourceOntology", "ontology"]).optional(),
+          ontologyId: ContractIdentifierSchema.optional(),
+          parentId: ContractIdentifierSchema.optional(),
+          navId: ContractIdentifierSchema.optional()
+        }).strict().optional()
+      }).strict().optional(),
+      shareAccess: z12.object({
+        publicLinksEnabled: z12.boolean().optional(),
+        passwordGateEnabled: z12.boolean().optional(),
+        passwordAccessTtlSeconds: z12.number().int().positive().optional(),
+        defaultViewTreeDelivery: z12.enum(["manual", "auto"]).optional()
+      }).strict().optional(),
+      shareDialog: z12.object({
+        audience: z12.object({
+          enabled: z12.boolean().optional(),
+          allowed: z12.array(z12.enum(["user", "team", "public"])).optional(),
+          default: z12.enum(["user", "team", "public"]).optional()
+        }).strict().optional(),
+        accessLevel: z12.object({
+          enabled: z12.boolean().optional(),
+          allowed: z12.array(z12.enum(["read", "write"])).optional(),
+          default: z12.enum(["read", "write"]).optional()
+        }).strict().optional(),
+        viewTreeDelivery: z12.object({
+          enabled: z12.boolean().optional(),
+          allowed: z12.array(z12.enum(["manual", "auto"])).optional(),
+          default: z12.enum(["manual", "auto"]).optional()
+        }).strict().optional()
       }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  kernelRuntime: z11.object({
-    integrations: z11.object({
-      harbor: z11.object({ endpoint: z11.string().optional(), projectScopes: z11.array(z11.string()).optional(), authMode: z11.string().optional(), principal: z11.string().optional(), autoSync: z11.boolean().optional(), proxyUrl: z11.string().optional() }).strict().optional(),
-      gitlab: z11.object({ baseUrl: z11.string().optional(), groupScopes: z11.array(z11.string()).optional(), tokenMode: z11.string().optional(), deployProjectPath: z11.string().optional(), deploymentReportsEnabled: z11.boolean().optional(), proxyUrl: z11.string().optional() }).strict().optional(),
-      kubernetes: z11.object({ accessMode: z11.string().optional(), clusterAlias: z11.string().optional(), agentProjectPath: z11.string().optional(), agentName: z11.string().optional(), namespaceScopes: z11.array(z11.string()).optional(), rolloutObserverEnabled: z11.boolean().optional(), proxyUrl: z11.string().optional() }).strict().optional()
+  kernelRuntime: z12.object({
+    integrations: z12.object({
+      harbor: z12.object({
+        endpoint: z12.string().optional(),
+        projectScopes: z12.array(z12.string()).optional(),
+        authMode: z12.string().optional(),
+        principal: z12.string().optional(),
+        autoSync: z12.boolean().optional(),
+        proxyUrl: z12.string().optional()
+      }).strict().optional(),
+      gitlab: z12.object({
+        baseUrl: z12.string().optional(),
+        groupScopes: z12.array(z12.string()).optional(),
+        tokenMode: z12.string().optional(),
+        deployProjectPath: z12.string().optional(),
+        deploymentReportsEnabled: z12.boolean().optional(),
+        proxyUrl: z12.string().optional()
+      }).strict().optional(),
+      kubernetes: z12.object({
+        accessMode: z12.string().optional(),
+        clusterAlias: z12.string().optional(),
+        agentProjectPath: z12.string().optional(),
+        agentName: z12.string().optional(),
+        namespaceScopes: z12.array(z12.string()).optional(),
+        rolloutObserverEnabled: z12.boolean().optional(),
+        proxyUrl: z12.string().optional()
+      }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  data: z11.object({}).strict().optional(),
-  storage: z11.object({
-    presignMode: z11.enum(["frontend", "backend", "both"]).optional(),
-    presign: z11.object({
-      expiresInSeconds: z11.number().int().positive(),
-      buckets: z11.array(
-        z11.object({
+  data: z12.object({}).strict().optional(),
+  storage: z12.object({
+    presignMode: z12.enum(["frontend", "backend", "both"]).optional(),
+    presign: z12.object({
+      expiresInSeconds: z12.number().int().positive(),
+      buckets: z12.array(
+        z12.object({
           id: ContractIdentifierSchema,
           provider: ContractIdentifierSchema,
           preferredUrlPatternId: ContractIdentifierSchema,
-          urlPatterns: z11.array(
-            z11.object({
+          urlPatterns: z12.array(
+            z12.object({
               id: ContractIdentifierSchema,
-              type: z11.enum(["bucket-hostname", "provider-hostname"]),
-              hostname: z11.string().trim().min(1),
-              preferred: z11.boolean().optional(),
-              bucketSegment: z11.string().optional()
+              type: z12.enum(["bucket-hostname", "provider-hostname"]),
+              hostname: z12.string().trim().min(1),
+              preferred: z12.boolean().optional(),
+              bucketSegment: z12.string().optional()
             }).strict()
           )
         }).strict()
       )
     }).strict().optional()
   }).strict().optional(),
-  monkeyData: z11.object({ baseUrl: z11.string().optional() }).strict().optional()
+  monkeyData: z12.object({ baseUrl: z12.string().optional() }).strict().optional()
 }).strict();
-var TenantProductConfigSchema = z11.object({
-  contract: z11.literal("TenantProductConfig"),
+var TenantProductConfigSchema = z12.object({
+  contract: z12.literal("TenantProductConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: TenantDesignTokensConfigSchema,
-  moduleRefs: z11.array(ContractIdentifierSchema).default([]),
-  pageRefs: z11.array(ContractIdentifierSchema).default([]),
-  featureFlags: z11.record(z11.string(), z11.boolean()).default({}),
+  moduleRefs: z12.array(ContractIdentifierSchema).default([]),
+  pageRefs: z12.array(ContractIdentifierSchema).default([]),
+  featureFlags: z12.record(z12.string(), z12.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z11.record(z11.string(), ContractIdentifierSchema),
-  warnings: z11.array(z11.string()).default([]),
+  sourceMap: z12.record(z12.string(), ContractIdentifierSchema),
+  warnings: z12.array(z12.string()).default([]),
   menus: MenuDefinitionSetSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
-var TenantRuntimeConfigSchema = z11.object({
-  contract: z11.literal("TenantRuntimeConfig"),
+var TenantRuntimeConfigSchema = z12.object({
+  contract: z12.literal("TenantRuntimeConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: ResolvedThemeTokensSchema,
-  moduleRefs: z11.array(ContractIdentifierSchema).default([]),
-  pageRefs: z11.array(ContractIdentifierSchema).default([]),
-  featureFlags: z11.record(z11.string(), z11.boolean()).default({}),
+  moduleRefs: z12.array(ContractIdentifierSchema).default([]),
+  pageRefs: z12.array(ContractIdentifierSchema).default([]),
+  featureFlags: z12.record(z12.string(), z12.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z11.record(z11.string(), ContractIdentifierSchema),
-  warnings: z11.array(z11.string()).default([]),
+  sourceMap: z12.record(z12.string(), ContractIdentifierSchema),
+  warnings: z12.array(z12.string()).default([]),
   menuBundle: MenuRuntimeBundleSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
@@ -13880,8 +15757,8 @@ var compileWorkflowPersistenceProjection = (input) => {
 };
 
 // src/contracts/access.ts
-import { z as z12 } from "zod";
-var PermissionDefinitionSchema = z12.object({
+import { z as z13 } from "zod";
+var PermissionDefinitionSchema = z13.object({
   code: ContractIdentifierSchema,
   name: LocalizedTextSchema,
   description: LocalizedTextSchema.optional(),
@@ -13889,29 +15766,29 @@ var PermissionDefinitionSchema = z12.object({
   action: ContractIdentifierSchema,
   domain: ContractIdentifierSchema.optional()
 }).strict();
-var PermissionBundleSchema = z12.object({
+var PermissionBundleSchema = z13.object({
   bundleId: ContractIdentifierSchema,
   name: LocalizedTextSchema,
-  permissionCodes: z12.array(ContractIdentifierSchema).default([])
+  permissionCodes: z13.array(ContractIdentifierSchema).default([])
 }).strict();
-var SystemGroupDefinitionSchema = z12.object({
+var SystemGroupDefinitionSchema = z13.object({
   groupCode: ContractIdentifierSchema,
   name: LocalizedTextSchema,
   description: LocalizedTextSchema.optional(),
-  permissionPolicy: z12.enum(["bundles", "studio_current", "all_current"]).default("bundles"),
-  permissionBundleIds: z12.array(ContractIdentifierSchema).default([])
+  permissionPolicy: z13.enum(["bundles", "studio_current", "all_current"]).default("bundles"),
+  permissionBundleIds: z13.array(ContractIdentifierSchema).default([])
 }).strict().refine((value) => value.permissionPolicy !== "bundles" || value.permissionBundleIds.length > 0, {
   message: "A bundles permission policy requires at least one permission bundle.",
   path: ["permissionBundleIds"]
 });
-var ProductAccessDeclarationSchema = z12.object({
-  contract: z12.literal("ProductAccessDeclaration"),
+var ProductAccessDeclarationSchema = z13.object({
+  contract: z13.literal("ProductAccessDeclaration"),
   declarationId: ContractIdentifierSchema,
   version: ContractVersionSchema,
   ownerRepo: ContractIdentifierSchema,
-  permissions: z12.array(PermissionDefinitionSchema).default([]),
-  permissionBundles: z12.array(PermissionBundleSchema).default([]),
-  systemGroups: z12.array(SystemGroupDefinitionSchema).min(1)
+  permissions: z13.array(PermissionDefinitionSchema).default([]),
+  permissionBundles: z13.array(PermissionBundleSchema).default([]),
+  systemGroups: z13.array(SystemGroupDefinitionSchema).min(1)
 }).strict();
 
 // src/runtime/access-compiler.ts
@@ -13972,27 +15849,34 @@ var compileProductAccessDeclaration = (input) => {
 export {
   APPLICATION_HANDOFF_QUERY_PARAMETER,
   DEFAULT_CONDUCTOR_OWNER_EMAIL,
+  DeclarativeControlCompilationError,
   MONKEYS_REQUIRED_THEME_TOKEN_PATHS,
   MenuCompilationError,
   ThemeTokenValidationError,
+  accessPolicyChainImplies,
   applyViewRuntimeBindings,
   assertMonkeysThemeTokensComplete,
   assertThemeTokensDocumentStructure,
   buildApplicationHandoffUrl,
   buildChangeImpactGraph,
+  canonicalContentHash,
   compileCapabilityRegistry,
   compileConductorWorkflowDefinition,
   compileMenuRuntimeBundle,
+  compileNavigationRuntimeBundle,
+  compilePageRuntimeBundle,
   compilePageRuntimeProjection,
   compileProductAccessDeclaration,
   compileProductDeclaration,
   compileProductRuntimeCatalog,
   compileRenderTree,
+  compileRouteClaims,
   compileTenantRuntimeBindings,
   compileTenantRuntimeConfig,
   compileToolCapabilityManifest,
   compileViewProviderInput,
   compileViewProviderRegistry,
+  compileWorkbenchRuntimeBundle,
   compileWorkflowDefinitionFromConductor,
   compileWorkflowPersistenceProjection,
   createAgentSessionEventProjection,
@@ -14000,8 +15884,15 @@ export {
   createOpenApiCapabilityRegistrySource,
   createToolCapabilityManifest,
   createWorkflowCapabilityManifest,
+  declarativeCreateTemplateRevisionHash,
+  declarativeCreateTemplateSourceHash,
+  declarativeProductResourceRevisionHash,
+  declarativeProductResourceSourceHash,
+  declarativeRouteSpaceRevisionHash,
+  declarativeRouteSpaceSourceHash,
   extractOpenApiCapabilityManifests,
   isCompiledMenuItemSelected,
+  materializeRouteSpacePath,
   mergeThemeTokenDocuments,
   parseApplicationHandoff,
   projectAgentSessionEvents,
@@ -14010,11 +15901,17 @@ export {
   readMenuActivationFromSearch,
   resolveMenuActivationId,
   resolveThemeTokens,
+  resolveWorkbenchEntry,
+  revisionRefKey,
+  sameRevisionRef,
+  sameStableRef,
   serializeApplicationHandoff,
   serializeMenuActivationSearch,
+  stableRefKey,
   toAgentSessionViewModel,
   validateDomainCommand,
   validateThemeTokensDocument,
-  validateThemeTokensDocumentStructure
+  validateThemeTokensDocumentStructure,
+  validateWorkbenchRuntimeSet
 };
 //# sourceMappingURL=index.mjs.map