@inf-monkeys-tech/monkeys 1.0.36 → 1.0.37

package/lib/esm/runtime/index.mjs

@@ -8567,7 +8567,7 @@ function toAgentSessionViewModel(projection, snapshot) {
 }
 
 // src/contracts/semantic.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/contracts/data.ts
 import { z as z6 } from "zod";
@@ -8635,6 +8635,9 @@ var DomainEventSchema = z6.object({
   occurredAt: IsoDateTimeSchema
 }).strict();
 
+// src/contracts/menu.ts
+import { z as z8 } from "zod";
+
 // src/contracts/page.ts
 import { z as z7 } from "zod";
 var PageTypeSchema = z7.enum([
@@ -8722,6 +8725,9 @@ var PageDefinitionSchema = z7.object({
   access: z7.object({
     actions: z7.array(z7.enum(["read", "write", "execute", "manage-permissions"])).default([])
   }).strict(),
+  input: z7.object({
+    schemaRef: ContractIdentifierSchema
+  }).strict().optional(),
   rendererConfig: z7.object({
     schemaRef: ContractIdentifierSchema,
     value: JsonObjectSchema
@@ -8911,39 +8917,313 @@ var PageRuntimeProjectionSchema = z7.object({
   }
 });
 
+// src/contracts/menu.ts
+var MENU_ACTIVATION_QUERY_PARAMETER = "__menuActivation";
+var MENU_CONTRACT_VERSION = 1;
+var MENU_MAX_DEFINITIONS = 128;
+var MENU_MAX_NODES = 1024;
+var MENU_MAX_TREE_DEPTH = 16;
+var MENU_MAX_INPUT_BYTES = 64 * 1024;
+var MENU_MAX_INPUT_VALUES = 2048;
+var MenuOrderSchema = z8.number().int().min(-1e6).max(1e6);
+var inspectJsonValue = (value) => {
+  let maxDepth = 0;
+  let values = 0;
+  const visit = (candidate, depth) => {
+    values += 1;
+    maxDepth = Math.max(maxDepth, depth);
+    if (Array.isArray(candidate)) {
+      candidate.forEach((item) => visit(item, depth + 1));
+      return;
+    }
+    if (candidate && typeof candidate === "object") {
+      Object.values(candidate).forEach((item) => visit(item, depth + 1));
+    }
+  };
+  visit(value, 1);
+  return {
+    bytes: new TextEncoder().encode(JSON.stringify(value)).byteLength,
+    depth: maxDepth,
+    values
+  };
+};
+var MenuBoundedInputSchema = JsonObjectSchema.superRefine((value, context) => {
+  const bounds = inspectJsonValue(value);
+  if (bounds.bytes > MENU_MAX_INPUT_BYTES) {
+    context.addIssue({
+      code: "custom",
+      message: `Menu input exceeds ${MENU_MAX_INPUT_BYTES} UTF-8 bytes.`
+    });
+  }
+  if (bounds.depth > MENU_MAX_TREE_DEPTH) {
+    context.addIssue({
+      code: "custom",
+      message: `Menu input exceeds maximum depth ${MENU_MAX_TREE_DEPTH}.`
+    });
+  }
+  if (bounds.values > MENU_MAX_INPUT_VALUES) {
+    context.addIssue({
+      code: "custom",
+      message: `Menu input exceeds ${MENU_MAX_INPUT_VALUES} values.`
+    });
+  }
+});
+var MenuPageRefSchema = z8.object({
+  applicationId: ContractIdentifierSchema,
+  pageId: ContractIdentifierSchema
+}).strict();
+var MenuSourceInputBindingSchema = z8.discriminatedUnion("exposure", [
+  z8.object({ exposure: z8.literal("client"), value: MenuBoundedInputSchema }).strict(),
+  z8.object({ exposure: z8.literal("server"), value: MenuBoundedInputSchema }).strict()
+]);
+var MenuRuntimeInputBindingSchema = z8.discriminatedUnion("exposure", [
+  z8.object({ exposure: z8.literal("client"), value: MenuBoundedInputSchema }).strict(),
+  z8.object({ exposure: z8.literal("server") }).strict()
+]);
+var MenuNavigateBehaviorSchema = z8.object({
+  kind: z8.literal("navigate"),
+  page: MenuPageRefSchema,
+  activationId: ContractIdentifierSchema.optional(),
+  input: MenuSourceInputBindingSchema.optional()
+}).strict();
+var MenuActionBehaviorSchema = z8.object({
+  kind: z8.literal("action"),
+  actionRef: ContractIdentifierSchema,
+  input: MenuBoundedInputSchema.optional()
+}).strict();
+var MenuBehaviorSchema = z8.discriminatedUnion("kind", [
+  MenuNavigateBehaviorSchema,
+  MenuActionBehaviorSchema
+]);
+var MenuNodeBaseShape = {
+  nodeId: ContractIdentifierSchema,
+  parentNodeId: ContractIdentifierSchema.optional(),
+  order: MenuOrderSchema
+};
+var MenuGroupNodeSchema = z8.object({
+  ...MenuNodeBaseShape,
+  kind: z8.literal("group"),
+  label: LocalizedTextSchema.optional(),
+  iconRef: ContractIdentifierSchema.optional()
+}).strict();
+var MenuDividerNodeSchema = z8.object({
+  ...MenuNodeBaseShape,
+  kind: z8.literal("divider")
+}).strict();
+var MenuItemNodeSchema = z8.object({
+  ...MenuNodeBaseShape,
+  kind: z8.literal("item"),
+  label: LocalizedTextSchema,
+  iconRef: ContractIdentifierSchema.optional(),
+  tone: z8.enum(["default", "danger"]).optional(),
+  requiredPermission: ContractIdentifierSchema.optional(),
+  behavior: MenuBehaviorSchema
+}).strict();
+var MenuNodeSchema = z8.discriminatedUnion("kind", [
+  MenuGroupNodeSchema,
+  MenuDividerNodeSchema,
+  MenuItemNodeSchema
+]);
+var MenuContributionSchema = z8.object({
+  providerId: ContractIdentifierSchema,
+  parentNodeId: ContractIdentifierSchema.optional(),
+  order: MenuOrderSchema
+}).strict();
+var validateMenuStructure = (menu, context) => {
+  const nodesById = /* @__PURE__ */ new Map();
+  menu.nodes.forEach((node, index) => {
+    if (nodesById.has(node.nodeId)) {
+      context.addIssue({
+        code: "custom",
+        path: ["nodes", index, "nodeId"],
+        message: `Duplicate menu nodeId: ${node.nodeId}`
+      });
+      return;
+    }
+    nodesById.set(node.nodeId, { node, index });
+  });
+  const validateParent = (parentNodeId, path) => {
+    if (!parentNodeId) return;
+    const parent = nodesById.get(parentNodeId);
+    if (!parent) {
+      context.addIssue({ code: "custom", path, message: `Unknown menu parentNodeId: ${parentNodeId}` });
+      return;
+    }
+    if (parent.node.kind !== "group") {
+      context.addIssue({ code: "custom", path, message: `Menu parent ${parentNodeId} must be a group.` });
+    }
+  };
+  menu.nodes.forEach((node, index) => validateParent(node.parentNodeId, ["nodes", index, "parentNodeId"]));
+  menu.contributions.forEach((contribution, index) => validateParent(contribution.parentNodeId, ["contributions", index, "parentNodeId"]));
+  menu.nodes.forEach((node, index) => {
+    const ancestors = /* @__PURE__ */ new Set([node.nodeId]);
+    let parentNodeId = node.parentNodeId;
+    let depth = 1;
+    while (parentNodeId) {
+      if (ancestors.has(parentNodeId)) {
+        context.addIssue({
+          code: "custom",
+          path: ["nodes", index, "parentNodeId"],
+          message: `Menu node cycle contains ${node.nodeId}.`
+        });
+        break;
+      }
+      ancestors.add(parentNodeId);
+      depth += 1;
+      if (depth > MENU_MAX_TREE_DEPTH) {
+        context.addIssue({
+          code: "custom",
+          path: ["nodes", index, "parentNodeId"],
+          message: `Menu tree exceeds maximum depth ${MENU_MAX_TREE_DEPTH}.`
+        });
+        break;
+      }
+      parentNodeId = nodesById.get(parentNodeId)?.node.parentNodeId;
+    }
+  });
+  const contributionKeys = /* @__PURE__ */ new Set();
+  menu.contributions.forEach((contribution, index) => {
+    const key = `${contribution.parentNodeId ?? ""}\0${contribution.providerId}`;
+    if (contributionKeys.has(key)) {
+      context.addIssue({
+        code: "custom",
+        path: ["contributions", index, "providerId"],
+        message: `Duplicate menu contribution provider at parent: ${contribution.providerId}`
+      });
+    }
+    contributionKeys.add(key);
+  });
+};
+var MenuDefinitionSchema = z8.object({
+  contract: z8.literal("MenuDefinition"),
+  version: z8.literal(MENU_CONTRACT_VERSION),
+  applicationId: ContractIdentifierSchema,
+  surface: ContractIdentifierSchema,
+  menuId: ContractIdentifierSchema,
+  nodes: z8.array(MenuNodeSchema).max(MENU_MAX_NODES),
+  contributions: z8.array(MenuContributionSchema).max(MENU_MAX_NODES).default([])
+}).strict().superRefine(validateMenuStructure);
+var MenuDefinitionSetSchema = z8.union([
+  z8.literal("*"),
+  z8.object({
+    version: z8.literal(MENU_CONTRACT_VERSION),
+    definitions: z8.array(MenuDefinitionSchema).max(MENU_MAX_DEFINITIONS)
+  }).strict()
+]);
+var MenuAccessRequirementSchema = z8.object({
+  authenticated: z8.boolean().default(true),
+  permissionAllOf: z8.array(ContractIdentifierSchema).default([]),
+  permissionAnyOf: z8.array(ContractIdentifierSchema).default([]),
+  featureFlags: z8.array(ContractIdentifierSchema).default([])
+}).strict();
+var MenuPageRegistrationSchema = z8.object({
+  applicationId: ContractIdentifierSchema,
+  page: PageDefinitionSchema
+}).strict();
+var MenuActionRegistrationSchema = z8.object({
+  applicationId: ContractIdentifierSchema,
+  actionRef: ContractIdentifierSchema,
+  inputSchemaRef: ContractIdentifierSchema.optional(),
+  access: MenuAccessRequirementSchema
+}).strict();
+var MenuContributionProviderRegistrationSchema = z8.object({
+  applicationId: ContractIdentifierSchema,
+  providerId: ContractIdentifierSchema,
+  surfaces: z8.array(ContractIdentifierSchema).min(1).optional()
+}).strict();
+var CompiledMenuNavigateBehaviorSchema = z8.object({
+  kind: z8.literal("navigate"),
+  page: MenuPageRefSchema,
+  activationId: ContractIdentifierSchema,
+  input: MenuRuntimeInputBindingSchema.optional()
+}).strict();
+var CompiledMenuActionBehaviorSchema = z8.object({
+  kind: z8.literal("action"),
+  actionRef: ContractIdentifierSchema,
+  input: MenuBoundedInputSchema.optional()
+}).strict();
+var CompiledMenuBehaviorSchema = z8.discriminatedUnion("kind", [
+  CompiledMenuNavigateBehaviorSchema,
+  CompiledMenuActionBehaviorSchema
+]);
+var CompiledMenuItemAccessSchema = MenuAccessRequirementSchema.extend({
+  requiredPermission: ContractIdentifierSchema.optional()
+}).strict();
+var CompiledMenuGroupNodeSchema = MenuGroupNodeSchema;
+var CompiledMenuDividerNodeSchema = MenuDividerNodeSchema;
+var CompiledMenuItemNodeSchema = MenuItemNodeSchema.omit({ behavior: true, requiredPermission: true }).extend({
+  behavior: CompiledMenuBehaviorSchema,
+  access: CompiledMenuItemAccessSchema
+}).strict();
+var CompiledMenuNodeSchema = z8.discriminatedUnion("kind", [
+  CompiledMenuGroupNodeSchema,
+  CompiledMenuDividerNodeSchema,
+  CompiledMenuItemNodeSchema
+]);
+var CompiledMenuProjectionSchema = z8.object({
+  applicationId: ContractIdentifierSchema,
+  surface: ContractIdentifierSchema,
+  menuId: ContractIdentifierSchema,
+  nodes: z8.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES),
+  contributions: z8.array(MenuContributionSchema).max(MENU_MAX_NODES)
+}).strict();
+var MenuNavigationTargetSchema = z8.object({
+  page: MenuPageRefSchema,
+  activationId: ContractIdentifierSchema,
+  input: MenuRuntimeInputBindingSchema.optional()
+}).strict();
+var MenuRuntimeBundleSchema = z8.object({
+  contract: z8.literal("MenuRuntimeBundle"),
+  version: z8.literal(MENU_CONTRACT_VERSION),
+  applicationId: ContractIdentifierSchema,
+  sourceVersion: ContractIdentifierSchema,
+  contentHash: Sha256Schema,
+  menus: z8.array(CompiledMenuProjectionSchema).max(MENU_MAX_DEFINITIONS),
+  navigationTargets: z8.array(MenuNavigationTargetSchema),
+  sourceMap: z8.record(z8.string(), ContractIdentifierSchema).default({})
+}).strict();
+var MenuContributionResultSchema = z8.object({
+  contract: z8.literal("MenuContributionResult"),
+  applicationId: ContractIdentifierSchema,
+  surface: ContractIdentifierSchema,
+  menuId: ContractIdentifierSchema,
+  providerId: ContractIdentifierSchema,
+  nodes: z8.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES)
+}).strict();
+
 // src/contracts/semantic.ts
-var ConceptRelationshipSchema = z8.object({
+var ConceptRelationshipSchema = z9.object({
   kind: ContractIdentifierSchema,
   targetConceptId: ContractIdentifierSchema,
-  cardinality: z8.enum(["one", "optional", "many"])
+  cardinality: z9.enum(["one", "optional", "many"])
 }).strict();
-var ConceptDefinitionSchema = z8.object({
-  contract: z8.literal("ConceptDefinition"),
+var ConceptDefinitionSchema = z9.object({
+  contract: z9.literal("ConceptDefinition"),
   conceptId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z8.string().trim().min(1),
-  description: z8.string().optional(),
+  displayName: z9.string().trim().min(1),
+  description: z9.string().optional(),
   schemaRef: ContractIdentifierSchema,
   ontologyId: ContractIdentifierSchema.optional(),
-  capabilityIds: z8.array(ContractIdentifierSchema).default([]),
-  commandNames: z8.array(ContractIdentifierSchema).default([]),
-  relationships: z8.array(ConceptRelationshipSchema).default([])
+  capabilityIds: z9.array(ContractIdentifierSchema).default([]),
+  commandNames: z9.array(ContractIdentifierSchema).default([]),
+  relationships: z9.array(ConceptRelationshipSchema).default([])
 }).strict();
-var DomainCommandDefinitionSchema = z8.object({
-  contract: z8.literal("DomainCommandDefinition"),
+var DomainCommandDefinitionSchema = z9.object({
+  contract: z9.literal("DomainCommandDefinition"),
   commandName: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z8.string().trim().min(1),
-  description: z8.string().optional(),
-  targetKinds: z8.array(ContractIdentifierSchema).min(1),
+  displayName: z9.string().trim().min(1),
+  description: z9.string().optional(),
+  targetKinds: z9.array(ContractIdentifierSchema).min(1),
   inputSchemaRef: ContractIdentifierSchema,
   outputSchemaRef: ContractIdentifierSchema.optional(),
-  requiredPermissionCodes: z8.array(ContractIdentifierSchema).default([]),
+  requiredPermissionCodes: z9.array(ContractIdentifierSchema).default([]),
   handlerRef: EntityRefSchema,
-  sideEffects: z8.array(z8.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
+  sideEffects: z9.array(z9.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
 }).strict();
-var DomainCommandSchema = z8.object({
-  contract: z8.literal("DomainCommand"),
+var DomainCommandSchema = z9.object({
+  contract: z9.literal("DomainCommand"),
   commandId: ContractIdentifierSchema,
   commandName: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
@@ -8951,29 +9231,30 @@ var DomainCommandSchema = z8.object({
   idempotencyKey: ContractIdentifierSchema,
   targetRef: EntityRefSchema,
   actorRef: EntityRefSchema,
-  source: z8.object({
-    product: z8.enum(["studio", "kernel", "compute", "agent", "mcp", "service"]),
+  source: z9.object({
+    product: z9.enum(["studio", "kernel", "compute", "agent", "mcp", "service"]),
     pageId: ContractIdentifierSchema.optional(),
     capabilityId: ContractIdentifierSchema.optional()
   }).strict(),
   payload: JsonObjectSchema,
   issuedAt: IsoDateTimeSchema
 }).strict();
-var ProductDeclarationSchema = z8.object({
-  contract: z8.literal("ProductDeclaration"),
+var ProductDeclarationSchema = z9.object({
+  contract: z9.literal("ProductDeclaration"),
   declarationId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  concepts: z8.array(ConceptDefinitionSchema).default([]),
-  ontologies: z8.array(OntologyDefinitionSchema).default([]),
-  projections: z8.array(ProjectionSpecSchema).default([]),
-  commands: z8.array(DomainCommandDefinitionSchema).default([]),
-  capabilities: z8.array(CapabilityManifestSchema).default([]),
-  pages: z8.array(PageDefinitionSchema).default([])
+  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 = z8.object({
+var DeclarationGraphEdgeSchema = z9.object({
   from: EntityRefSchema,
   to: EntityRefSchema,
-  relation: z8.enum([
+  relation: z9.enum([
     "uses-ontology",
     "uses-projection",
     "uses-capability",
@@ -8981,17 +9262,17 @@ var DeclarationGraphEdgeSchema = z8.object({
     "relates-to-concept"
   ])
 }).strict();
-var ChangeImpactSchema = z8.object({
+var ChangeImpactSchema = z9.object({
   changedRef: EntityRefSchema,
-  affectedRefs: z8.array(EntityRefSchema),
-  reasons: z8.array(ContractIdentifierSchema).min(1)
+  affectedRefs: z9.array(EntityRefSchema),
+  reasons: z9.array(ContractIdentifierSchema).min(1)
 }).strict();
-var ChangeImpactGraphSchema = z8.object({
-  contract: z8.literal("ChangeImpactGraph"),
+var ChangeImpactGraphSchema = z9.object({
+  contract: z9.literal("ChangeImpactGraph"),
   declarationId: ContractIdentifierSchema,
-  nodes: z8.array(EntityRefSchema),
-  edges: z8.array(DeclarationGraphEdgeSchema),
-  impacts: z8.array(ChangeImpactSchema),
+  nodes: z9.array(EntityRefSchema),
+  edges: z9.array(DeclarationGraphEdgeSchema),
+  impacts: z9.array(ChangeImpactSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
 
@@ -9134,6 +9415,11 @@ var compileProductDeclaration = (input) => {
   const commandsByName = uniqueIndex(declaration.commands, (value) => value.commandName, "command name");
   const capabilitiesById = uniqueIndex(declaration.capabilities, (value) => value.id, "capability id");
   const pagesById = uniqueIndex(declaration.pages, (value) => value.pageId, "page id");
+  const menusByKey = uniqueIndex(
+    declaration.menus,
+    (value) => `${value.applicationId}/${value.surface}/${value.menuId}`,
+    "menu definition"
+  );
   const nodes = [];
   const edges = [];
   const addNode = (kind, id) => nodes.push(ref(kind, id));
@@ -9148,6 +9434,7 @@ var compileProductDeclaration = (input) => {
   }
   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) {
@@ -9193,6 +9480,7 @@ var compileProductDeclaration = (input) => {
     commandsByName,
     capabilitiesById,
     pagesById,
+    menusByKey,
     nodes: Object.freeze(nodes),
     edges: Object.freeze(edges)
   });
@@ -9271,6 +9559,512 @@ var buildChangeImpactGraph = (previousInput, nextInput, generatedAt = (/* @__PUR
   });
 };
 
+// src/runtime/menu-compiler.ts
+var MenuCompilationError = class extends Error {
+  constructor(code, path, message) {
+    super(`${path}: ${message}`);
+    this.name = "MenuCompilationError";
+    this.code = code;
+    this.path = path;
+  }
+};
+var menuKey = (applicationId, surface, menuId) => `${applicationId}\0${surface}\0${menuId}`;
+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) => {
+  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 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 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 uniqueIndex2 = (values, key, path) => {
+  const result = /* @__PURE__ */ new Map();
+  values.forEach((value, index) => {
+    const identity = key(value);
+    if (result.has(identity)) {
+      throw new MenuCompilationError(
+        "duplicate-registration",
+        `${path}[${index}]`,
+        `Duplicate registry identity: ${identity.split("\0").join("/")}`
+      );
+    }
+    result.set(identity, value);
+  });
+  return result;
+};
+var normalizedSiblingOrder = (left, right) => left.order - right.order || left.nodeId.localeCompare(right.nodeId);
+var normalizeNodeOrder = (nodes) => {
+  const childrenByParent = /* @__PURE__ */ new Map();
+  nodes.forEach((node) => {
+    const parent = node.parentNodeId ?? "";
+    const children = childrenByParent.get(parent) ?? [];
+    children.push(node);
+    childrenByParent.set(parent, children);
+  });
+  childrenByParent.forEach((children) => children.sort(normalizedSiblingOrder));
+  const ordered = [];
+  const appendChildren = (parentNodeId) => {
+    for (const node of childrenByParent.get(parentNodeId) ?? []) {
+      ordered.push(node);
+      appendChildren(node.nodeId);
+    }
+  };
+  appendChildren("");
+  return ordered;
+};
+var requirementFromPage = (registration) => ({
+  authenticated: registration.page.visibility.authenticated,
+  permissionAllOf: registration.page.visibility.permissionAllOf,
+  permissionAnyOf: registration.page.visibility.permissionAnyOf,
+  featureFlags: registration.page.visibility.featureFlags
+});
+var validatePermissionCodes = (permissions, knownPermissions, path) => {
+  permissions.forEach((permission, index) => {
+    if (!knownPermissions.has(permission)) {
+      throw new MenuCompilationError(
+        "unknown-permission",
+        `${path}[${index}]`,
+        `Unknown platform permission: ${permission}`
+      );
+    }
+  });
+};
+var validateInput = (value, schemaRef, validators, path) => {
+  if (!schemaRef) {
+    throw new MenuCompilationError(
+      "missing-input-schema",
+      path,
+      "Input is configured but the target has no input schema reference."
+    );
+  }
+  const validator = validators.get(schemaRef);
+  if (!validator) {
+    throw new MenuCompilationError(
+      "unknown-input-schema",
+      path,
+      `No input validator is registered for ${schemaRef}.`
+    );
+  }
+  try {
+    return MenuBoundedInputSchema.parse(validator(value));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new MenuCompilationError("invalid-input", path, `Input validation failed for ${schemaRef}: ${message}`);
+  }
+};
+var evaluateAccess = (item, context) => {
+  const reasons = [];
+  const protectedBySession = item.access.authenticated || item.access.permissionAllOf.length > 0 || item.access.permissionAnyOf.length > 0 || item.access.requiredPermission !== void 0;
+  if (!context.sessionResolved && protectedBySession) reasons.push("session-unresolved");
+  if (item.access.authenticated && !context.authenticated) reasons.push("authentication");
+  const granted = new Set(context.permissionCodes);
+  const elevated = context.isKernelSuperAdmin === true || granted.has("*");
+  if (item.access.permissionAllOf.some((permission) => !granted.has(permission))) {
+    reasons.push("permission-all");
+  }
+  if (item.access.permissionAnyOf.length > 0 && !item.access.permissionAnyOf.some((permission) => granted.has(permission))) {
+    reasons.push("permission-any");
+  }
+  if (!elevated && item.access.requiredPermission && !granted.has(item.access.requiredPermission)) {
+    reasons.push("required-permission");
+  }
+  if (item.access.featureFlags.some((flag) => context.featureFlags[flag] !== true)) {
+    reasons.push("feature-flag");
+  }
+  return Object.freeze({ allowed: reasons.length === 0, reasons: Object.freeze(reasons) });
+};
+var resolveMenuActivationId = (page, activationId) => activationId ?? page.pageId;
+var readMenuActivationFromSearch = (search) => {
+  const params = typeof search === "string" ? new URLSearchParams(search) : search;
+  const value = params.get(MENU_ACTIVATION_QUERY_PARAMETER)?.trim();
+  return value || void 0;
+};
+var serializeMenuActivationSearch = (search, page, activationId) => {
+  const params = new URLSearchParams(typeof search === "string" ? search : search.toString());
+  const effectiveActivationId = resolveMenuActivationId(page, activationId);
+  if (effectiveActivationId === page.pageId) params.delete(MENU_ACTIVATION_QUERY_PARAMETER);
+  else params.set(MENU_ACTIVATION_QUERY_PARAMETER, effectiveActivationId);
+  return params.toString();
+};
+var isCompiledMenuItemSelected = (item, page, activationId) => item.behavior.kind === "navigate" && pageKey(item.behavior.page) === pageKey(page) && item.behavior.activationId === resolveMenuActivationId(page, activationId);
+var compileMenuRuntimeBundle = (input) => {
+  const applicationId = ContractIdentifierSchema.parse(input.applicationId);
+  const supportedSurfaces = new Set(input.supportedSurfaces.map((surface) => ContractIdentifierSchema.parse(surface)));
+  const definitions = input.definitions.map((definition) => MenuDefinitionSchema.parse(definition));
+  const pages = input.pages.map((registration) => MenuPageRegistrationSchema.parse(registration));
+  const actions = input.actions.map((registration) => MenuActionRegistrationSchema.parse(registration));
+  const contributionProviders = input.contributionProviders.map((registration) => MenuContributionProviderRegistrationSchema.parse(registration));
+  const inputValidators = input.inputValidators ?? /* @__PURE__ */ new Map();
+  const knownPermissions = new Set(input.permissionCodes.map((permission) => ContractIdentifierSchema.parse(permission)));
+  pages.forEach((registration, index) => {
+    if (!registration.page.visibility.productContexts.some((context) => context === registration.applicationId)) {
+      throw new MenuCompilationError(
+        "invalid-page-application",
+        `pages[${index}].applicationId`,
+        `Page ${registration.page.pageId} is not visible in ${registration.applicationId}.`
+      );
+    }
+  });
+  const pagesByKey = uniqueIndex2(pages, (registration) => pageKey({
+    applicationId: registration.applicationId,
+    pageId: registration.page.pageId
+  }), "pages");
+  const actionsByKey = uniqueIndex2(actions, (registration) => actionKey(
+    registration.applicationId,
+    registration.actionRef
+  ), "actions");
+  const providersByKey = uniqueIndex2(contributionProviders, (registration) => providerKey(
+    registration.applicationId,
+    registration.providerId
+  ), "contributionProviders");
+  const definitionsByKey = /* @__PURE__ */ new Map();
+  definitions.forEach((definition, index) => {
+    const identity = menuKey(definition.applicationId, definition.surface, definition.menuId);
+    if (definitionsByKey.has(identity)) {
+      throw new MenuCompilationError(
+        "duplicate-definition",
+        `definitions[${index}]`,
+        `Duplicate menu definition: ${definition.applicationId}/${definition.surface}/${definition.menuId}`
+      );
+    }
+    definitionsByKey.set(identity, definition);
+  });
+  const targetSourceSignatures = /* @__PURE__ */ new Map();
+  const navigationTargetsByKey = /* @__PURE__ */ new Map();
+  const serverInputByTargetKey = /* @__PURE__ */ new Map();
+  const requestedTargetKeys = /* @__PURE__ */ new Set();
+  const requestedMenus = [];
+  definitions.forEach((definition, definitionIndex) => {
+    if (definition.applicationId === applicationId && !supportedSurfaces.has(definition.surface)) {
+      throw new MenuCompilationError(
+        "unsupported-surface",
+        `definitions[${definitionIndex}].surface`,
+        `Application ${applicationId} does not support menu surface ${definition.surface}.`
+      );
+    }
+    const compiledNodes = definition.nodes.map((node, nodeIndex) => {
+      if (node.kind !== "item") return node;
+      const nodePath = `definitions[${definitionIndex}].nodes[${nodeIndex}]`;
+      if (node.requiredPermission && !knownPermissions.has(node.requiredPermission)) {
+        throw new MenuCompilationError(
+          "unknown-permission",
+          `${nodePath}.requiredPermission`,
+          `Unknown platform permission: ${node.requiredPermission}`
+        );
+      }
+      let access;
+      if (node.behavior.kind === "navigate") {
+        const registration = pagesByKey.get(pageKey(node.behavior.page));
+        if (!registration) {
+          throw new MenuCompilationError(
+            "unknown-page",
+            `${nodePath}.behavior.page`,
+            `Unknown page reference: ${node.behavior.page.applicationId}/${node.behavior.page.pageId}`
+          );
+        }
+        access = requirementFromPage(registration);
+        validatePermissionCodes(access.permissionAllOf, knownPermissions, `${nodePath}.targetAccess.permissionAllOf`);
+        validatePermissionCodes(access.permissionAnyOf, knownPermissions, `${nodePath}.targetAccess.permissionAnyOf`);
+        const activationId = resolveMenuActivationId(node.behavior.page, node.behavior.activationId);
+        const identity = targetKey(node.behavior.page, activationId);
+        let runtimeInput;
+        let normalizedSourceInput;
+        if (node.behavior.input) {
+          const normalized = validateInput(
+            node.behavior.input.value,
+            registration.page.input?.schemaRef,
+            inputValidators,
+            `${nodePath}.behavior.input.value`
+          );
+          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));
+          }
+        }
+        const signature = stableSerialize({
+          kind: "navigate",
+          page: node.behavior.page,
+          activationId,
+          input: normalizedSourceInput
+        });
+        const existingSignature = targetSourceSignatures.get(identity);
+        if (existingSignature !== void 0 && existingSignature !== signature) {
+          throw new MenuCompilationError(
+            "conflicting-navigation-target",
+            `${nodePath}.behavior`,
+            `Navigation target ${node.behavior.page.applicationId}/${node.behavior.page.pageId}/${activationId} has conflicting behavior or input.`
+          );
+        }
+        targetSourceSignatures.set(identity, signature);
+        if (!navigationTargetsByKey.has(identity)) {
+          navigationTargetsByKey.set(identity, {
+            page: node.behavior.page,
+            activationId,
+            input: runtimeInput
+          });
+        }
+        if (definition.applicationId === applicationId) requestedTargetKeys.add(identity);
+        const { requiredPermission: requiredPermission2, behavior: _behavior2, ...presentation2 } = node;
+        return CompiledMenuItemNodeSchema.parse({
+          ...presentation2,
+          behavior: {
+            kind: "navigate",
+            page: node.behavior.page,
+            activationId,
+            input: runtimeInput
+          },
+          access: { ...access, requiredPermission: requiredPermission2 }
+        });
+      }
+      const action = actionsByKey.get(actionKey(definition.applicationId, node.behavior.actionRef));
+      if (!action) {
+        throw new MenuCompilationError(
+          "unknown-action",
+          `${nodePath}.behavior.actionRef`,
+          `Unknown action reference for ${definition.applicationId}: ${node.behavior.actionRef}`
+        );
+      }
+      access = action.access;
+      validatePermissionCodes(access.permissionAllOf, knownPermissions, `${nodePath}.targetAccess.permissionAllOf`);
+      validatePermissionCodes(access.permissionAnyOf, knownPermissions, `${nodePath}.targetAccess.permissionAnyOf`);
+      const actionInput = node.behavior.input ? validateInput(node.behavior.input, action.inputSchemaRef, inputValidators, `${nodePath}.behavior.input`) : void 0;
+      const { requiredPermission, behavior: _behavior, ...presentation } = node;
+      return CompiledMenuItemNodeSchema.parse({
+        ...presentation,
+        behavior: { kind: "action", actionRef: node.behavior.actionRef, input: actionInput },
+        access: { ...access, requiredPermission }
+      });
+    });
+    definition.contributions.forEach((contribution, contributionIndex) => {
+      const provider = providersByKey.get(providerKey(definition.applicationId, contribution.providerId));
+      const path = `definitions[${definitionIndex}].contributions[${contributionIndex}].providerId`;
+      if (!provider) {
+        throw new MenuCompilationError(
+          "unknown-contribution-provider",
+          path,
+          `Unknown contribution provider for ${definition.applicationId}: ${contribution.providerId}`
+        );
+      }
+      if (provider.surfaces && !provider.surfaces.includes(definition.surface)) {
+        throw new MenuCompilationError(
+          "unsupported-contribution-surface",
+          path,
+          `Provider ${contribution.providerId} does not support surface ${definition.surface}.`
+        );
+      }
+    });
+    if (definition.applicationId !== applicationId) return;
+    requestedMenus.push(CompiledMenuProjectionSchema.parse({
+      applicationId: definition.applicationId,
+      surface: definition.surface,
+      menuId: definition.menuId,
+      nodes: normalizeNodeOrder(compiledNodes),
+      contributions: [...definition.contributions].sort((left, right) => (left.parentNodeId ?? "").localeCompare(right.parentNodeId ?? "") || left.order - right.order || left.providerId.localeCompare(right.providerId))
+    }));
+  });
+  const menus = requestedMenus.sort((left, right) => left.surface.localeCompare(right.surface) || left.menuId.localeCompare(right.menuId));
+  const navigationTargets = [...requestedTargetKeys].map((identity) => navigationTargetsByKey.get(identity)).filter((target) => target !== void 0).sort((left, right) => left.page.applicationId.localeCompare(right.page.applicationId) || left.page.pageId.localeCompare(right.page.pageId) || left.activationId.localeCompare(right.activationId));
+  const unsignedDocument = {
+    contract: "MenuRuntimeBundle",
+    version: MENU_CONTRACT_VERSION,
+    applicationId,
+    sourceVersion: input.sourceVersion,
+    menus,
+    navigationTargets,
+    sourceMap: Object.fromEntries(
+      Object.entries(input.sourceMap ?? {}).sort(([left], [right]) => left.localeCompare(right))
+    )
+  };
+  const document = MenuRuntimeBundleSchema.parse({
+    ...unsignedDocument,
+    contentHash: sha256Hex(stableSerialize(unsignedDocument))
+  });
+  const menusByKey = new Map(document.menus.map((menu) => [
+    menuKey(menu.applicationId, menu.surface, menu.menuId),
+    menu
+  ]));
+  const documentTargetsByKey = new Map(document.navigationTargets.map((target) => [
+    targetKey(target.page, target.activationId),
+    target
+  ]));
+  const resolveNavigationTarget = (page, explicitActivationId) => {
+    const parsedPage = MenuPageRefSchema.parse(page);
+    if (explicitActivationId !== void 0) {
+      const parsedActivation = ContractIdentifierSchema.safeParse(explicitActivationId);
+      if (!parsedActivation.success) return Object.freeze({ status: "invalid", reason: "invalid-activation" });
+      const target2 = documentTargetsByKey.get(targetKey(parsedPage, parsedActivation.data));
+      if (target2) return Object.freeze({ status: "resolved", target: target2 });
+      const sameActivation = document.navigationTargets.find((candidate) => candidate.page.applicationId === parsedPage.applicationId && candidate.activationId === parsedActivation.data);
+      return Object.freeze({
+        status: "invalid",
+        reason: sameActivation ? "page-mismatch" : "unknown-activation"
+      });
+    }
+    const target = documentTargetsByKey.get(targetKey(parsedPage, parsedPage.pageId));
+    return target ? Object.freeze({ status: "resolved", target }) : Object.freeze({ status: "unmatched" });
+  };
+  return Object.freeze({
+    document: deepFreeze(document),
+    menusByKey,
+    navigationTargetsByKey: documentTargetsByKey,
+    serverInputByTargetKey,
+    evaluateItemAccess: evaluateAccess,
+    resolveNavigationTarget,
+    selectedNodeIds(menu, page, activationId) {
+      if (menu.applicationId !== document.applicationId) return /* @__PURE__ */ new Set();
+      const nodesById = new Map(menu.nodes.map((node) => [node.nodeId, node]));
+      const selected = /* @__PURE__ */ new Set();
+      for (const node of menu.nodes) {
+        if (node.kind !== "item" || !isCompiledMenuItemSelected(node, page, activationId)) continue;
+        selected.add(node.nodeId);
+        let parentNodeId = node.parentNodeId;
+        while (parentNodeId) {
+          selected.add(parentNodeId);
+          parentNodeId = nodesById.get(parentNodeId)?.parentNodeId;
+        }
+      }
+      return selected;
+    }
+  });
+};
+
 // src/runtime/view-provider-registry.ts
 var referenceVersion = (version) => version === void 0 ? void 0 : String(version);
 var sameStringSet = (left, right) => {
@@ -9546,7 +10340,7 @@ var compilePageRuntimeProjection = (input) => {
   const guardsByPageId = unique2(document.guards, (guard) => guard.pageId, "guard pageId");
   const renderersByPageId = unique2(document.renderers, (renderer) => renderer.pageId, "renderer pageId");
   const matchers = pages.map((page) => ({ page, pattern: routePattern(page.routePath), specificity: routeSpecificity(page.routePath) })).sort((left, right) => right.specificity - left.specificity || left.page.pageId.localeCompare(right.page.pageId));
-  const evaluateAccess = (pageId, context) => {
+  const evaluateAccess2 = (pageId, context) => {
     const guard = guardsByPageId.get(pageId);
     if (!guard) throw new Error(`Unknown page guard: ${pageId}`);
     const reasons = [];
@@ -9569,9 +10363,9 @@ var compilePageRuntimeProjection = (input) => {
     navigationByPageId,
     guardsByPageId,
     renderersByPageId,
-    evaluateAccess,
+    evaluateAccess: evaluateAccess2,
     visibleNavigation(context) {
-      return Object.freeze(document.navigation.filter((item) => evaluateAccess(item.pageId, context).allowed));
+      return Object.freeze(document.navigation.filter((item) => evaluateAccess2(item.pageId, context).allowed));
     },
     matchRoute(pathname) {
       const path = pathname.split("?")[0]?.split("#")[0] || "/";
@@ -9735,10 +10529,10 @@ var compileRenderTree = (input) => {
 };
 
 // src/contracts/tenant.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/contracts/theme.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/theme-tokens/core.ts
 var import_ajv = __toESM(require_ajv());
@@ -11965,20 +12759,20 @@ function assertMonkeysThemeTokensComplete(input) {
 }
 
 // src/contracts/theme.ts
-var ThemeTokenTypeSchema = z9.enum(THEME_TOKEN_TYPES);
-var ThemeTokenSchema = z9.record(z9.string(), z9.unknown()).superRefine((input, context) => {
+var ThemeTokenTypeSchema = z10.enum(THEME_TOKEN_TYPES);
+var ThemeTokenSchema = z10.record(z10.string(), z10.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 = z9.record(z9.string(), z9.unknown()).superRefine((input, context) => {
+var ThemeTokenGroupSchema = z10.record(z10.string(), z10.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocumentStructure(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
   }
 });
-var ThemeTokensSchema = z9.record(z9.string(), z9.unknown()).superRefine((input, context) => {
+var ThemeTokensSchema = z10.record(z10.string(), z10.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocument(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
@@ -12005,9 +12799,9 @@ var ResolvedThemeTokensSchema = ThemeTokensSchema.superRefine((input, context) =
 });
 
 // src/contracts/tenant.ts
-var DesignTokenFileSourceSchema = z10.object({
-  type: z10.literal("file"),
-  path: z10.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenFileSourceSchema = z11.object({
+  type: z11.literal("file"),
+  path: z11.string().trim().min(1).superRefine((source, context) => {
     if (/^[a-z][a-z\d+.-]*:/i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -12016,9 +12810,9 @@ var DesignTokenFileSourceSchema = z10.object({
     }
   })
 }).strict();
-var DesignTokenUrlSourceSchema = z10.object({
-  type: z10.literal("url"),
-  url: z10.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenUrlSourceSchema = z11.object({
+  type: z11.literal("url"),
+  url: z11.string().trim().min(1).superRefine((source, context) => {
     if (!/^https?:\/\//i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -12027,94 +12821,94 @@ var DesignTokenUrlSourceSchema = z10.object({
     }
   })
 }).strict();
-var DesignTokenInlineSourceSchema = z10.object({
-  type: z10.literal("inline"),
+var DesignTokenInlineSourceSchema = z11.object({
+  type: z11.literal("inline"),
   document: ThemeTokensSchema
 }).strict();
-var DesignTokenSourceSchema = z10.discriminatedUnion("type", [
+var DesignTokenSourceSchema = z11.discriminatedUnion("type", [
   DesignTokenFileSourceSchema,
   DesignTokenUrlSourceSchema,
   DesignTokenInlineSourceSchema
 ]);
-var TenantDesignTokensConfigSchema = z10.object({
+var TenantDesignTokensConfigSchema = z11.object({
   /** Ordered tenant overrides. The backend always applies the product default first. */
-  tokenSources: z10.array(DesignTokenSourceSchema)
+  tokenSources: z11.array(DesignTokenSourceSchema)
 }).strict();
-var TenantAuthBindingSchema = z10.object({
-  kind: z10.literal("auth-provider"),
+var TenantAuthBindingSchema = z11.object({
+  kind: z11.literal("auth-provider"),
   providerId: ContractIdentifierSchema,
   policyRef: ContractIdentifierSchema.optional()
 }).strict();
-var TenantDataBindingSchema = z10.discriminatedUnion("kind", [
-  z10.object({
-    kind: z10.literal("data-provider"),
+var TenantDataBindingSchema = z11.discriminatedUnion("kind", [
+  z11.object({
+    kind: z11.literal("data-provider"),
     providerId: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict(),
-  z10.object({
-    kind: z10.literal("projection"),
+  z11.object({
+    kind: z11.literal("projection"),
     projectionRef: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict()
 ]);
-var TenantAuthBindingsSchema = z10.record(
+var TenantAuthBindingsSchema = z11.record(
   ContractIdentifierSchema,
   TenantAuthBindingSchema
 );
-var TenantDataBindingsSchema = z10.record(
+var TenantDataBindingsSchema = z11.record(
   ContractIdentifierSchema,
   TenantDataBindingSchema
 );
-var TenantTrendRadarSourceSchema = z10.object({
+var TenantTrendRadarSourceSchema = z11.object({
   ontologyId: ContractIdentifierSchema,
   viewId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarSourcesSchema = z10.object({
+var TenantTrendRadarSourcesSchema = z11.object({
   hotwords: TenantTrendRadarSourceSchema.optional(),
   brands: TenantTrendRadarSourceSchema.optional()
 }).strict();
-var AssetVariantsSchema = z10.object({
-  light: z10.string().optional(),
-  dark: z10.string().optional()
+var AssetVariantsSchema = z11.object({
+  light: z11.string().optional(),
+  dark: z11.string().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 = z10.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/, "Expected a stable current-user menu identifier.");
-var CurrentUserMenuDisplayTextSchema = z10.union([
-  z10.string().trim().min(1),
-  z10.record(z10.string().trim().min(1), z10.string().trim().min(1)).refine((value) => Object.keys(value).length > 0, "Localized menu text must contain at least one locale.")
+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 CurrentUserMenuNavigationItemSchema = z10.object({
+var CurrentUserMenuNavigationItemSchema = z11.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z10.literal("navigation"),
+  kind: z11.literal("navigation"),
   ref: CurrentUserMenuIdentifierSchema
 }).strict();
-var CurrentUserMenuControlItemSchema = z10.object({
+var CurrentUserMenuControlItemSchema = z11.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z10.literal("control"),
-  ref: z10.enum(CURRENT_USER_MENU_CONTROL_REFS)
+  kind: z11.literal("control"),
+  ref: z11.enum(CURRENT_USER_MENU_CONTROL_REFS)
 }).strict();
-var CurrentUserMenuActionItemSchema = z10.object({
+var CurrentUserMenuActionItemSchema = z11.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z10.literal("action"),
-  ref: z10.enum(CURRENT_USER_MENU_ACTION_REFS),
-  tone: z10.enum(["default", "danger"]).optional()
+  kind: z11.literal("action"),
+  ref: z11.enum(CURRENT_USER_MENU_ACTION_REFS),
+  tone: z11.enum(["default", "danger"]).optional()
 }).strict();
-var CurrentUserMenuItemSchema = z10.discriminatedUnion("kind", [
+var CurrentUserMenuItemSchema = z11.discriminatedUnion("kind", [
   CurrentUserMenuNavigationItemSchema,
   CurrentUserMenuControlItemSchema,
   CurrentUserMenuActionItemSchema
 ]);
-var CurrentUserMenuSectionSchema = z10.object({
+var CurrentUserMenuSectionSchema = z11.object({
   id: CurrentUserMenuIdentifierSchema,
   label: CurrentUserMenuDisplayTextSchema.optional(),
-  dividerBefore: z10.boolean().optional(),
-  items: z10.array(CurrentUserMenuItemSchema)
+  dividerBefore: z11.boolean().optional(),
+  items: z11.array(CurrentUserMenuItemSchema)
 }).strict();
-var CurrentUserMenuConfigSchema = z10.object({
-  version: z10.literal(1),
-  sections: z10.array(CurrentUserMenuSectionSchema).max(20)
+var CurrentUserMenuConfigSchema = z11.object({
+  version: z11.literal(1),
+  sections: z11.array(CurrentUserMenuSectionSchema).max(20)
 }).strict().superRefine((value, context) => {
   const sectionIds = /* @__PURE__ */ new Set();
   const itemIds = /* @__PURE__ */ new Set();
@@ -12148,7 +12942,7 @@ var CurrentUserMenuConfigSchema = z10.object({
     });
   }
 });
-var LegacyCurrentUserMenuProfileSchema = z10.array(z10.enum(LEGACY_CURRENT_USER_MENU_ITEM_IDS)).superRefine((value, context) => {
+var LegacyCurrentUserMenuProfileSchema = z11.array(z11.enum(LEGACY_CURRENT_USER_MENU_ITEM_IDS)).superRefine((value, context) => {
   const seen = /* @__PURE__ */ new Set();
   value.forEach((item, index) => {
     if (seen.has(item)) {
@@ -12161,73 +12955,73 @@ var LegacyCurrentUserMenuProfileSchema = z10.array(z10.enum(LEGACY_CURRENT_USER_
     seen.add(item);
   });
 });
-var CurrentUserMenuProfileSchema = z10.union([
-  z10.literal("*"),
+var CurrentUserMenuProfileSchema = z11.union([
+  z11.literal("*"),
   LegacyCurrentUserMenuProfileSchema,
   CurrentUserMenuConfigSchema
 ]);
-var ThemeHeadbarSchema = z10.object({
-  theme: z10.enum(["card", "glassy", "ghost"]).optional(),
-  navPosition: z10.enum(["left", "center", "right"]).optional(),
-  actions: z10.union([z10.literal("*"), z10.array(ContractIdentifierSchema)]).optional(),
+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(),
   profile: CurrentUserMenuProfileSchema.optional(),
-  showTeamQuota: z10.boolean().optional()
+  showTeamQuota: z11.boolean().optional()
 }).strict();
-var TenantHeadbarModuleLeafSchema = z10.object({
+var TenantHeadbarModuleLeafSchema = z11.object({
   id: ContractIdentifierSchema,
-  extraInfo: z10.boolean().optional(),
-  displayName: z10.union([z10.string(), z10.record(LocaleIdentifierSchema, z10.string())]).optional(),
-  visible: z10.boolean().optional(),
-  disabled: z10.boolean().optional(),
-  icon: z10.string().optional(),
-  showQuickSwitcher: z10.boolean().optional(),
-  showSidebar: z10.boolean().optional(),
-  showContentFrame: z10.boolean().optional()
+  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()
 }).strict();
 var TenantHeadbarModuleItemSchema = TenantHeadbarModuleLeafSchema.extend({
-  children: z10.array(TenantHeadbarModuleLeafSchema).optional()
+  children: z11.array(TenantHeadbarModuleLeafSchema).optional()
 }).strict();
-var KernelHeadbarSchema = z10.object({
-  theme: z10.literal("card").optional(),
-  layoutMode: z10.enum(["boxed", "full-bleed"]).optional(),
-  heightPx: z10.number().positive().optional(),
-  navPosition: z10.enum(["left", "center", "right"]).optional(),
-  brandTitle: z10.string().optional(),
-  menuRadius: z10.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
+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 = z10.object({
-  color: z10.string().optional(),
-  url: z10.string().optional(),
-  type: z10.enum(["svg", "image"]).optional(),
-  hintTextColor: z10.string().optional()
+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 = z10.object({
+var WorkbenchCustomerToolSchema = z11.object({
   id: ContractIdentifierSchema,
-  label: z10.union([z10.string(), z10.record(LocaleIdentifierSchema, z10.string())]).optional(),
-  fixed: z10.boolean().optional()
+  label: z11.union([z11.string(), z11.record(LocaleIdentifierSchema, z11.string())]).optional(),
+  fixed: z11.boolean().optional()
 }).strict();
-var WorkbenchStudioOverrideSchema = z10.object({
-  studioName: z10.string().trim().min(1),
-  dropdownToolsDefault: z10.array(ContractIdentifierSchema).optional(),
-  existingToolsDefault: z10.array(ContractIdentifierSchema).optional(),
-  historyColumnsDefault: z10.number().int().min(1).max(6).optional()
+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()
 }).strict();
-var TenantWorkbenchPageContextSchema = z10.object({
+var TenantWorkbenchPageContextSchema = z11.object({
   workflow: JsonObjectSchema.optional(),
   agent: JsonObjectSchema.optional(),
   agentId: ContractIdentifierSchema.optional(),
   designProject: JsonObjectSchema.optional(),
   designMetadataId: ContractIdentifierSchema.optional(),
-  iframeUrl: z10.string().trim().min(1).optional(),
-  info: z10.object({
+  iframeUrl: z11.string().trim().min(1).optional(),
+  info: z11.object({
     displayName: LocalizedTextSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    iconUrl: z10.string().trim().min(1).optional()
+    iconUrl: z11.string().trim().min(1).optional()
   }).strict().optional(),
-  isBuiltinPinned: z10.boolean().optional(),
-  isBuiltinReadonly: z10.boolean().optional()
+  isBuiltinPinned: z11.boolean().optional(),
+  isBuiltinReadonly: z11.boolean().optional()
 }).strict();
-var TenantWorkbenchPageEnvelopeSchema = z10.object({
+var TenantWorkbenchPageEnvelopeSchema = z11.object({
   definition: PageDefinitionSchema,
   context: TenantWorkbenchPageContextSchema
 }).strict().superRefine(({ definition }, context) => {
@@ -12260,56 +13054,56 @@ var TenantWorkbenchPageEnvelopeSchema = z10.object({
     });
   }
 });
-var TenantWorkbenchPageGroupSchema = z10.object({
+var TenantWorkbenchPageGroupSchema = z11.object({
   id: ContractIdentifierSchema,
-  pageIds: z10.array(ContractIdentifierSchema),
+  pageIds: z11.array(ContractIdentifierSchema),
   displayName: LocalizedTextSchema,
-  isBuiltIn: z10.boolean(),
-  iconUrl: z10.string().optional(),
-  sortIndex: z10.number().int().nullable().optional(),
+  isBuiltIn: z11.boolean(),
+  iconUrl: z11.string().optional(),
+  sortIndex: z11.number().int().nullable().optional(),
   presetRelationId: ContractIdentifierSchema.optional(),
   relationKey: ContractIdentifierSchema.nullable().optional(),
   studioId: ContractIdentifierSchema.optional()
 }).strict();
-var TenantWorkbenchConfigSchema = z10.object({
-  pages: z10.array(TenantWorkbenchPageEnvelopeSchema),
-  pageGroups: z10.array(TenantWorkbenchPageGroupSchema),
-  catalog: z10.object({ enabled: z10.boolean().optional(), defaultEntry: z10.boolean().optional() }).strict().optional(),
-  quickSwitcherMaxItems: z10.number().int().nonnegative().optional(),
-  defaultOrder: z10.object({
-    groups: z10.array(ContractIdentifierSchema),
-    pages: z10.record(ContractIdentifierSchema, z10.array(ContractIdentifierSchema))
+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))
   }).strict().optional(),
-  customers: z10.object({
-    dropdownToolsDefault: z10.array(ContractIdentifierSchema).optional(),
-    layoutManagerTools: z10.array(WorkbenchCustomerToolSchema).optional(),
-    studioTabsMode: z10.enum(["dropdown", "tabs"]).optional(),
-    historyWatermark: z10.object({
-      svgUrl: z10.string().optional(),
-      coverage: z10.array(z10.enum(["list", "detail", "download"])).optional(),
-      maxLongEdgeRatio: z10.number().positive().optional(),
-      sizing: z10.object({
+  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({
         mode: ContractIdentifierSchema,
-        heightRatio: z10.number().positive().optional(),
-        minHeightPx: z10.number().nonnegative().optional(),
-        maxHeightPx: z10.number().nonnegative().optional()
+        heightRatio: z11.number().positive().optional(),
+        minHeightPx: z11.number().nonnegative().optional(),
+        maxHeightPx: z11.number().nonnegative().optional()
       }).strict().optional(),
-      enhance: z10.object({
-        enabled: z10.boolean().optional(),
-        backgroundLumaThreshold: z10.number().min(0).max(1).optional(),
-        stroke: z10.object({
-          color: z10.string().optional(),
-          opacity: z10.number().min(0).max(1).optional(),
-          widthRatio: z10.number().nonnegative().optional(),
-          blurRatio: z10.number().nonnegative().optional(),
-          steps: z10.number().int().positive().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()
         }).strict().optional()
       }).strict().optional()
     }).strict().optional(),
-    layoutManagerEnabled: z10.boolean().optional(),
-    existingToolsDefault: z10.array(ContractIdentifierSchema).optional(),
-    historyColumnsDefault: z10.number().int().min(1).max(6).optional(),
-    studioOverrides: z10.array(WorkbenchStudioOverrideSchema).optional()
+    layoutManagerEnabled: z11.boolean().optional(),
+    existingToolsDefault: z11.array(ContractIdentifierSchema).optional(),
+    historyColumnsDefault: z11.number().int().min(1).max(6).optional(),
+    studioOverrides: z11.array(WorkbenchStudioOverrideSchema).optional()
   }).strict().optional()
 }).strict().superRefine(({ pages, pageGroups }, context) => {
   const pageIds = pages.map(({ definition }) => definition.pageId);
@@ -12333,38 +13127,38 @@ var TenantWorkbenchConfigSchema = z10.object({
     });
   });
 });
-var LoginPageSchema = z10.object({
-  background: z10.object({ imageUrl: z10.string().optional(), gradient: z10.string().optional() }).strict().optional(),
-  logo: z10.object({
-    url: z10.string().optional(),
-    lightUrl: z10.string().optional(),
-    darkUrl: z10.string().optional(),
-    position: z10.enum(["top", "middle", "bottom"]).optional(),
-    scale: z10.number().positive().optional()
+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()
   }).strict().optional(),
-  customCss: z10.string().optional()
+  customCss: z11.string().optional()
 }).strict();
 var LandingPageHeadbarConfigShape = {
-  headbarMode: z10.enum(["shared", "hidden"]).optional()
+  headbarMode: z11.enum(["shared", "hidden"]).optional()
 };
-var LandingPageDefaultConfigSchema = z10.object({
-  mode: z10.literal("default"),
+var LandingPageDefaultConfigSchema = z11.object({
+  mode: z11.literal("default"),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageMarkdownConfigSchema = z10.object({
-  mode: z10.literal("markdown"),
-  content: z10.string(),
+var LandingPageMarkdownConfigSchema = z11.object({
+  mode: z11.literal("markdown"),
+  content: z11.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageHtmlConfigSchema = z10.object({
-  mode: z10.literal("html"),
-  content: z10.string(),
+var LandingPageHtmlConfigSchema = z11.object({
+  mode: z11.literal("html"),
+  content: z11.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageIframeConfigSchema = z10.object({
-  mode: z10.literal("iframe"),
+var LandingPageIframeConfigSchema = z11.object({
+  mode: z11.literal("iframe"),
   ...LandingPageHeadbarConfigShape,
-  url: z10.string().refine((value) => {
+  url: z11.string().refine((value) => {
     if (/^\/(?!\/)/.test(value)) {
       return !value.includes("\\");
     }
@@ -12376,243 +13170,245 @@ var LandingPageIframeConfigSchema = z10.object({
     }
   }, "Landing page iframe URL must use a root-relative path or HTTP(S) without embedded credentials.")
 }).strict();
-var TenantLandingPageConfigSchema = z10.discriminatedUnion("mode", [
+var TenantLandingPageConfigSchema = z11.discriminatedUnion("mode", [
   LandingPageDefaultConfigSchema,
   LandingPageMarkdownConfigSchema,
   LandingPageHtmlConfigSchema,
   LandingPageIframeConfigSchema
 ]);
-var TenantApplicationConfigSchema = z10.object({
-  theme: z10.object({
-    id: z10.string().optional(),
-    name: z10.string().optional(),
-    title: z10.string().optional(),
+var TenantApplicationConfigSchema = z11.object({
+  theme: z11.object({
+    id: z11.string().optional(),
+    name: z11.string().optional(),
+    title: z11.string().optional(),
     favicon: AssetVariantsSchema.optional(),
     logo: AssetVariantsSchema.optional(),
-    pwaIcon: z10.string().optional(),
-    form: z10.object({ variant: z10.enum(["bento", "ghost"]) }).strict().optional(),
-    toast: z10.object({
-      position: z10.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
+    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"])
     }).strict().optional(),
-    icons: z10.object({ error: CustomIconSchema.optional(), empty: CustomIconSchema.optional() }).strict().optional(),
-    views: z10.object({
-      form: z10.object({
-        toast: z10.object({ afterCreate: z10.boolean(), afterDelete: z10.boolean() }).strict(),
-        progress: z10.enum(["estimate", "infinite"]),
-        onlyResult: z10.boolean(),
-        tabular: z10.object({ theme: z10.enum(["default", "tentiary", "primary"]) }).strict()
+    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()
       }).strict()
     }).strict().optional(),
     loginPage: LoginPageSchema.optional(),
-    extraLanguageURL: z10.record(z10.string(), z10.string()).optional(),
-    hideSpaceHeader: z10.boolean().optional(),
-    showSidebarTeamSelector: z10.boolean().optional(),
-    showWorkbenchSidebar: z10.boolean().optional(),
-    workbenchViewTheme: z10.enum(["default", "bsd-blue"]).optional(),
-    defaults: z10.object({
-      showFormInImageDetail: z10.boolean().optional(),
-      darkMode: z10.enum(["light", "dark", "auto"]).optional(),
-      language: z10.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
-      showDarkModeToggle: z10.boolean().optional(),
-      showLanguageToggle: z10.boolean().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()
     }).strict().optional(),
-    modules: z10.object({
-      monkeysSpaceSidebar: z10.union([z10.literal("*"), z10.array(ContractIdentifierSchema)]).optional(),
-      monkeysSpaceHeadbar: z10.union([
-        z10.literal("*"),
-        z10.array(TenantHeadbarModuleItemSchema)
+    modules: z11.object({
+      monkeysSpaceSidebar: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional(),
+      monkeysSpaceHeadbar: z11.union([
+        z11.literal("*"),
+        z11.array(TenantHeadbarModuleItemSchema)
       ]).optional(),
-      settingsSidebar: z10.union([z10.literal("*"), z10.array(ContractIdentifierSchema)]).optional()
+      settingsSidebar: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional()
     }).strict().optional(),
     headbar: ThemeHeadbarSchema.optional(),
-    kernelLayout: z10.object({
-      navigationMode: z10.enum(["sidebar", "topbar"]).optional(),
-      allowNavigationModeSwitch: z10.boolean().optional(),
+    kernelLayout: z11.object({
+      navigationMode: z11.enum(["sidebar", "topbar"]).optional(),
+      allowNavigationModeSwitch: z11.boolean().optional(),
       headbar: KernelHeadbarSchema.optional()
     }).strict().optional(),
-    paginationPosition: z10.enum(["left", "right"]).optional(),
-    ugcViewIconOnlyMode: z10.boolean().optional(),
-    workflowPreviewExecutionGrid: z10.object({
-      selectionModeDisplayType: z10.enum(["operation-button", "dropdown-menu"]).optional(),
-      clickBehavior: z10.enum(["preview", "select", "fill-form", "none"]).optional(),
-      showErrorFilter: z10.boolean().optional(),
-      displayType: z10.enum(["grid", "masonry"]).optional(),
-      showDetailButton: z10.boolean().optional()
+    paginationPosition: z11.enum(["left", "right"]).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()
     }).strict().optional(),
-    workbenchSidebarDefaultOpen: z10.boolean().optional(),
-    workbenchSidebarMoreAction: z10.boolean().optional(),
-    workbenchSidebarApart: z10.boolean().optional(),
-    workbenchSidebarToggleGroupDetail: z10.boolean().optional(),
-    workbenchSidebarViewType: z10.boolean().optional(),
-    workbenchSidebarFormViewEmbed: z10.boolean().optional(),
-    workbenchSidebarModernMode: z10.boolean().optional(),
-    ugc: z10.object({ onItemClick: z10.boolean(), subtitle: z10.boolean().optional() }).strict().optional(),
-    uniImagePreview: z10.boolean().optional(),
-    imagePreviewStyle: z10.union([z10.literal(false), z10.enum(["simple", "normal", "uni"])]).optional(),
-    teamAsUser: z10.boolean().optional(),
-    themeMode: z10.enum(["shadow", "border"]).optional(),
-    density: z10.enum(["compact", "default", "comfortable"]).optional(),
-    pageZoom: z10.number().positive().optional(),
-    miniMode: z10.object({ showPreviewViewExecutionResultGrid: z10.boolean() }).strict().optional(),
-    workflow: z10.object({ allowConcurrentRuns: z10.boolean() }).strict().optional(),
-    historyResult: z10.object({ display: z10.boolean() }).strict().optional(),
-    uploader: z10.object({
-      orientation: z10.enum(["vertical", "horizontal"]),
-      pasteButton: z10.boolean(),
-      statusText: z10.boolean()
+    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(),
+    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()
     }).strict().optional(),
-    designProjects: z10.object({
-      oneOnOne: z10.boolean(),
-      newTabOpenBoard: z10.boolean(),
-      defaultShowGrid: z10.boolean().optional(),
-      createDefaultFrame: z10.boolean(),
-      showPageMenu: z10.boolean(),
-      showMainMenu: z10.boolean(),
-      showStylePanel: z10.boolean(),
-      showToolbar: z10.boolean(),
-      toolbarPosition: z10.enum(["bottom", "left"]).optional(),
-      showContextMenu: z10.boolean(),
-      showActionsMenu: z10.boolean(),
-      showPageAndLayerSidebar: z10.boolean().optional(),
-      showBoardOperationSidebar: z10.boolean().optional(),
-      showMiniToolsToolbar: z10.boolean().optional(),
-      showRightSidebar: z10.boolean().optional(),
-      showRealtimeDrawing: z10.boolean().optional(),
-      showWorkflow: z10.boolean().optional(),
-      showVersionManager: z10.boolean().optional(),
-      showAgent: z10.boolean().optional(),
-      AgentTools: z10.array(ContractIdentifierSchema).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()
     }).strict().optional(),
     workbench: TenantWorkbenchConfigSchema.optional(),
-    visionProWorkflows: z10.array(ContractIdentifierSchema).optional(),
-    initTeam: z10.boolean().optional(),
-    imageThumbnail: z10.boolean().optional(),
-    pages: z10.object({
-      allowPageKeys: z10.union([z10.literal("*"), z10.array(ContractIdentifierSchema)]),
+    visionProWorkflows: z11.array(ContractIdentifierSchema).optional(),
+    initTeam: z11.boolean().optional(),
+    imageThumbnail: z11.boolean().optional(),
+    pages: z11.object({
+      allowPageKeys: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]),
       defaultPageKey: ContractIdentifierSchema.optional()
     }).strict().optional(),
-    agent: z10.object({
+    agent: z11.object({
       logo: AssetVariantsSchema.optional(),
-      brandDisplayMode: z10.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
-      density: z10.enum(["compact", "default", "comfortable"]).optional()
+      brandDisplayMode: z11.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
+      density: z11.enum(["compact", "default", "comfortable"]).optional()
     }).strict().optional()
   }).strict(),
   landingPage: TenantLandingPageConfigSchema.optional(),
-  auth: z10.object({
-    enabled: z10.array(ContractIdentifierSchema).default([]),
-    oidc: z10.object({ buttonText: z10.string().optional(), autoSignin: z10.boolean().optional() }).strict().optional(),
-    password: z10.object({ disableAutoRegister: z10.boolean().optional() }).strict().optional(),
-    hideAuthToast: z10.boolean().optional(),
-    autoReload: z10.boolean().optional(),
-    defaultOtherTeam: z10.boolean().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({ disableAutoRegister: z11.boolean().optional() }).strict().optional(),
+    hideAuthToast: z11.boolean().optional(),
+    autoReload: z11.boolean().optional(),
+    defaultOtherTeam: z11.boolean().optional()
   }).strict(),
-  endpoints: z10.record(ContractIdentifierSchema, z10.string()),
-  module: z10.union([z10.literal("*"), z10.array(ContractIdentifierSchema)]),
-  behavior: z10.object({
-    clearWorkflowFormStorageAfterUpdate: z10.boolean().optional(),
-    autoApproveOAuth: z10.boolean().optional(),
-    rememberWorkflowModelSelection: z10.boolean().optional()
+  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()
   }).strict(),
-  dataManagement: z10.object({
-    favoriteOntologyId: z10.string().optional(),
-    pairedOntologyId: z10.string().optional(),
-    galleryOntologyIds: z10.array(ContractIdentifierSchema).max(20).optional(),
-    galleryOntologyId: z10.string().optional(),
-    dataBrowserDefaultOntologyId: z10.string().optional(),
-    workflowResultOntologyId: z10.string().optional(),
-    homeAdvertisement: z10.object({
+  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({
       ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
-      viewType: z10.enum(["filter", "container", "share_link"]).optional(),
+      viewType: z11.enum(["filter", "container", "share_link"]).optional(),
       teamId: ContractIdentifierSchema.optional(),
-      teamOnly: z10.boolean().optional(),
-      pageSize: z10.number().int().positive().optional(),
-      sortBy: z10.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
-      sortOrder: z10.enum(["asc", "desc"]).optional(),
-      fieldMap: z10.record(z10.string(), z10.string()).optional(),
-      columnIds: z10.record(z10.string(), z10.string()).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()
     }).strict().optional(),
-    homeTrendAssistant: z10.object({
+    homeTrendAssistant: z11.object({
       ontologyId: ContractIdentifierSchema.optional(),
       viewId: ContractIdentifierSchema.optional(),
       viewInstanceId: ContractIdentifierSchema.optional(),
-      viewName: z10.string().optional(),
+      viewName: z11.string().optional(),
       teamId: ContractIdentifierSchema.optional(),
       designOptionsWorkflowId: ContractIdentifierSchema.optional(),
-      tep: z10.object({ baseUrl: z10.string().optional(), timeoutMs: z10.number().int().positive().optional() }).strict().optional(),
-      runtime: z10.object({ appId: ContractIdentifierSchema, tepBaseUrlConfigured: z10.boolean(), tepAuthorizationConfigured: z10.boolean(), tepCookieConfigured: z10.boolean() }).strict().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()
     }).strict().optional(),
     trendRadar: TenantTrendRadarSourcesSchema.optional(),
-    sharing: z10.object({
-      silentViewLinks: z10.object({ enabled: z10.boolean().optional(), placement: z10.object({ mode: z10.enum(["sourceOntology", "ontology"]).optional(), ontologyId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
-      shareAccess: z10.object({ publicLinksEnabled: z10.boolean().optional(), passwordGateEnabled: z10.boolean().optional(), passwordAccessTtlSeconds: z10.number().int().positive().optional(), defaultViewTreeDelivery: z10.enum(["manual", "auto"]).optional() }).strict().optional(),
-      shareDialog: z10.object({
-        audience: z10.object({ enabled: z10.boolean().optional(), allowed: z10.array(z10.enum(["user", "team", "public"])).optional(), default: z10.enum(["user", "team", "public"]).optional() }).strict().optional(),
-        accessLevel: z10.object({ enabled: z10.boolean().optional(), allowed: z10.array(z10.enum(["read", "write"])).optional(), default: z10.enum(["read", "write"]).optional() }).strict().optional(),
-        viewTreeDelivery: z10.object({ enabled: z10.boolean().optional(), allowed: z10.array(z10.enum(["manual", "auto"])).optional(), default: z10.enum(["manual", "auto"]).optional() }).strict().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()
       }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  compute: z10.object({
-    integrations: z10.object({
-      harbor: z10.object({ endpoint: z10.string().optional(), projectScopes: z10.array(z10.string()).optional(), authMode: z10.string().optional(), principal: z10.string().optional(), autoSync: z10.boolean().optional(), proxyUrl: z10.string().optional() }).strict().optional(),
-      gitlab: z10.object({ baseUrl: z10.string().optional(), groupScopes: z10.array(z10.string()).optional(), tokenMode: z10.string().optional(), deployProjectPath: z10.string().optional(), deploymentReportsEnabled: z10.boolean().optional(), proxyUrl: z10.string().optional() }).strict().optional(),
-      kubernetes: z10.object({ accessMode: z10.string().optional(), clusterAlias: z10.string().optional(), agentProjectPath: z10.string().optional(), agentName: z10.string().optional(), namespaceScopes: z10.array(z10.string()).optional(), rolloutObserverEnabled: z10.boolean().optional(), proxyUrl: z10.string().optional() }).strict().optional()
+  compute: 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()
     }).strict().optional()
   }).strict().optional(),
-  data: z10.object({}).strict().optional(),
-  storage: z10.object({
-    presignMode: z10.enum(["frontend", "backend", "both"]).optional(),
-    presign: z10.object({
-      expiresInSeconds: z10.number().int().positive(),
-      buckets: z10.array(
-        z10.object({
+  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({
           id: ContractIdentifierSchema,
           provider: ContractIdentifierSchema,
           preferredUrlPatternId: ContractIdentifierSchema,
-          urlPatterns: z10.array(
-            z10.object({
+          urlPatterns: z11.array(
+            z11.object({
               id: ContractIdentifierSchema,
-              type: z10.enum(["bucket-hostname", "provider-hostname"]),
-              hostname: z10.string().trim().min(1),
-              preferred: z10.boolean().optional(),
-              bucketSegment: z10.string().optional()
+              type: z11.enum(["bucket-hostname", "provider-hostname"]),
+              hostname: z11.string().trim().min(1),
+              preferred: z11.boolean().optional(),
+              bucketSegment: z11.string().optional()
             }).strict()
           )
         }).strict()
       )
     }).strict().optional()
   }).strict().optional(),
-  monkeyData: z10.object({ baseUrl: z10.string().optional() }).strict().optional()
+  monkeyData: z11.object({ baseUrl: z11.string().optional() }).strict().optional()
 }).strict();
-var TenantProductConfigSchema = z10.object({
-  contract: z10.literal("TenantProductConfig"),
+var TenantProductConfigSchema = z11.object({
+  contract: z11.literal("TenantProductConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: TenantDesignTokensConfigSchema,
-  moduleRefs: z10.array(ContractIdentifierSchema).default([]),
-  pageRefs: z10.array(ContractIdentifierSchema).default([]),
-  featureFlags: z10.record(z10.string(), z10.boolean()).default({}),
+  moduleRefs: z11.array(ContractIdentifierSchema).default([]),
+  pageRefs: z11.array(ContractIdentifierSchema).default([]),
+  featureFlags: z11.record(z11.string(), z11.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z10.record(z10.string(), ContractIdentifierSchema),
-  warnings: z10.array(z10.string()).default([]),
+  sourceMap: z11.record(z11.string(), ContractIdentifierSchema),
+  warnings: z11.array(z11.string()).default([]),
+  menus: MenuDefinitionSetSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
-var TenantRuntimeConfigSchema = z10.object({
-  contract: z10.literal("TenantRuntimeConfig"),
+var TenantRuntimeConfigSchema = z11.object({
+  contract: z11.literal("TenantRuntimeConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: ResolvedThemeTokensSchema,
-  moduleRefs: z10.array(ContractIdentifierSchema).default([]),
-  pageRefs: z10.array(ContractIdentifierSchema).default([]),
-  featureFlags: z10.record(z10.string(), z10.boolean()).default({}),
+  moduleRefs: z11.array(ContractIdentifierSchema).default([]),
+  pageRefs: z11.array(ContractIdentifierSchema).default([]),
+  featureFlags: z11.record(z11.string(), z11.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z10.record(z10.string(), ContractIdentifierSchema),
-  warnings: z10.array(z10.string()).default([]),
+  sourceMap: z11.record(z11.string(), ContractIdentifierSchema),
+  warnings: z11.array(z11.string()).default([]),
+  menuBundle: MenuRuntimeBundleSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
 
@@ -12633,6 +13429,7 @@ var compileTenantRuntimeConfig = (input) => {
     dataBinding: productConfig.dataBinding,
     sourceMap: productConfig.sourceMap,
     warnings: productConfig.warnings,
+    menuBundle: input.menuBundle,
     applicationConfig: productConfig.applicationConfig
   }));
 };
@@ -12888,6 +13685,7 @@ export {
   APPLICATION_HANDOFF_QUERY_PARAMETER,
   DEFAULT_CONDUCTOR_OWNER_EMAIL,
   MONKEYS_REQUIRED_THEME_TOKEN_PATHS,
+  MenuCompilationError,
   ThemeTokenValidationError,
   applyViewRuntimeBindings,
   assertMonkeysThemeTokensComplete,
@@ -12896,6 +13694,7 @@ export {
   buildChangeImpactGraph,
   compileCapabilityRegistry,
   compileConductorWorkflowDefinition,
+  compileMenuRuntimeBundle,
   compilePageRuntimeProjection,
   compileProductDeclaration,
   compileProductRuntimeCatalog,
@@ -12913,13 +13712,17 @@ export {
   createToolCapabilityManifest,
   createWorkflowCapabilityManifest,
   extractOpenApiCapabilityManifests,
+  isCompiledMenuItemSelected,
   mergeThemeTokenDocuments,
   parseApplicationHandoff,
   projectAgentSessionEvents,
   publishOpenApiToolCapabilityManifests,
   readApplicationHandoffFromUrl,
+  readMenuActivationFromSearch,
+  resolveMenuActivationId,
   resolveThemeTokens,
   serializeApplicationHandoff,
+  serializeMenuActivationSearch,
   toAgentSessionViewModel,
   validateDomainCommand,
   validateThemeTokensDocument,