@inf-monkeys-tech/monkeys 1.0.35 → 1.0.37

package/lib/esm/contracts/index.mjs

@@ -8266,6 +8266,9 @@ var DomainEventSchema = z8.object({
   occurredAt: IsoDateTimeSchema
 }).strict();
 
+// src/contracts/menu.ts
+import { z as z10 } from "zod";
+
 // src/contracts/page.ts
 import { z as z9 } from "zod";
 var PageTypeSchema = z9.enum([
@@ -8353,6 +8356,9 @@ var PageDefinitionSchema = z9.object({
   access: z9.object({
     actions: z9.array(z9.enum(["read", "write", "execute", "manage-permissions"])).default([])
   }).strict(),
+  input: z9.object({
+    schemaRef: ContractIdentifierSchema
+  }).strict().optional(),
   rendererConfig: z9.object({
     schemaRef: ContractIdentifierSchema,
     value: JsonObjectSchema
@@ -8542,40 +8548,314 @@ var PageRuntimeProjectionSchema = z9.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 = z10.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 = z10.object({
+  applicationId: ContractIdentifierSchema,
+  pageId: ContractIdentifierSchema
+}).strict();
+var MenuSourceInputBindingSchema = z10.discriminatedUnion("exposure", [
+  z10.object({ exposure: z10.literal("client"), value: MenuBoundedInputSchema }).strict(),
+  z10.object({ exposure: z10.literal("server"), value: MenuBoundedInputSchema }).strict()
+]);
+var MenuRuntimeInputBindingSchema = z10.discriminatedUnion("exposure", [
+  z10.object({ exposure: z10.literal("client"), value: MenuBoundedInputSchema }).strict(),
+  z10.object({ exposure: z10.literal("server") }).strict()
+]);
+var MenuNavigateBehaviorSchema = z10.object({
+  kind: z10.literal("navigate"),
+  page: MenuPageRefSchema,
+  activationId: ContractIdentifierSchema.optional(),
+  input: MenuSourceInputBindingSchema.optional()
+}).strict();
+var MenuActionBehaviorSchema = z10.object({
+  kind: z10.literal("action"),
+  actionRef: ContractIdentifierSchema,
+  input: MenuBoundedInputSchema.optional()
+}).strict();
+var MenuBehaviorSchema = z10.discriminatedUnion("kind", [
+  MenuNavigateBehaviorSchema,
+  MenuActionBehaviorSchema
+]);
+var MenuNodeBaseShape = {
+  nodeId: ContractIdentifierSchema,
+  parentNodeId: ContractIdentifierSchema.optional(),
+  order: MenuOrderSchema
+};
+var MenuGroupNodeSchema = z10.object({
+  ...MenuNodeBaseShape,
+  kind: z10.literal("group"),
+  label: LocalizedTextSchema.optional(),
+  iconRef: ContractIdentifierSchema.optional()
+}).strict();
+var MenuDividerNodeSchema = z10.object({
+  ...MenuNodeBaseShape,
+  kind: z10.literal("divider")
+}).strict();
+var MenuItemNodeSchema = z10.object({
+  ...MenuNodeBaseShape,
+  kind: z10.literal("item"),
+  label: LocalizedTextSchema,
+  iconRef: ContractIdentifierSchema.optional(),
+  tone: z10.enum(["default", "danger"]).optional(),
+  requiredPermission: ContractIdentifierSchema.optional(),
+  behavior: MenuBehaviorSchema
+}).strict();
+var MenuNodeSchema = z10.discriminatedUnion("kind", [
+  MenuGroupNodeSchema,
+  MenuDividerNodeSchema,
+  MenuItemNodeSchema
+]);
+var MenuContributionSchema = z10.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 = z10.object({
+  contract: z10.literal("MenuDefinition"),
+  version: z10.literal(MENU_CONTRACT_VERSION),
+  applicationId: ContractIdentifierSchema,
+  surface: ContractIdentifierSchema,
+  menuId: ContractIdentifierSchema,
+  nodes: z10.array(MenuNodeSchema).max(MENU_MAX_NODES),
+  contributions: z10.array(MenuContributionSchema).max(MENU_MAX_NODES).default([])
+}).strict().superRefine(validateMenuStructure);
+var MenuDefinitionSetSchema = z10.union([
+  z10.literal("*"),
+  z10.object({
+    version: z10.literal(MENU_CONTRACT_VERSION),
+    definitions: z10.array(MenuDefinitionSchema).max(MENU_MAX_DEFINITIONS)
+  }).strict()
+]);
+var MenuAccessRequirementSchema = z10.object({
+  authenticated: z10.boolean().default(true),
+  permissionAllOf: z10.array(ContractIdentifierSchema).default([]),
+  permissionAnyOf: z10.array(ContractIdentifierSchema).default([]),
+  featureFlags: z10.array(ContractIdentifierSchema).default([])
+}).strict();
+var MenuPageRegistrationSchema = z10.object({
+  applicationId: ContractIdentifierSchema,
+  page: PageDefinitionSchema
+}).strict();
+var MenuActionRegistrationSchema = z10.object({
+  applicationId: ContractIdentifierSchema,
+  actionRef: ContractIdentifierSchema,
+  inputSchemaRef: ContractIdentifierSchema.optional(),
+  access: MenuAccessRequirementSchema
+}).strict();
+var MenuContributionProviderRegistrationSchema = z10.object({
+  applicationId: ContractIdentifierSchema,
+  providerId: ContractIdentifierSchema,
+  surfaces: z10.array(ContractIdentifierSchema).min(1).optional()
+}).strict();
+var CompiledMenuNavigateBehaviorSchema = z10.object({
+  kind: z10.literal("navigate"),
+  page: MenuPageRefSchema,
+  activationId: ContractIdentifierSchema,
+  input: MenuRuntimeInputBindingSchema.optional()
+}).strict();
+var CompiledMenuActionBehaviorSchema = z10.object({
+  kind: z10.literal("action"),
+  actionRef: ContractIdentifierSchema,
+  input: MenuBoundedInputSchema.optional()
+}).strict();
+var CompiledMenuBehaviorSchema = z10.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 = z10.discriminatedUnion("kind", [
+  CompiledMenuGroupNodeSchema,
+  CompiledMenuDividerNodeSchema,
+  CompiledMenuItemNodeSchema
+]);
+var CompiledMenuProjectionSchema = z10.object({
+  applicationId: ContractIdentifierSchema,
+  surface: ContractIdentifierSchema,
+  menuId: ContractIdentifierSchema,
+  nodes: z10.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES),
+  contributions: z10.array(MenuContributionSchema).max(MENU_MAX_NODES)
+}).strict();
+var MenuNavigationTargetSchema = z10.object({
+  page: MenuPageRefSchema,
+  activationId: ContractIdentifierSchema,
+  input: MenuRuntimeInputBindingSchema.optional()
+}).strict();
+var MenuRuntimeBundleSchema = z10.object({
+  contract: z10.literal("MenuRuntimeBundle"),
+  version: z10.literal(MENU_CONTRACT_VERSION),
+  applicationId: ContractIdentifierSchema,
+  sourceVersion: ContractIdentifierSchema,
+  contentHash: Sha256Schema,
+  menus: z10.array(CompiledMenuProjectionSchema).max(MENU_MAX_DEFINITIONS),
+  navigationTargets: z10.array(MenuNavigationTargetSchema),
+  sourceMap: z10.record(z10.string(), ContractIdentifierSchema).default({})
+}).strict();
+var MenuContributionResultSchema = z10.object({
+  contract: z10.literal("MenuContributionResult"),
+  applicationId: ContractIdentifierSchema,
+  surface: ContractIdentifierSchema,
+  menuId: ContractIdentifierSchema,
+  providerId: ContractIdentifierSchema,
+  nodes: z10.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES)
+}).strict();
+
 // src/contracts/semantic.ts
-import { z as z10 } from "zod";
-var ConceptRelationshipSchema = z10.object({
+import { z as z11 } from "zod";
+var ConceptRelationshipSchema = z11.object({
   kind: ContractIdentifierSchema,
   targetConceptId: ContractIdentifierSchema,
-  cardinality: z10.enum(["one", "optional", "many"])
+  cardinality: z11.enum(["one", "optional", "many"])
 }).strict();
-var ConceptDefinitionSchema = z10.object({
-  contract: z10.literal("ConceptDefinition"),
+var ConceptDefinitionSchema = z11.object({
+  contract: z11.literal("ConceptDefinition"),
   conceptId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z10.string().trim().min(1),
-  description: z10.string().optional(),
+  displayName: z11.string().trim().min(1),
+  description: z11.string().optional(),
   schemaRef: ContractIdentifierSchema,
   ontologyId: ContractIdentifierSchema.optional(),
-  capabilityIds: z10.array(ContractIdentifierSchema).default([]),
-  commandNames: z10.array(ContractIdentifierSchema).default([]),
-  relationships: z10.array(ConceptRelationshipSchema).default([])
+  capabilityIds: z11.array(ContractIdentifierSchema).default([]),
+  commandNames: z11.array(ContractIdentifierSchema).default([]),
+  relationships: z11.array(ConceptRelationshipSchema).default([])
 }).strict();
-var DomainCommandDefinitionSchema = z10.object({
-  contract: z10.literal("DomainCommandDefinition"),
+var DomainCommandDefinitionSchema = z11.object({
+  contract: z11.literal("DomainCommandDefinition"),
   commandName: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z10.string().trim().min(1),
-  description: z10.string().optional(),
-  targetKinds: z10.array(ContractIdentifierSchema).min(1),
+  displayName: z11.string().trim().min(1),
+  description: z11.string().optional(),
+  targetKinds: z11.array(ContractIdentifierSchema).min(1),
   inputSchemaRef: ContractIdentifierSchema,
   outputSchemaRef: ContractIdentifierSchema.optional(),
-  requiredPermissionCodes: z10.array(ContractIdentifierSchema).default([]),
+  requiredPermissionCodes: z11.array(ContractIdentifierSchema).default([]),
   handlerRef: EntityRefSchema,
-  sideEffects: z10.array(z10.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
+  sideEffects: z11.array(z11.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
 }).strict();
-var DomainCommandSchema = z10.object({
-  contract: z10.literal("DomainCommand"),
+var DomainCommandSchema = z11.object({
+  contract: z11.literal("DomainCommand"),
   commandId: ContractIdentifierSchema,
   commandName: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
@@ -8583,29 +8863,30 @@ var DomainCommandSchema = z10.object({
   idempotencyKey: ContractIdentifierSchema,
   targetRef: EntityRefSchema,
   actorRef: EntityRefSchema,
-  source: z10.object({
-    product: z10.enum(["studio", "kernel", "compute", "agent", "mcp", "service"]),
+  source: z11.object({
+    product: z11.enum(["studio", "kernel", "compute", "agent", "mcp", "service"]),
     pageId: ContractIdentifierSchema.optional(),
     capabilityId: ContractIdentifierSchema.optional()
   }).strict(),
   payload: JsonObjectSchema,
   issuedAt: IsoDateTimeSchema
 }).strict();
-var ProductDeclarationSchema = z10.object({
-  contract: z10.literal("ProductDeclaration"),
+var ProductDeclarationSchema = z11.object({
+  contract: z11.literal("ProductDeclaration"),
   declarationId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  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([])
-}).strict();
-var DeclarationGraphEdgeSchema = z10.object({
+  concepts: z11.array(ConceptDefinitionSchema).default([]),
+  ontologies: z11.array(OntologyDefinitionSchema).default([]),
+  projections: z11.array(ProjectionSpecSchema).default([]),
+  commands: z11.array(DomainCommandDefinitionSchema).default([]),
+  capabilities: z11.array(CapabilityManifestSchema).default([]),
+  pages: z11.array(PageDefinitionSchema).default([]),
+  menus: z11.array(MenuDefinitionSchema).default([])
+}).strict();
+var DeclarationGraphEdgeSchema = z11.object({
   from: EntityRefSchema,
   to: EntityRefSchema,
-  relation: z10.enum([
+  relation: z11.enum([
     "uses-ontology",
     "uses-projection",
     "uses-capability",
@@ -8613,25 +8894,25 @@ var DeclarationGraphEdgeSchema = z10.object({
     "relates-to-concept"
   ])
 }).strict();
-var ChangeImpactSchema = z10.object({
+var ChangeImpactSchema = z11.object({
   changedRef: EntityRefSchema,
-  affectedRefs: z10.array(EntityRefSchema),
-  reasons: z10.array(ContractIdentifierSchema).min(1)
+  affectedRefs: z11.array(EntityRefSchema),
+  reasons: z11.array(ContractIdentifierSchema).min(1)
 }).strict();
-var ChangeImpactGraphSchema = z10.object({
-  contract: z10.literal("ChangeImpactGraph"),
+var ChangeImpactGraphSchema = z11.object({
+  contract: z11.literal("ChangeImpactGraph"),
   declarationId: ContractIdentifierSchema,
-  nodes: z10.array(EntityRefSchema),
-  edges: z10.array(DeclarationGraphEdgeSchema),
-  impacts: z10.array(ChangeImpactSchema),
+  nodes: z11.array(EntityRefSchema),
+  edges: z11.array(DeclarationGraphEdgeSchema),
+  impacts: z11.array(ChangeImpactSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/tenant.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/contracts/theme.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/theme-tokens/core.ts
 var import_ajv = __toESM(require_ajv());
@@ -10825,20 +11106,20 @@ var MONKEYS_REQUIRED_THEME_TOKEN_PATHS = Object.freeze({
 });
 
 // src/contracts/theme.ts
-var ThemeTokenTypeSchema = z11.enum(THEME_TOKEN_TYPES);
-var ThemeTokenSchema = z11.record(z11.string(), z11.unknown()).superRefine((input, context) => {
+var ThemeTokenTypeSchema = z12.enum(THEME_TOKEN_TYPES);
+var ThemeTokenSchema = z12.record(z12.string(), z12.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 = z11.record(z11.string(), z11.unknown()).superRefine((input, context) => {
+var ThemeTokenGroupSchema = z12.record(z12.string(), z12.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocumentStructure(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
   }
 });
-var ThemeTokensSchema = z11.record(z11.string(), z11.unknown()).superRefine((input, context) => {
+var ThemeTokensSchema = z12.record(z12.string(), z12.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocument(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
@@ -10865,9 +11146,9 @@ var ResolvedThemeTokensSchema = ThemeTokensSchema.superRefine((input, context) =
 });
 
 // src/contracts/tenant.ts
-var DesignTokenFileSourceSchema = z12.object({
-  type: z12.literal("file"),
-  path: z12.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenFileSourceSchema = z13.object({
+  type: z13.literal("file"),
+  path: z13.string().trim().min(1).superRefine((source, context) => {
     if (/^[a-z][a-z\d+.-]*:/i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -10876,9 +11157,9 @@ var DesignTokenFileSourceSchema = z12.object({
     }
   })
 }).strict();
-var DesignTokenUrlSourceSchema = z12.object({
-  type: z12.literal("url"),
-  url: z12.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenUrlSourceSchema = z13.object({
+  type: z13.literal("url"),
+  url: z13.string().trim().min(1).superRefine((source, context) => {
     if (!/^https?:\/\//i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -10887,118 +11168,207 @@ var DesignTokenUrlSourceSchema = z12.object({
     }
   })
 }).strict();
-var DesignTokenInlineSourceSchema = z12.object({
-  type: z12.literal("inline"),
+var DesignTokenInlineSourceSchema = z13.object({
+  type: z13.literal("inline"),
   document: ThemeTokensSchema
 }).strict();
-var DesignTokenSourceSchema = z12.discriminatedUnion("type", [
+var DesignTokenSourceSchema = z13.discriminatedUnion("type", [
   DesignTokenFileSourceSchema,
   DesignTokenUrlSourceSchema,
   DesignTokenInlineSourceSchema
 ]);
-var TenantDesignTokensConfigSchema = z12.object({
+var TenantDesignTokensConfigSchema = z13.object({
   /** Ordered tenant overrides. The backend always applies the product default first. */
-  tokenSources: z12.array(DesignTokenSourceSchema)
+  tokenSources: z13.array(DesignTokenSourceSchema)
 }).strict();
-var TenantAuthBindingSchema = z12.object({
-  kind: z12.literal("auth-provider"),
+var TenantAuthBindingSchema = z13.object({
+  kind: z13.literal("auth-provider"),
   providerId: ContractIdentifierSchema,
   policyRef: ContractIdentifierSchema.optional()
 }).strict();
-var TenantDataBindingSchema = z12.discriminatedUnion("kind", [
-  z12.object({
-    kind: z12.literal("data-provider"),
+var TenantDataBindingSchema = z13.discriminatedUnion("kind", [
+  z13.object({
+    kind: z13.literal("data-provider"),
     providerId: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict(),
-  z12.object({
-    kind: z12.literal("projection"),
+  z13.object({
+    kind: z13.literal("projection"),
     projectionRef: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict()
 ]);
-var TenantAuthBindingsSchema = z12.record(
+var TenantAuthBindingsSchema = z13.record(
   ContractIdentifierSchema,
   TenantAuthBindingSchema
 );
-var TenantDataBindingsSchema = z12.record(
+var TenantDataBindingsSchema = z13.record(
   ContractIdentifierSchema,
   TenantDataBindingSchema
 );
-var TenantTrendRadarSourceSchema = z12.object({
+var TenantTrendRadarSourceSchema = z13.object({
   ontologyId: ContractIdentifierSchema,
   viewId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarSourcesSchema = z12.object({
+var TenantTrendRadarSourcesSchema = z13.object({
   hotwords: TenantTrendRadarSourceSchema.optional(),
   brands: TenantTrendRadarSourceSchema.optional()
 }).strict();
-var AssetVariantsSchema = z12.object({
-  light: z12.string().optional(),
-  dark: z12.string().optional()
+var AssetVariantsSchema = z13.object({
+  light: z13.string().optional(),
+  dark: z13.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 = z13.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/, "Expected a stable current-user menu identifier.");
+var CurrentUserMenuDisplayTextSchema = z13.union([
+  z13.string().trim().min(1),
+  z13.record(z13.string().trim().min(1), z13.string().trim().min(1)).refine((value) => Object.keys(value).length > 0, "Localized menu text must contain at least one locale.")
+]);
+var CurrentUserMenuNavigationItemSchema = z13.object({
+  id: CurrentUserMenuIdentifierSchema,
+  kind: z13.literal("navigation"),
+  ref: CurrentUserMenuIdentifierSchema
+}).strict();
+var CurrentUserMenuControlItemSchema = z13.object({
+  id: CurrentUserMenuIdentifierSchema,
+  kind: z13.literal("control"),
+  ref: z13.enum(CURRENT_USER_MENU_CONTROL_REFS)
+}).strict();
+var CurrentUserMenuActionItemSchema = z13.object({
+  id: CurrentUserMenuIdentifierSchema,
+  kind: z13.literal("action"),
+  ref: z13.enum(CURRENT_USER_MENU_ACTION_REFS),
+  tone: z13.enum(["default", "danger"]).optional()
 }).strict();
-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: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]).optional(),
-  showTeamQuota: z12.boolean().optional()
+var CurrentUserMenuItemSchema = z13.discriminatedUnion("kind", [
+  CurrentUserMenuNavigationItemSchema,
+  CurrentUserMenuControlItemSchema,
+  CurrentUserMenuActionItemSchema
+]);
+var CurrentUserMenuSectionSchema = z13.object({
+  id: CurrentUserMenuIdentifierSchema,
+  label: CurrentUserMenuDisplayTextSchema.optional(),
+  dividerBefore: z13.boolean().optional(),
+  items: z13.array(CurrentUserMenuItemSchema)
 }).strict();
-var TenantHeadbarModuleLeafSchema = z12.object({
+var CurrentUserMenuConfigSchema = z13.object({
+  version: z13.literal(1),
+  sections: z13.array(CurrentUserMenuSectionSchema).max(20)
+}).strict().superRefine((value, context) => {
+  const sectionIds = /* @__PURE__ */ new Set();
+  const itemIds = /* @__PURE__ */ new Set();
+  let itemCount = 0;
+  value.sections.forEach((section, sectionIndex) => {
+    if (sectionIds.has(section.id)) {
+      context.addIssue({
+        code: "custom",
+        message: `Duplicate current-user menu section id ${section.id}.`,
+        path: ["sections", sectionIndex, "id"]
+      });
+    }
+    sectionIds.add(section.id);
+    itemCount += section.items.length;
+    section.items.forEach((item, itemIndex) => {
+      if (itemIds.has(item.id)) {
+        context.addIssue({
+          code: "custom",
+          message: `Duplicate current-user menu item id ${item.id}.`,
+          path: ["sections", sectionIndex, "items", itemIndex, "id"]
+        });
+      }
+      itemIds.add(item.id);
+    });
+  });
+  if (itemCount > 100) {
+    context.addIssue({
+      code: "custom",
+      message: "Current-user menu supports at most 100 items.",
+      path: ["sections"]
+    });
+  }
+});
+var LegacyCurrentUserMenuProfileSchema = z13.array(z13.enum(LEGACY_CURRENT_USER_MENU_ITEM_IDS)).superRefine((value, context) => {
+  const seen = /* @__PURE__ */ new Set();
+  value.forEach((item, index) => {
+    if (seen.has(item)) {
+      context.addIssue({
+        code: "custom",
+        message: `Duplicate legacy current-user menu item ${item}.`,
+        path: [index]
+      });
+    }
+    seen.add(item);
+  });
+});
+var CurrentUserMenuProfileSchema = z13.union([
+  z13.literal("*"),
+  LegacyCurrentUserMenuProfileSchema,
+  CurrentUserMenuConfigSchema
+]);
+var ThemeHeadbarSchema = z13.object({
+  theme: z13.enum(["card", "glassy", "ghost"]).optional(),
+  navPosition: z13.enum(["left", "center", "right"]).optional(),
+  actions: z13.union([z13.literal("*"), z13.array(ContractIdentifierSchema)]).optional(),
+  profile: CurrentUserMenuProfileSchema.optional(),
+  showTeamQuota: z13.boolean().optional()
+}).strict();
+var TenantHeadbarModuleLeafSchema = z13.object({
   id: ContractIdentifierSchema,
-  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()
+  extraInfo: z13.boolean().optional(),
+  displayName: z13.union([z13.string(), z13.record(LocaleIdentifierSchema, z13.string())]).optional(),
+  visible: z13.boolean().optional(),
+  disabled: z13.boolean().optional(),
+  icon: z13.string().optional(),
+  showQuickSwitcher: z13.boolean().optional(),
+  showSidebar: z13.boolean().optional(),
+  showContentFrame: z13.boolean().optional()
 }).strict();
 var TenantHeadbarModuleItemSchema = TenantHeadbarModuleLeafSchema.extend({
-  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({
+  children: z13.array(TenantHeadbarModuleLeafSchema).optional()
+}).strict();
+var KernelHeadbarSchema = z13.object({
+  theme: z13.literal("card").optional(),
+  layoutMode: z13.enum(["boxed", "full-bleed"]).optional(),
+  heightPx: z13.number().positive().optional(),
+  navPosition: z13.enum(["left", "center", "right"]).optional(),
+  brandTitle: z13.string().optional(),
+  menuRadius: z13.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
+}).strict();
+var CustomIconSchema = z13.object({
+  color: z13.string().optional(),
+  url: z13.string().optional(),
+  type: z13.enum(["svg", "image"]).optional(),
+  hintTextColor: z13.string().optional()
+}).strict();
+var WorkbenchCustomerToolSchema = z13.object({
   id: ContractIdentifierSchema,
-  label: z12.union([z12.string(), z12.record(LocaleIdentifierSchema, z12.string())]).optional(),
-  fixed: z12.boolean().optional()
+  label: z13.union([z13.string(), z13.record(LocaleIdentifierSchema, z13.string())]).optional(),
+  fixed: z13.boolean().optional()
 }).strict();
-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()
+var WorkbenchStudioOverrideSchema = z13.object({
+  studioName: z13.string().trim().min(1),
+  dropdownToolsDefault: z13.array(ContractIdentifierSchema).optional(),
+  existingToolsDefault: z13.array(ContractIdentifierSchema).optional(),
+  historyColumnsDefault: z13.number().int().min(1).max(6).optional()
 }).strict();
-var TenantWorkbenchPageContextSchema = z12.object({
+var TenantWorkbenchPageContextSchema = z13.object({
   workflow: JsonObjectSchema.optional(),
   agent: JsonObjectSchema.optional(),
   agentId: ContractIdentifierSchema.optional(),
   designProject: JsonObjectSchema.optional(),
   designMetadataId: ContractIdentifierSchema.optional(),
-  iframeUrl: z12.string().trim().min(1).optional(),
-  info: z12.object({
+  iframeUrl: z13.string().trim().min(1).optional(),
+  info: z13.object({
     displayName: LocalizedTextSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    iconUrl: z12.string().trim().min(1).optional()
+    iconUrl: z13.string().trim().min(1).optional()
   }).strict().optional(),
-  isBuiltinPinned: z12.boolean().optional(),
-  isBuiltinReadonly: z12.boolean().optional()
+  isBuiltinPinned: z13.boolean().optional(),
+  isBuiltinReadonly: z13.boolean().optional()
 }).strict();
-var TenantWorkbenchPageEnvelopeSchema = z12.object({
+var TenantWorkbenchPageEnvelopeSchema = z13.object({
   definition: PageDefinitionSchema,
   context: TenantWorkbenchPageContextSchema
 }).strict().superRefine(({ definition }, context) => {
@@ -11031,56 +11401,56 @@ var TenantWorkbenchPageEnvelopeSchema = z12.object({
     });
   }
 });
-var TenantWorkbenchPageGroupSchema = z12.object({
+var TenantWorkbenchPageGroupSchema = z13.object({
   id: ContractIdentifierSchema,
-  pageIds: z12.array(ContractIdentifierSchema),
+  pageIds: z13.array(ContractIdentifierSchema),
   displayName: LocalizedTextSchema,
-  isBuiltIn: z12.boolean(),
-  iconUrl: z12.string().optional(),
-  sortIndex: z12.number().int().nullable().optional(),
+  isBuiltIn: z13.boolean(),
+  iconUrl: z13.string().optional(),
+  sortIndex: z13.number().int().nullable().optional(),
   presetRelationId: ContractIdentifierSchema.optional(),
   relationKey: ContractIdentifierSchema.nullable().optional(),
   studioId: ContractIdentifierSchema.optional()
 }).strict();
-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(),
-  quickSwitcherMaxItems: z12.number().int().nonnegative().optional(),
-  defaultOrder: z12.object({
-    groups: z12.array(ContractIdentifierSchema),
-    pages: z12.record(ContractIdentifierSchema, z12.array(ContractIdentifierSchema))
+var TenantWorkbenchConfigSchema = z13.object({
+  pages: z13.array(TenantWorkbenchPageEnvelopeSchema),
+  pageGroups: z13.array(TenantWorkbenchPageGroupSchema),
+  catalog: z13.object({ enabled: z13.boolean().optional(), defaultEntry: z13.boolean().optional() }).strict().optional(),
+  quickSwitcherMaxItems: z13.number().int().nonnegative().optional(),
+  defaultOrder: z13.object({
+    groups: z13.array(ContractIdentifierSchema),
+    pages: z13.record(ContractIdentifierSchema, z13.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({
+  customers: z13.object({
+    dropdownToolsDefault: z13.array(ContractIdentifierSchema).optional(),
+    layoutManagerTools: z13.array(WorkbenchCustomerToolSchema).optional(),
+    studioTabsMode: z13.enum(["dropdown", "tabs"]).optional(),
+    historyWatermark: z13.object({
+      svgUrl: z13.string().optional(),
+      coverage: z13.array(z13.enum(["list", "detail", "download"])).optional(),
+      maxLongEdgeRatio: z13.number().positive().optional(),
+      sizing: z13.object({
         mode: ContractIdentifierSchema,
-        heightRatio: z12.number().positive().optional(),
-        minHeightPx: z12.number().nonnegative().optional(),
-        maxHeightPx: z12.number().nonnegative().optional()
+        heightRatio: z13.number().positive().optional(),
+        minHeightPx: z13.number().nonnegative().optional(),
+        maxHeightPx: z13.number().nonnegative().optional()
       }).strict().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()
+      enhance: z13.object({
+        enabled: z13.boolean().optional(),
+        backgroundLumaThreshold: z13.number().min(0).max(1).optional(),
+        stroke: z13.object({
+          color: z13.string().optional(),
+          opacity: z13.number().min(0).max(1).optional(),
+          widthRatio: z13.number().nonnegative().optional(),
+          blurRatio: z13.number().nonnegative().optional(),
+          steps: z13.number().int().positive().optional()
         }).strict().optional()
       }).strict().optional()
     }).strict().optional(),
-    layoutManagerEnabled: z12.boolean().optional(),
-    existingToolsDefault: z12.array(ContractIdentifierSchema).optional(),
-    historyColumnsDefault: z12.number().int().min(1).max(6).optional(),
-    studioOverrides: z12.array(WorkbenchStudioOverrideSchema).optional()
+    layoutManagerEnabled: z13.boolean().optional(),
+    existingToolsDefault: z13.array(ContractIdentifierSchema).optional(),
+    historyColumnsDefault: z13.number().int().min(1).max(6).optional(),
+    studioOverrides: z13.array(WorkbenchStudioOverrideSchema).optional()
   }).strict().optional()
 }).strict().superRefine(({ pages, pageGroups }, context) => {
   const pageIds = pages.map(({ definition }) => definition.pageId);
@@ -11104,38 +11474,38 @@ var TenantWorkbenchConfigSchema = z12.object({
     });
   });
 });
-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()
+var LoginPageSchema = z13.object({
+  background: z13.object({ imageUrl: z13.string().optional(), gradient: z13.string().optional() }).strict().optional(),
+  logo: z13.object({
+    url: z13.string().optional(),
+    lightUrl: z13.string().optional(),
+    darkUrl: z13.string().optional(),
+    position: z13.enum(["top", "middle", "bottom"]).optional(),
+    scale: z13.number().positive().optional()
   }).strict().optional(),
-  customCss: z12.string().optional()
+  customCss: z13.string().optional()
 }).strict();
 var LandingPageHeadbarConfigShape = {
-  headbarMode: z12.enum(["shared", "hidden"]).optional()
+  headbarMode: z13.enum(["shared", "hidden"]).optional()
 };
-var LandingPageDefaultConfigSchema = z12.object({
-  mode: z12.literal("default"),
+var LandingPageDefaultConfigSchema = z13.object({
+  mode: z13.literal("default"),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageMarkdownConfigSchema = z12.object({
-  mode: z12.literal("markdown"),
-  content: z12.string(),
+var LandingPageMarkdownConfigSchema = z13.object({
+  mode: z13.literal("markdown"),
+  content: z13.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageHtmlConfigSchema = z12.object({
-  mode: z12.literal("html"),
-  content: z12.string(),
+var LandingPageHtmlConfigSchema = z13.object({
+  mode: z13.literal("html"),
+  content: z13.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageIframeConfigSchema = z12.object({
-  mode: z12.literal("iframe"),
+var LandingPageIframeConfigSchema = z13.object({
+  mode: z13.literal("iframe"),
   ...LandingPageHeadbarConfigShape,
-  url: z12.string().refine((value) => {
+  url: z13.string().refine((value) => {
     if (/^\/(?!\/)/.test(value)) {
       return !value.includes("\\");
     }
@@ -11147,422 +11517,424 @@ var LandingPageIframeConfigSchema = z12.object({
     }
   }, "Landing page iframe URL must use a root-relative path or HTTP(S) without embedded credentials.")
 }).strict();
-var TenantLandingPageConfigSchema = z12.discriminatedUnion("mode", [
+var TenantLandingPageConfigSchema = z13.discriminatedUnion("mode", [
   LandingPageDefaultConfigSchema,
   LandingPageMarkdownConfigSchema,
   LandingPageHtmlConfigSchema,
   LandingPageIframeConfigSchema
 ]);
-var TenantApplicationConfigSchema = z12.object({
-  theme: z12.object({
-    id: z12.string().optional(),
-    name: z12.string().optional(),
-    title: z12.string().optional(),
+var TenantApplicationConfigSchema = z13.object({
+  theme: z13.object({
+    id: z13.string().optional(),
+    name: z13.string().optional(),
+    title: z13.string().optional(),
     favicon: AssetVariantsSchema.optional(),
     logo: AssetVariantsSchema.optional(),
-    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"])
+    pwaIcon: z13.string().optional(),
+    form: z13.object({ variant: z13.enum(["bento", "ghost"]) }).strict().optional(),
+    toast: z13.object({
+      position: z13.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(),
-    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()
+    icons: z13.object({ error: CustomIconSchema.optional(), empty: CustomIconSchema.optional() }).strict().optional(),
+    views: z13.object({
+      form: z13.object({
+        toast: z13.object({ afterCreate: z13.boolean(), afterDelete: z13.boolean() }).strict(),
+        progress: z13.enum(["estimate", "infinite"]),
+        onlyResult: z13.boolean(),
+        tabular: z13.object({ theme: z13.enum(["default", "tentiary", "primary"]) }).strict()
       }).strict()
     }).strict().optional(),
     loginPage: LoginPageSchema.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()
+    extraLanguageURL: z13.record(z13.string(), z13.string()).optional(),
+    hideSpaceHeader: z13.boolean().optional(),
+    showSidebarTeamSelector: z13.boolean().optional(),
+    showWorkbenchSidebar: z13.boolean().optional(),
+    workbenchViewTheme: z13.enum(["default", "bsd-blue"]).optional(),
+    defaults: z13.object({
+      showFormInImageDetail: z13.boolean().optional(),
+      darkMode: z13.enum(["light", "dark", "auto"]).optional(),
+      language: z13.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
+      showDarkModeToggle: z13.boolean().optional(),
+      showLanguageToggle: z13.boolean().optional()
     }).strict().optional(),
-    modules: z12.object({
-      monkeysSpaceSidebar: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]).optional(),
-      monkeysSpaceHeadbar: z12.union([
-        z12.literal("*"),
-        z12.array(TenantHeadbarModuleItemSchema)
+    modules: z13.object({
+      monkeysSpaceSidebar: z13.union([z13.literal("*"), z13.array(ContractIdentifierSchema)]).optional(),
+      monkeysSpaceHeadbar: z13.union([
+        z13.literal("*"),
+        z13.array(TenantHeadbarModuleItemSchema)
       ]).optional(),
-      settingsSidebar: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]).optional()
+      settingsSidebar: z13.union([z13.literal("*"), z13.array(ContractIdentifierSchema)]).optional()
     }).strict().optional(),
     headbar: ThemeHeadbarSchema.optional(),
-    kernelLayout: z12.object({
-      navigationMode: z12.enum(["sidebar", "topbar"]).optional(),
-      allowNavigationModeSwitch: z12.boolean().optional(),
+    kernelLayout: z13.object({
+      navigationMode: z13.enum(["sidebar", "topbar"]).optional(),
+      allowNavigationModeSwitch: z13.boolean().optional(),
       headbar: KernelHeadbarSchema.optional()
     }).strict().optional(),
-    paginationPosition: z12.enum(["left", "right"]).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()
+    paginationPosition: z13.enum(["left", "right"]).optional(),
+    ugcViewIconOnlyMode: z13.boolean().optional(),
+    workflowPreviewExecutionGrid: z13.object({
+      selectionModeDisplayType: z13.enum(["operation-button", "dropdown-menu"]).optional(),
+      clickBehavior: z13.enum(["preview", "select", "fill-form", "none"]).optional(),
+      showErrorFilter: z13.boolean().optional(),
+      displayType: z13.enum(["grid", "masonry"]).optional(),
+      showDetailButton: z13.boolean().optional()
     }).strict().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(),
-    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(),
-    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()
+    workbenchSidebarDefaultOpen: z13.boolean().optional(),
+    workbenchSidebarMoreAction: z13.boolean().optional(),
+    workbenchSidebarApart: z13.boolean().optional(),
+    workbenchSidebarToggleGroupDetail: z13.boolean().optional(),
+    workbenchSidebarViewType: z13.boolean().optional(),
+    workbenchSidebarFormViewEmbed: z13.boolean().optional(),
+    workbenchSidebarModernMode: z13.boolean().optional(),
+    ugc: z13.object({ onItemClick: z13.boolean(), subtitle: z13.boolean().optional() }).strict().optional(),
+    uniImagePreview: z13.boolean().optional(),
+    imagePreviewStyle: z13.union([z13.literal(false), z13.enum(["simple", "normal", "uni"])]).optional(),
+    teamAsUser: z13.boolean().optional(),
+    themeMode: z13.enum(["shadow", "border"]).optional(),
+    density: z13.enum(["compact", "default", "comfortable"]).optional(),
+    pageZoom: z13.number().positive().optional(),
+    miniMode: z13.object({ showPreviewViewExecutionResultGrid: z13.boolean() }).strict().optional(),
+    workflow: z13.object({ allowConcurrentRuns: z13.boolean() }).strict().optional(),
+    historyResult: z13.object({ display: z13.boolean() }).strict().optional(),
+    uploader: z13.object({
+      orientation: z13.enum(["vertical", "horizontal"]),
+      pasteButton: z13.boolean(),
+      statusText: z13.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()
+    designProjects: z13.object({
+      oneOnOne: z13.boolean(),
+      newTabOpenBoard: z13.boolean(),
+      defaultShowGrid: z13.boolean().optional(),
+      createDefaultFrame: z13.boolean(),
+      showPageMenu: z13.boolean(),
+      showMainMenu: z13.boolean(),
+      showStylePanel: z13.boolean(),
+      showToolbar: z13.boolean(),
+      toolbarPosition: z13.enum(["bottom", "left"]).optional(),
+      showContextMenu: z13.boolean(),
+      showActionsMenu: z13.boolean(),
+      showPageAndLayerSidebar: z13.boolean().optional(),
+      showBoardOperationSidebar: z13.boolean().optional(),
+      showMiniToolsToolbar: z13.boolean().optional(),
+      showRightSidebar: z13.boolean().optional(),
+      showRealtimeDrawing: z13.boolean().optional(),
+      showWorkflow: z13.boolean().optional(),
+      showVersionManager: z13.boolean().optional(),
+      showAgent: z13.boolean().optional(),
+      AgentTools: z13.array(ContractIdentifierSchema).optional()
     }).strict().optional(),
     workbench: TenantWorkbenchConfigSchema.optional(),
-    visionProWorkflows: z12.array(ContractIdentifierSchema).optional(),
-    initTeam: z12.boolean().optional(),
-    imageThumbnail: z12.boolean().optional(),
-    pages: z12.object({
-      allowPageKeys: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]),
+    visionProWorkflows: z13.array(ContractIdentifierSchema).optional(),
+    initTeam: z13.boolean().optional(),
+    imageThumbnail: z13.boolean().optional(),
+    pages: z13.object({
+      allowPageKeys: z13.union([z13.literal("*"), z13.array(ContractIdentifierSchema)]),
       defaultPageKey: ContractIdentifierSchema.optional()
     }).strict().optional(),
-    agent: z12.object({
+    agent: z13.object({
       logo: AssetVariantsSchema.optional(),
-      brandDisplayMode: z12.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
-      density: z12.enum(["compact", "default", "comfortable"]).optional()
+      brandDisplayMode: z13.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
+      density: z13.enum(["compact", "default", "comfortable"]).optional()
     }).strict().optional()
   }).strict(),
   landingPage: TenantLandingPageConfigSchema.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({ disableAutoRegister: z12.boolean().optional() }).strict().optional(),
-    hideAuthToast: z12.boolean().optional(),
-    autoReload: z12.boolean().optional(),
-    defaultOtherTeam: z12.boolean().optional()
+  auth: z13.object({
+    enabled: z13.array(ContractIdentifierSchema).default([]),
+    oidc: z13.object({ buttonText: z13.string().optional(), autoSignin: z13.boolean().optional() }).strict().optional(),
+    password: z13.object({ disableAutoRegister: z13.boolean().optional() }).strict().optional(),
+    hideAuthToast: z13.boolean().optional(),
+    autoReload: z13.boolean().optional(),
+    defaultOtherTeam: z13.boolean().optional()
   }).strict(),
-  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()
+  endpoints: z13.record(ContractIdentifierSchema, z13.string()),
+  module: z13.union([z13.literal("*"), z13.array(ContractIdentifierSchema)]),
+  behavior: z13.object({
+    clearWorkflowFormStorageAfterUpdate: z13.boolean().optional(),
+    autoApproveOAuth: z13.boolean().optional(),
+    rememberWorkflowModelSelection: z13.boolean().optional()
   }).strict(),
-  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({
+  dataManagement: z13.object({
+    favoriteOntologyId: z13.string().optional(),
+    pairedOntologyId: z13.string().optional(),
+    galleryOntologyIds: z13.array(ContractIdentifierSchema).max(20).optional(),
+    galleryOntologyId: z13.string().optional(),
+    dataBrowserDefaultOntologyId: z13.string().optional(),
+    workflowResultOntologyId: z13.string().optional(),
+    homeAdvertisement: z13.object({
       ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
-      viewType: z12.enum(["filter", "container", "share_link"]).optional(),
+      viewType: z13.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()
+      teamOnly: z13.boolean().optional(),
+      pageSize: z13.number().int().positive().optional(),
+      sortBy: z13.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
+      sortOrder: z13.enum(["asc", "desc"]).optional(),
+      fieldMap: z13.record(z13.string(), z13.string()).optional(),
+      columnIds: z13.record(z13.string(), z13.string()).optional()
     }).strict().optional(),
-    homeTrendAssistant: z12.object({
+    homeTrendAssistant: z13.object({
       ontologyId: ContractIdentifierSchema.optional(),
       viewId: ContractIdentifierSchema.optional(),
       viewInstanceId: ContractIdentifierSchema.optional(),
-      viewName: z12.string().optional(),
+      viewName: z13.string().optional(),
       teamId: ContractIdentifierSchema.optional(),
       designOptionsWorkflowId: ContractIdentifierSchema.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()
+      tep: z13.object({ baseUrl: z13.string().optional(), timeoutMs: z13.number().int().positive().optional() }).strict().optional(),
+      runtime: z13.object({ appId: ContractIdentifierSchema, tepBaseUrlConfigured: z13.boolean(), tepAuthorizationConfigured: z13.boolean(), tepCookieConfigured: z13.boolean() }).strict().optional()
     }).strict().optional(),
     trendRadar: TenantTrendRadarSourcesSchema.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()
+    sharing: z13.object({
+      silentViewLinks: z13.object({ enabled: z13.boolean().optional(), placement: z13.object({ mode: z13.enum(["sourceOntology", "ontology"]).optional(), ontologyId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
+      shareAccess: z13.object({ publicLinksEnabled: z13.boolean().optional(), passwordGateEnabled: z13.boolean().optional(), passwordAccessTtlSeconds: z13.number().int().positive().optional(), defaultViewTreeDelivery: z13.enum(["manual", "auto"]).optional() }).strict().optional(),
+      shareDialog: z13.object({
+        audience: z13.object({ enabled: z13.boolean().optional(), allowed: z13.array(z13.enum(["user", "team", "public"])).optional(), default: z13.enum(["user", "team", "public"]).optional() }).strict().optional(),
+        accessLevel: z13.object({ enabled: z13.boolean().optional(), allowed: z13.array(z13.enum(["read", "write"])).optional(), default: z13.enum(["read", "write"]).optional() }).strict().optional(),
+        viewTreeDelivery: z13.object({ enabled: z13.boolean().optional(), allowed: z13.array(z13.enum(["manual", "auto"])).optional(), default: z13.enum(["manual", "auto"]).optional() }).strict().optional()
       }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  compute: 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()
+  compute: z13.object({
+    integrations: z13.object({
+      harbor: z13.object({ endpoint: z13.string().optional(), projectScopes: z13.array(z13.string()).optional(), authMode: z13.string().optional(), principal: z13.string().optional(), autoSync: z13.boolean().optional(), proxyUrl: z13.string().optional() }).strict().optional(),
+      gitlab: z13.object({ baseUrl: z13.string().optional(), groupScopes: z13.array(z13.string()).optional(), tokenMode: z13.string().optional(), deployProjectPath: z13.string().optional(), deploymentReportsEnabled: z13.boolean().optional(), proxyUrl: z13.string().optional() }).strict().optional(),
+      kubernetes: z13.object({ accessMode: z13.string().optional(), clusterAlias: z13.string().optional(), agentProjectPath: z13.string().optional(), agentName: z13.string().optional(), namespaceScopes: z13.array(z13.string()).optional(), rolloutObserverEnabled: z13.boolean().optional(), proxyUrl: z13.string().optional() }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  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({
+  data: z13.object({}).strict().optional(),
+  storage: z13.object({
+    presignMode: z13.enum(["frontend", "backend", "both"]).optional(),
+    presign: z13.object({
+      expiresInSeconds: z13.number().int().positive(),
+      buckets: z13.array(
+        z13.object({
           id: ContractIdentifierSchema,
           provider: ContractIdentifierSchema,
           preferredUrlPatternId: ContractIdentifierSchema,
-          urlPatterns: z12.array(
-            z12.object({
+          urlPatterns: z13.array(
+            z13.object({
               id: ContractIdentifierSchema,
-              type: z12.enum(["bucket-hostname", "provider-hostname"]),
-              hostname: z12.string().trim().min(1),
-              preferred: z12.boolean().optional(),
-              bucketSegment: z12.string().optional()
+              type: z13.enum(["bucket-hostname", "provider-hostname"]),
+              hostname: z13.string().trim().min(1),
+              preferred: z13.boolean().optional(),
+              bucketSegment: z13.string().optional()
             }).strict()
           )
         }).strict()
       )
     }).strict().optional()
   }).strict().optional(),
-  monkeyData: z12.object({ baseUrl: z12.string().optional() }).strict().optional()
+  monkeyData: z13.object({ baseUrl: z13.string().optional() }).strict().optional()
 }).strict();
-var TenantProductConfigSchema = z12.object({
-  contract: z12.literal("TenantProductConfig"),
+var TenantProductConfigSchema = z13.object({
+  contract: z13.literal("TenantProductConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: TenantDesignTokensConfigSchema,
-  moduleRefs: z12.array(ContractIdentifierSchema).default([]),
-  pageRefs: z12.array(ContractIdentifierSchema).default([]),
-  featureFlags: z12.record(z12.string(), z12.boolean()).default({}),
+  moduleRefs: z13.array(ContractIdentifierSchema).default([]),
+  pageRefs: z13.array(ContractIdentifierSchema).default([]),
+  featureFlags: z13.record(z13.string(), z13.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z12.record(z12.string(), ContractIdentifierSchema),
-  warnings: z12.array(z12.string()).default([]),
+  sourceMap: z13.record(z13.string(), ContractIdentifierSchema),
+  warnings: z13.array(z13.string()).default([]),
+  menus: MenuDefinitionSetSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
-var TenantRuntimeConfigSchema = z12.object({
-  contract: z12.literal("TenantRuntimeConfig"),
+var TenantRuntimeConfigSchema = z13.object({
+  contract: z13.literal("TenantRuntimeConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: ResolvedThemeTokensSchema,
-  moduleRefs: z12.array(ContractIdentifierSchema).default([]),
-  pageRefs: z12.array(ContractIdentifierSchema).default([]),
-  featureFlags: z12.record(z12.string(), z12.boolean()).default({}),
+  moduleRefs: z13.array(ContractIdentifierSchema).default([]),
+  pageRefs: z13.array(ContractIdentifierSchema).default([]),
+  featureFlags: z13.record(z13.string(), z13.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z12.record(z12.string(), ContractIdentifierSchema),
-  warnings: z12.array(z12.string()).default([]),
+  sourceMap: z13.record(z13.string(), ContractIdentifierSchema),
+  warnings: z13.array(z13.string()).default([]),
+  menuBundle: MenuRuntimeBundleSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
 
 // src/contracts/trend.ts
-import { z as z13 } from "zod";
-var RadarDecisionMetricsSchema = z13.object({
-  currentSales: z13.number().finite(),
-  forecastSales: z13.number().finite(),
-  searchHeat: z13.number().finite(),
-  socialHeat: z13.number().finite(),
-  confidence: z13.number().min(0).max(1)
-}).strict();
-var TrendSourceSchema = z13.object({
+import { z as z14 } from "zod";
+var RadarDecisionMetricsSchema = z14.object({
+  currentSales: z14.number().finite(),
+  forecastSales: z14.number().finite(),
+  searchHeat: z14.number().finite(),
+  socialHeat: z14.number().finite(),
+  confidence: z14.number().min(0).max(1)
+}).strict();
+var TrendSourceSchema = z14.object({
   sourceId: ContractIdentifierSchema,
   provider: ContractIdentifierSchema,
-  channel: z13.enum(["trend", "ecommerce", "social", "search", "internal"]),
+  channel: z14.enum(["trend", "ecommerce", "social", "search", "internal"]),
   collectedAt: IsoDateTimeSchema,
-  sourceUrl: z13.string().url().optional(),
-  evidenceRefs: z13.array(EntityRefSchema).default([])
+  sourceUrl: z14.string().url().optional(),
+  evidenceRefs: z14.array(EntityRefSchema).default([])
 }).strict();
-var TrendIngestRunSchema = z13.object({
-  contract: z13.literal("TrendIngestRun"),
+var TrendIngestRunSchema = z14.object({
+  contract: z14.literal("TrendIngestRun"),
   ingestRunId: ContractIdentifierSchema,
   sourceId: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  status: z13.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
-  recordCount: z13.number().int().nonnegative(),
-  errorCount: z13.number().int().nonnegative(),
+  status: z14.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
+  recordCount: z14.number().int().nonnegative(),
+  errorCount: z14.number().int().nonnegative(),
   startedAt: IsoDateTimeSchema,
   completedAt: IsoDateTimeSchema.optional()
 }).strict();
-var TrendSourceRecordSchema = z13.object({
-  contract: z13.literal("TrendSourceRecord"),
+var TrendSourceRecordSchema = z14.object({
+  contract: z14.literal("TrendSourceRecord"),
   sourceRecordId: ContractIdentifierSchema,
   source: TrendSourceSchema,
   ingestRunRef: EntityRefSchema,
-  recordVersion: z13.number().int().positive(),
+  recordVersion: z14.number().int().positive(),
   contentHash: Sha256Schema,
   payload: JsonValueSchema,
   idempotencyKey: ContractIdentifierSchema,
   collectedAt: IsoDateTimeSchema
 }).strict();
-var HotwordBodySchema = z13.object({
-  contract: z13.literal("HotwordBody"),
+var HotwordBodySchema = z14.object({
+  contract: z14.literal("HotwordBody"),
   hotwordId: ContractIdentifierSchema,
-  label: z13.string().trim().min(1),
-  normalizedLabel: z13.string().trim().min(1),
-  categories: z13.array(ContractIdentifierSchema).default([]),
-  sourceRefs: z13.array(TrendSourceSchema).min(1),
-  relationRefs: z13.array(EntityRefSchema).default([]),
+  label: z14.string().trim().min(1),
+  normalizedLabel: z14.string().trim().min(1),
+  categories: z14.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z14.array(TrendSourceSchema).min(1),
+  relationRefs: z14.array(EntityRefSchema).default([]),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 }).strict();
 var CommerceBodyFieldsSchema = {
-  displayName: z13.string().trim().min(1),
-  normalizedName: z13.string().trim().min(1),
-  categories: z13.array(ContractIdentifierSchema).default([]),
-  sourceRefs: z13.array(EntityRefSchema).min(1),
-  relationRefs: z13.array(EntityRefSchema).default([]),
+  displayName: z14.string().trim().min(1),
+  normalizedName: z14.string().trim().min(1),
+  categories: z14.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z14.array(EntityRefSchema).min(1),
+  relationRefs: z14.array(EntityRefSchema).default([]),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 };
-var BrandBodySchema = z13.object({
-  contract: z13.literal("BrandBody"),
+var BrandBodySchema = z14.object({
+  contract: z14.literal("BrandBody"),
   brandId: ContractIdentifierSchema,
   ...CommerceBodyFieldsSchema
 }).strict();
-var ProductBodySchema = z13.object({
-  contract: z13.literal("ProductBody"),
+var ProductBodySchema = z14.object({
+  contract: z14.literal("ProductBody"),
   productId: ContractIdentifierSchema,
   brandRef: EntityRefSchema.optional(),
   ...CommerceBodyFieldsSchema
 }).strict();
-var TrendMetricSnapshotSchema = z13.object({
-  contract: z13.literal("TrendMetricSnapshot"),
+var TrendMetricSnapshotSchema = z14.object({
+  contract: z14.literal("TrendMetricSnapshot"),
   snapshotId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   observedAt: IsoDateTimeSchema,
-  metrics: z13.record(z13.string(), z13.number().finite()),
-  confidence: z13.number().min(0).max(1),
-  evidenceRefs: z13.array(EntityRefSchema).min(1)
+  metrics: z14.record(z14.string(), z14.number().finite()),
+  confidence: z14.number().min(0).max(1),
+  evidenceRefs: z14.array(EntityRefSchema).min(1)
 }).strict();
-var RadarScoreModelBodySchema = z13.object({
-  contract: z13.literal("RadarScoreModelBody"),
+var RadarScoreModelBodySchema = z14.object({
+  contract: z14.literal("RadarScoreModelBody"),
   modelId: ContractIdentifierSchema,
-  version: z13.number().int().positive(),
+  version: z14.number().int().positive(),
   weights: RadarDecisionMetricsSchema,
-  thresholds: z13.record(z13.string(), z13.number().finite()).default({}),
-  explanationRules: z13.record(z13.string(), z13.string().trim().min(1)).default({}),
+  thresholds: z14.record(z14.string(), z14.number().finite()).default({}),
+  explanationRules: z14.record(z14.string(), z14.string().trim().min(1)).default({}),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarScoreProjectionSchema = z13.object({
-  contract: z13.literal("RadarScoreProjection"),
+var RadarScoreProjectionSchema = z14.object({
+  contract: z14.literal("RadarScoreProjection"),
   projectionId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   modelRef: EntityRefSchema,
-  totalScore: z13.number().finite(),
+  totalScore: z14.number().finite(),
   dimensions: RadarDecisionMetricsSchema,
-  evidenceRefs: z13.array(EntityRefSchema).min(1),
+  evidenceRefs: z14.array(EntityRefSchema).min(1),
   freshnessAt: IsoDateTimeSchema
 }).strict();
-var RadarPanoramaNodeSchema = z13.object({
+var RadarPanoramaNodeSchema = z14.object({
   ref: EntityRefSchema,
-  label: z13.string().trim().min(1),
-  categories: z13.array(ContractIdentifierSchema).default([]),
-  score: z13.number().finite().optional(),
+  label: z14.string().trim().min(1),
+  categories: z14.array(ContractIdentifierSchema).default([]),
+  score: z14.number().finite().optional(),
   freshnessAt: IsoDateTimeSchema.optional()
 }).strict();
-var RadarPanoramaEdgeSchema = z13.object({
+var RadarPanoramaEdgeSchema = z14.object({
   sourceRef: EntityRefSchema,
   targetRef: EntityRefSchema,
   relation: ContractIdentifierSchema,
-  evidenceRefs: z13.array(EntityRefSchema).default([])
+  evidenceRefs: z14.array(EntityRefSchema).default([])
 }).strict();
-var RadarPanoramaSchema = z13.object({
-  contract: z13.literal("RadarPanorama"),
-  nodes: z13.array(RadarPanoramaNodeSchema),
-  edges: z13.array(RadarPanoramaEdgeSchema),
+var RadarPanoramaSchema = z14.object({
+  contract: z14.literal("RadarPanorama"),
+  nodes: z14.array(RadarPanoramaNodeSchema),
+  edges: z14.array(RadarPanoramaEdgeSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
-var BrandGeneticsProfileSchema = z13.object({
-  contract: z13.literal("BrandGeneticsProfile"),
+var BrandGeneticsProfileSchema = z14.object({
+  contract: z14.literal("BrandGeneticsProfile"),
   brandRef: EntityRefSchema,
-  categories: z13.array(ContractIdentifierSchema).default([]),
-  signature: z13.record(ContractIdentifierSchema, z13.number().finite()),
-  relatedRefs: z13.array(EntityRefSchema).default([]),
-  evidenceRefs: z13.array(EntityRefSchema).default([]),
+  categories: z14.array(ContractIdentifierSchema).default([]),
+  signature: z14.record(ContractIdentifierSchema, z14.number().finite()),
+  relatedRefs: z14.array(EntityRefSchema).default([]),
+  evidenceRefs: z14.array(EntityRefSchema).default([]),
   computedAt: IsoDateTimeSchema
 }).strict();
-var RadarOpportunityMatrixPointSchema = z13.object({
+var RadarOpportunityMatrixPointSchema = z14.object({
   subjectRef: EntityRefSchema,
-  label: z13.string().trim().min(1),
-  x: z13.number().finite(),
-  y: z13.number().finite(),
-  score: z13.number().finite(),
-  evidenceRefs: z13.array(EntityRefSchema).default([])
-}).strict();
-var RadarOpportunityMatrixSchema = z13.object({
-  contract: z13.literal("RadarOpportunityMatrix"),
-  xMetric: z13.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
-  yMetric: z13.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
-  points: z13.array(RadarOpportunityMatrixPointSchema),
+  label: z14.string().trim().min(1),
+  x: z14.number().finite(),
+  y: z14.number().finite(),
+  score: z14.number().finite(),
+  evidenceRefs: z14.array(EntityRefSchema).default([])
+}).strict();
+var RadarOpportunityMatrixSchema = z14.object({
+  contract: z14.literal("RadarOpportunityMatrix"),
+  xMetric: z14.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  yMetric: z14.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  points: z14.array(RadarOpportunityMatrixPointSchema),
   computedAt: IsoDateTimeSchema
 }).strict();
-var RadarQueryBodySchema = z13.object({
-  contract: z13.literal("RadarQueryBody"),
+var RadarQueryBodySchema = z14.object({
+  contract: z14.literal("RadarQueryBody"),
   queryId: ContractIdentifierSchema,
-  filters: z13.record(z13.string(), JsonValueSchema).default({}),
-  sort: z13.object({
+  filters: z14.record(z14.string(), JsonValueSchema).default({}),
+  sort: z14.object({
     field: ContractIdentifierSchema,
-    direction: z13.enum(["asc", "desc"])
+    direction: z14.enum(["asc", "desc"])
   }).strict(),
-  pageSize: z13.number().int().min(1).max(200),
+  pageSize: z14.number().int().min(1).max(200),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var SavedRadarQuerySchema = z13.object({
-  contract: z13.literal("SavedRadarQuery"),
+var SavedRadarQuerySchema = z14.object({
+  contract: z14.literal("SavedRadarQuery"),
   savedQueryId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   ownerRef: EntityRefSchema,
-  name: z13.string().trim().min(1),
+  name: z14.string().trim().min(1),
   queryRef: EntityRefSchema,
-  expectedVersion: z13.number().int().nonnegative(),
+  expectedVersion: z14.number().int().nonnegative(),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var RadarSelectionSchema = z13.object({
-  contract: z13.literal("RadarSelection"),
+var RadarSelectionSchema = z14.object({
+  contract: z14.literal("RadarSelection"),
   selectionId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   ownerRef: EntityRefSchema,
-  subjectRefs: z13.array(EntityRefSchema),
-  status: z13.enum(["stashed", "selected", "rejected", "archived"]),
-  note: z13.string().optional(),
-  expectedVersion: z13.number().int().nonnegative(),
+  subjectRefs: z14.array(EntityRefSchema),
+  status: z14.enum(["stashed", "selected", "rejected", "archived"]),
+  note: z14.string().optional(),
+  expectedVersion: z14.number().int().nonnegative(),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisRunSchema = z13.object({
-  contract: z13.literal("RadarAnalysisRun"),
+var RadarAnalysisRunSchema = z14.object({
+  contract: z14.literal("RadarAnalysisRun"),
   runId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   selectionRef: EntityRefSchema,
@@ -11571,66 +11943,66 @@ var RadarAnalysisRunSchema = z13.object({
   designProjectRef: EntityRefSchema.optional(),
   replayedFromRef: EntityRefSchema.optional(),
   workflowDefinitionTeamId: ContractIdentifierSchema.optional(),
-  workflowInput: z13.record(z13.string(), JsonValueSchema).default({}),
-  createDesignProject: z13.boolean().default(true),
-  designProjectName: z13.string().trim().min(1).max(200).optional(),
+  workflowInput: z14.record(z14.string(), JsonValueSchema).default({}),
+  createDesignProject: z14.boolean().default(true),
+  designProjectName: z14.string().trim().min(1).max(200).optional(),
   modelRef: EntityRefSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  status: z13.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
-  outputRefs: z13.array(EntityRefSchema).default([]),
-  error: z13.object({
+  status: z14.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
+  outputRefs: z14.array(EntityRefSchema).default([]),
+  error: z14.object({
     code: ContractIdentifierSchema,
-    message: z13.string().trim().min(1),
-    retryable: z13.boolean()
+    message: z14.string().trim().min(1),
+    retryable: z14.boolean()
   }).strict().optional(),
   startedAt: IsoDateTimeSchema.optional(),
   completedAt: IsoDateTimeSchema.optional(),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisAssetSchema = z13.object({
+var RadarAnalysisAssetSchema = z14.object({
   artifactRef: EntityRefSchema,
   kind: ContractIdentifierSchema,
-  mimeType: z13.string().trim().min(1).optional(),
-  url: z13.string().url(),
-  metadata: z13.record(z13.string(), JsonValueSchema).default({}),
+  mimeType: z14.string().trim().min(1).optional(),
+  url: z14.string().url(),
+  metadata: z14.record(z14.string(), JsonValueSchema).default({}),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisDetailSchema = z13.object({
-  contract: z13.literal("RadarAnalysisDetail"),
+var RadarAnalysisDetailSchema = z14.object({
+  contract: z14.literal("RadarAnalysisDetail"),
   run: RadarAnalysisRunSchema,
-  runVersion: z13.number().int().positive(),
+  runVersion: z14.number().int().positive(),
   selection: RadarSelectionSchema,
-  outputs: z13.array(OutputRecordSchema),
-  assets: z13.array(RadarAnalysisAssetSchema),
-  lineage: z13.array(LineageRecordSchema)
+  outputs: z14.array(OutputRecordSchema),
+  assets: z14.array(RadarAnalysisAssetSchema),
+  lineage: z14.array(LineageRecordSchema)
 }).strict();
-var RadarActionRecordSchema = z13.object({
-  contract: z13.literal("RadarActionRecord"),
+var RadarActionRecordSchema = z14.object({
+  contract: z14.literal("RadarActionRecord"),
   actionId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   actorRef: EntityRefSchema,
-  action: z13.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
+  action: z14.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
   targetRef: EntityRefSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  expectedVersion: z13.number().int().nonnegative(),
+  expectedVersion: z14.number().int().nonnegative(),
   occurredAt: IsoDateTimeSchema
 }).strict();
-var RadarWritebackRecordSchema = z13.object({
-  contract: z13.literal("RadarWritebackRecord"),
+var RadarWritebackRecordSchema = z14.object({
+  contract: z14.literal("RadarWritebackRecord"),
   writebackId: ContractIdentifierSchema,
   actionRef: EntityRefSchema,
   targetRef: EntityRefSchema,
-  status: z13.enum(["PENDING", "APPLIED", "FAILED"]),
-  resultingVersion: z13.number().int().nonnegative().optional(),
-  error: z13.string().trim().min(1).optional(),
+  status: z14.enum(["PENDING", "APPLIED", "FAILED"]),
+  resultingVersion: z14.number().int().nonnegative().optional(),
+  error: z14.string().trim().min(1).optional(),
   recordedAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/workflow-definition.ts
-import { z as z14 } from "zod";
-var ConductorTaskTypeSchema = z14.enum([
+import { z as z15 } from "zod";
+var ConductorTaskTypeSchema = z15.enum([
   "SIMPLE",
   "DYNAMIC",
   "FORK_JOIN",
@@ -11679,46 +12051,46 @@ var requiredTaskFields = {
   WAIT: ["inputParameters"],
   TERMINATE: ["inputParameters"]
 };
-var ConductorTaskDefinitionSchema = z14.lazy(
-  () => z14.object({
+var ConductorTaskDefinitionSchema = z15.lazy(
+  () => z15.object({
     name: ContractIdentifierSchema,
     taskReferenceName: ContractIdentifierSchema,
     type: ConductorTaskTypeSchema,
-    inputParameters: z14.record(z14.string(), JsonValueSchema).optional(),
-    startDelay: z14.number().int().nonnegative().optional(),
-    optional: z14.boolean().optional(),
-    asyncComplete: z14.boolean().optional(),
-    rateLimited: z14.boolean().optional(),
-    retryCount: z14.number().int().nonnegative().optional(),
-    taskDefinition: z14.record(z14.string(), JsonValueSchema).optional(),
-    loopCondition: z14.string().optional(),
-    loopOver: z14.array(ConductorTaskDefinitionSchema).optional(),
-    sink: z14.string().optional(),
-    forkTasks: z14.array(z14.array(ConductorTaskDefinitionSchema)).optional(),
-    joinOn: z14.array(ContractIdentifierSchema).optional(),
-    defaultExclusiveJoinTask: z14.array(ContractIdentifierSchema).optional(),
-    dynamicForkTasksParam: z14.string().optional(),
-    dynamicForkTasksInputParamName: z14.string().optional(),
-    subWorkflowParam: z14.object({
-      $ref: z14.string().optional(),
+    inputParameters: z15.record(z15.string(), JsonValueSchema).optional(),
+    startDelay: z15.number().int().nonnegative().optional(),
+    optional: z15.boolean().optional(),
+    asyncComplete: z15.boolean().optional(),
+    rateLimited: z15.boolean().optional(),
+    retryCount: z15.number().int().nonnegative().optional(),
+    taskDefinition: z15.record(z15.string(), JsonValueSchema).optional(),
+    loopCondition: z15.string().optional(),
+    loopOver: z15.array(ConductorTaskDefinitionSchema).optional(),
+    sink: z15.string().optional(),
+    forkTasks: z15.array(z15.array(ConductorTaskDefinitionSchema)).optional(),
+    joinOn: z15.array(ContractIdentifierSchema).optional(),
+    defaultExclusiveJoinTask: z15.array(ContractIdentifierSchema).optional(),
+    dynamicForkTasksParam: z15.string().optional(),
+    dynamicForkTasksInputParamName: z15.string().optional(),
+    subWorkflowParam: z15.object({
+      $ref: z15.string().optional(),
       name: ContractIdentifierSchema,
-      version: z14.number().int().positive().optional(),
-      taskToDomain: z14.record(z14.string(), z14.string()).optional(),
-      workflowDefinition: z14.record(z14.string(), JsonValueSchema).optional()
+      version: z15.number().int().positive().optional(),
+      taskToDomain: z15.record(z15.string(), z15.string()).optional(),
+      workflowDefinition: z15.record(z15.string(), JsonValueSchema).optional()
     }).strict().optional(),
-    decisionCases: z14.record(z14.string(), z14.array(ConductorTaskDefinitionSchema)).optional(),
-    defaultCase: z14.array(ConductorTaskDefinitionSchema).optional(),
-    evaluatorType: z14.enum(["value-param", "javascript", "graaljs"]).optional(),
-    expression: z14.string().optional(),
+    decisionCases: z15.record(z15.string(), z15.array(ConductorTaskDefinitionSchema)).optional(),
+    defaultCase: z15.array(ConductorTaskDefinitionSchema).optional(),
+    evaluatorType: z15.enum(["value-param", "javascript", "graaljs"]).optional(),
+    expression: z15.string().optional(),
     __alias: JsonValueSchema.optional(),
-    callbackFromWorker: z14.boolean().optional(),
+    callbackFromWorker: z15.boolean().optional(),
     caseExpression: JsonValueSchema.optional(),
-    caseValueParam: z14.string().optional(),
-    dependencies: z14.array(JsonValueSchema).optional(),
-    description: z14.string().optional(),
-    dynamicTaskNameParam: z14.string().optional(),
-    joinMode: z14.string().optional(),
-    permissive: z14.boolean().optional(),
+    caseValueParam: z15.string().optional(),
+    dependencies: z15.array(JsonValueSchema).optional(),
+    description: z15.string().optional(),
+    dynamicTaskNameParam: z15.string().optional(),
+    joinMode: z15.string().optional(),
+    permissive: z15.boolean().optional(),
     joinTaskRef: ContractIdentifierSchema.optional(),
     forkTaskRef: ContractIdentifierSchema.optional()
   }).strict().superRefine((task, context) => {
@@ -11732,29 +12104,29 @@ var ConductorTaskDefinitionSchema = z14.lazy(
     }
   })
 );
-var ConductorWorkflowDefinitionSchema = z14.object({
-  ownerApp: z14.string().optional(),
-  createTime: z14.number().int().nonnegative().optional(),
-  updateTime: z14.number().int().nonnegative().optional(),
-  createdBy: z14.string().optional(),
-  updatedBy: z14.string().optional(),
+var ConductorWorkflowDefinitionSchema = z15.object({
+  ownerApp: z15.string().optional(),
+  createTime: z15.number().int().nonnegative().optional(),
+  updateTime: z15.number().int().nonnegative().optional(),
+  createdBy: z15.string().optional(),
+  updatedBy: z15.string().optional(),
   name: ContractIdentifierSchema,
-  description: z14.string().optional(),
-  version: z14.number().int().positive(),
-  tasks: z14.array(ConductorTaskDefinitionSchema),
-  inputParameters: z14.array(ContractIdentifierSchema),
-  outputParameters: z14.record(z14.string(), JsonValueSchema).optional(),
+  description: z15.string().optional(),
+  version: z15.number().int().positive(),
+  tasks: z15.array(ConductorTaskDefinitionSchema),
+  inputParameters: z15.array(ContractIdentifierSchema),
+  outputParameters: z15.record(z15.string(), JsonValueSchema).optional(),
   failureWorkflow: ContractIdentifierSchema.optional(),
-  schemaVersion: z14.number().int().positive().optional(),
-  restartable: z14.boolean().optional(),
-  workflowStatusListenerEnabled: z14.boolean().optional(),
-  ownerEmail: z14.string().email().optional(),
-  timeoutPolicy: z14.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
-  timeoutSeconds: z14.number().int().nonnegative(),
-  variables: z14.record(z14.string(), JsonValueSchema).optional(),
-  inputTemplate: z14.record(z14.string(), JsonValueSchema).optional()
-}).strict();
-var WorkflowParameterTypeSchema = z14.enum([
+  schemaVersion: z15.number().int().positive().optional(),
+  restartable: z15.boolean().optional(),
+  workflowStatusListenerEnabled: z15.boolean().optional(),
+  ownerEmail: z15.string().email().optional(),
+  timeoutPolicy: z15.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+  timeoutSeconds: z15.number().int().nonnegative(),
+  variables: z15.record(z15.string(), JsonValueSchema).optional(),
+  inputTemplate: z15.record(z15.string(), JsonValueSchema).optional()
+}).strict();
+var WorkflowParameterTypeSchema = z15.enum([
   "string",
   "file",
   "number",
@@ -11764,213 +12136,213 @@ var WorkflowParameterTypeSchema = z14.enum([
   "notice",
   "canvas-assist"
 ]);
-var WorkflowConditionalStateSchema = z14.object({
-  conditions: z14.array(
-    z14.object({
-      field: z14.string(),
-      operator: z14.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
+var WorkflowConditionalStateSchema = z15.object({
+  conditions: z15.array(
+    z15.object({
+      field: z15.string(),
+      operator: z15.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
       value: JsonValueSchema
     }).strict()
   ),
-  logic: z14.enum(["AND", "OR"]).optional()
-}).strict();
-var ImageSelectMappingAppearanceSchema = z14.object({
-  columns: z14.number().int().min(1).max(4).optional(),
-  cardSize: z14.enum(["sm", "md", "lg"]).optional(),
-  imageAspectRatio: z14.enum(["square", "4:5", "3:4", "16:9"]).optional(),
-  gap: z14.enum(["sm", "md", "lg"]).optional(),
-  radius: z14.enum(["sm", "md", "lg", "xl"]).optional(),
-  borderStyle: z14.enum(["none", "soft", "strong"]).optional(),
-  borderWidth: z14.union([z14.literal(0), z14.literal(1), z14.literal(2)]).optional(),
-  enableScroll: z14.boolean().optional(),
-  maxHeight: z14.number().int().min(160).max(1200).optional(),
-  enableCollapse: z14.boolean().optional(),
-  visibleRows: z14.number().int().min(1).max(6).optional(),
-  hideLabel: z14.boolean().optional(),
-  hideDescription: z14.boolean().optional(),
-  hideValue: z14.boolean().optional()
-}).strict();
-var ComfyWorkflowPortBindingSchema = z14.object({
-  node: z14.union([z14.string(), z14.number()]),
-  key: z14.string().optional()
-}).strict();
-var WorkflowParameterTypeOptionsSchema = z14.object({
-  editor: z14.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
-  editorLanguage: z14.enum(["javaScript", "json", "python", "sql"]).optional(),
-  maxValue: z14.number().optional(),
-  minValue: z14.number().optional(),
-  max: z14.number().optional(),
-  min: z14.number().optional(),
-  multipleValues: z14.boolean().optional(),
-  numberPrecision: z14.number().nonnegative().optional(),
-  password: z14.boolean().optional(),
-  rows: z14.number().int().positive().optional(),
-  assetType: z14.string().optional(),
-  accept: z14.string().optional(),
-  maxSize: z14.number().positive().optional(),
-  fileType: z14.string().optional(),
-  aiMultiShotMainImageField: z14.string().optional(),
-  aiMultiShotWorkflowAppId: z14.string().optional(),
-  aiMultiShotWorkflowId: z14.string().optional(),
-  allowCustomInput: z14.boolean().optional(),
-  allowUploadVideo: z14.boolean().optional(),
-  aspectRatioField: z14.string().optional(),
-  assemblyValueType: z14.string().optional(),
-  autoAnalyzeDesignImage: z14.boolean().optional(),
-  autoDetectAspectRatio: z14.boolean().optional(),
-  autoIncrementId: z14.boolean().optional(),
+  logic: z15.enum(["AND", "OR"]).optional()
+}).strict();
+var ImageSelectMappingAppearanceSchema = z15.object({
+  columns: z15.number().int().min(1).max(4).optional(),
+  cardSize: z15.enum(["sm", "md", "lg"]).optional(),
+  imageAspectRatio: z15.enum(["square", "4:5", "3:4", "16:9"]).optional(),
+  gap: z15.enum(["sm", "md", "lg"]).optional(),
+  radius: z15.enum(["sm", "md", "lg", "xl"]).optional(),
+  borderStyle: z15.enum(["none", "soft", "strong"]).optional(),
+  borderWidth: z15.union([z15.literal(0), z15.literal(1), z15.literal(2)]).optional(),
+  enableScroll: z15.boolean().optional(),
+  maxHeight: z15.number().int().min(160).max(1200).optional(),
+  enableCollapse: z15.boolean().optional(),
+  visibleRows: z15.number().int().min(1).max(6).optional(),
+  hideLabel: z15.boolean().optional(),
+  hideDescription: z15.boolean().optional(),
+  hideValue: z15.boolean().optional()
+}).strict();
+var ComfyWorkflowPortBindingSchema = z15.object({
+  node: z15.union([z15.string(), z15.number()]),
+  key: z15.string().optional()
+}).strict();
+var WorkflowParameterTypeOptionsSchema = z15.object({
+  editor: z15.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
+  editorLanguage: z15.enum(["javaScript", "json", "python", "sql"]).optional(),
+  maxValue: z15.number().optional(),
+  minValue: z15.number().optional(),
+  max: z15.number().optional(),
+  min: z15.number().optional(),
+  multipleValues: z15.boolean().optional(),
+  numberPrecision: z15.number().nonnegative().optional(),
+  password: z15.boolean().optional(),
+  rows: z15.number().int().positive().optional(),
+  assetType: z15.string().optional(),
+  accept: z15.string().optional(),
+  maxSize: z15.number().positive().optional(),
+  fileType: z15.string().optional(),
+  aiMultiShotMainImageField: z15.string().optional(),
+  aiMultiShotWorkflowAppId: z15.string().optional(),
+  aiMultiShotWorkflowId: z15.string().optional(),
+  allowCustomInput: z15.boolean().optional(),
+  allowUploadVideo: z15.boolean().optional(),
+  aspectRatioField: z15.string().optional(),
+  assemblyValueType: z15.string().optional(),
+  autoAnalyzeDesignImage: z15.boolean().optional(),
+  autoDetectAspectRatio: z15.boolean().optional(),
+  autoIncrementId: z15.boolean().optional(),
   comfyOptions: ComfyWorkflowPortBindingSchema.optional(),
-  comfyuiModelServerId: z14.string().optional(),
-  comfyuiModelTypeName: z14.string().optional(),
+  comfyuiModelServerId: z15.string().optional(),
+  comfyuiModelTypeName: z15.string().optional(),
   defaultCustomInput: JsonValueSchema.optional(),
-  descriptionAlert: z14.boolean().optional(),
-  disabled: z14.union([z14.boolean(), WorkflowConditionalStateSchema]).optional(),
-  editable: z14.union([z14.boolean(), WorkflowConditionalStateSchema]).optional(),
-  enableAiMultiShot: z14.boolean().optional(),
-  enableBooleanSwitchMode: z14.boolean().optional(),
-  enableClear: z14.boolean().optional(),
-  enableExpand: z14.boolean().optional(),
-  enableImageMask: z14.boolean().optional(),
-  enableImageOverlay: z14.boolean().optional(),
-  enablePopupEditor: z14.boolean().optional(),
-  enablePromptFontSize: z14.boolean().optional(),
-  enableReset: z14.boolean().optional(),
-  enableSelectItemIcon: z14.boolean().optional(),
-  enableSelectList: z14.boolean().optional(),
-  enableSelectSearch: z14.boolean().optional(),
-  enableSliderEnterMode: z14.boolean().optional(),
-  enableVoice: z14.boolean().optional(),
-  expandButtonText: z14.string().optional(),
-  foldUp: z14.boolean().optional(),
-  hidden: z14.boolean().optional(),
-  hideRequiredDot: z14.boolean().optional(),
-  inlineTitleWithSelect: z14.boolean().optional(),
-  knowledgeGraphButtonText: z14.string().optional(),
-  identifyAttributeCount: z14.union([z14.number().nonnegative(), z14.string().min(1), z14.object({ min: z14.number().nonnegative().optional(), max: z14.number().nonnegative().optional() }).strict()]).optional(),
-  identifyAttributes: z14.array(JsonValueSchema).optional(),
-  identifyMaxVariants: z14.number().int().nonnegative().optional(),
-  identifySourceField: z14.string().optional(),
-  imageOverlayBaseField: z14.string().optional(),
-  imageOverlayOverlayField: z14.string().optional(),
+  descriptionAlert: z15.boolean().optional(),
+  disabled: z15.union([z15.boolean(), WorkflowConditionalStateSchema]).optional(),
+  editable: z15.union([z15.boolean(), WorkflowConditionalStateSchema]).optional(),
+  enableAiMultiShot: z15.boolean().optional(),
+  enableBooleanSwitchMode: z15.boolean().optional(),
+  enableClear: z15.boolean().optional(),
+  enableExpand: z15.boolean().optional(),
+  enableImageMask: z15.boolean().optional(),
+  enableImageOverlay: z15.boolean().optional(),
+  enablePopupEditor: z15.boolean().optional(),
+  enablePromptFontSize: z15.boolean().optional(),
+  enableReset: z15.boolean().optional(),
+  enableSelectItemIcon: z15.boolean().optional(),
+  enableSelectList: z15.boolean().optional(),
+  enableSelectSearch: z15.boolean().optional(),
+  enableSliderEnterMode: z15.boolean().optional(),
+  enableVoice: z15.boolean().optional(),
+  expandButtonText: z15.string().optional(),
+  foldUp: z15.boolean().optional(),
+  hidden: z15.boolean().optional(),
+  hideRequiredDot: z15.boolean().optional(),
+  inlineTitleWithSelect: z15.boolean().optional(),
+  knowledgeGraphButtonText: z15.string().optional(),
+  identifyAttributeCount: z15.union([z15.number().nonnegative(), z15.string().min(1), z15.object({ min: z15.number().nonnegative().optional(), max: z15.number().nonnegative().optional() }).strict()]).optional(),
+  identifyAttributes: z15.array(JsonValueSchema).optional(),
+  identifyMaxVariants: z15.number().int().nonnegative().optional(),
+  identifySourceField: z15.string().optional(),
+  imageOverlayBaseField: z15.string().optional(),
+  imageOverlayOverlayField: z15.string().optional(),
   imageSelectMappingAppearance: ImageSelectMappingAppearanceSchema.optional(),
-  imageSelectMappingColumns: z14.number().int().min(1).max(4).optional(),
-  imageSelectMappingEnableCustomUpload: z14.boolean().optional(),
-  imageSelectMappingHideLabel: z14.boolean().optional(),
-  imageSelectMappingHideLink: z14.boolean().optional(),
-  imageSelectMappingHideMeta: z14.boolean().optional(),
-  imageSelectMappingInlineUseLargeUploadBox: z14.boolean().optional(),
-  imageSelectMappingPromptField: z14.string().optional(),
-  imageSelectMappingTabOrder: z14.enum(["template-first", "upload-first"]).optional(),
-  imageSelectMappingTabWidthMode: z14.enum(["content", "fill"]).optional(),
+  imageSelectMappingColumns: z15.number().int().min(1).max(4).optional(),
+  imageSelectMappingEnableCustomUpload: z15.boolean().optional(),
+  imageSelectMappingHideLabel: z15.boolean().optional(),
+  imageSelectMappingHideLink: z15.boolean().optional(),
+  imageSelectMappingHideMeta: z15.boolean().optional(),
+  imageSelectMappingInlineUseLargeUploadBox: z15.boolean().optional(),
+  imageSelectMappingPromptField: z15.string().optional(),
+  imageSelectMappingTabOrder: z15.enum(["template-first", "upload-first"]).optional(),
+  imageSelectMappingTabWidthMode: z15.enum(["content", "fill"]).optional(),
   imageSelectMappingTemplatePrompt: LocalizedTextSchema.optional(),
   imageSelectMappingTemplateTabTitle: LocalizedTextSchema.optional(),
-  imageSelectMappingUploadMode: z14.enum(["tabs", "inline"]).optional(),
+  imageSelectMappingUploadMode: z15.enum(["tabs", "inline"]).optional(),
   imageSelectMappingUploadPrompt: LocalizedTextSchema.optional(),
   imageSelectMappingUploadTabTitle: LocalizedTextSchema.optional(),
-  endpoints: z14.array(JsonValueSchema).optional(),
-  examples: z14.array(JsonValueSchema).optional(),
+  endpoints: z15.array(JsonValueSchema).optional(),
+  examples: z15.array(JsonValueSchema).optional(),
   extraData: JsonValueSchema.optional(),
   layer: JsonValueSchema.optional(),
   map: JsonValueSchema.optional(),
-  multiline: z14.boolean().optional(),
-  options: z14.array(JsonValueSchema).optional(),
-  originalFiles: z14.array(JsonValueSchema).optional(),
+  multiline: z15.boolean().optional(),
+  options: z15.array(JsonValueSchema).optional(),
+  originalFiles: z15.array(JsonValueSchema).optional(),
   placeholder: LocalizedTextSchema.optional(),
-  preserveSelectListOrder: z14.boolean().optional(),
+  preserveSelectListOrder: z15.boolean().optional(),
   promptDictionary: JsonValueSchema.optional(),
-  promptFontSize: z14.number().optional(),
+  promptFontSize: z15.number().optional(),
   promptModeToggle: JsonValueSchema.optional(),
-  requireActiveSelectFilter: z14.boolean().optional(),
-  restoreDefaultOnEmptyEnter: z14.boolean().optional(),
-  search: z14.boolean().optional(),
-  selectButtonEnableCollapse: z14.boolean().optional(),
-  selectButtonVisibleRows: z14.number().int().positive().optional(),
-  selectList: z14.array(JsonValueSchema).optional(),
-  selectListDisplayMode: z14.string().optional(),
-  selectPromptField: z14.string().optional(),
-  showAddLocalFileButton: z14.boolean().optional(),
-  singleColumn: z14.boolean().optional(),
-  singleFrameForMultiple: z14.boolean().optional(),
-  textSingleLine: z14.boolean().optional(),
-  textareaMiniHeight: z14.number().nonnegative().optional(),
+  requireActiveSelectFilter: z15.boolean().optional(),
+  restoreDefaultOnEmptyEnter: z15.boolean().optional(),
+  search: z15.boolean().optional(),
+  selectButtonEnableCollapse: z15.boolean().optional(),
+  selectButtonVisibleRows: z15.number().int().positive().optional(),
+  selectList: z15.array(JsonValueSchema).optional(),
+  selectListDisplayMode: z15.string().optional(),
+  selectPromptField: z15.string().optional(),
+  showAddLocalFileButton: z15.boolean().optional(),
+  singleColumn: z15.boolean().optional(),
+  singleFrameForMultiple: z15.boolean().optional(),
+  textSingleLine: z15.boolean().optional(),
+  textareaMiniHeight: z15.number().nonnegative().optional(),
   tips: LocalizedTextSchema.optional(),
   visibility: JsonValueSchema.optional(),
-  voiceButtonText: z14.string().optional(),
-  designAnalysisFields: z14.array(JsonValueSchema).optional(),
-  designAnalysisFillStrategy: z14.string().optional(),
-  designAnalysisMaxFields: z14.number().int().nonnegative().optional(),
-  designAnalysisType: z14.string().optional(),
-  designAnalysisFieldPrefix: z14.string().optional()
-}).strict();
-var WorkflowParameterSchema = z14.lazy(
-  () => z14.object({
+  voiceButtonText: z15.string().optional(),
+  designAnalysisFields: z15.array(JsonValueSchema).optional(),
+  designAnalysisFillStrategy: z15.string().optional(),
+  designAnalysisMaxFields: z15.number().int().nonnegative().optional(),
+  designAnalysisType: z15.string().optional(),
+  designAnalysisFieldPrefix: z15.string().optional()
+}).strict();
+var WorkflowParameterSchema = z15.lazy(
+  () => z15.object({
     displayName: LocalizedTextSchema,
     name: ContractIdentifierSchema,
     type: WorkflowParameterTypeSchema,
     typeOptions: WorkflowParameterTypeOptionsSchema.optional(),
     default: JsonValueSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    hint: z14.string().optional(),
-    displayOptions: z14.object({
-      hide: z14.record(z14.string(), z14.array(JsonValueSchema)).optional(),
-      show: z14.record(z14.string(), z14.array(JsonValueSchema)).optional()
+    hint: z15.string().optional(),
+    displayOptions: z15.object({
+      hide: z15.record(z15.string(), z15.array(JsonValueSchema)).optional(),
+      show: z15.record(z15.string(), z15.array(JsonValueSchema)).optional()
     }).strict().optional(),
-    options: z14.array(z14.union([
-      z14.object({ name: LocalizedTextSchema, value: z14.union([z14.string(), z14.number(), z14.boolean()]), action: z14.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
+    options: z15.array(z15.union([
+      z15.object({ name: LocalizedTextSchema, value: z15.union([z15.string(), z15.number(), z15.boolean()]), action: z15.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
       WorkflowParameterSchema,
-      z14.object({ displayName: z14.string(), name: ContractIdentifierSchema, values: z14.array(WorkflowParameterSchema) }).strict()
+      z15.object({ displayName: z15.string(), name: ContractIdentifierSchema, values: z15.array(WorkflowParameterSchema) }).strict()
     ])).optional(),
     placeholder: LocalizedTextSchema.optional(),
-    isNodeSetting: z14.boolean().optional(),
-    noDataExpression: z14.boolean().optional(),
-    required: z14.boolean().optional(),
-    example: z14.string().optional(),
-    extractValue: z14.object({ type: z14.literal("regex"), regex: z14.string() }).strict().optional(),
-    properties: z14.array(WorkflowParameterSchema).optional(),
-    assetType: z14.string().optional(),
-    flag: z14.boolean().optional(),
-    enableExpand: z14.boolean().optional(),
-    enableVoice: z14.boolean().optional(),
-    expandButtonText: z14.string().optional(),
-    knowledgeGraphButtonText: z14.string().optional(),
-    selectListDisplayMode: z14.string().optional(),
-    voiceButtonText: z14.string().optional()
+    isNodeSetting: z15.boolean().optional(),
+    noDataExpression: z15.boolean().optional(),
+    required: z15.boolean().optional(),
+    example: z15.string().optional(),
+    extractValue: z15.object({ type: z15.literal("regex"), regex: z15.string() }).strict().optional(),
+    properties: z15.array(WorkflowParameterSchema).optional(),
+    assetType: z15.string().optional(),
+    flag: z15.boolean().optional(),
+    enableExpand: z15.boolean().optional(),
+    enableVoice: z15.boolean().optional(),
+    expandButtonText: z15.string().optional(),
+    knowledgeGraphButtonText: z15.string().optional(),
+    selectListDisplayMode: z15.string().optional(),
+    voiceButtonText: z15.string().optional()
   }).strict()
 );
-var WorkflowOutputBindingSchema = z14.object({ key: ContractIdentifierSchema, value: z14.string() }).strict();
-var WorkflowNodeSchema = z14.object({
+var WorkflowOutputBindingSchema = z15.object({ key: ContractIdentifierSchema, value: z15.string() }).strict();
+var WorkflowNodeSchema = z15.object({
   id: ContractIdentifierSchema,
   referenceName: ContractIdentifierSchema,
   capabilityRef: ContractIdentifierSchema,
   capabilityVersion: ContractIdentifierSchema.optional(),
-  inputBindings: z14.record(z14.string(), JsonValueSchema).default({}),
-  configuration: z14.object({ executor: z14.literal("conductor"), task: ConductorTaskDefinitionSchema }).strict()
+  inputBindings: z15.record(z15.string(), JsonValueSchema).default({}),
+  configuration: z15.object({ executor: z15.literal("conductor"), task: ConductorTaskDefinitionSchema }).strict()
 }).strict().superRefine((node, context) => {
   if (node.configuration.task.taskReferenceName !== node.referenceName) context.addIssue({ code: "custom", path: ["configuration", "task", "taskReferenceName"], message: "Conductor task reference must match node referenceName." });
   if (node.configuration.task.name !== node.capabilityRef) context.addIssue({ code: "custom", path: ["configuration", "task", "name"], message: "Conductor task name must match node capabilityRef." });
   if (JSON.stringify(node.configuration.task.inputParameters ?? {}) !== JSON.stringify(node.inputBindings)) context.addIssue({ code: "custom", path: ["configuration", "task", "inputParameters"], message: "Conductor task inputs must match node inputBindings." });
 });
-var WorkflowEdgeSchema = z14.object({
+var WorkflowEdgeSchema = z15.object({
   from: ContractIdentifierSchema,
   to: ContractIdentifierSchema,
   outputPort: ContractIdentifierSchema.optional(),
   inputPort: ContractIdentifierSchema.optional(),
-  condition: z14.string().optional()
+  condition: z15.string().optional()
 }).strict();
-var WorkflowTriggerSchema = z14.object({
+var WorkflowTriggerSchema = z15.object({
   id: ContractIdentifierSchema,
-  type: z14.enum(["manual", "schedule", "webhook", "event", "api"]),
-  enabled: z14.boolean(),
-  schedule: z14.object({ cron: z14.string().trim().min(1) }).strict().optional(),
-  webhook: z14.object({
-    path: z14.string().trim().min(1).optional(),
-    method: z14.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
-    auth: z14.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
-    basicAuth: z14.object({ username: z14.string(), password: z14.string() }).strict().optional(),
-    headerAuth: z14.object({ name: z14.string().trim().min(1), value: z14.string() }).strict().optional(),
-    responseUntil: z14.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
+  type: z15.enum(["manual", "schedule", "webhook", "event", "api"]),
+  enabled: z15.boolean(),
+  schedule: z15.object({ cron: z15.string().trim().min(1) }).strict().optional(),
+  webhook: z15.object({
+    path: z15.string().trim().min(1).optional(),
+    method: z15.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
+    auth: z15.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
+    basicAuth: z15.object({ username: z15.string(), password: z15.string() }).strict().optional(),
+    headerAuth: z15.object({ name: z15.string().trim().min(1), value: z15.string() }).strict().optional(),
+    responseUntil: z15.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
   }).strict().optional(),
-  event: z14.object({
+  event: z15.object({
     eventType: ContractIdentifierSchema,
     configuration: JsonValueSchema.optional()
   }).strict().optional()
@@ -11979,63 +12351,63 @@ var WorkflowTriggerSchema = z14.object({
   if (trigger.type === "webhook" && !trigger.webhook) context.addIssue({ code: "custom", path: ["webhook"], message: "Webhook trigger requires webhook configuration." });
   if (trigger.type === "event" && !trigger.event) context.addIssue({ code: "custom", path: ["event"], message: "Event trigger requires event configuration." });
 });
-var WorkflowValidationIssueSchema = z14.object({
+var WorkflowValidationIssueSchema = z15.object({
   taskReferenceName: ContractIdentifierSchema,
-  issueType: z14.enum(["ERROR", "WARNING"]),
-  detailReason: z14.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
-  humanMessage: z14.object({ en: z14.string(), zh: z14.string() }).strict()
+  issueType: z15.enum(["ERROR", "WARNING"]),
+  detailReason: z15.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
+  humanMessage: z15.object({ en: z15.string(), zh: z15.string() }).strict()
 }).strict();
-var WorkflowDefinitionSchema = z14.object({
-  contract: z14.literal("WorkflowDefinition"),
+var WorkflowDefinitionSchema = z15.object({
+  contract: z15.literal("WorkflowDefinition"),
   metadata: ContractMetadataSchema.omit({ name: true, description: true, labels: true }).extend({
     name: LocalizedTextSchema,
     description: LocalizedTextSchema.optional(),
-    role: z14.enum(["workflow", "template"]),
+    role: z15.enum(["workflow", "template"]),
     teamId: ContractIdentifierSchema,
     creatorRef: EntityRefSchema,
-    tags: z14.array(ContractIdentifierSchema).default([])
+    tags: z15.array(ContractIdentifierSchema).default([])
   }).strict(),
-  revision: z14.object({
-    kind: z14.enum(["release", "backup"]),
-    recordVersion: z14.number().int().positive(),
-    sourceVersion: z14.number().int().positive().optional()
+  revision: z15.object({
+    kind: z15.enum(["release", "backup"]),
+    recordVersion: z15.number().int().positive(),
+    sourceVersion: z15.number().int().positive().optional()
   }).strict().superRefine((revision, context) => {
     if (revision.kind === "backup" && revision.sourceVersion === void 0) context.addIssue({ code: "custom", path: ["sourceVersion"], message: "Backup revisions require a sourceVersion." });
   }),
-  presentation: z14.object({ iconUrl: z14.string().optional(), thumbnail: z14.string().optional() }).strict(),
-  ports: z14.object({ inputs: z14.array(ContractPortSchema).default([]), outputs: z14.array(ContractPortSchema).default([]) }).strict(),
-  parameters: z14.object({ variables: z14.array(WorkflowParameterSchema).default([]), outputs: z14.array(WorkflowOutputBindingSchema).default([]) }).strict(),
-  graph: z14.object({ nodes: z14.array(WorkflowNodeSchema), edges: z14.array(WorkflowEdgeSchema).default([]) }).strict(),
-  execution: z14.object({
-    timeoutMs: z14.number().int().positive().optional(),
-    retries: z14.number().int().nonnegative().default(0),
-    concurrencyLimit: z14.number().int().positive().optional(),
-    idempotency: z14.enum(["required", "supported", "none"]),
-    rateLimit: z14.object({ enabled: z14.boolean(), max: z14.number().int().nonnegative(), windowMs: z14.number().int().nonnegative() }).strict().superRefine((rateLimit, context) => {
+  presentation: z15.object({ iconUrl: z15.string().optional(), thumbnail: z15.string().optional() }).strict(),
+  ports: z15.object({ inputs: z15.array(ContractPortSchema).default([]), outputs: z15.array(ContractPortSchema).default([]) }).strict(),
+  parameters: z15.object({ variables: z15.array(WorkflowParameterSchema).default([]), outputs: z15.array(WorkflowOutputBindingSchema).default([]) }).strict(),
+  graph: z15.object({ nodes: z15.array(WorkflowNodeSchema), edges: z15.array(WorkflowEdgeSchema).default([]) }).strict(),
+  execution: z15.object({
+    timeoutMs: z15.number().int().positive().optional(),
+    retries: z15.number().int().nonnegative().default(0),
+    concurrencyLimit: z15.number().int().positive().optional(),
+    idempotency: z15.enum(["required", "supported", "none"]),
+    rateLimit: z15.object({ enabled: z15.boolean(), max: z15.number().int().nonnegative(), windowMs: z15.number().int().nonnegative() }).strict().superRefine((rateLimit, context) => {
       if (rateLimit.enabled && (rateLimit.max === 0 || rateLimit.windowMs === 0)) context.addIssue({ code: "custom", message: "Enabled rate limit requires positive max and windowMs." });
     }).optional(),
-    conductor: z14.object({
-      ownerApp: z14.string().optional(),
-      createTime: z14.number().int().nonnegative().optional(),
-      updateTime: z14.number().int().nonnegative().optional(),
-      createdBy: z14.string().optional(),
-      updatedBy: z14.string().optional(),
+    conductor: z15.object({
+      ownerApp: z15.string().optional(),
+      createTime: z15.number().int().nonnegative().optional(),
+      updateTime: z15.number().int().nonnegative().optional(),
+      createdBy: z15.string().optional(),
+      updatedBy: z15.string().optional(),
       failureWorkflow: ContractIdentifierSchema.optional(),
-      schemaVersion: z14.number().int().positive().optional(),
-      restartable: z14.boolean().optional(),
-      workflowStatusListenerEnabled: z14.boolean().optional(),
-      ownerEmail: z14.string().email().optional(),
-      timeoutPolicy: z14.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
-      variables: z14.record(z14.string(), JsonValueSchema).optional(),
-      inputTemplate: z14.record(z14.string(), JsonValueSchema).optional()
+      schemaVersion: z15.number().int().positive().optional(),
+      restartable: z15.boolean().optional(),
+      workflowStatusListenerEnabled: z15.boolean().optional(),
+      ownerEmail: z15.string().email().optional(),
+      timeoutPolicy: z15.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+      variables: z15.record(z15.string(), JsonValueSchema).optional(),
+      inputTemplate: z15.record(z15.string(), JsonValueSchema).optional()
     }).strict()
   }).strict(),
-  triggers: z14.array(WorkflowTriggerSchema).default([]),
-  views: z14.array(z14.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
-  dataContracts: z14.object({ reads: z14.array(ContractIdentifierSchema).default([]), writes: z14.array(ContractIdentifierSchema).default([]), emits: z14.array(ContractIdentifierSchema).default([]) }).strict(),
-  governance: z14.object({ activated: z14.boolean(), validated: z14.boolean(), validationIssues: z14.array(WorkflowValidationIssueSchema).default([]), hidden: z14.boolean().optional() }).strict(),
-  interfaces: z14.object({
-    openai: z14.object({ enabled: z14.boolean(), modelName: z14.string().trim().min(1).optional() }).strict(),
+  triggers: z15.array(WorkflowTriggerSchema).default([]),
+  views: z15.array(z15.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
+  dataContracts: z15.object({ reads: z15.array(ContractIdentifierSchema).default([]), writes: z15.array(ContractIdentifierSchema).default([]), emits: z15.array(ContractIdentifierSchema).default([]) }).strict(),
+  governance: z15.object({ activated: z15.boolean(), validated: z15.boolean(), validationIssues: z15.array(WorkflowValidationIssueSchema).default([]), hidden: z15.boolean().optional() }).strict(),
+  interfaces: z15.object({
+    openai: z15.object({ enabled: z15.boolean(), modelName: z15.string().trim().min(1).optional() }).strict(),
     shortcutRef: EntityRefSchema.optional(),
     preferredAppId: ContractIdentifierSchema.optional()
   }).strict().superRefine((interfaces, context) => {
@@ -12054,21 +12426,21 @@ var WorkflowDefinitionSchema = z14.object({
 });
 
 // src/contracts/workflow-runtime.ts
-import { z as z15 } from "zod";
-var WorkflowCatalogEntrySchema = z15.object({
-  contract: z15.literal("WorkflowCatalogEntry"),
+import { z as z16 } from "zod";
+var WorkflowCatalogEntrySchema = z16.object({
+  contract: z16.literal("WorkflowCatalogEntry"),
   workflowId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   creatorRef: EntityRefSchema,
   currentDefinitionRef: EntityRefSchema,
-  lifecycle: z15.enum(["ACTIVE", "DELETED"]),
-  asset: z15.object({
-    preset: z15.boolean(),
-    marketplacePublished: z15.boolean(),
+  lifecycle: z16.enum(["ACTIVE", "DELETED"]),
+  asset: z16.object({
+    preset: z16.boolean(),
+    marketplacePublished: z16.boolean(),
     publishConfig: JsonObjectSchema.optional(),
-    sort: z15.number().int(),
+    sort: z16.number().int(),
     forkFromRef: EntityRefSchema.optional(),
-    notAuthorized: z15.boolean()
+    notAuthorized: z16.boolean()
   }).strict(),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema,
@@ -12103,17 +12475,17 @@ var WorkflowCatalogEntrySchema = z15.object({
     });
   }
 });
-var WorkflowPublicationSchema = z15.object({
-  contract: z15.literal("WorkflowPublication"),
+var WorkflowPublicationSchema = z16.object({
+  contract: z16.literal("WorkflowPublication"),
   publicationId: ContractIdentifierSchema,
   definitionRef: EntityRefSchema,
   runtimeDefinitionRef: EntityRefSchema,
   sourceHash: Sha256Schema,
   compiledHash: Sha256Schema,
-  status: z15.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
+  status: z16.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
   publisherRef: EntityRefSchema,
   publishedAt: IsoDateTimeSchema.optional(),
-  failureReason: z15.string().trim().min(1).optional()
+  failureReason: z16.string().trim().min(1).optional()
 }).strict().superRefine((publication, context) => {
   if (publication.definitionRef.kind !== "workflow-definition") {
     context.addIssue({
@@ -12144,12 +12516,12 @@ var WorkflowPublicationSchema = z15.object({
     });
   }
 });
-var WorkflowCompletionCommitSchema = z15.object({
-  contract: z15.literal("WorkflowCompletionCommit"),
+var WorkflowCompletionCommitSchema = z16.object({
+  contract: z16.literal("WorkflowCompletionCommit"),
   commitId: ContractIdentifierSchema,
   run: ApplicationRunSchema,
-  outputs: z15.array(OutputRecordSchema),
-  artifacts: z15.array(ArtifactManifestSchema),
+  outputs: z16.array(OutputRecordSchema),
+  artifacts: z16.array(ArtifactManifestSchema),
   lineage: LineageRecordSchema,
   completedAt: IsoDateTimeSchema
 }).strict().superRefine((commit, context) => {
@@ -12191,15 +12563,15 @@ var WorkflowCompletionCommitSchema = z15.object({
     }
   });
 });
-var WorkflowCompletionReceiptSchema = z15.object({
-  contract: z15.literal("WorkflowCompletionReceipt"),
+var WorkflowCompletionReceiptSchema = z16.object({
+  contract: z16.literal("WorkflowCompletionReceipt"),
   commitId: ContractIdentifierSchema,
   runRef: EntityRefSchema,
-  outputRefs: z15.array(EntityRefSchema),
-  artifactRefs: z15.array(EntityRefSchema),
+  outputRefs: z16.array(EntityRefSchema),
+  artifactRefs: z16.array(EntityRefSchema),
   contentHash: Sha256Schema,
   committedAt: IsoDateTimeSchema,
-  idempotentReplay: z15.boolean()
+  idempotentReplay: z16.boolean()
 }).strict().superRefine((receipt, context) => {
   if (receipt.runRef.kind !== "application-run") {
     context.addIssue({
@@ -12284,6 +12656,8 @@ export {
   BodyRelationRecordSchema,
   BrandBodySchema,
   BrandGeneticsProfileSchema,
+  CURRENT_USER_MENU_ACTION_REFS,
+  CURRENT_USER_MENU_CONTROL_REFS,
   CapabilityManifestSchema,
   CapabilityProviderBindingSchema,
   CapabilityRegistryDocumentSchema,
@@ -12292,6 +12666,15 @@ export {
   CapabilitySourceTypeSchema,
   ChangeImpactGraphSchema,
   ChangeImpactSchema,
+  CompiledMenuActionBehaviorSchema,
+  CompiledMenuBehaviorSchema,
+  CompiledMenuDividerNodeSchema,
+  CompiledMenuGroupNodeSchema,
+  CompiledMenuItemAccessSchema,
+  CompiledMenuItemNodeSchema,
+  CompiledMenuNavigateBehaviorSchema,
+  CompiledMenuNodeSchema,
+  CompiledMenuProjectionSchema,
   CompletionEventSchema,
   CompletionHeaderSchema,
   ConceptDefinitionSchema,
@@ -12303,6 +12686,14 @@ export {
   ContractMetadataSchema,
   ContractPortSchema,
   ContractVersionSchema,
+  CurrentUserMenuActionItemSchema,
+  CurrentUserMenuConfigSchema,
+  CurrentUserMenuControlItemSchema,
+  CurrentUserMenuDisplayTextSchema,
+  CurrentUserMenuItemSchema,
+  CurrentUserMenuNavigationItemSchema,
+  CurrentUserMenuProfileSchema,
+  CurrentUserMenuSectionSchema,
   DataContinuityEnvelopeSchema,
   DeclarationGraphEdgeSchema,
   DesignTokenSourceSchema,
@@ -12316,9 +12707,38 @@ export {
   IsoDateTimeSchema,
   JsonObjectSchema,
   JsonValueSchema,
+  LEGACY_CURRENT_USER_MENU_ITEM_IDS,
   LineageRecordSchema,
   LocaleIdentifierSchema,
   LocalizedTextSchema,
+  MENU_ACTIVATION_QUERY_PARAMETER,
+  MENU_CONTRACT_VERSION,
+  MENU_MAX_DEFINITIONS,
+  MENU_MAX_INPUT_BYTES,
+  MENU_MAX_INPUT_VALUES,
+  MENU_MAX_NODES,
+  MENU_MAX_TREE_DEPTH,
+  MenuAccessRequirementSchema,
+  MenuActionBehaviorSchema,
+  MenuActionRegistrationSchema,
+  MenuBehaviorSchema,
+  MenuBoundedInputSchema,
+  MenuContributionProviderRegistrationSchema,
+  MenuContributionResultSchema,
+  MenuContributionSchema,
+  MenuDefinitionSchema,
+  MenuDefinitionSetSchema,
+  MenuDividerNodeSchema,
+  MenuGroupNodeSchema,
+  MenuItemNodeSchema,
+  MenuNavigateBehaviorSchema,
+  MenuNavigationTargetSchema,
+  MenuNodeSchema,
+  MenuPageRefSchema,
+  MenuPageRegistrationSchema,
+  MenuRuntimeBundleSchema,
+  MenuRuntimeInputBindingSchema,
+  MenuSourceInputBindingSchema,
   OntologyDefinitionSchema,
   OutputRecordSchema,
   OverlayNodeSchema,