@inf-monkeys-tech/monkeys 1.0.45 → 1.0.47

package/lib/esm/schemas/index.mjs

@@ -6563,7 +6563,7 @@ var require_ajv = __commonJS({
   }
 });
 
-// src/contracts/artifact.ts
+// src/contracts/access.ts
 import { z as z2 } from "zod";
 
 // src/contracts/common.ts
@@ -6604,59 +6604,94 @@ var EntityRefSchema = z.object({
   ownerRepo: ContractIdentifierSchema.optional()
 }).strict();
 
+// src/contracts/access.ts
+var PermissionDefinitionSchema = z2.object({
+  code: ContractIdentifierSchema,
+  name: LocalizedTextSchema,
+  description: LocalizedTextSchema.optional(),
+  resource: ContractIdentifierSchema,
+  action: ContractIdentifierSchema,
+  domain: ContractIdentifierSchema.optional()
+}).strict();
+var PermissionBundleSchema = z2.object({
+  bundleId: ContractIdentifierSchema,
+  name: LocalizedTextSchema,
+  permissionCodes: z2.array(ContractIdentifierSchema).default([])
+}).strict();
+var SystemGroupDefinitionSchema = z2.object({
+  groupCode: ContractIdentifierSchema,
+  name: LocalizedTextSchema,
+  description: LocalizedTextSchema.optional(),
+  permissionPolicy: z2.enum(["bundles", "studio_current", "all_current"]).default("bundles"),
+  permissionBundleIds: z2.array(ContractIdentifierSchema).default([])
+}).strict().refine((value) => value.permissionPolicy !== "bundles" || value.permissionBundleIds.length > 0, {
+  message: "A bundles permission policy requires at least one permission bundle.",
+  path: ["permissionBundleIds"]
+});
+var ProductAccessDeclarationSchema = z2.object({
+  contract: z2.literal("ProductAccessDeclaration"),
+  declarationId: ContractIdentifierSchema,
+  version: ContractVersionSchema,
+  ownerRepo: ContractIdentifierSchema,
+  permissions: z2.array(PermissionDefinitionSchema).default([]),
+  permissionBundles: z2.array(PermissionBundleSchema).default([]),
+  systemGroups: z2.array(SystemGroupDefinitionSchema).min(1)
+}).strict();
+
 // src/contracts/artifact.ts
-var StorageLocatorSchema = z2.object({
+import { z as z3 } from "zod";
+var StorageLocatorSchema = z3.object({
   provider: ContractIdentifierSchema,
   bucket: ContractIdentifierSchema.optional(),
   key: ContractIdentifierSchema,
   region: ContractIdentifierSchema.optional(),
-  url: z2.string().url().optional(),
+  url: z3.string().url().optional(),
   expiresAt: IsoDateTimeSchema.optional()
 }).strict();
-var ArtifactAccessSchema = z2.object({
+var ArtifactAccessSchema = z3.object({
   tenantId: ContractIdentifierSchema.optional(),
   teamId: ContractIdentifierSchema.optional(),
   ownerRef: EntityRefSchema.optional(),
-  visibility: z2.enum(["private", "team", "tenant", "public"])
+  visibility: z3.enum(["private", "team", "tenant", "public"])
 }).strict();
-var ArtifactManifestSchema = z2.object({
-  contract: z2.literal("ArtifactManifest"),
+var ArtifactManifestSchema = z3.object({
+  contract: z3.literal("ArtifactManifest"),
   artifactId: ContractIdentifierSchema,
   kind: ContractIdentifierSchema,
-  mimeType: z2.string().trim().min(1),
-  byteSize: z2.number().int().nonnegative().optional(),
+  mimeType: z3.string().trim().min(1),
+  byteSize: z3.number().int().nonnegative().optional(),
   sha256: Sha256Schema,
   storage: StorageLocatorSchema,
   sourceRef: EntityRefSchema.optional(),
   runRef: EntityRefSchema,
   outputRef: EntityRefSchema,
-  producer: z2.object({
+  producer: z3.object({
     service: ContractIdentifierSchema,
     version: ContractIdentifierSchema,
     capabilityRef: EntityRefSchema.optional()
   }).strict(),
   access: ArtifactAccessSchema,
-  metadata: z2.record(z2.string(), JsonValueSchema).default({}),
+  metadata: z3.record(z3.string(), JsonValueSchema).default({}),
   createdAt: IsoDateTimeSchema
 }).strict();
-var OutputRecordSchema = z2.object({
-  contract: z2.literal("OutputRecord"),
+var OutputRecordSchema = z3.object({
+  contract: z3.literal("OutputRecord"),
   outputId: ContractIdentifierSchema,
   runRef: EntityRefSchema,
   outputPort: ContractIdentifierSchema,
   value: JsonValueSchema.optional(),
-  artifactRefs: z2.array(EntityRefSchema).default([]),
+  artifactRefs: z3.array(EntityRefSchema).default([]),
   schemaRef: ContractIdentifierSchema.optional(),
   createdAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/capability.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/contracts/render.ts
-import { z as z3 } from "zod";
-var ProductContextSchema = z3.enum(["studio", "kernel", "compute"]);
-var RenderNodeStateSchema = z3.enum([
+import { z as z4 } from "zod";
+var ProductContextSchema = z4.enum(["studio", "kernel", "compute"]);
+var RenderNodeStateSchema = z4.enum([
   "idle",
   "loading",
   "empty",
@@ -6665,7 +6700,7 @@ var RenderNodeStateSchema = z3.enum([
   "disabled",
   "selected"
 ]);
-var RenderNodeKindSchema = z3.enum([
+var RenderNodeKindSchema = z4.enum([
   "shell",
   "page",
   "navigation",
@@ -6677,16 +6712,16 @@ var RenderNodeKindSchema = z3.enum([
   "overlay",
   "professional-provider"
 ]);
-var RenderSurfaceSchema = z3.object({
-  frameOwner: z3.enum(["host", "provider", "none"]),
+var RenderSurfaceSchema = z4.object({
+  frameOwner: z4.enum(["host", "provider", "none"]),
   tone: ContractIdentifierSchema.optional(),
-  density: z3.enum(["compact", "default", "comfortable"])
+  density: z4.enum(["compact", "default", "comfortable"])
 }).strict();
-var RenderScrollSchema = z3.object({
-  owner: z3.enum(["page", "surface", "provider"]),
-  axis: z3.enum(["x", "y", "both", "none"]),
+var RenderScrollSchema = z4.object({
+  owner: z4.enum(["page", "surface", "provider"]),
+  axis: z4.enum(["x", "y", "both", "none"]),
   restoreKey: ContractIdentifierSchema.optional(),
-  virtualizationBoundary: z3.boolean()
+  virtualizationBoundary: z4.boolean()
 }).strict().superRefine((scroll, context) => {
   if (scroll.owner === "provider" && scroll.restoreKey) {
     context.addIssue({
@@ -6703,11 +6738,11 @@ var RenderScrollSchema = z3.object({
     });
   }
 });
-var RenderActivationSchema = z3.object({
+var RenderActivationSchema = z4.object({
   activationId: ContractIdentifierSchema,
-  mode: z3.enum(["navigate", "select", "drawer", "modal", "fullscreen", "inline"]),
-  targetPath: z3.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.").optional(),
-  history: z3.enum(["push", "replace"]).optional()
+  mode: z4.enum(["navigate", "select", "drawer", "modal", "fullscreen", "inline"]),
+  targetPath: z4.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.").optional(),
+  history: z4.enum(["push", "replace"]).optional()
 }).strict().superRefine((activation, context) => {
   if (activation.mode === "navigate" && !activation.targetPath) {
     context.addIssue({ code: "custom", path: ["targetPath"], message: "Navigate activation requires an application-relative targetPath." });
@@ -6716,19 +6751,19 @@ var RenderActivationSchema = z3.object({
     context.addIssue({ code: "custom", path: ["targetPath"], message: "Only navigate activation may declare targetPath." });
   }
 });
-var RenderLifecycleSchema = z3.object({
-  mountPolicy: z3.enum(["always", "when-visible", "when-active"]),
-  queryPolicy: z3.enum(["always", "when-visible", "when-active", "manual"]),
-  retainOnDeactivate: z3.boolean(),
-  deepLink: z3.boolean(),
-  focusReturn: z3.boolean()
-}).strict();
-var RenderLayoutSchema = z3.object({
-  mode: z3.enum(["contents", "block", "flex", "grid", "absolute"]),
-  direction: z3.enum(["row", "column"]).optional(),
-  columns: z3.number().int().positive().optional(),
-  align: z3.enum(["start", "center", "end", "stretch"]).optional(),
-  justify: z3.enum(["start", "center", "end", "between", "around"]).optional(),
+var RenderLifecycleSchema = z4.object({
+  mountPolicy: z4.enum(["always", "when-visible", "when-active"]),
+  queryPolicy: z4.enum(["always", "when-visible", "when-active", "manual"]),
+  retainOnDeactivate: z4.boolean(),
+  deepLink: z4.boolean(),
+  focusReturn: z4.boolean()
+}).strict();
+var RenderLayoutSchema = z4.object({
+  mode: z4.enum(["contents", "block", "flex", "grid", "absolute"]),
+  direction: z4.enum(["row", "column"]).optional(),
+  columns: z4.number().int().positive().optional(),
+  align: z4.enum(["start", "center", "end", "stretch"]).optional(),
+  justify: z4.enum(["start", "center", "end", "between", "around"]).optional(),
   gapTokenRef: EntityRefSchema.optional()
 }).strict().superRefine((layout, context) => {
   if (layout.direction && layout.mode !== "flex") {
@@ -6741,9 +6776,9 @@ var RenderLayoutSchema = z3.object({
     context.addIssue({ code: "custom", path: ["gapTokenRef", "kind"], message: "gapTokenRef must reference design-token." });
   }
 });
-var RenderResponsiveRuleSchema = z3.object({
-  minWidthPx: z3.number().nonnegative().optional(),
-  maxWidthPx: z3.number().positive().optional(),
+var RenderResponsiveRuleSchema = z4.object({
+  minWidthPx: z4.number().nonnegative().optional(),
+  maxWidthPx: z4.number().positive().optional(),
   layout: RenderLayoutSchema
 }).strict().superRefine((rule, context) => {
   if (rule.minWidthPx === void 0 && rule.maxWidthPx === void 0) {
@@ -6781,14 +6816,14 @@ var requirePinnedOwnedRef = (reference, expectedKind, path, context) => {
     });
   }
 };
-var RenderNodeSchema = z3.object({
-  contract: z3.literal("RenderNode"),
+var RenderNodeSchema = z4.object({
+  contract: z4.literal("RenderNode"),
   nodeId: ContractIdentifierSchema,
   kind: RenderNodeKindSchema,
   version: ContractVersionSchema,
   ownerRepo: ContractIdentifierSchema,
   parentNodeId: ContractIdentifierSchema.optional(),
-  children: z3.array(ContractIdentifierSchema),
+  children: z4.array(ContractIdentifierSchema),
   slot: ContractIdentifierSchema.optional(),
   pageRef: EntityRefSchema,
   semanticRef: EntityRefSchema.optional(),
@@ -6801,7 +6836,7 @@ var RenderNodeSchema = z3.object({
   activation: RenderActivationSchema,
   lifecycle: RenderLifecycleSchema,
   layout: RenderLayoutSchema,
-  responsive: z3.array(RenderResponsiveRuleSchema),
+  responsive: z4.array(RenderResponsiveRuleSchema),
   accessRef: EntityRefSchema.optional(),
   evidenceRef: EntityRefSchema.optional(),
   state: RenderNodeStateSchema,
@@ -6833,39 +6868,39 @@ var RenderNodeSchema = z3.object({
     });
   }
 });
-var RenderTreeSchema = z3.object({
-  contract: z3.literal("RenderTree"),
+var RenderTreeSchema = z4.object({
+  contract: z4.literal("RenderTree"),
   treeId: ContractIdentifierSchema,
   product: ProductContextSchema,
   rootNodeId: ContractIdentifierSchema,
-  nodes: z3.array(RenderNodeSchema).min(1)
+  nodes: z4.array(RenderNodeSchema).min(1)
 }).strict();
-var OverlayZIndexLaneSchema = z3.enum([
+var OverlayZIndexLaneSchema = z4.enum([
   "popover",
   "drawer",
   "modal",
   "fullscreen",
   "system"
 ]);
-var OverlayNodeSchema = z3.object({
-  contract: z3.literal("OverlayNode"),
+var OverlayNodeSchema = z4.object({
+  contract: z4.literal("OverlayNode"),
   overlayId: ContractIdentifierSchema,
   renderNode: RenderNodeSchema,
-  presentation: z3.enum(["drawer", "modal", "fullscreen"]),
+  presentation: z4.enum(["drawer", "modal", "fullscreen"]),
   zIndexLane: OverlayZIndexLaneSchema,
-  url: z3.object({
+  url: z4.object({
     parameter: ContractIdentifierSchema,
     value: ContractIdentifierSchema,
-    openMode: z3.enum(["push", "replace"]),
-    closeMode: z3.enum(["back", "replace"])
+    openMode: z4.enum(["push", "replace"]),
+    closeMode: z4.enum(["back", "replace"])
   }).strict(),
-  focus: z3.object({
-    initial: z3.enum(["first-interactive", "container", "explicit"]),
-    trap: z3.boolean()
+  focus: z4.object({
+    initial: z4.enum(["first-interactive", "container", "explicit"]),
+    trap: z4.boolean()
   }).strict(),
-  close: z3.object({
-    escape: z3.boolean(),
-    backdrop: z3.boolean()
+  close: z4.object({
+    escape: z4.boolean(),
+    backdrop: z4.boolean()
   }).strict()
 }).strict().superRefine((value, context) => {
   if (value.renderNode.kind !== "overlay") {
@@ -6904,8 +6939,8 @@ var OverlayNodeSchema = z3.object({
     });
   }
 });
-var ProductPathSchema = z3.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.");
-var ApplicationHandoffEndpointSchema = z3.object({
+var ProductPathSchema = z4.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.");
+var ApplicationHandoffEndpointSchema = z4.object({
   product: ProductContextSchema,
   pageId: ContractIdentifierSchema,
   viewId: ContractIdentifierSchema.optional(),
@@ -6914,8 +6949,8 @@ var ApplicationHandoffEndpointSchema = z3.object({
   activationId: ContractIdentifierSchema.optional(),
   path: ProductPathSchema
 }).strict();
-var ApplicationHandoffSchema = z3.object({
-  contract: z3.literal("ApplicationHandoff"),
+var ApplicationHandoffSchema = z4.object({
+  contract: z4.literal("ApplicationHandoff"),
   handoffId: ContractIdentifierSchema,
   source: ApplicationHandoffEndpointSchema,
   target: ApplicationHandoffEndpointSchema,
@@ -6931,8 +6966,8 @@ var ApplicationHandoffSchema = z3.object({
     });
   }
 });
-var ViewProviderDescriptorSchema = z3.object({
-  contract: z3.literal("ViewProviderDescriptor"),
+var ViewProviderDescriptorSchema = z4.object({
+  contract: z4.literal("ViewProviderDescriptor"),
   providerId: ContractIdentifierSchema,
   providerVersion: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
@@ -6940,22 +6975,22 @@ var ViewProviderDescriptorSchema = z3.object({
   rendererKey: ContractIdentifierSchema,
   renderModelSchemaRef: ContractIdentifierSchema,
   intentSchemaRef: ContractIdentifierSchema.optional(),
-  loading: z3.enum(["eager", "lazy", "viewport", "on-activation"]),
-  stateOwner: z3.enum(["host", "provider", "external"]),
-  supportedPageTypes: z3.array(ContractIdentifierSchema).min(1),
-  supportedSurfaces: z3.array(z3.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"])).min(1),
-  frameOwner: z3.enum(["host", "provider", "none"]),
-  sideEffects: z3.array(z3.enum(["network", "storage", "navigation", "worker", "websocket"])),
+  loading: z4.enum(["eager", "lazy", "viewport", "on-activation"]),
+  stateOwner: z4.enum(["host", "provider", "external"]),
+  supportedPageTypes: z4.array(ContractIdentifierSchema).min(1),
+  supportedSurfaces: z4.array(z4.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"])).min(1),
+  frameOwner: z4.enum(["host", "provider", "none"]),
+  sideEffects: z4.array(z4.enum(["network", "storage", "navigation", "worker", "websocket"])),
   sideEffectAdapterRef: EntityRefSchema.optional(),
-  lifecycle: z3.object({
-    preserveMount: z3.boolean(),
-    preserveScroll: z3.boolean(),
+  lifecycle: z4.object({
+    preserveMount: z4.boolean(),
+    preserveScroll: z4.boolean(),
     focusModel: ContractIdentifierSchema
   }).strict(),
-  performance: z3.object({
-    lazy: z3.boolean(),
-    virtualized: z3.boolean(),
-    budgetMs: z3.number().positive().optional()
+  performance: z4.object({
+    lazy: z4.boolean(),
+    virtualized: z4.boolean(),
+    budgetMs: z4.number().positive().optional()
   }).strict(),
   accessRef: EntityRefSchema.optional(),
   evidenceRef: EntityRefSchema.optional()
@@ -6987,54 +7022,54 @@ var ViewProviderDescriptorSchema = z3.object({
 });
 
 // src/contracts/capability.ts
-var ContractPortSchema = z4.object({
+var ContractPortSchema = z5.object({
   name: ContractIdentifierSchema,
   schemaRef: ContractIdentifierSchema,
-  required: z4.boolean().default(false),
-  multiple: z4.boolean().default(false),
-  description: z4.string().optional()
+  required: z5.boolean().default(false),
+  multiple: z5.boolean().default(false),
+  description: z5.string().optional()
 }).strict();
-var CapabilityProviderBindingSchema = z4.object({
+var CapabilityProviderBindingSchema = z5.object({
   providerRef: EntityRefSchema,
-  productContexts: z4.array(ProductContextSchema).default([]),
-  priority: z4.number().int().default(0)
+  productContexts: z5.array(ProductContextSchema).default([]),
+  priority: z5.number().int().default(0)
 }).strict();
-var CapabilityManifestSchema = z4.object({
-  contract: z4.literal("CapabilityManifest"),
+var CapabilityManifestSchema = z5.object({
+  contract: z5.literal("CapabilityManifest"),
   id: ContractIdentifierSchema,
   capabilityVersion: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  kind: z4.enum(["primitive", "composite", "view", "professional-provider", "tool", "workflow"]),
-  displayName: z4.string().trim().min(1),
-  description: z4.string().optional(),
-  ports: z4.object({
-    inputs: z4.array(ContractPortSchema).default([]),
-    outputs: z4.array(ContractPortSchema).default([])
+  kind: z5.enum(["primitive", "composite", "view", "professional-provider", "tool", "workflow"]),
+  displayName: z5.string().trim().min(1),
+  description: z5.string().optional(),
+  ports: z5.object({
+    inputs: z5.array(ContractPortSchema).default([]),
+    outputs: z5.array(ContractPortSchema).default([])
   }).strict(),
-  runtime: z4.object({
-    providerBindings: z4.array(CapabilityProviderBindingSchema).min(1),
-    loading: z4.enum(["eager", "lazy", "viewport", "on-activation"]),
+  runtime: z5.object({
+    providerBindings: z5.array(CapabilityProviderBindingSchema).min(1),
+    loading: z5.enum(["eager", "lazy", "viewport", "on-activation"]),
     fallbackCapabilityRef: EntityRefSchema.optional(),
-    stateOwner: z4.enum(["host", "provider", "external"]),
+    stateOwner: z5.enum(["host", "provider", "external"]),
     stateSchemaRef: ContractIdentifierSchema.optional(),
-    sideEffects: z4.array(z4.enum(["network", "storage", "navigation", "worker", "websocket"])).default([])
+    sideEffects: z5.array(z5.enum(["network", "storage", "navigation", "worker", "websocket"])).default([])
   }).strict(),
-  placement: z4.object({
-    surfaces: z4.array(ContractIdentifierSchema).min(1),
-    slots: z4.array(ContractIdentifierSchema).default([]),
-    variants: z4.array(ContractIdentifierSchema).default([]),
-    tokenRefs: z4.array(ContractIdentifierSchema).default([])
+  placement: z5.object({
+    surfaces: z5.array(ContractIdentifierSchema).min(1),
+    slots: z5.array(ContractIdentifierSchema).default([]),
+    variants: z5.array(ContractIdentifierSchema).default([]),
+    tokenRefs: z5.array(ContractIdentifierSchema).default([])
   }).strict(),
-  accessibility: z4.object({
+  accessibility: z5.object({
     keyboardModel: ContractIdentifierSchema,
     focusModel: ContractIdentifierSchema,
     labelContract: ContractIdentifierSchema
   }).strict(),
-  observability: z4.object({
+  observability: z5.object({
     eventNamespace: ContractIdentifierSchema,
-    metrics: z4.array(ContractIdentifierSchema).default([]),
-    evidenceRefs: z4.array(ContractIdentifierSchema).default([]),
-    performanceBudgetMs: z4.number().positive().optional()
+    metrics: z5.array(ContractIdentifierSchema).default([]),
+    evidenceRefs: z5.array(ContractIdentifierSchema).default([]),
+    performanceBudgetMs: z5.number().positive().optional()
   }).strict()
 }).strict().superRefine((manifest, context) => {
   const providerIds = /* @__PURE__ */ new Set();
@@ -7056,25 +7091,25 @@ var CapabilityManifestSchema = z4.object({
     }
   });
 });
-var CapabilitySourceTypeSchema = z4.enum([
+var CapabilitySourceTypeSchema = z5.enum([
   "tool-manifest",
   "plugin-manifest",
   "openapi",
   "workflow",
   "comfyui"
 ]);
-var CapabilityRegistrySourceSchema = z4.object({
+var CapabilityRegistrySourceSchema = z5.object({
   sourceType: CapabilitySourceTypeSchema,
   sourceId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema
 }).strict();
-var CapabilityRegistryEntrySchema = z4.object({
+var CapabilityRegistryEntrySchema = z5.object({
   manifest: CapabilityManifestSchema,
-  sources: z4.array(CapabilityRegistrySourceSchema).min(1)
+  sources: z5.array(CapabilityRegistrySourceSchema).min(1)
 }).strict();
-var CapabilityRegistryDocumentSchema = z4.object({
-  contract: z4.literal("CapabilityRegistry"),
-  entries: z4.array(CapabilityRegistryEntrySchema)
+var CapabilityRegistryDocumentSchema = z5.object({
+  contract: z5.literal("CapabilityRegistry"),
+  entries: z5.array(CapabilityRegistryEntrySchema)
 }).strict().superRefine((registry, context) => {
   const ids = /* @__PURE__ */ new Set();
   registry.entries.forEach((entry, index) => {
@@ -7090,25 +7125,25 @@ var CapabilityRegistryDocumentSchema = z4.object({
 });
 
 // src/contracts/agent.ts
-import { z as z5 } from "zod";
-var StudioAgentModeSchema = z5.enum(["chat", "work"]);
+import { z as z6 } from "zod";
+var StudioAgentModeSchema = z6.enum(["chat", "work"]);
 var AgentModeSchema = StudioAgentModeSchema;
-var AgentConfigurationCapabilitySchema = z5.enum([
+var AgentConfigurationCapabilitySchema = z6.enum([
   "models",
   "skills",
   "tools",
   "mcp",
   "reasoning"
 ]);
-var AgentModeCapabilitiesSchema = z5.object({
-  models: z5.boolean(),
-  skills: z5.boolean(),
-  tools: z5.boolean(),
-  mcp: z5.boolean(),
-  reasoning: z5.boolean()
+var AgentModeCapabilitiesSchema = z6.object({
+  models: z6.boolean(),
+  skills: z6.boolean(),
+  tools: z6.boolean(),
+  mcp: z6.boolean(),
+  reasoning: z6.boolean()
 }).strict();
-var AgentResourceModeSupportSchema = z5.object({
-  modes: z5.array(AgentModeSchema).min(1)
+var AgentResourceModeSupportSchema = z6.object({
+  modes: z6.array(AgentModeSchema).min(1)
 }).strict();
 var AGENT_MODE_CAPABILITIES = Object.freeze({
   chat: AgentModeCapabilitiesSchema.parse({
@@ -7126,7 +7161,7 @@ var AGENT_MODE_CAPABILITIES = Object.freeze({
     reasoning: true
   })
 });
-var AgentSessionCapabilitySchema = z5.enum([
+var AgentSessionCapabilitySchema = z6.enum([
   "text",
   "reasoning",
   "plan",
@@ -7149,30 +7184,30 @@ var AgentSessionCapabilitySchema = z5.enum([
   "steering",
   "summary"
 ]);
-var AgentSessionCapabilitiesSchema = z5.object({
-  text: z5.boolean().default(true),
-  reasoning: z5.boolean().default(false),
-  plan: z5.boolean().default(false),
-  tasks: z5.boolean().default(false),
-  tools: z5.boolean().default(false),
-  mcp: z5.boolean().default(false),
-  shell: z5.boolean().default(false),
-  fileChange: z5.boolean().default(false),
-  skills: z5.boolean().default(false),
-  approval: z5.boolean().default(false),
-  artifacts: z5.boolean().default(false),
-  usage: z5.boolean().default(false),
-  resume: z5.boolean().default(false),
-  diff: z5.boolean().default(false),
-  workspaceFiles: z5.boolean().default(false),
-  terminal: z5.boolean().default(false),
-  testResults: z5.boolean().default(false),
-  threadForking: z5.boolean().default(false),
-  editAndRerun: z5.boolean().default(false),
-  steering: z5.boolean().default(false),
-  summary: z5.boolean().default(false)
-}).strict();
-var AgentSessionPermissionProfileSchema = z5.enum([
+var AgentSessionCapabilitiesSchema = z6.object({
+  text: z6.boolean().default(true),
+  reasoning: z6.boolean().default(false),
+  plan: z6.boolean().default(false),
+  tasks: z6.boolean().default(false),
+  tools: z6.boolean().default(false),
+  mcp: z6.boolean().default(false),
+  shell: z6.boolean().default(false),
+  fileChange: z6.boolean().default(false),
+  skills: z6.boolean().default(false),
+  approval: z6.boolean().default(false),
+  artifacts: z6.boolean().default(false),
+  usage: z6.boolean().default(false),
+  resume: z6.boolean().default(false),
+  diff: z6.boolean().default(false),
+  workspaceFiles: z6.boolean().default(false),
+  terminal: z6.boolean().default(false),
+  testResults: z6.boolean().default(false),
+  threadForking: z6.boolean().default(false),
+  editAndRerun: z6.boolean().default(false),
+  steering: z6.boolean().default(false),
+  summary: z6.boolean().default(false)
+}).strict();
+var AgentSessionPermissionProfileSchema = z6.enum([
   "approval-required",
   "auto-approve",
   "full-access"
@@ -7204,13 +7239,13 @@ var AGENT_SESSION_CAPABILITY_EVIDENCE = Object.freeze({
   steering: { eventTypes: ["steer"], commandTypes: ["steer"] },
   summary: { eventTypes: ["summary"], commandTypes: ["retry-summary"] }
 });
-var AgentSessionSnapshotSchema = z5.object({
+var AgentSessionSnapshotSchema = z6.object({
   mode: AgentModeSchema,
-  modelId: z5.string().trim().min(1),
+  modelId: z6.string().trim().min(1),
   capabilities: AgentSessionCapabilitiesSchema,
   permissionProfile: AgentSessionPermissionProfileSchema.optional()
 }).strict();
-var AgentSessionStatusSchema = z5.enum([
+var AgentSessionStatusSchema = z6.enum([
   "queued",
   "running",
   "waiting_approval",
@@ -7219,56 +7254,56 @@ var AgentSessionStatusSchema = z5.enum([
   "completed",
   "failed"
 ]);
-var AgentSessionTerminalStatusSchema = z5.enum(["stopped", "completed", "failed"]);
-var AgentSessionLineageSchema = z5.object({
+var AgentSessionTerminalStatusSchema = z6.enum(["stopped", "completed", "failed"]);
+var AgentSessionLineageSchema = z6.object({
   forkedFromThreadId: ContractIdentifierSchema,
   forkedFromMessageId: ContractIdentifierSchema,
   sourceRunId: ContractIdentifierSchema
 }).strict();
-var AgentSessionContextInheritanceSchema = z5.object({
-  messages: z5.enum(["through-source-message", "exclude"]),
-  attachments: z5.enum(["inherit", "exclude"]),
-  summaries: z5.enum(["inherit", "exclude"]),
-  toolResults: z5.enum(["inherit", "exclude"]),
-  codeChanges: z5.enum(["inherit", "exclude"])
+var AgentSessionContextInheritanceSchema = z6.object({
+  messages: z6.enum(["through-source-message", "exclude"]),
+  attachments: z6.enum(["inherit", "exclude"]),
+  summaries: z6.enum(["inherit", "exclude"]),
+  toolResults: z6.enum(["inherit", "exclude"]),
+  codeChanges: z6.enum(["inherit", "exclude"])
 }).strict();
-var AgentSessionInheritedContextMessageSchema = z5.object({
+var AgentSessionInheritedContextMessageSchema = z6.object({
   messageId: ContractIdentifierSchema,
-  role: z5.enum(["user", "assistant"]),
-  parts: z5.array(JsonValueSchema).min(1)
+  role: z6.enum(["user", "assistant"]),
+  parts: z6.array(JsonValueSchema).min(1)
 }).strict();
-var AgentSessionUnavailableResourceSchema = z5.object({
+var AgentSessionUnavailableResourceSchema = z6.object({
   messageId: ContractIdentifierSchema,
-  kind: z5.enum(["attachment", "tool-result", "code-change"]),
-  reason: z5.enum(["excluded", "unavailable", "unsupported"])
+  kind: z6.enum(["attachment", "tool-result", "code-change"]),
+  reason: z6.enum(["excluded", "unavailable", "unsupported"])
 }).strict();
-var AgentSessionInheritedContextSchema = z5.object({
+var AgentSessionInheritedContextSchema = z6.object({
   sourceThreadId: ContractIdentifierSchema,
   sourceMessageId: ContractIdentifierSchema,
   sourceRunId: ContractIdentifierSchema,
-  messages: z5.array(AgentSessionInheritedContextMessageSchema).max(24),
-  summary: z5.string().trim().min(1).optional(),
-  unavailableResources: z5.array(AgentSessionUnavailableResourceSchema).default([]),
+  messages: z6.array(AgentSessionInheritedContextMessageSchema).max(24),
+  summary: z6.string().trim().min(1).optional(),
+  unavailableResources: z6.array(AgentSessionUnavailableResourceSchema).default([]),
   capturedAt: IsoDateTimeSchema
 }).strict();
-var AgentSessionContinuationRequestSchema = z5.object({
-  contract: z5.literal("AgentSessionContinuationRequest"),
+var AgentSessionContinuationRequestSchema = z6.object({
+  contract: z6.literal("AgentSessionContinuationRequest"),
   idempotencyKey: ContractIdentifierSchema,
   sourceMessageId: ContractIdentifierSchema,
   sourceRunId: ContractIdentifierSchema,
   inheritance: AgentSessionContextInheritanceSchema
 }).strict();
-var AgentSessionContinuationResultSchema = z5.object({
-  contract: z5.literal("AgentSessionContinuationResult"),
+var AgentSessionContinuationResultSchema = z6.object({
+  contract: z6.literal("AgentSessionContinuationResult"),
   idempotencyKey: ContractIdentifierSchema,
   threadId: ContractIdentifierSchema,
   lineage: AgentSessionLineageSchema,
   inheritance: AgentSessionContextInheritanceSchema,
-  unavailableResources: z5.array(AgentSessionUnavailableResourceSchema).default([]),
-  duplicate: z5.boolean(),
+  unavailableResources: z6.array(AgentSessionUnavailableResourceSchema).default([]),
+  duplicate: z6.boolean(),
   createdAt: IsoDateTimeSchema
 }).strict();
-var AgentSessionActiveBranchSchema = z5.object({
+var AgentSessionActiveBranchSchema = z6.object({
   branchId: ContractIdentifierSchema,
   threadId: ContractIdentifierSchema,
   sourceMessageId: ContractIdentifierSchema,
@@ -7276,7 +7311,7 @@ var AgentSessionActiveBranchSchema = z5.object({
   lineage: AgentSessionLineageSchema.optional(),
   createdAt: IsoDateTimeSchema
 }).strict();
-var AgentSessionRunSchema = z5.object({
+var AgentSessionRunSchema = z6.object({
   runId: ContractIdentifierSchema,
   sessionId: ContractIdentifierSchema,
   sourceMessageId: ContractIdentifierSchema,
@@ -7286,7 +7321,7 @@ var AgentSessionRunSchema = z5.object({
   stoppedAt: IsoDateTimeSchema.optional(),
   completedAt: IsoDateTimeSchema.optional(),
   failedAt: IsoDateTimeSchema.optional(),
-  durationMs: z5.number().nonnegative().optional()
+  durationMs: z6.number().nonnegative().optional()
 }).strict().superRefine((value, context) => {
   const terminalTimestamps = [value.stoppedAt, value.completedAt, value.failedAt].filter(Boolean);
   if (terminalTimestamps.length > 1) {
@@ -7333,7 +7368,7 @@ var AgentSessionRunSchema = z5.object({
     });
   }
 });
-var AgentSessionCommandTypeSchema = z5.enum([
+var AgentSessionCommandTypeSchema = z6.enum([
   "stop",
   "resume",
   "retry",
@@ -7343,22 +7378,22 @@ var AgentSessionCommandTypeSchema = z5.enum([
   "edit-and-rerun",
   "steer"
 ]);
-var AgentSessionCommandHeaderSchema = z5.object({
-  contract: z5.literal("AgentSessionCommand"),
+var AgentSessionCommandHeaderSchema = z6.object({
+  contract: z6.literal("AgentSessionCommand"),
   commandId: ContractIdentifierSchema,
   sessionId: ContractIdentifierSchema,
   runId: ContractIdentifierSchema.optional(),
   idempotencyKey: ContractIdentifierSchema,
-  expectedSequence: z5.number().int().min(-1),
+  expectedSequence: z6.number().int().min(-1),
   issuedAt: IsoDateTimeSchema
 }).strict();
 var sessionCommand = (commandType, payload) => AgentSessionCommandHeaderSchema.extend({
-  commandType: z5.literal(commandType),
-  payload: z5.object(payload).strict()
+  commandType: z6.literal(commandType),
+  payload: z6.object(payload).strict()
 }).strict();
-var AgentSessionCommandSchema = z5.discriminatedUnion("commandType", [
+var AgentSessionCommandSchema = z6.discriminatedUnion("commandType", [
   sessionCommand("stop", {
-    reason: z5.string().trim().min(1).optional()
+    reason: z6.string().trim().min(1).optional()
   }),
   sessionCommand("resume", {
     resumeEventId: ContractIdentifierSchema.optional()
@@ -7372,8 +7407,8 @@ var AgentSessionCommandSchema = z5.discriminatedUnion("commandType", [
   }),
   sessionCommand("approval", {
     approvalId: ContractIdentifierSchema,
-    decision: z5.enum(["approved", "rejected"]),
-    reason: z5.string().trim().min(1).optional()
+    decision: z6.enum(["approved", "rejected"]),
+    reason: z6.string().trim().min(1).optional()
   }),
   sessionCommand("fork", {
     sourceThreadId: ContractIdentifierSchema,
@@ -7385,12 +7420,12 @@ var AgentSessionCommandSchema = z5.discriminatedUnion("commandType", [
     sourceThreadId: ContractIdentifierSchema,
     sourceMessageId: ContractIdentifierSchema,
     sourceRunId: ContractIdentifierSchema,
-    replacementParts: z5.array(JsonValueSchema).min(1),
+    replacementParts: z6.array(JsonValueSchema).min(1),
     inheritance: AgentSessionContextInheritanceSchema
   }),
   sessionCommand("steer", {
     targetRunId: ContractIdentifierSchema,
-    text: z5.string().trim().min(1)
+    text: z6.string().trim().min(1)
   })
 ]).superRefine((value, context) => {
   if (value.commandType === "steer" && value.runId !== value.payload.targetRunId) {
@@ -7409,9 +7444,9 @@ var AgentSessionCommandSchema = z5.discriminatedUnion("commandType", [
   }
 });
 var AgentSessionTargetedCommandSchema = AgentSessionCommandSchema.and(
-  z5.object({ runId: ContractIdentifierSchema })
+  z6.object({ runId: ContractIdentifierSchema })
 );
-var AgentSessionCommandErrorCodeSchema = z5.enum([
+var AgentSessionCommandErrorCodeSchema = z6.enum([
   "SESSION_NOT_FOUND",
   "RUN_NOT_FOUND",
   "ACTIVE_RUN_NOT_FOUND",
@@ -7432,25 +7467,25 @@ var AgentSessionCommandErrorCodeSchema = z5.enum([
   "ACTIVE_BRANCH_NOT_FOUND",
   "COMMAND_EXECUTION_FAILED"
 ]);
-var AgentSessionCommandResultSchema = z5.object({
-  contract: z5.literal("AgentSessionCommandResult"),
+var AgentSessionCommandResultSchema = z6.object({
+  contract: z6.literal("AgentSessionCommandResult"),
   commandId: ContractIdentifierSchema,
   sessionId: ContractIdentifierSchema,
   runId: ContractIdentifierSchema.optional(),
   idempotencyKey: ContractIdentifierSchema,
-  outcome: z5.enum(["accepted", "duplicate", "rejected", "failed"]),
+  outcome: z6.enum(["accepted", "duplicate", "rejected", "failed"]),
   sessionStatus: AgentSessionStatusSchema,
-  acceptedSequence: z5.number().int().nonnegative().optional(),
-  resultEventIds: z5.array(ContractIdentifierSchema).default([]),
-  operation: z5.object({
+  acceptedSequence: z6.number().int().nonnegative().optional(),
+  resultEventIds: z6.array(ContractIdentifierSchema).default([]),
+  operation: z6.object({
     lineage: AgentSessionLineageSchema,
     activeBranch: AgentSessionActiveBranchSchema
   }).strict().optional(),
-  termination: z5.enum(["requested", "confirmed"]).optional(),
-  error: z5.object({
+  termination: z6.enum(["requested", "confirmed"]).optional(),
+  error: z6.object({
     code: AgentSessionCommandErrorCodeSchema,
-    message: z5.string(),
-    retryable: z5.boolean()
+    message: z6.string(),
+    retryable: z6.boolean()
   }).strict().optional(),
   occurredAt: IsoDateTimeSchema
 }).strict().superRefine((value, context) => {
@@ -7503,13 +7538,13 @@ var AgentSessionCommandResultSchema = z5.object({
     });
   }
 });
-var AgentSessionCommandPolicySchema = z5.object({
+var AgentSessionCommandPolicySchema = z6.object({
   capability: AgentSessionCapabilitySchema.optional(),
-  allowedStatuses: z5.array(AgentSessionStatusSchema).min(1),
-  requiresRunId: z5.boolean(),
-  sourceSessionEffect: z5.enum(["transition", "preserve"]),
-  idempotencyScope: z5.literal("session-command"),
-  sequenceRule: z5.enum(["match-current", "target-run"])
+  allowedStatuses: z6.array(AgentSessionStatusSchema).min(1),
+  requiresRunId: z6.boolean(),
+  sourceSessionEffect: z6.enum(["transition", "preserve"]),
+  idempotencyScope: z6.literal("session-command"),
+  sequenceRule: z6.enum(["match-current", "target-run"])
 }).strict();
 var sessionCommandPolicy = (policy) => AgentSessionCommandPolicySchema.parse(policy);
 var AGENT_SESSION_COMMAND_POLICIES = Object.freeze({
@@ -7579,150 +7614,150 @@ var AGENT_SESSION_COMMAND_POLICIES = Object.freeze({
 function isAgentSessionTerminalStatus(status) {
   return AgentSessionTerminalStatusSchema.safeParse(status).success;
 }
-var AgentSessionEventHeaderSchema = z5.object({
-  contract: z5.literal("AgentSessionEvent"),
+var AgentSessionEventHeaderSchema = z6.object({
+  contract: z6.literal("AgentSessionEvent"),
   eventId: ContractIdentifierSchema,
   sessionId: ContractIdentifierSchema,
   runId: ContractIdentifierSchema.optional(),
   sourceMessageId: ContractIdentifierSchema.optional(),
-  sequence: z5.number().int().nonnegative(),
+  sequence: z6.number().int().nonnegative(),
   idempotencyKey: ContractIdentifierSchema,
   occurredAt: IsoDateTimeSchema
 }).strict();
 var sessionEvent = (eventType, payload) => AgentSessionEventHeaderSchema.extend({
-  eventType: z5.literal(eventType),
-  payload: z5.object(payload).strict()
+  eventType: z6.literal(eventType),
+  payload: z6.object(payload).strict()
 }).strict();
-var AgentSessionEventSchema = z5.discriminatedUnion("eventType", [
+var AgentSessionEventSchema = z6.discriminatedUnion("eventType", [
   sessionEvent("message", {
     messageId: ContractIdentifierSchema,
-    role: z5.enum(["user", "assistant", "system"]),
-    operation: z5.enum(["append", "replace"]).default("append"),
-    parts: z5.array(JsonValueSchema),
-    status: z5.enum(["streaming", "completed", "failed"]).optional()
+    role: z6.enum(["user", "assistant", "system"]),
+    operation: z6.enum(["append", "replace"]).default("append"),
+    parts: z6.array(JsonValueSchema),
+    status: z6.enum(["streaming", "completed", "failed"]).optional()
   }),
   sessionEvent("reasoning", {
     reasoningId: ContractIdentifierSchema,
-    text: z5.string(),
-    status: z5.enum(["streaming", "completed"])
+    text: z6.string(),
+    status: z6.enum(["streaming", "completed"])
   }),
   sessionEvent("plan", {
     planId: ContractIdentifierSchema,
-    title: z5.string().optional(),
-    status: z5.enum(["pending", "running", "completed", "failed"]),
-    steps: z5.array(
-      z5.object({
+    title: z6.string().optional(),
+    status: z6.enum(["pending", "running", "completed", "failed"]),
+    steps: z6.array(
+      z6.object({
         id: ContractIdentifierSchema,
-        title: z5.string(),
-        status: z5.enum(["pending", "running", "completed", "failed", "skipped"])
+        title: z6.string(),
+        status: z6.enum(["pending", "running", "completed", "failed", "skipped"])
       }).strict()
     )
   }),
   sessionEvent("task", {
     taskId: ContractIdentifierSchema,
-    title: z5.string(),
-    status: z5.enum(["pending", "running", "completed", "failed", "skipped"]),
-    detail: z5.string().optional()
+    title: z6.string(),
+    status: z6.enum(["pending", "running", "completed", "failed", "skipped"]),
+    detail: z6.string().optional()
   }),
   sessionEvent("tool", {
     toolCallId: ContractIdentifierSchema,
-    toolName: z5.string().trim().min(1),
-    status: z5.enum(["pending", "running", "completed", "failed", "denied"]),
+    toolName: z6.string().trim().min(1),
+    status: z6.enum(["pending", "running", "completed", "failed", "denied"]),
     input: JsonValueSchema.optional(),
     output: JsonValueSchema.optional(),
-    error: z5.string().optional(),
+    error: z6.string().optional(),
     startedAt: IsoDateTimeSchema.optional(),
     completedAt: IsoDateTimeSchema.optional()
   }),
   sessionEvent("approval", {
     approvalId: ContractIdentifierSchema,
     toolCallId: ContractIdentifierSchema.optional(),
-    status: z5.enum(["requested", "approved", "rejected", "expired"]),
-    title: z5.string(),
-    description: z5.string().optional(),
+    status: z6.enum(["requested", "approved", "rejected", "expired"]),
+    title: z6.string(),
+    description: z6.string().optional(),
     requestedAction: JsonValueSchema.optional()
   }),
   sessionEvent("status", {
     status: AgentSessionStatusSchema,
-    detail: z5.string().optional(),
+    detail: z6.string().optional(),
     startedAt: IsoDateTimeSchema.optional(),
     stoppingRequestedAt: IsoDateTimeSchema.optional(),
     stoppedAt: IsoDateTimeSchema.optional(),
     completedAt: IsoDateTimeSchema.optional(),
     failedAt: IsoDateTimeSchema.optional(),
-    durationMs: z5.number().nonnegative().optional()
+    durationMs: z6.number().nonnegative().optional()
   }),
   sessionEvent("artifact", {
     artifactId: ContractIdentifierSchema,
-    name: z5.string().trim().min(1),
-    kind: z5.enum(["file", "image", "video", "audio", "web", "other"]),
-    status: z5.enum(["pending", "ready", "failed"]),
-    mimeType: z5.string().optional(),
-    url: z5.string().url().optional(),
-    size: z5.number().int().nonnegative().optional(),
+    name: z6.string().trim().min(1),
+    kind: z6.enum(["file", "image", "video", "audio", "web", "other"]),
+    status: z6.enum(["pending", "ready", "failed"]),
+    mimeType: z6.string().optional(),
+    url: z6.string().url().optional(),
+    size: z6.number().int().nonnegative().optional(),
     sourceEventId: ContractIdentifierSchema.optional()
   }),
   sessionEvent("usage", {
-    inputTokens: z5.number().int().nonnegative().optional(),
-    outputTokens: z5.number().int().nonnegative().optional(),
-    totalTokens: z5.number().int().nonnegative().optional(),
-    contextTokens: z5.number().int().nonnegative().optional(),
-    contextWindow: z5.number().int().positive().optional()
+    inputTokens: z6.number().int().nonnegative().optional(),
+    outputTokens: z6.number().int().nonnegative().optional(),
+    totalTokens: z6.number().int().nonnegative().optional(),
+    contextTokens: z6.number().int().nonnegative().optional(),
+    contextWindow: z6.number().int().positive().optional()
   }),
   sessionEvent("resume", {
-    resumable: z5.boolean(),
+    resumable: z6.boolean(),
     state: JsonObjectSchema.optional(),
-    reason: z5.string().optional()
+    reason: z6.string().optional()
   }),
   sessionEvent("error", {
-    code: z5.string().trim().min(1),
-    message: z5.string(),
-    retryable: z5.boolean(),
+    code: z6.string().trim().min(1),
+    message: z6.string(),
+    retryable: z6.boolean(),
     sourceEventId: ContractIdentifierSchema.optional(),
     details: JsonObjectSchema.optional()
   }),
   sessionEvent("diff", {
-    path: z5.string().trim().min(1),
-    status: z5.enum(["added", "modified", "deleted", "renamed"]),
-    patch: z5.string().optional()
+    path: z6.string().trim().min(1),
+    status: z6.enum(["added", "modified", "deleted", "renamed"]),
+    patch: z6.string().optional()
   }),
   sessionEvent("workspace-file", {
-    path: z5.string().trim().min(1),
-    operation: z5.enum(["upsert", "delete"]),
-    mimeType: z5.string().optional(),
-    size: z5.number().int().nonnegative().optional()
+    path: z6.string().trim().min(1),
+    operation: z6.enum(["upsert", "delete"]),
+    mimeType: z6.string().optional(),
+    size: z6.number().int().nonnegative().optional()
   }),
   sessionEvent("terminal", {
     terminalId: ContractIdentifierSchema,
-    stream: z5.enum(["stdin", "stdout", "stderr", "status"]),
-    chunk: z5.string(),
-    exitCode: z5.number().int().optional()
+    stream: z6.enum(["stdin", "stdout", "stderr", "status"]),
+    chunk: z6.string(),
+    exitCode: z6.number().int().optional()
   }),
   sessionEvent("test-result", {
     testId: ContractIdentifierSchema,
-    name: z5.string(),
-    status: z5.enum(["running", "passed", "failed", "skipped"]),
-    durationMs: z5.number().nonnegative().optional(),
-    output: z5.string().optional()
+    name: z6.string(),
+    status: z6.enum(["running", "passed", "failed", "skipped"]),
+    durationMs: z6.number().nonnegative().optional(),
+    output: z6.string().optional()
   }),
   sessionEvent("steer", {
     commandId: ContractIdentifierSchema,
     targetRunId: ContractIdentifierSchema,
-    text: z5.string().trim().min(1),
-    status: z5.enum(["accepted", "applied", "failed"]),
-    error: z5.object({
+    text: z6.string().trim().min(1),
+    status: z6.enum(["accepted", "applied", "failed"]),
+    error: z6.object({
       code: AgentSessionCommandErrorCodeSchema,
-      message: z5.string(),
-      retryable: z5.boolean()
+      message: z6.string(),
+      retryable: z6.boolean()
     }).strict().optional()
   }),
   sessionEvent("summary", {
     summaryId: ContractIdentifierSchema,
     runId: ContractIdentifierSchema,
-    text: z5.string(),
-    highlights: z5.array(z5.string()),
-    pendingItems: z5.array(z5.string()),
-    status: z5.enum(["generating", "completed", "failed"])
+    text: z6.string(),
+    highlights: z6.array(z6.string()),
+    pendingItems: z6.array(z6.string()),
+    status: z6.enum(["generating", "completed", "failed"])
   })
 ]).superRefine((value, context) => {
   if (value.eventType === "steer") {
@@ -7778,14 +7813,14 @@ var AgentSessionRunEventSchema = AgentSessionEventSchema.superRefine((value, con
     });
   }
 });
-var AgentSessionViewModelSchema = z5.object({
-  contract: z5.literal("AgentSessionViewModel"),
+var AgentSessionViewModelSchema = z6.object({
+  contract: z6.literal("AgentSessionViewModel"),
   sessionId: ContractIdentifierSchema,
   snapshot: AgentSessionSnapshotSchema,
   status: AgentSessionStatusSchema,
-  events: z5.array(AgentSessionEventSchema),
-  lastSequence: z5.number().int().min(-1),
-  resumable: z5.boolean().default(false),
+  events: z6.array(AgentSessionEventSchema),
+  lastSequence: z6.number().int().min(-1),
+  resumable: z6.boolean().default(false),
   lineage: AgentSessionLineageSchema.optional(),
   activeBranch: AgentSessionActiveBranchSchema.optional()
 }).strict().superRefine((value, context) => {
@@ -7834,55 +7869,55 @@ var AgentSessionViewModelSchema = z5.object({
     });
   }
 });
-var AgentWorkbenchNavigationItemStatusSchema = z5.enum(["idle", "running", "completed", "error"]);
-var AgentWorkbenchCollectionStatusSchema = z5.enum(["loading", "ready", "error"]);
-var AgentWorkbenchAgentItemSchema = z5.object({
+var AgentWorkbenchNavigationItemStatusSchema = z6.enum(["idle", "running", "completed", "error"]);
+var AgentWorkbenchCollectionStatusSchema = z6.enum(["loading", "ready", "error"]);
+var AgentWorkbenchAgentItemSchema = z6.object({
   id: ContractIdentifierSchema,
-  name: z5.string().min(1),
-  description: z5.string().optional(),
-  iconUrl: z5.string().url().optional(),
-  builtIn: z5.boolean().default(false),
-  pinned: z5.boolean().default(false),
-  pinPending: z5.boolean().default(false)
-}).strict();
-var AgentWorkbenchSessionItemSchema = z5.object({
+  name: z6.string().min(1),
+  description: z6.string().optional(),
+  iconUrl: z6.string().url().optional(),
+  builtIn: z6.boolean().default(false),
+  pinned: z6.boolean().default(false),
+  pinPending: z6.boolean().default(false)
+}).strict();
+var AgentWorkbenchSessionItemSchema = z6.object({
   id: ContractIdentifierSchema,
-  title: z5.string().min(1),
+  title: z6.string().min(1),
   updatedAt: IsoDateTimeSchema,
-  thumbnailUrl: z5.string().url().optional(),
+  thumbnailUrl: z6.string().url().optional(),
   mode: AgentModeSchema.optional(),
   status: AgentWorkbenchNavigationItemStatusSchema.default("idle"),
-  pinned: z5.boolean().default(false),
-  contextUsage: z5.object({
-    usedTokens: z5.number().int().nonnegative(),
-    maxTokens: z5.number().int().positive()
+  pinned: z6.boolean().default(false),
+  contextUsage: z6.object({
+    usedTokens: z6.number().int().nonnegative(),
+    maxTokens: z6.number().int().positive()
   }).strict().optional()
 }).strict();
-var AgentWorkbenchNavigationCapabilitiesSchema = z5.object({
-  createAgent: z5.boolean().default(false),
-  createSession: z5.boolean().default(true),
-  manageCapabilities: z5.boolean().default(false),
-  manageAgentSettings: z5.boolean().default(false),
-  pinAgents: z5.boolean().default(false),
-  pinSessions: z5.boolean().default(false),
-  renameSessions: z5.boolean().default(false),
-  deleteSessions: z5.boolean().default(false)
-}).strict();
-var AgentWorkbenchNavigationViewModelSchema = z5.object({
-  contract: z5.literal("AgentWorkbenchNavigationViewModel"),
-  activeTab: z5.enum(["agents", "sessions"]).default("sessions"),
-  searchQuery: z5.string().default(""),
+var AgentWorkbenchNavigationCapabilitiesSchema = z6.object({
+  createAgent: z6.boolean().default(false),
+  createSession: z6.boolean().default(true),
+  manageCapabilities: z6.boolean().default(false),
+  manageAgentSettings: z6.boolean().default(false),
+  pinAgents: z6.boolean().default(false),
+  pinSessions: z6.boolean().default(false),
+  renameSessions: z6.boolean().default(false),
+  deleteSessions: z6.boolean().default(false)
+}).strict();
+var AgentWorkbenchNavigationViewModelSchema = z6.object({
+  contract: z6.literal("AgentWorkbenchNavigationViewModel"),
+  activeTab: z6.enum(["agents", "sessions"]).default("sessions"),
+  searchQuery: z6.string().default(""),
   selectedAgentItem: ContractIdentifierSchema.optional(),
   selectedSessionItem: ContractIdentifierSchema.optional(),
-  agents: z5.object({
+  agents: z6.object({
     status: AgentWorkbenchCollectionStatusSchema,
-    items: z5.array(AgentWorkbenchAgentItemSchema),
-    error: z5.string().optional()
+    items: z6.array(AgentWorkbenchAgentItemSchema),
+    error: z6.string().optional()
   }).strict(),
-  sessions: z5.object({
+  sessions: z6.object({
     status: AgentWorkbenchCollectionStatusSchema,
-    items: z5.array(AgentWorkbenchSessionItemSchema),
-    error: z5.string().optional()
+    items: z6.array(AgentWorkbenchSessionItemSchema),
+    error: z6.string().optional()
   }).strict(),
   capabilities: AgentWorkbenchNavigationCapabilitiesSchema
 }).strict().superRefine((value, context) => {
@@ -7898,44 +7933,44 @@ var AgentWorkbenchNavigationViewModelSchema = z5.object({
   validateCollection(value.agents, "agents");
   validateCollection(value.sessions, "sessions");
 });
-var AgentWorkbenchComposerStatusSchema = z5.enum([
+var AgentWorkbenchComposerStatusSchema = z6.enum([
   "idle",
   "loading",
   "streaming",
   "stopping",
   "error"
 ]);
-var AgentWorkbenchComposerAttachmentSchema = z5.object({
+var AgentWorkbenchComposerAttachmentSchema = z6.object({
   id: ContractIdentifierSchema,
-  name: z5.string().min(1),
-  mediaType: z5.string().min(1).optional(),
-  previewUrl: z5.string().min(1).optional(),
-  status: z5.enum(["uploading", "ready", "error"]).default("ready")
+  name: z6.string().min(1),
+  mediaType: z6.string().min(1).optional(),
+  previewUrl: z6.string().min(1).optional(),
+  status: z6.enum(["uploading", "ready", "error"]).default("ready")
 }).strict();
-var AgentWorkbenchComposerQueueItemSchema = z5.object({
+var AgentWorkbenchComposerQueueItemSchema = z6.object({
   id: ContractIdentifierSchema,
-  text: z5.string(),
-  attachmentCount: z5.number().int().nonnegative().default(0),
-  status: z5.enum(["queued", "sending", "error"]).default("queued")
+  text: z6.string(),
+  attachmentCount: z6.number().int().nonnegative().default(0),
+  status: z6.enum(["queued", "sending", "error"]).default("queued")
 }).strict();
-var AgentWorkbenchComposerModelOptionSchema = z5.object({
+var AgentWorkbenchComposerModelOptionSchema = z6.object({
   id: ContractIdentifierSchema,
-  label: z5.string().min(1),
-  provider: z5.string().min(1).optional(),
+  label: z6.string().min(1),
+  provider: z6.string().min(1).optional(),
   mode: AgentModeSchema,
-  disabled: z5.boolean().default(false)
-}).strict();
-var AgentWorkbenchComposerCapabilitiesSchema = z5.object({
-  attachments: z5.boolean().default(false),
-  voiceInput: z5.boolean().default(false),
-  webSearch: z5.boolean().default(false),
-  modelSelection: z5.boolean().default(false),
-  reasoning: z5.boolean().default(false),
-  permissions: z5.boolean().default(false),
-  queue: z5.boolean().default(false),
-  stop: z5.boolean().default(false)
-}).strict();
-var AgentWorkbenchQuickStartIconSchema = z5.enum([
+  disabled: z6.boolean().default(false)
+}).strict();
+var AgentWorkbenchComposerCapabilitiesSchema = z6.object({
+  attachments: z6.boolean().default(false),
+  voiceInput: z6.boolean().default(false),
+  webSearch: z6.boolean().default(false),
+  modelSelection: z6.boolean().default(false),
+  reasoning: z6.boolean().default(false),
+  permissions: z6.boolean().default(false),
+  queue: z6.boolean().default(false),
+  stop: z6.boolean().default(false)
+}).strict();
+var AgentWorkbenchQuickStartIconSchema = z6.enum([
   "sparkles",
   "palette",
   "search",
@@ -7943,55 +7978,55 @@ var AgentWorkbenchQuickStartIconSchema = z5.enum([
   "code",
   "shopping-bag"
 ]);
-var AgentWorkbenchQuickStartTemplateActionSchema = z5.enum(["prompt", "upload"]);
-var AgentWorkbenchQuickStartTemplateSchema = z5.object({
+var AgentWorkbenchQuickStartTemplateActionSchema = z6.enum(["prompt", "upload"]);
+var AgentWorkbenchQuickStartTemplateSchema = z6.object({
   id: ContractIdentifierSchema,
-  title: z5.string().min(1),
-  description: z5.string().min(1).optional(),
-  prompt: z5.string().min(1),
+  title: z6.string().min(1),
+  description: z6.string().min(1).optional(),
+  prompt: z6.string().min(1),
   action: AgentWorkbenchQuickStartTemplateActionSchema.default("prompt"),
   icon: AgentWorkbenchQuickStartIconSchema.optional(),
-  coverImageUrl: z5.string().min(1).optional(),
-  accept: z5.string().min(1).default("*/*"),
-  multiple: z5.boolean().default(false),
-  modes: z5.array(AgentModeSchema).min(1).optional()
+  coverImageUrl: z6.string().min(1).optional(),
+  accept: z6.string().min(1).default("*/*"),
+  multiple: z6.boolean().default(false),
+  modes: z6.array(AgentModeSchema).min(1).optional()
 }).strict();
-var AgentWorkbenchQuickStartSectionSchema = z5.object({
+var AgentWorkbenchQuickStartSectionSchema = z6.object({
   id: ContractIdentifierSchema,
-  label: z5.string().min(1),
-  templates: z5.array(AgentWorkbenchQuickStartTemplateSchema).min(1)
+  label: z6.string().min(1),
+  templates: z6.array(AgentWorkbenchQuickStartTemplateSchema).min(1)
 }).strict();
-var AgentWorkbenchQuickStartCategorySchema = z5.object({
+var AgentWorkbenchQuickStartCategorySchema = z6.object({
   id: ContractIdentifierSchema,
-  label: z5.string().min(1),
+  label: z6.string().min(1),
   icon: AgentWorkbenchQuickStartIconSchema.optional(),
-  sections: z5.array(AgentWorkbenchQuickStartSectionSchema).min(1)
+  sections: z6.array(AgentWorkbenchQuickStartSectionSchema).min(1)
 }).strict();
-var AgentWorkbenchQuickStartViewModelSchema = z5.object({
-  contract: z5.literal("AgentWorkbenchQuickStartViewModel"),
+var AgentWorkbenchQuickStartViewModelSchema = z6.object({
+  contract: z6.literal("AgentWorkbenchQuickStartViewModel"),
   mode: AgentModeSchema,
-  categories: z5.array(AgentWorkbenchQuickStartCategorySchema).min(1),
-  disabled: z5.boolean().default(false)
+  categories: z6.array(AgentWorkbenchQuickStartCategorySchema).min(1),
+  disabled: z6.boolean().default(false)
 }).strict();
-var AgentWorkbenchComposerViewModelSchema = z5.object({
-  contract: z5.literal("AgentWorkbenchComposerViewModel"),
-  value: z5.string().default(""),
+var AgentWorkbenchComposerViewModelSchema = z6.object({
+  contract: z6.literal("AgentWorkbenchComposerViewModel"),
+  value: z6.string().default(""),
   status: AgentWorkbenchComposerStatusSchema.default("idle"),
   mode: AgentModeSchema,
-  placeholder: z5.string().optional(),
-  attachments: z5.array(AgentWorkbenchComposerAttachmentSchema).default([]),
-  queuedDrafts: z5.array(AgentWorkbenchComposerQueueItemSchema).default([]),
-  model: z5.object({
+  placeholder: z6.string().optional(),
+  attachments: z6.array(AgentWorkbenchComposerAttachmentSchema).default([]),
+  queuedDrafts: z6.array(AgentWorkbenchComposerQueueItemSchema).default([]),
+  model: z6.object({
     selectedId: ContractIdentifierSchema.optional(),
-    options: z5.array(AgentWorkbenchComposerModelOptionSchema)
+    options: z6.array(AgentWorkbenchComposerModelOptionSchema)
   }).strict(),
-  reasoning: z5.object({
-    value: z5.enum(["low", "medium", "high", "xhigh"]),
-    options: z5.array(z5.enum(["low", "medium", "high", "xhigh"])).min(1)
+  reasoning: z6.object({
+    value: z6.enum(["low", "medium", "high", "xhigh"]),
+    options: z6.array(z6.enum(["low", "medium", "high", "xhigh"])).min(1)
   }).strict().optional(),
   permissionProfile: AgentSessionPermissionProfileSchema.optional(),
-  webSearchEnabled: z5.boolean().default(false),
-  error: z5.string().optional(),
+  webSearchEnabled: z6.boolean().default(false),
+  error: z6.string().optional(),
   capabilities: AgentWorkbenchComposerCapabilitiesSchema
 }).strict().superRefine((value, context) => {
   if (value.status === "error" && !value.error) {
@@ -8012,38 +8047,38 @@ var AgentWorkbenchComposerViewModelSchema = z5.object({
 var AgentExecutionModeSchema = AgentModeSchema;
 
 // src/contracts/context.ts
-import { z as z6 } from "zod";
-var ActorRefSchema = z6.object({
-  kind: z6.enum(["human", "agent", "service", "tenant", "public"]),
+import { z as z7 } from "zod";
+var ActorRefSchema = z7.object({
+  kind: z7.enum(["human", "agent", "service", "tenant", "public"]),
   id: ContractIdentifierSchema.optional(),
   userId: ContractIdentifierSchema.optional(),
   agentId: ContractIdentifierSchema.optional(),
   serviceId: ContractIdentifierSchema.optional()
 }).strict();
-var AuthorityScopeSchema = z6.object({
+var AuthorityScopeSchema = z7.object({
   resource: ContractIdentifierSchema,
-  actions: z6.array(ContractIdentifierSchema).min(1),
-  constraints: z6.record(z6.string(), JsonValueSchema).optional()
+  actions: z7.array(ContractIdentifierSchema).min(1),
+  constraints: z7.record(z7.string(), JsonValueSchema).optional()
 }).strict();
-var RequestScopeSchema = z6.object({
-  contract: z6.literal("RequestScope"),
+var RequestScopeSchema = z7.object({
+  contract: z7.literal("RequestScope"),
   requestId: ContractIdentifierSchema,
   traceId: ContractIdentifierSchema.optional(),
   appId: ContractIdentifierSchema,
   tenantId: ContractIdentifierSchema.optional(),
   teamId: ContractIdentifierSchema.optional(),
   actor: ActorRefSchema,
-  session: z6.object({
+  session: z7.object({
     authType: ContractIdentifierSchema,
-    authenticated: z6.boolean(),
-    membershipVerified: z6.boolean()
+    authenticated: z7.boolean(),
+    membershipVerified: z7.boolean()
   }).strict(),
-  permissionCodes: z6.array(ContractIdentifierSchema).default([]),
-  authority: z6.array(AuthorityScopeSchema).default([]),
+  permissionCodes: z7.array(ContractIdentifierSchema).default([]),
+  authority: z7.array(AuthorityScopeSchema).default([]),
   issuedAt: IsoDateTimeSchema
 }).strict();
-var ExecutionLinkSchema = z6.object({
-  contract: z6.literal("ExecutionLink"),
+var ExecutionLinkSchema = z7.object({
+  contract: z7.literal("ExecutionLink"),
   requestId: ContractIdentifierSchema,
   traceId: ContractIdentifierSchema.optional(),
   correlationId: ContractIdentifierSchema.optional(),
@@ -8053,43 +8088,43 @@ var ExecutionLinkSchema = z6.object({
   taskRef: EntityRefSchema.optional(),
   parentRunRef: EntityRefSchema.optional()
 }).strict();
-var CompletionHeaderSchema = z6.object({
-  contract: z6.literal("CompletionHeader"),
+var CompletionHeaderSchema = z7.object({
+  contract: z7.literal("CompletionHeader"),
   eventId: ContractIdentifierSchema,
   runtimeEventId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  sequence: z6.number().int().nonnegative(),
+  sequence: z7.number().int().nonnegative(),
   execution: ExecutionLinkSchema,
-  producer: z6.object({
+  producer: z7.object({
     service: ContractIdentifierSchema,
     runtime: ContractIdentifierSchema,
     version: ContractIdentifierSchema
   }).strict(),
-  status: z6.enum(["SUCCEEDED", "FAILED", "CANCELLED", "TIMED_OUT"]),
+  status: z7.enum(["SUCCEEDED", "FAILED", "CANCELLED", "TIMED_OUT"]),
   occurredAt: IsoDateTimeSchema,
   payloadSchemaRef: ContractIdentifierSchema.optional()
 }).strict();
-var CompletionEventSchema = z6.object({
+var CompletionEventSchema = z7.object({
   header: CompletionHeaderSchema,
   payload: JsonValueSchema.optional()
 }).strict();
-var AgentRuntimeEventSchema = z6.object({
-  contract: z6.literal("AgentRuntimeEvent"),
+var AgentRuntimeEventSchema = z7.object({
+  contract: z7.literal("AgentRuntimeEvent"),
   runtimeEventId: ContractIdentifierSchema,
   streamId: ContractIdentifierSchema,
-  sequence: z6.number().int().nonnegative(),
+  sequence: z7.number().int().nonnegative(),
   requestId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   threadId: ContractIdentifierSchema.optional(),
-  eventType: z6.enum(["messages:append", "messages:update", "thread:update", "tool-call:upsert", "session:event"]),
+  eventType: z7.enum(["messages:append", "messages:update", "thread:update", "tool-call:upsert", "session:event"]),
   payload: JsonValueSchema,
   occurredAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/continuity.ts
-import { z as z7 } from "zod";
-var DataContinuityEnvelopeSchema = z7.object({
-  contract: z7.literal("DataContinuityEnvelope"),
+import { z as z8 } from "zod";
+var DataContinuityEnvelopeSchema = z8.object({
+  contract: z8.literal("DataContinuityEnvelope"),
   tenantId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   sourceRef: EntityRefSchema.optional(),
@@ -8104,28 +8139,28 @@ var DataContinuityEnvelopeSchema = z7.object({
   (value) => Boolean(value.sourceRef || value.bodyRef || value.runRef || value.outputRef || value.artifactRef),
   "At least one continuity ref is required."
 );
-var BodyRelationRecordSchema = z7.object({
-  contract: z7.literal("BodyRelationRecord"),
+var BodyRelationRecordSchema = z8.object({
+  contract: z8.literal("BodyRelationRecord"),
   relationId: ContractIdentifierSchema,
   relationKind: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   objectRef: EntityRefSchema,
   ownerRepo: ContractIdentifierSchema,
-  authorityScope: z7.enum(["tenant", "team", "global"]),
+  authorityScope: z8.enum(["tenant", "team", "global"]),
   properties: JsonObjectSchema.default({}),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 }).strict();
-var ApplicationRunSchema = z7.object({
-  contract: z7.literal("ApplicationRun"),
+var ApplicationRunSchema = z8.object({
+  contract: z8.literal("ApplicationRun"),
   runId: ContractIdentifierSchema,
   definitionRef: EntityRefSchema,
   runtimeLedgerRef: EntityRefSchema.optional(),
   requestId: ContractIdentifierSchema,
   actorRef: EntityRefSchema,
-  status: z7.enum(["PENDING", "RUNNING", "COMPLETED", "FAILED", "CANCELLED", "EXPIRED"]),
-  inputRefs: z7.array(EntityRefSchema).default([]),
-  outputRefs: z7.array(EntityRefSchema).default([]),
+  status: z8.enum(["PENDING", "RUNNING", "COMPLETED", "FAILED", "CANCELLED", "EXPIRED"]),
+  inputRefs: z8.array(EntityRefSchema).default([]),
+  outputRefs: z8.array(EntityRefSchema).default([]),
   startedAt: IsoDateTimeSchema.optional(),
   completedAt: IsoDateTimeSchema.optional(),
   expiresAt: IsoDateTimeSchema.optional(),
@@ -8167,77 +8202,77 @@ var ApplicationRunSchema = z7.object({
     });
   }
 });
-var ExpiringAccessGrantSchema = z7.object({
-  contract: z7.literal("ExpiringAccessGrant"),
+var ExpiringAccessGrantSchema = z8.object({
+  contract: z8.literal("ExpiringAccessGrant"),
   grantId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   resourceRef: EntityRefSchema,
-  permissions: z7.array(ContractIdentifierSchema).min(1),
+  permissions: z8.array(ContractIdentifierSchema).min(1),
   issuedAt: IsoDateTimeSchema,
   expiresAt: IsoDateTimeSchema,
   revokedAt: IsoDateTimeSchema.optional()
 }).strict().refine((value) => Date.parse(value.expiresAt) > Date.parse(value.issuedAt), "expiresAt must be after issuedAt");
 
 // src/contracts/data.ts
-import { z as z8 } from "zod";
-var SourceRecordRefSchema = z8.object({
+import { z as z9 } from "zod";
+var SourceRecordRefSchema = z9.object({
   sourceId: ContractIdentifierSchema,
   recordId: ContractIdentifierSchema,
-  recordVersion: z8.union([z8.number().int().nonnegative(), ContractIdentifierSchema]),
+  recordVersion: z9.union([z9.number().int().nonnegative(), ContractIdentifierSchema]),
   hash: Sha256Schema
 }).strict();
-var OntologyDefinitionSchema = z8.object({
-  contract: z8.literal("OntologyDefinition"),
+var OntologyDefinitionSchema = z9.object({
+  contract: z9.literal("OntologyDefinition"),
   ontologyId: ContractIdentifierSchema,
   dataSpaceId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
   bodySchemaRef: ContractIdentifierSchema,
-  authority: z8.object({
+  authority: z9.object({
     service: ContractIdentifierSchema,
     storage: ContractIdentifierSchema,
-    scope: z8.enum(["tenant", "team", "user", "global"])
+    scope: z9.enum(["tenant", "team", "user", "global"])
   }).strict(),
-  relationKinds: z8.array(ContractIdentifierSchema).default([]),
-  metricKinds: z8.array(ContractIdentifierSchema).default([])
+  relationKinds: z9.array(ContractIdentifierSchema).default([]),
+  metricKinds: z9.array(ContractIdentifierSchema).default([])
 }).strict();
-var ProjectionSpecSchema = z8.object({
-  contract: z8.literal("ProjectionSpec"),
+var ProjectionSpecSchema = z9.object({
+  contract: z9.literal("ProjectionSpec"),
   projectionId: ContractIdentifierSchema,
-  ontologyIds: z8.array(ContractIdentifierSchema).min(1),
+  ontologyIds: z9.array(ContractIdentifierSchema).min(1),
   outputSchemaRef: ContractIdentifierSchema,
-  operator: z8.object({
-    kind: z8.enum(["query", "aggregate", "relationship", "search", "custom"]),
-    configuration: z8.record(z8.string(), JsonValueSchema).default({})
+  operator: z9.object({
+    kind: z9.enum(["query", "aggregate", "relationship", "search", "custom"]),
+    configuration: z9.record(z9.string(), JsonValueSchema).default({})
   }).strict(),
-  materialization: z8.enum(["on-demand", "event-driven", "scheduled"]),
-  invalidationEvents: z8.array(ContractIdentifierSchema).default([]),
-  rebuildable: z8.literal(true),
-  lineagePolicy: z8.object({
-    sourceRecords: z8.boolean(),
-    bodyVersions: z8.boolean(),
-    runRefs: z8.boolean(),
-    actorRefs: z8.boolean()
+  materialization: z9.enum(["on-demand", "event-driven", "scheduled"]),
+  invalidationEvents: z9.array(ContractIdentifierSchema).default([]),
+  rebuildable: z9.literal(true),
+  lineagePolicy: z9.object({
+    sourceRecords: z9.boolean(),
+    bodyVersions: z9.boolean(),
+    runRefs: z9.boolean(),
+    actorRefs: z9.boolean()
   }).strict()
 }).strict();
-var LineageRecordSchema = z8.object({
-  contract: z8.literal("LineageRecord"),
+var LineageRecordSchema = z9.object({
+  contract: z9.literal("LineageRecord"),
   lineageId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
-  sourceRecords: z8.array(SourceRecordRefSchema).default([]),
-  bodyRefs: z8.array(EntityRefSchema).default([]),
-  runRefs: z8.array(EntityRefSchema).default([]),
-  outputRefs: z8.array(EntityRefSchema).default([]),
-  artifactRefs: z8.array(EntityRefSchema).default([]),
-  actorRefs: z8.array(EntityRefSchema).default([]),
-  evidenceRefs: z8.array(EntityRefSchema).default([]),
+  sourceRecords: z9.array(SourceRecordRefSchema).default([]),
+  bodyRefs: z9.array(EntityRefSchema).default([]),
+  runRefs: z9.array(EntityRefSchema).default([]),
+  outputRefs: z9.array(EntityRefSchema).default([]),
+  artifactRefs: z9.array(EntityRefSchema).default([]),
+  actorRefs: z9.array(EntityRefSchema).default([]),
+  evidenceRefs: z9.array(EntityRefSchema).default([]),
   recordedAt: IsoDateTimeSchema
 }).strict();
-var DomainEventSchema = z8.object({
-  contract: z8.literal("DomainEvent"),
+var DomainEventSchema = z9.object({
+  contract: z9.literal("DomainEvent"),
   eventId: ContractIdentifierSchema,
   eventType: ContractIdentifierSchema,
   aggregateRef: EntityRefSchema,
-  aggregateVersion: z8.number().int().nonnegative(),
+  aggregateVersion: z9.number().int().nonnegative(),
   requestId: ContractIdentifierSchema,
   actorRef: EntityRefSchema,
   payload: JsonValueSchema,
@@ -8245,11 +8280,11 @@ var DomainEventSchema = z8.object({
 }).strict();
 
 // src/contracts/menu.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/contracts/page.ts
-import { z as z9 } from "zod";
-var PageTypeSchema = z9.enum([
+import { z as z10 } from "zod";
+var PageTypeSchema = z10.enum([
   "page",
   "workspace",
   "view",
@@ -8270,14 +8305,14 @@ var PageTypeSchema = z9.enum([
   "global-design-board",
   "iframe"
 ]);
-var PageVisibilitySchema = z9.object({
-  authenticated: z9.boolean().default(true),
-  permissionAllOf: z9.array(ContractIdentifierSchema).default([]),
-  permissionAnyOf: z9.array(ContractIdentifierSchema).default([]),
-  featureFlags: z9.array(ContractIdentifierSchema).default([]),
-  productContexts: z9.array(z9.enum(["studio", "kernel", "compute"])).min(1)
-}).strict();
-var PageRoutePathSchema = z9.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative route path.");
+var PageVisibilitySchema = z10.object({
+  authenticated: z10.boolean().default(true),
+  permissionAllOf: z10.array(ContractIdentifierSchema).default([]),
+  permissionAnyOf: z10.array(ContractIdentifierSchema).default([]),
+  featureFlags: z10.array(ContractIdentifierSchema).default([]),
+  productContexts: z10.array(z10.enum(["studio", "kernel", "compute"])).min(1)
+}).strict();
+var PageRoutePathSchema = z10.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative route path.");
 var requireCapabilityReference = (reference, path, context) => {
   if (reference.kind !== "capability") {
     context.addIssue({
@@ -8301,53 +8336,53 @@ var requireCapabilityReference = (reference, path, context) => {
     });
   }
 };
-var PageDefinitionSchema = z9.object({
-  contract: z9.literal("PageDefinition"),
+var PageDefinitionSchema = z10.object({
+  contract: z10.literal("PageDefinition"),
   pageId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
   title: LocalizedTextSchema,
   pageType: PageTypeSchema,
-  ownership: z9.object({
+  ownership: z10.object({
     teamId: ContractIdentifierSchema.optional(),
     creatorRef: EntityRefSchema.optional(),
     studioId: ContractIdentifierSchema.optional(),
-    builtIn: z9.boolean()
+    builtIn: z10.boolean()
   }).strict(),
-  record: z9.object({
-    createdTimestamp: z9.number().int().nonnegative().optional(),
-    updatedTimestamp: z9.number().int().nonnegative().optional(),
-    deleted: z9.boolean().default(false)
+  record: z10.object({
+    createdTimestamp: z10.number().int().nonnegative().optional(),
+    updatedTimestamp: z10.number().int().nonnegative().optional(),
+    deleted: z10.boolean().default(false)
   }).strict(),
-  surface: z9.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
+  surface: z10.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
   routeId: ContractIdentifierSchema,
   routePath: PageRoutePathSchema,
   rendererKey: ContractIdentifierSchema,
   capabilityRef: EntityRefSchema,
-  capabilityRefs: z9.array(EntityRefSchema).default([]),
+  capabilityRefs: z10.array(EntityRefSchema).default([]),
   workflowRef: EntityRefSchema.optional(),
-  binding: z9.object({
+  binding: z10.object({
     sourceRef: ContractIdentifierSchema.optional(),
     ontologyId: ContractIdentifierSchema.optional(),
     projectionRef: ContractIdentifierSchema.optional(),
     stateRef: ContractIdentifierSchema.optional()
   }).strict(),
-  access: z9.object({
-    actions: z9.array(z9.enum(["read", "write", "execute", "manage-permissions"])).default([])
+  access: z10.object({
+    actions: z10.array(z10.enum(["read", "write", "execute", "manage-permissions"])).default([])
   }).strict(),
-  input: z9.object({
+  input: z10.object({
     schemaRef: ContractIdentifierSchema
   }).strict().optional(),
-  rendererConfig: z9.object({
+  rendererConfig: z10.object({
     schemaRef: ContractIdentifierSchema,
     value: JsonObjectSchema
   }).strict(),
-  navigation: z9.object({
+  navigation: z10.object({
     label: LocalizedTextSchema,
     iconRef: ContractIdentifierSchema.optional(),
     parentPageId: ContractIdentifierSchema.optional(),
-    order: z9.number().int().optional(),
-    hidden: z9.boolean().default(false),
-    pinned: z9.boolean().default(false)
+    order: z10.number().int().optional(),
+    hidden: z10.boolean().default(false),
+    pinned: z10.boolean().default(false)
   }).strict(),
   visibility: PageVisibilitySchema
 }).strict().superRefine((page, context) => {
@@ -8368,8 +8403,8 @@ var PageDefinitionSchema = z9.object({
   });
   if (page.workflowRef && page.workflowRef.kind !== "workflow") context.addIssue({ code: "custom", path: ["workflowRef", "kind"], message: "workflowRef must reference a workflow." });
 });
-var PageRuntimeDescriptorSchema = z9.object({
-  contract: z9.literal("PageRuntimeDescriptor"),
+var PageRuntimeDescriptorSchema = z10.object({
+  contract: z10.literal("PageRuntimeDescriptor"),
   page: PageDefinitionSchema,
   nodeId: ContractIdentifierSchema,
   parentNodeId: ContractIdentifierSchema.optional(),
@@ -8377,54 +8412,54 @@ var PageRuntimeDescriptorSchema = z9.object({
   semanticRef: ContractIdentifierSchema.optional(),
   dataContextRef: ContractIdentifierSchema.optional(),
   providerRef: EntityRefSchema.optional(),
-  surface: z9.object({
+  surface: z10.object({
     frameOwner: ContractIdentifierSchema,
     tone: ContractIdentifierSchema.optional(),
-    density: z9.enum(["compact", "default", "comfortable"]).default("default")
+    density: z10.enum(["compact", "default", "comfortable"]).default("default")
   }).strict(),
-  scroll: z9.object({
-    owner: z9.enum(["page", "surface", "provider"]),
-    axis: z9.enum(["x", "y", "both", "none"]),
+  scroll: z10.object({
+    owner: z10.enum(["page", "surface", "provider"]),
+    axis: z10.enum(["x", "y", "both", "none"]),
     restoreKey: ContractIdentifierSchema.optional(),
-    virtualized: z9.boolean().default(false)
+    virtualized: z10.boolean().default(false)
   }).strict(),
-  activation: z9.enum(["navigate", "select", "drawer", "modal", "fullscreen"]),
-  lifecycle: z9.object({
-    mountPolicy: z9.enum(["always", "when-visible", "when-active"]),
-    queryPolicy: z9.enum(["always", "when-visible", "when-active", "manual"]),
-    deepLink: z9.boolean(),
-    focusReturn: z9.boolean()
+  activation: z10.enum(["navigate", "select", "drawer", "modal", "fullscreen"]),
+  lifecycle: z10.object({
+    mountPolicy: z10.enum(["always", "when-visible", "when-active"]),
+    queryPolicy: z10.enum(["always", "when-visible", "when-active", "manual"]),
+    deepLink: z10.boolean(),
+    focusReturn: z10.boolean()
   }).strict()
 }).strict();
-var PageRouteProjectionSchema = z9.object({
+var PageRouteProjectionSchema = z10.object({
   pageId: ContractIdentifierSchema,
   routeId: ContractIdentifierSchema,
   path: PageRoutePathSchema
 }).strict();
-var PageNavigationProjectionSchema = z9.object({
+var PageNavigationProjectionSchema = z10.object({
   pageId: ContractIdentifierSchema,
   routeId: ContractIdentifierSchema,
   path: PageRoutePathSchema,
   label: LocalizedTextSchema,
   iconRef: ContractIdentifierSchema.optional(),
   parentPageId: ContractIdentifierSchema.optional(),
-  order: z9.number().int().optional(),
-  pinned: z9.boolean()
+  order: z10.number().int().optional(),
+  pinned: z10.boolean()
 }).strict();
-var PageGuardProjectionSchema = z9.object({
+var PageGuardProjectionSchema = z10.object({
   pageId: ContractIdentifierSchema,
-  authenticated: z9.boolean(),
-  permissionAllOf: z9.array(ContractIdentifierSchema),
-  permissionAnyOf: z9.array(ContractIdentifierSchema),
-  featureFlags: z9.array(ContractIdentifierSchema),
-  actions: z9.array(z9.enum(["read", "write", "execute", "manage-permissions"]))
+  authenticated: z10.boolean(),
+  permissionAllOf: z10.array(ContractIdentifierSchema),
+  permissionAnyOf: z10.array(ContractIdentifierSchema),
+  featureFlags: z10.array(ContractIdentifierSchema),
+  actions: z10.array(z10.enum(["read", "write", "execute", "manage-permissions"]))
 }).strict();
-var PageRendererProjectionSchema = z9.object({
+var PageRendererProjectionSchema = z10.object({
   pageId: ContractIdentifierSchema,
-  surface: z9.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
+  surface: z10.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
   rendererKey: ContractIdentifierSchema,
   capabilityRef: EntityRefSchema,
-  capabilityRefs: z9.array(EntityRefSchema),
+  capabilityRefs: z10.array(EntityRefSchema),
   providerRef: EntityRefSchema,
   binding: PageDefinitionSchema.shape.binding,
   rendererConfig: PageDefinitionSchema.shape.rendererConfig,
@@ -8465,13 +8500,13 @@ var duplicateProjectionIdentity = (values, identity) => {
   }
   return void 0;
 };
-var PageRuntimeProjectionSchema = z9.object({
-  contract: z9.literal("PageRuntimeProjection"),
-  product: z9.enum(["studio", "kernel", "compute"]),
-  routes: z9.array(PageRouteProjectionSchema),
-  navigation: z9.array(PageNavigationProjectionSchema),
-  guards: z9.array(PageGuardProjectionSchema),
-  renderers: z9.array(PageRendererProjectionSchema)
+var PageRuntimeProjectionSchema = z10.object({
+  contract: z10.literal("PageRuntimeProjection"),
+  product: z10.enum(["studio", "kernel", "compute"]),
+  routes: z10.array(PageRouteProjectionSchema),
+  navigation: z10.array(PageNavigationProjectionSchema),
+  guards: z10.array(PageGuardProjectionSchema),
+  renderers: z10.array(PageRendererProjectionSchema)
 }).strict().superRefine((projection, context) => {
   const tables = [
     ["routes", projection.routes.map((value) => value.pageId)],
@@ -8533,7 +8568,7 @@ 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 MenuOrderSchema = z11.number().int().min(-1e6).max(1e6);
 var inspectJsonValue = (value) => {
   let maxDepth = 0;
   let values = 0;
@@ -8576,30 +8611,30 @@ var MenuBoundedInputSchema = JsonObjectSchema.superRefine((value, context) => {
     });
   }
 });
-var MenuPageRefSchema = z10.object({
+var MenuPageRefSchema = z11.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 MenuSourceInputBindingSchema = z11.discriminatedUnion("exposure", [
+  z11.object({ exposure: z11.literal("client"), value: MenuBoundedInputSchema }).strict(),
+  z11.object({ exposure: z11.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 MenuRuntimeInputBindingSchema = z11.discriminatedUnion("exposure", [
+  z11.object({ exposure: z11.literal("client"), value: MenuBoundedInputSchema }).strict(),
+  z11.object({ exposure: z11.literal("server") }).strict()
 ]);
-var MenuNavigateBehaviorSchema = z10.object({
-  kind: z10.literal("navigate"),
+var MenuNavigateBehaviorSchema = z11.object({
+  kind: z11.literal("navigate"),
   page: MenuPageRefSchema,
   activationId: ContractIdentifierSchema.optional(),
   input: MenuSourceInputBindingSchema.optional()
 }).strict();
-var MenuActionBehaviorSchema = z10.object({
-  kind: z10.literal("action"),
+var MenuActionBehaviorSchema = z11.object({
+  kind: z11.literal("action"),
   actionRef: ContractIdentifierSchema,
   input: MenuBoundedInputSchema.optional()
 }).strict();
-var MenuBehaviorSchema = z10.discriminatedUnion("kind", [
+var MenuBehaviorSchema = z11.discriminatedUnion("kind", [
   MenuNavigateBehaviorSchema,
   MenuActionBehaviorSchema
 ]);
@@ -8608,33 +8643,33 @@ var MenuNodeBaseShape = {
   parentNodeId: ContractIdentifierSchema.optional(),
   order: MenuOrderSchema
 };
-var MenuGroupNodeSchema = z10.object({
+var MenuGroupNodeSchema = z11.object({
   ...MenuNodeBaseShape,
-  kind: z10.literal("group"),
+  kind: z11.literal("group"),
   label: LocalizedTextSchema.optional(),
   iconRef: ContractIdentifierSchema.optional(),
-  disabled: z10.boolean().optional()
+  disabled: z11.boolean().optional()
 }).strict();
-var MenuDividerNodeSchema = z10.object({
+var MenuDividerNodeSchema = z11.object({
   ...MenuNodeBaseShape,
-  kind: z10.literal("divider")
+  kind: z11.literal("divider")
 }).strict();
-var MenuItemNodeSchema = z10.object({
+var MenuItemNodeSchema = z11.object({
   ...MenuNodeBaseShape,
-  kind: z10.literal("item"),
+  kind: z11.literal("item"),
   label: LocalizedTextSchema,
   iconRef: ContractIdentifierSchema.optional(),
-  tone: z10.enum(["default", "danger"]).optional(),
-  disabled: z10.boolean().optional(),
+  tone: z11.enum(["default", "danger"]).optional(),
+  disabled: z11.boolean().optional(),
   requiredPermission: ContractIdentifierSchema.optional(),
   behavior: MenuBehaviorSchema
 }).strict();
-var MenuNodeSchema = z10.discriminatedUnion("kind", [
+var MenuNodeSchema = z11.discriminatedUnion("kind", [
   MenuGroupNodeSchema,
   MenuDividerNodeSchema,
   MenuItemNodeSchema
 ]);
-var MenuContributionSchema = z10.object({
+var MenuContributionSchema = z11.object({
   providerId: ContractIdentifierSchema,
   parentNodeId: ContractIdentifierSchema.optional(),
   order: MenuOrderSchema
@@ -8704,55 +8739,55 @@ var validateMenuStructure = (menu, context) => {
     contributionKeys.add(key);
   });
 };
-var MenuDefinitionSchema = z10.object({
-  contract: z10.literal("MenuDefinition"),
-  version: z10.literal(MENU_CONTRACT_VERSION),
+var MenuDefinitionSchema = z11.object({
+  contract: z11.literal("MenuDefinition"),
+  version: z11.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([])
+  nodes: z11.array(MenuNodeSchema).max(MENU_MAX_NODES),
+  contributions: z11.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)
+var MenuDefinitionSetSchema = z11.union([
+  z11.literal("*"),
+  z11.object({
+    version: z11.literal(MENU_CONTRACT_VERSION),
+    definitions: z11.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([])
+var MenuAccessRequirementSchema = z11.object({
+  authenticated: z11.boolean().default(true),
+  permissionAllOf: z11.array(ContractIdentifierSchema).default([]),
+  permissionAnyOf: z11.array(ContractIdentifierSchema).default([]),
+  featureFlags: z11.array(ContractIdentifierSchema).default([])
 }).strict();
-var MenuPageRegistrationSchema = z10.object({
+var MenuPageRegistrationSchema = z11.object({
   applicationId: ContractIdentifierSchema,
   page: PageDefinitionSchema
 }).strict();
-var MenuActionRegistrationSchema = z10.object({
+var MenuActionRegistrationSchema = z11.object({
   applicationId: ContractIdentifierSchema,
   actionRef: ContractIdentifierSchema,
   inputSchemaRef: ContractIdentifierSchema.optional(),
   access: MenuAccessRequirementSchema
 }).strict();
-var MenuContributionProviderRegistrationSchema = z10.object({
+var MenuContributionProviderRegistrationSchema = z11.object({
   applicationId: ContractIdentifierSchema,
   providerId: ContractIdentifierSchema,
-  surfaces: z10.array(ContractIdentifierSchema).min(1).optional()
+  surfaces: z11.array(ContractIdentifierSchema).min(1).optional()
 }).strict();
-var CompiledMenuNavigateBehaviorSchema = z10.object({
-  kind: z10.literal("navigate"),
+var CompiledMenuNavigateBehaviorSchema = z11.object({
+  kind: z11.literal("navigate"),
   page: MenuPageRefSchema,
   activationId: ContractIdentifierSchema,
   input: MenuRuntimeInputBindingSchema.optional()
 }).strict();
-var CompiledMenuActionBehaviorSchema = z10.object({
-  kind: z10.literal("action"),
+var CompiledMenuActionBehaviorSchema = z11.object({
+  kind: z11.literal("action"),
   actionRef: ContractIdentifierSchema,
   input: MenuBoundedInputSchema.optional()
 }).strict();
-var CompiledMenuBehaviorSchema = z10.discriminatedUnion("kind", [
+var CompiledMenuBehaviorSchema = z11.discriminatedUnion("kind", [
   CompiledMenuNavigateBehaviorSchema,
   CompiledMenuActionBehaviorSchema
 ]);
@@ -8765,76 +8800,76 @@ var CompiledMenuItemNodeSchema = MenuItemNodeSchema.omit({ behavior: true, requi
   behavior: CompiledMenuBehaviorSchema,
   access: CompiledMenuItemAccessSchema
 }).strict();
-var CompiledMenuNodeSchema = z10.discriminatedUnion("kind", [
+var CompiledMenuNodeSchema = z11.discriminatedUnion("kind", [
   CompiledMenuGroupNodeSchema,
   CompiledMenuDividerNodeSchema,
   CompiledMenuItemNodeSchema
 ]);
-var CompiledMenuProjectionSchema = z10.object({
+var CompiledMenuProjectionSchema = z11.object({
   applicationId: ContractIdentifierSchema,
   surface: ContractIdentifierSchema,
   menuId: ContractIdentifierSchema,
-  nodes: z10.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES),
-  contributions: z10.array(MenuContributionSchema).max(MENU_MAX_NODES)
+  nodes: z11.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES),
+  contributions: z11.array(MenuContributionSchema).max(MENU_MAX_NODES)
 }).strict();
-var MenuNavigationTargetSchema = z10.object({
+var MenuNavigationTargetSchema = z11.object({
   page: MenuPageRefSchema,
   activationId: ContractIdentifierSchema,
   input: MenuRuntimeInputBindingSchema.optional()
 }).strict();
-var MenuRuntimeBundleSchema = z10.object({
-  contract: z10.literal("MenuRuntimeBundle"),
-  version: z10.literal(MENU_CONTRACT_VERSION),
+var MenuRuntimeBundleSchema = z11.object({
+  contract: z11.literal("MenuRuntimeBundle"),
+  version: z11.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({})
+  menus: z11.array(CompiledMenuProjectionSchema).max(MENU_MAX_DEFINITIONS),
+  navigationTargets: z11.array(MenuNavigationTargetSchema),
+  sourceMap: z11.record(z11.string(), ContractIdentifierSchema).default({})
 }).strict();
-var MenuContributionResultSchema = z10.object({
-  contract: z10.literal("MenuContributionResult"),
+var MenuContributionResultSchema = z11.object({
+  contract: z11.literal("MenuContributionResult"),
   applicationId: ContractIdentifierSchema,
   surface: ContractIdentifierSchema,
   menuId: ContractIdentifierSchema,
   providerId: ContractIdentifierSchema,
-  nodes: z10.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES)
+  nodes: z11.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES)
 }).strict();
 
 // src/contracts/semantic.ts
-import { z as z11 } from "zod";
-var ConceptRelationshipSchema = z11.object({
+import { z as z12 } from "zod";
+var ConceptRelationshipSchema = z12.object({
   kind: ContractIdentifierSchema,
   targetConceptId: ContractIdentifierSchema,
-  cardinality: z11.enum(["one", "optional", "many"])
+  cardinality: z12.enum(["one", "optional", "many"])
 }).strict();
-var ConceptDefinitionSchema = z11.object({
-  contract: z11.literal("ConceptDefinition"),
+var ConceptDefinitionSchema = z12.object({
+  contract: z12.literal("ConceptDefinition"),
   conceptId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z11.string().trim().min(1),
-  description: z11.string().optional(),
+  displayName: z12.string().trim().min(1),
+  description: z12.string().optional(),
   schemaRef: ContractIdentifierSchema,
   ontologyId: ContractIdentifierSchema.optional(),
-  capabilityIds: z11.array(ContractIdentifierSchema).default([]),
-  commandNames: z11.array(ContractIdentifierSchema).default([]),
-  relationships: z11.array(ConceptRelationshipSchema).default([])
+  capabilityIds: z12.array(ContractIdentifierSchema).default([]),
+  commandNames: z12.array(ContractIdentifierSchema).default([]),
+  relationships: z12.array(ConceptRelationshipSchema).default([])
 }).strict();
-var DomainCommandDefinitionSchema = z11.object({
-  contract: z11.literal("DomainCommandDefinition"),
+var DomainCommandDefinitionSchema = z12.object({
+  contract: z12.literal("DomainCommandDefinition"),
   commandName: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z11.string().trim().min(1),
-  description: z11.string().optional(),
-  targetKinds: z11.array(ContractIdentifierSchema).min(1),
+  displayName: z12.string().trim().min(1),
+  description: z12.string().optional(),
+  targetKinds: z12.array(ContractIdentifierSchema).min(1),
   inputSchemaRef: ContractIdentifierSchema,
   outputSchemaRef: ContractIdentifierSchema.optional(),
-  requiredPermissionCodes: z11.array(ContractIdentifierSchema).default([]),
+  requiredPermissionCodes: z12.array(ContractIdentifierSchema).default([]),
   handlerRef: EntityRefSchema,
-  sideEffects: z11.array(z11.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
+  sideEffects: z12.array(z12.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
 }).strict();
-var DomainCommandSchema = z11.object({
-  contract: z11.literal("DomainCommand"),
+var DomainCommandSchema = z12.object({
+  contract: z12.literal("DomainCommand"),
   commandId: ContractIdentifierSchema,
   commandName: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
@@ -8842,30 +8877,30 @@ var DomainCommandSchema = z11.object({
   idempotencyKey: ContractIdentifierSchema,
   targetRef: EntityRefSchema,
   actorRef: EntityRefSchema,
-  source: z11.object({
-    product: z11.enum(["studio", "kernel", "compute", "agent", "mcp", "service"]),
+  source: z12.object({
+    product: z12.enum(["studio", "kernel", "compute", "agent", "mcp", "service"]),
     pageId: ContractIdentifierSchema.optional(),
     capabilityId: ContractIdentifierSchema.optional()
   }).strict(),
   payload: JsonObjectSchema,
   issuedAt: IsoDateTimeSchema
 }).strict();
-var ProductDeclarationSchema = z11.object({
-  contract: z11.literal("ProductDeclaration"),
+var ProductDeclarationSchema = z12.object({
+  contract: z12.literal("ProductDeclaration"),
   declarationId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  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({
+  concepts: z12.array(ConceptDefinitionSchema).default([]),
+  ontologies: z12.array(OntologyDefinitionSchema).default([]),
+  projections: z12.array(ProjectionSpecSchema).default([]),
+  commands: z12.array(DomainCommandDefinitionSchema).default([]),
+  capabilities: z12.array(CapabilityManifestSchema).default([]),
+  pages: z12.array(PageDefinitionSchema).default([]),
+  menus: z12.array(MenuDefinitionSchema).default([])
+}).strict();
+var DeclarationGraphEdgeSchema = z12.object({
   from: EntityRefSchema,
   to: EntityRefSchema,
-  relation: z11.enum([
+  relation: z12.enum([
     "uses-ontology",
     "uses-projection",
     "uses-capability",
@@ -8873,25 +8908,25 @@ var DeclarationGraphEdgeSchema = z11.object({
     "relates-to-concept"
   ])
 }).strict();
-var ChangeImpactSchema = z11.object({
+var ChangeImpactSchema = z12.object({
   changedRef: EntityRefSchema,
-  affectedRefs: z11.array(EntityRefSchema),
-  reasons: z11.array(ContractIdentifierSchema).min(1)
+  affectedRefs: z12.array(EntityRefSchema),
+  reasons: z12.array(ContractIdentifierSchema).min(1)
 }).strict();
-var ChangeImpactGraphSchema = z11.object({
-  contract: z11.literal("ChangeImpactGraph"),
+var ChangeImpactGraphSchema = z12.object({
+  contract: z12.literal("ChangeImpactGraph"),
   declarationId: ContractIdentifierSchema,
-  nodes: z11.array(EntityRefSchema),
-  edges: z11.array(DeclarationGraphEdgeSchema),
-  impacts: z11.array(ChangeImpactSchema),
+  nodes: z12.array(EntityRefSchema),
+  edges: z12.array(DeclarationGraphEdgeSchema),
+  impacts: z12.array(ChangeImpactSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/tenant.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/contracts/theme.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/theme-tokens/core.ts
 var import_ajv = __toESM(require_ajv());
@@ -11085,20 +11120,20 @@ var MONKEYS_REQUIRED_THEME_TOKEN_PATHS = Object.freeze({
 });
 
 // src/contracts/theme.ts
-var ThemeTokenTypeSchema = z12.enum(THEME_TOKEN_TYPES);
-var ThemeTokenSchema = z12.record(z12.string(), z12.unknown()).superRefine((input, context) => {
+var ThemeTokenTypeSchema = z13.enum(THEME_TOKEN_TYPES);
+var ThemeTokenSchema = z13.record(z13.string(), z13.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 = z12.record(z12.string(), z12.unknown()).superRefine((input, context) => {
+var ThemeTokenGroupSchema = z13.record(z13.string(), z13.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocumentStructure(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
   }
 });
-var ThemeTokensSchema = z12.record(z12.string(), z12.unknown()).superRefine((input, context) => {
+var ThemeTokensSchema = z13.record(z13.string(), z13.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocument(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
@@ -11125,9 +11160,9 @@ var ResolvedThemeTokensSchema = ThemeTokensSchema.superRefine((input, context) =
 });
 
 // src/contracts/tenant.ts
-var DesignTokenFileSourceSchema = z13.object({
-  type: z13.literal("file"),
-  path: z13.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenFileSourceSchema = z14.object({
+  type: z14.literal("file"),
+  path: z14.string().trim().min(1).superRefine((source, context) => {
     if (/^[a-z][a-z\d+.-]*:/i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -11136,9 +11171,9 @@ var DesignTokenFileSourceSchema = z13.object({
     }
   })
 }).strict();
-var DesignTokenUrlSourceSchema = z13.object({
-  type: z13.literal("url"),
-  url: z13.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenUrlSourceSchema = z14.object({
+  type: z14.literal("url"),
+  url: z14.string().trim().min(1).superRefine((source, context) => {
     if (!/^https?:\/\//i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -11147,99 +11182,99 @@ var DesignTokenUrlSourceSchema = z13.object({
     }
   })
 }).strict();
-var DesignTokenInlineSourceSchema = z13.object({
-  type: z13.literal("inline"),
+var DesignTokenInlineSourceSchema = z14.object({
+  type: z14.literal("inline"),
   document: ThemeTokensSchema
 }).strict();
-var DesignTokenSourceSchema = z13.discriminatedUnion("type", [
+var DesignTokenSourceSchema = z14.discriminatedUnion("type", [
   DesignTokenFileSourceSchema,
   DesignTokenUrlSourceSchema,
   DesignTokenInlineSourceSchema
 ]);
-var TenantDesignTokensConfigSchema = z13.object({
+var TenantDesignTokensConfigSchema = z14.object({
   /** Ordered tenant overrides. The backend always applies the product default first. */
-  tokenSources: z13.array(DesignTokenSourceSchema)
+  tokenSources: z14.array(DesignTokenSourceSchema)
 }).strict();
-var TenantAuthBindingSchema = z13.object({
-  kind: z13.literal("auth-provider"),
+var TenantAuthBindingSchema = z14.object({
+  kind: z14.literal("auth-provider"),
   providerId: ContractIdentifierSchema,
   policyRef: ContractIdentifierSchema.optional()
 }).strict();
-var TenantDataBindingSchema = z13.discriminatedUnion("kind", [
-  z13.object({
-    kind: z13.literal("data-provider"),
+var TenantDataBindingSchema = z14.discriminatedUnion("kind", [
+  z14.object({
+    kind: z14.literal("data-provider"),
     providerId: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict(),
-  z13.object({
-    kind: z13.literal("projection"),
+  z14.object({
+    kind: z14.literal("projection"),
     projectionRef: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict()
 ]);
-var TenantAuthBindingsSchema = z13.record(
+var TenantAuthBindingsSchema = z14.record(
   ContractIdentifierSchema,
   TenantAuthBindingSchema
 );
-var TenantDataBindingsSchema = z13.record(
+var TenantDataBindingsSchema = z14.record(
   ContractIdentifierSchema,
   TenantDataBindingSchema
 );
-var TenantTrendRadarSourceSchema = z13.object({
+var TenantTrendRadarSourceSchema = z14.object({
   ontologyId: ContractIdentifierSchema,
   viewId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarCollectionTargetSchema = z13.object({
+var TenantTrendRadarCollectionTargetSchema = z14.object({
   ontologyId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarSourcesSchema = z13.object({
+var TenantTrendRadarSourcesSchema = z14.object({
   products: TenantTrendRadarSourceSchema.optional(),
   hotwords: TenantTrendRadarSourceSchema.optional(),
   brands: TenantTrendRadarSourceSchema.optional(),
   collection: TenantTrendRadarCollectionTargetSchema.optional()
 }).strict();
-var AssetVariantsSchema = z13.object({
-  light: z13.string().optional(),
-  dark: z13.string().optional()
+var AssetVariantsSchema = z14.object({
+  light: z14.string().optional(),
+  dark: z14.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 CurrentUserMenuIdentifierSchema = z14.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/, "Expected a stable current-user menu identifier.");
+var CurrentUserMenuDisplayTextSchema = z14.union([
+  z14.string().trim().min(1),
+  z14.record(z14.string().trim().min(1), z14.string().trim().min(1)).refine((value) => Object.keys(value).length > 0, "Localized menu text must contain at least one locale.")
 ]);
-var CurrentUserMenuNavigationItemSchema = z13.object({
+var CurrentUserMenuNavigationItemSchema = z14.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z13.literal("navigation"),
+  kind: z14.literal("navigation"),
   ref: CurrentUserMenuIdentifierSchema
 }).strict();
-var CurrentUserMenuControlItemSchema = z13.object({
+var CurrentUserMenuControlItemSchema = z14.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z13.literal("control"),
-  ref: z13.enum(CURRENT_USER_MENU_CONTROL_REFS)
+  kind: z14.literal("control"),
+  ref: z14.enum(CURRENT_USER_MENU_CONTROL_REFS)
 }).strict();
-var CurrentUserMenuActionItemSchema = z13.object({
+var CurrentUserMenuActionItemSchema = z14.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z13.literal("action"),
-  ref: z13.enum(CURRENT_USER_MENU_ACTION_REFS),
-  tone: z13.enum(["default", "danger"]).optional()
+  kind: z14.literal("action"),
+  ref: z14.enum(CURRENT_USER_MENU_ACTION_REFS),
+  tone: z14.enum(["default", "danger"]).optional()
 }).strict();
-var CurrentUserMenuItemSchema = z13.discriminatedUnion("kind", [
+var CurrentUserMenuItemSchema = z14.discriminatedUnion("kind", [
   CurrentUserMenuNavigationItemSchema,
   CurrentUserMenuControlItemSchema,
   CurrentUserMenuActionItemSchema
 ]);
-var CurrentUserMenuSectionSchema = z13.object({
+var CurrentUserMenuSectionSchema = z14.object({
   id: CurrentUserMenuIdentifierSchema,
   label: CurrentUserMenuDisplayTextSchema.optional(),
-  dividerBefore: z13.boolean().optional(),
-  items: z13.array(CurrentUserMenuItemSchema)
+  dividerBefore: z14.boolean().optional(),
+  items: z14.array(CurrentUserMenuItemSchema)
 }).strict();
-var CurrentUserMenuConfigSchema = z13.object({
-  version: z13.literal(1),
-  sections: z13.array(CurrentUserMenuSectionSchema).max(20)
+var CurrentUserMenuConfigSchema = z14.object({
+  version: z14.literal(1),
+  sections: z14.array(CurrentUserMenuSectionSchema).max(20)
 }).strict().superRefine((value, context) => {
   const sectionIds = /* @__PURE__ */ new Set();
   const itemIds = /* @__PURE__ */ new Set();
@@ -11273,7 +11308,7 @@ var CurrentUserMenuConfigSchema = z13.object({
     });
   }
 });
-var LegacyCurrentUserMenuProfileSchema = z13.array(z13.enum(LEGACY_CURRENT_USER_MENU_ITEM_IDS)).superRefine((value, context) => {
+var LegacyCurrentUserMenuProfileSchema = z14.array(z14.enum(LEGACY_CURRENT_USER_MENU_ITEM_IDS)).superRefine((value, context) => {
   const seen = /* @__PURE__ */ new Set();
   value.forEach((item, index) => {
     if (seen.has(item)) {
@@ -11286,73 +11321,73 @@ var LegacyCurrentUserMenuProfileSchema = z13.array(z13.enum(LEGACY_CURRENT_USER_
     seen.add(item);
   });
 });
-var CurrentUserMenuProfileSchema = z13.union([
-  z13.literal("*"),
+var CurrentUserMenuProfileSchema = z14.union([
+  z14.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(),
+var ThemeHeadbarSchema = z14.object({
+  theme: z14.enum(["card", "glassy", "ghost"]).optional(),
+  navPosition: z14.enum(["left", "center", "right"]).optional(),
+  actions: z14.union([z14.literal("*"), z14.array(ContractIdentifierSchema)]).optional(),
   profile: CurrentUserMenuProfileSchema.optional(),
-  showTeamQuota: z13.boolean().optional()
+  showTeamQuota: z14.boolean().optional()
 }).strict();
-var TenantHeadbarModuleLeafSchema = z13.object({
+var TenantHeadbarModuleLeafSchema = z14.object({
   id: ContractIdentifierSchema,
-  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()
+  extraInfo: z14.boolean().optional(),
+  displayName: z14.union([z14.string(), z14.record(LocaleIdentifierSchema, z14.string())]).optional(),
+  visible: z14.boolean().optional(),
+  disabled: z14.boolean().optional(),
+  icon: z14.string().optional(),
+  showQuickSwitcher: z14.boolean().optional(),
+  showSidebar: z14.boolean().optional(),
+  showContentFrame: z14.boolean().optional()
 }).strict();
 var TenantHeadbarModuleItemSchema = TenantHeadbarModuleLeafSchema.extend({
-  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({
+  children: z14.array(TenantHeadbarModuleLeafSchema).optional()
+}).strict();
+var KernelHeadbarSchema = z14.object({
+  theme: z14.literal("card").optional(),
+  layoutMode: z14.enum(["boxed", "full-bleed"]).optional(),
+  heightPx: z14.number().positive().optional(),
+  navPosition: z14.enum(["left", "center", "right"]).optional(),
+  brandTitle: z14.string().optional(),
+  menuRadius: z14.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
+}).strict();
+var CustomIconSchema = z14.object({
+  color: z14.string().optional(),
+  url: z14.string().optional(),
+  type: z14.enum(["svg", "image"]).optional(),
+  hintTextColor: z14.string().optional()
+}).strict();
+var WorkbenchCustomerToolSchema = z14.object({
   id: ContractIdentifierSchema,
-  label: z13.union([z13.string(), z13.record(LocaleIdentifierSchema, z13.string())]).optional(),
-  fixed: z13.boolean().optional()
+  label: z14.union([z14.string(), z14.record(LocaleIdentifierSchema, z14.string())]).optional(),
+  fixed: z14.boolean().optional()
 }).strict();
-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()
+var WorkbenchStudioOverrideSchema = z14.object({
+  studioName: z14.string().trim().min(1),
+  dropdownToolsDefault: z14.array(ContractIdentifierSchema).optional(),
+  existingToolsDefault: z14.array(ContractIdentifierSchema).optional(),
+  historyColumnsDefault: z14.number().int().min(1).max(6).optional()
 }).strict();
-var TenantWorkbenchPageContextSchema = z13.object({
+var TenantWorkbenchPageContextSchema = z14.object({
   workflow: JsonObjectSchema.optional(),
   agent: JsonObjectSchema.optional(),
   agentId: ContractIdentifierSchema.optional(),
   designProject: JsonObjectSchema.optional(),
   designMetadataId: ContractIdentifierSchema.optional(),
-  iframeUrl: z13.string().trim().min(1).optional(),
-  info: z13.object({
+  iframeUrl: z14.string().trim().min(1).optional(),
+  info: z14.object({
     displayName: LocalizedTextSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    iconUrl: z13.string().trim().min(1).optional()
+    iconUrl: z14.string().trim().min(1).optional()
   }).strict().optional(),
-  isBuiltinPinned: z13.boolean().optional(),
-  isBuiltinReadonly: z13.boolean().optional()
+  isBuiltinPinned: z14.boolean().optional(),
+  isBuiltinReadonly: z14.boolean().optional()
 }).strict();
-var TenantWorkbenchPageEnvelopeSchema = z13.object({
+var TenantWorkbenchPageEnvelopeSchema = z14.object({
   definition: PageDefinitionSchema,
   context: TenantWorkbenchPageContextSchema
 }).strict().superRefine(({ definition }, context) => {
@@ -11385,56 +11420,56 @@ var TenantWorkbenchPageEnvelopeSchema = z13.object({
     });
   }
 });
-var TenantWorkbenchPageGroupSchema = z13.object({
+var TenantWorkbenchPageGroupSchema = z14.object({
   id: ContractIdentifierSchema,
-  pageIds: z13.array(ContractIdentifierSchema),
+  pageIds: z14.array(ContractIdentifierSchema),
   displayName: LocalizedTextSchema,
-  isBuiltIn: z13.boolean(),
-  iconUrl: z13.string().optional(),
-  sortIndex: z13.number().int().nullable().optional(),
+  isBuiltIn: z14.boolean(),
+  iconUrl: z14.string().optional(),
+  sortIndex: z14.number().int().nullable().optional(),
   presetRelationId: ContractIdentifierSchema.optional(),
   relationKey: ContractIdentifierSchema.nullable().optional(),
   studioId: ContractIdentifierSchema.optional()
 }).strict();
-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))
+var TenantWorkbenchConfigSchema = z14.object({
+  pages: z14.array(TenantWorkbenchPageEnvelopeSchema),
+  pageGroups: z14.array(TenantWorkbenchPageGroupSchema),
+  catalog: z14.object({ enabled: z14.boolean().optional(), defaultEntry: z14.boolean().optional() }).strict().optional(),
+  quickSwitcherMaxItems: z14.number().int().nonnegative().optional(),
+  defaultOrder: z14.object({
+    groups: z14.array(ContractIdentifierSchema),
+    pages: z14.record(ContractIdentifierSchema, z14.array(ContractIdentifierSchema))
   }).strict().optional(),
-  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({
+  customers: z14.object({
+    dropdownToolsDefault: z14.array(ContractIdentifierSchema).optional(),
+    layoutManagerTools: z14.array(WorkbenchCustomerToolSchema).optional(),
+    studioTabsMode: z14.enum(["dropdown", "tabs"]).optional(),
+    historyWatermark: z14.object({
+      svgUrl: z14.string().optional(),
+      coverage: z14.array(z14.enum(["list", "detail", "download"])).optional(),
+      maxLongEdgeRatio: z14.number().positive().optional(),
+      sizing: z14.object({
         mode: ContractIdentifierSchema,
-        heightRatio: z13.number().positive().optional(),
-        minHeightPx: z13.number().nonnegative().optional(),
-        maxHeightPx: z13.number().nonnegative().optional()
+        heightRatio: z14.number().positive().optional(),
+        minHeightPx: z14.number().nonnegative().optional(),
+        maxHeightPx: z14.number().nonnegative().optional()
       }).strict().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()
+      enhance: z14.object({
+        enabled: z14.boolean().optional(),
+        backgroundLumaThreshold: z14.number().min(0).max(1).optional(),
+        stroke: z14.object({
+          color: z14.string().optional(),
+          opacity: z14.number().min(0).max(1).optional(),
+          widthRatio: z14.number().nonnegative().optional(),
+          blurRatio: z14.number().nonnegative().optional(),
+          steps: z14.number().int().positive().optional()
         }).strict().optional()
       }).strict().optional()
     }).strict().optional(),
-    layoutManagerEnabled: z13.boolean().optional(),
-    existingToolsDefault: z13.array(ContractIdentifierSchema).optional(),
-    historyColumnsDefault: z13.number().int().min(1).max(6).optional(),
-    studioOverrides: z13.array(WorkbenchStudioOverrideSchema).optional()
+    layoutManagerEnabled: z14.boolean().optional(),
+    existingToolsDefault: z14.array(ContractIdentifierSchema).optional(),
+    historyColumnsDefault: z14.number().int().min(1).max(6).optional(),
+    studioOverrides: z14.array(WorkbenchStudioOverrideSchema).optional()
   }).strict().optional()
 }).strict().superRefine(({ pages, pageGroups }, context) => {
   const pageIds = pages.map(({ definition }) => definition.pageId);
@@ -11458,38 +11493,38 @@ var TenantWorkbenchConfigSchema = z13.object({
     });
   });
 });
-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()
+var LoginPageSchema = z14.object({
+  background: z14.object({ imageUrl: z14.string().optional(), gradient: z14.string().optional() }).strict().optional(),
+  logo: z14.object({
+    url: z14.string().optional(),
+    lightUrl: z14.string().optional(),
+    darkUrl: z14.string().optional(),
+    position: z14.enum(["top", "middle", "bottom"]).optional(),
+    scale: z14.number().positive().optional()
   }).strict().optional(),
-  customCss: z13.string().optional()
+  customCss: z14.string().optional()
 }).strict();
 var LandingPageHeadbarConfigShape = {
-  headbarMode: z13.enum(["shared", "hidden"]).optional()
+  headbarMode: z14.enum(["shared", "hidden"]).optional()
 };
-var LandingPageDefaultConfigSchema = z13.object({
-  mode: z13.literal("default"),
+var LandingPageDefaultConfigSchema = z14.object({
+  mode: z14.literal("default"),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageMarkdownConfigSchema = z13.object({
-  mode: z13.literal("markdown"),
-  content: z13.string(),
+var LandingPageMarkdownConfigSchema = z14.object({
+  mode: z14.literal("markdown"),
+  content: z14.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageHtmlConfigSchema = z13.object({
-  mode: z13.literal("html"),
-  content: z13.string(),
+var LandingPageHtmlConfigSchema = z14.object({
+  mode: z14.literal("html"),
+  content: z14.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageIframeConfigSchema = z13.object({
-  mode: z13.literal("iframe"),
+var LandingPageIframeConfigSchema = z14.object({
+  mode: z14.literal("iframe"),
   ...LandingPageHeadbarConfigShape,
-  url: z13.string().refine((value) => {
+  url: z14.string().refine((value) => {
     if (/^\/(?!\/)/.test(value)) {
       return !value.includes("\\");
     }
@@ -11501,473 +11536,480 @@ var LandingPageIframeConfigSchema = z13.object({
     }
   }, "Landing page iframe URL must use a root-relative path or HTTP(S) without embedded credentials.")
 }).strict();
-var TenantLandingPageConfigSchema = z13.discriminatedUnion("mode", [
+var TenantLandingPageConfigSchema = z14.discriminatedUnion("mode", [
   LandingPageDefaultConfigSchema,
   LandingPageMarkdownConfigSchema,
   LandingPageHtmlConfigSchema,
   LandingPageIframeConfigSchema
 ]);
-var TenantApplicationConfigSchema = z13.object({
-  theme: z13.object({
-    id: z13.string().optional(),
-    name: z13.string().optional(),
-    title: z13.string().optional(),
+var TenantApplicationConfigSchema = z14.object({
+  theme: z14.object({
+    id: z14.string().optional(),
+    name: z14.string().optional(),
+    title: z14.string().optional(),
     favicon: AssetVariantsSchema.optional(),
     logo: AssetVariantsSchema.optional(),
-    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"])
+    pwaIcon: z14.string().optional(),
+    form: z14.object({ variant: z14.enum(["bento", "ghost"]) }).strict().optional(),
+    toast: z14.object({
+      position: z14.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
     }).strict().optional(),
-    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()
+    icons: z14.object({ error: CustomIconSchema.optional(), empty: CustomIconSchema.optional() }).strict().optional(),
+    views: z14.object({
+      form: z14.object({
+        toast: z14.object({ afterCreate: z14.boolean(), afterDelete: z14.boolean() }).strict(),
+        progress: z14.enum(["estimate", "infinite"]),
+        onlyResult: z14.boolean(),
+        tabular: z14.object({ theme: z14.enum(["default", "tentiary", "primary"]) }).strict()
       }).strict()
     }).strict().optional(),
     loginPage: LoginPageSchema.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()
+    extraLanguageURL: z14.record(z14.string(), z14.string()).optional(),
+    hideSpaceHeader: z14.boolean().optional(),
+    showSidebarTeamSelector: z14.boolean().optional(),
+    showWorkbenchSidebar: z14.boolean().optional(),
+    workbenchViewTheme: z14.enum(["default", "bsd-blue"]).optional(),
+    defaults: z14.object({
+      showFormInImageDetail: z14.boolean().optional(),
+      darkMode: z14.enum(["light", "dark", "auto"]).optional(),
+      language: z14.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
+      showDarkModeToggle: z14.boolean().optional(),
+      showLanguageToggle: z14.boolean().optional()
     }).strict().optional(),
-    modules: z13.object({
-      monkeysSpaceSidebar: z13.union([z13.literal("*"), z13.array(ContractIdentifierSchema)]).optional(),
-      monkeysSpaceHeadbar: z13.union([
-        z13.literal("*"),
-        z13.array(TenantHeadbarModuleItemSchema)
+    modules: z14.object({
+      monkeysSpaceSidebar: z14.union([z14.literal("*"), z14.array(ContractIdentifierSchema)]).optional(),
+      monkeysSpaceHeadbar: z14.union([
+        z14.literal("*"),
+        z14.array(TenantHeadbarModuleItemSchema)
       ]).optional(),
-      settingsSidebar: z13.union([z13.literal("*"), z13.array(ContractIdentifierSchema)]).optional()
+      settingsSidebar: z14.union([z14.literal("*"), z14.array(ContractIdentifierSchema)]).optional()
     }).strict().optional(),
     headbar: ThemeHeadbarSchema.optional(),
-    kernelLayout: z13.object({
-      navigationMode: z13.enum(["sidebar", "topbar"]).optional(),
-      allowNavigationModeSwitch: z13.boolean().optional(),
+    kernelLayout: z14.object({
+      navigationMode: z14.enum(["sidebar", "topbar"]).optional(),
+      allowNavigationModeSwitch: z14.boolean().optional(),
       headbar: KernelHeadbarSchema.optional()
     }).strict().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()
+    paginationPosition: z14.enum(["left", "right"]).optional(),
+    ugcViewIconOnlyMode: z14.boolean().optional(),
+    workflowPreviewExecutionGrid: z14.object({
+      selectionModeDisplayType: z14.enum(["operation-button", "dropdown-menu"]).optional(),
+      clickBehavior: z14.enum(["preview", "select", "fill-form", "none"]).optional(),
+      showErrorFilter: z14.boolean().optional(),
+      displayType: z14.enum(["grid", "masonry"]).optional(),
+      showDetailButton: z14.boolean().optional()
+    }).strict().optional(),
+    workbenchSidebarDefaultOpen: z14.boolean().optional(),
+    workbenchSidebarMoreAction: z14.boolean().optional(),
+    workbenchSidebarApart: z14.boolean().optional(),
+    workbenchSidebarToggleGroupDetail: z14.boolean().optional(),
+    workbenchSidebarViewType: z14.boolean().optional(),
+    workbenchSidebarFormViewEmbed: z14.boolean().optional(),
+    workbenchSidebarModernMode: z14.boolean().optional(),
+    ugc: z14.object({ onItemClick: z14.boolean(), subtitle: z14.boolean().optional() }).strict().optional(),
+    uniImagePreview: z14.boolean().optional(),
+    imagePreviewStyle: z14.union([z14.literal(false), z14.enum(["simple", "normal", "uni"])]).optional(),
+    teamAsUser: z14.boolean().optional(),
+    themeMode: z14.enum(["shadow", "border"]).optional(),
+    density: z14.enum(["compact", "default", "comfortable"]).optional(),
+    statusStates: z14.object({
+      loading: z14.object({ variant: z14.enum(["spinner", "skeleton"]).optional() }).strict().optional(),
+      empty: z14.object({ variant: z14.enum(["default", "compact"]).optional() }).strict().optional(),
+      error: z14.object({ showRetry: z14.boolean().optional() }).strict().optional(),
+      permission: z14.object({ showRequestAccess: z14.boolean().optional() }).strict().optional(),
+      density: z14.enum(["compact", "default", "comfortable"]).optional()
     }).strict().optional(),
-    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()
+    pageZoom: z14.number().positive().optional(),
+    miniMode: z14.object({ showPreviewViewExecutionResultGrid: z14.boolean() }).strict().optional(),
+    workflow: z14.object({ allowConcurrentRuns: z14.boolean() }).strict().optional(),
+    historyResult: z14.object({ display: z14.boolean() }).strict().optional(),
+    uploader: z14.object({
+      orientation: z14.enum(["vertical", "horizontal"]),
+      pasteButton: z14.boolean(),
+      statusText: z14.boolean()
     }).strict().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()
+    designProjects: z14.object({
+      oneOnOne: z14.boolean(),
+      newTabOpenBoard: z14.boolean(),
+      defaultShowGrid: z14.boolean().optional(),
+      createDefaultFrame: z14.boolean(),
+      showPageMenu: z14.boolean(),
+      showMainMenu: z14.boolean(),
+      showStylePanel: z14.boolean(),
+      showToolbar: z14.boolean(),
+      toolbarPosition: z14.enum(["bottom", "left"]).optional(),
+      showContextMenu: z14.boolean(),
+      showActionsMenu: z14.boolean(),
+      showPageAndLayerSidebar: z14.boolean().optional(),
+      showBoardOperationSidebar: z14.boolean().optional(),
+      showMiniToolsToolbar: z14.boolean().optional(),
+      showRightSidebar: z14.boolean().optional(),
+      showRealtimeDrawing: z14.boolean().optional(),
+      showWorkflow: z14.boolean().optional(),
+      showVersionManager: z14.boolean().optional(),
+      showAgent: z14.boolean().optional(),
+      AgentTools: z14.array(ContractIdentifierSchema).optional()
     }).strict().optional(),
     workbench: TenantWorkbenchConfigSchema.optional(),
-    visionProWorkflows: z13.array(ContractIdentifierSchema).optional(),
-    initTeam: z13.boolean().optional(),
-    imageThumbnail: z13.boolean().optional(),
-    pages: z13.object({
-      allowPageKeys: z13.union([z13.literal("*"), z13.array(ContractIdentifierSchema)]),
+    visionProWorkflows: z14.array(ContractIdentifierSchema).optional(),
+    initTeam: z14.boolean().optional(),
+    imageThumbnail: z14.boolean().optional(),
+    pages: z14.object({
+      allowPageKeys: z14.union([z14.literal("*"), z14.array(ContractIdentifierSchema)]),
       defaultPageKey: ContractIdentifierSchema.optional(),
-      homeEntryEnabled: z13.boolean().optional()
+      homeEntryEnabled: z14.boolean().optional()
     }).strict().optional(),
-    agent: z13.object({
+    agent: z14.object({
       logo: AssetVariantsSchema.optional(),
-      brandDisplayMode: z13.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
-      density: z13.enum(["compact", "default", "comfortable"]).optional(),
-      sessionCentric: z13.boolean().optional(),
-      quickStartEnabled: z13.boolean().optional()
+      brandDisplayMode: z14.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
+      density: z14.enum(["compact", "default", "comfortable"]).optional(),
+      sessionCentric: z14.boolean().optional(),
+      quickStartEnabled: z14.boolean().optional()
     }).strict().optional()
   }).strict(),
   landingPage: TenantLandingPageConfigSchema.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()
+  auth: z14.object({
+    enabled: z14.array(ContractIdentifierSchema).default([]),
+    oidc: z14.object({ buttonText: z14.string().optional(), autoSignin: z14.boolean().optional() }).strict().optional(),
+    password: z14.object({ disableAutoRegister: z14.boolean().optional() }).strict().optional(),
+    hideAuthToast: z14.boolean().optional(),
+    autoReload: z14.boolean().optional(),
+    defaultOtherTeam: z14.boolean().optional()
   }).strict(),
-  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()
+  endpoints: z14.record(ContractIdentifierSchema, z14.string()),
+  module: z14.union([z14.literal("*"), z14.array(ContractIdentifierSchema)]),
+  behavior: z14.object({
+    clearWorkflowFormStorageAfterUpdate: z14.boolean().optional(),
+    autoApproveOAuth: z14.boolean().optional(),
+    rememberWorkflowModelSelection: z14.boolean().optional()
   }).strict(),
-  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({
+  dataManagement: z14.object({
+    favoriteOntologyId: z14.string().optional(),
+    pairedOntologyId: z14.string().optional(),
+    galleryOntologyIds: z14.array(ContractIdentifierSchema).max(20).optional(),
+    galleryOntologyId: z14.string().optional(),
+    dataBrowserDefaultOntologyId: z14.string().optional(),
+    workflowResultOntologyId: z14.string().optional(),
+    homeAdvertisement: z14.object({
       ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
-      viewType: z13.enum(["filter", "container", "share_link"]).optional(),
+      viewType: z14.enum(["filter", "container", "share_link"]).optional(),
       teamId: ContractIdentifierSchema.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()
+      teamOnly: z14.boolean().optional(),
+      pageSize: z14.number().int().positive().optional(),
+      sortBy: z14.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
+      sortOrder: z14.enum(["asc", "desc"]).optional(),
+      fieldMap: z14.record(z14.string(), z14.string()).optional(),
+      columnIds: z14.record(z14.string(), z14.string()).optional()
     }).strict().optional(),
-    homeTrendAssistant: z13.object({
+    homeTrendAssistant: z14.object({
       ontologyId: ContractIdentifierSchema.optional(),
       viewId: ContractIdentifierSchema.optional(),
       viewInstanceId: ContractIdentifierSchema.optional(),
-      viewName: z13.string().optional(),
+      viewName: z14.string().optional(),
       teamId: ContractIdentifierSchema.optional(),
       designOptionsWorkflowId: ContractIdentifierSchema.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()
+      tep: z14.object({ baseUrl: z14.string().optional(), timeoutMs: z14.number().int().positive().optional() }).strict().optional(),
+      runtime: z14.object({ appId: ContractIdentifierSchema, tepBaseUrlConfigured: z14.boolean(), tepAuthorizationConfigured: z14.boolean(), tepCookieConfigured: z14.boolean() }).strict().optional()
     }).strict().optional(),
     trendRadar: TenantTrendRadarSourcesSchema.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()
+    sharing: z14.object({
+      silentViewLinks: z14.object({ enabled: z14.boolean().optional(), placement: z14.object({ mode: z14.enum(["sourceOntology", "ontology"]).optional(), ontologyId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
+      shareAccess: z14.object({ publicLinksEnabled: z14.boolean().optional(), passwordGateEnabled: z14.boolean().optional(), passwordAccessTtlSeconds: z14.number().int().positive().optional(), defaultViewTreeDelivery: z14.enum(["manual", "auto"]).optional() }).strict().optional(),
+      shareDialog: z14.object({
+        audience: z14.object({ enabled: z14.boolean().optional(), allowed: z14.array(z14.enum(["user", "team", "public"])).optional(), default: z14.enum(["user", "team", "public"]).optional() }).strict().optional(),
+        accessLevel: z14.object({ enabled: z14.boolean().optional(), allowed: z14.array(z14.enum(["read", "write"])).optional(), default: z14.enum(["read", "write"]).optional() }).strict().optional(),
+        viewTreeDelivery: z14.object({ enabled: z14.boolean().optional(), allowed: z14.array(z14.enum(["manual", "auto"])).optional(), default: z14.enum(["manual", "auto"]).optional() }).strict().optional()
       }).strict().optional()
     }).strict().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()
+  compute: z14.object({
+    integrations: z14.object({
+      harbor: z14.object({ endpoint: z14.string().optional(), projectScopes: z14.array(z14.string()).optional(), authMode: z14.string().optional(), principal: z14.string().optional(), autoSync: z14.boolean().optional(), proxyUrl: z14.string().optional() }).strict().optional(),
+      gitlab: z14.object({ baseUrl: z14.string().optional(), groupScopes: z14.array(z14.string()).optional(), tokenMode: z14.string().optional(), deployProjectPath: z14.string().optional(), deploymentReportsEnabled: z14.boolean().optional(), proxyUrl: z14.string().optional() }).strict().optional(),
+      kubernetes: z14.object({ accessMode: z14.string().optional(), clusterAlias: z14.string().optional(), agentProjectPath: z14.string().optional(), agentName: z14.string().optional(), namespaceScopes: z14.array(z14.string()).optional(), rolloutObserverEnabled: z14.boolean().optional(), proxyUrl: z14.string().optional() }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  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({
+  data: z14.object({}).strict().optional(),
+  storage: z14.object({
+    presignMode: z14.enum(["frontend", "backend", "both"]).optional(),
+    presign: z14.object({
+      expiresInSeconds: z14.number().int().positive(),
+      buckets: z14.array(
+        z14.object({
           id: ContractIdentifierSchema,
           provider: ContractIdentifierSchema,
           preferredUrlPatternId: ContractIdentifierSchema,
-          urlPatterns: z13.array(
-            z13.object({
+          urlPatterns: z14.array(
+            z14.object({
               id: ContractIdentifierSchema,
-              type: z13.enum(["bucket-hostname", "provider-hostname"]),
-              hostname: z13.string().trim().min(1),
-              preferred: z13.boolean().optional(),
-              bucketSegment: z13.string().optional()
+              type: z14.enum(["bucket-hostname", "provider-hostname"]),
+              hostname: z14.string().trim().min(1),
+              preferred: z14.boolean().optional(),
+              bucketSegment: z14.string().optional()
             }).strict()
           )
         }).strict()
       )
     }).strict().optional()
   }).strict().optional(),
-  monkeyData: z13.object({ baseUrl: z13.string().optional() }).strict().optional()
+  monkeyData: z14.object({ baseUrl: z14.string().optional() }).strict().optional()
 }).strict();
-var TenantProductConfigSchema = z13.object({
-  contract: z13.literal("TenantProductConfig"),
+var TenantProductConfigSchema = z14.object({
+  contract: z14.literal("TenantProductConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: TenantDesignTokensConfigSchema,
-  moduleRefs: z13.array(ContractIdentifierSchema).default([]),
-  pageRefs: z13.array(ContractIdentifierSchema).default([]),
-  featureFlags: z13.record(z13.string(), z13.boolean()).default({}),
+  moduleRefs: z14.array(ContractIdentifierSchema).default([]),
+  pageRefs: z14.array(ContractIdentifierSchema).default([]),
+  featureFlags: z14.record(z14.string(), z14.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z13.record(z13.string(), ContractIdentifierSchema),
-  warnings: z13.array(z13.string()).default([]),
+  sourceMap: z14.record(z14.string(), ContractIdentifierSchema),
+  warnings: z14.array(z14.string()).default([]),
   menus: MenuDefinitionSetSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
-var TenantRuntimeConfigSchema = z13.object({
-  contract: z13.literal("TenantRuntimeConfig"),
+var TenantRuntimeConfigSchema = z14.object({
+  contract: z14.literal("TenantRuntimeConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: ResolvedThemeTokensSchema,
-  moduleRefs: z13.array(ContractIdentifierSchema).default([]),
-  pageRefs: z13.array(ContractIdentifierSchema).default([]),
-  featureFlags: z13.record(z13.string(), z13.boolean()).default({}),
+  moduleRefs: z14.array(ContractIdentifierSchema).default([]),
+  pageRefs: z14.array(ContractIdentifierSchema).default([]),
+  featureFlags: z14.record(z14.string(), z14.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z13.record(z13.string(), ContractIdentifierSchema),
-  warnings: z13.array(z13.string()).default([]),
+  sourceMap: z14.record(z14.string(), ContractIdentifierSchema),
+  warnings: z14.array(z14.string()).default([]),
   menuBundle: MenuRuntimeBundleSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
 
 // src/contracts/trend.ts
-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({
+import { z as z15 } from "zod";
+var RadarDecisionMetricsSchema = z15.object({
+  currentSales: z15.number().finite(),
+  forecastSales: z15.number().finite(),
+  searchHeat: z15.number().finite(),
+  socialHeat: z15.number().finite(),
+  confidence: z15.number().min(0).max(1)
+}).strict();
+var TrendSourceSchema = z15.object({
   sourceId: ContractIdentifierSchema,
   provider: ContractIdentifierSchema,
-  channel: z14.enum(["trend", "ecommerce", "social", "search", "internal"]),
+  channel: z15.enum(["trend", "ecommerce", "social", "search", "internal"]),
   collectedAt: IsoDateTimeSchema,
-  sourceUrl: z14.string().url().optional(),
-  evidenceRefs: z14.array(EntityRefSchema).default([])
+  sourceUrl: z15.string().url().optional(),
+  evidenceRefs: z15.array(EntityRefSchema).default([])
 }).strict();
-var TrendIngestRunSchema = z14.object({
-  contract: z14.literal("TrendIngestRun"),
+var TrendIngestRunSchema = z15.object({
+  contract: z15.literal("TrendIngestRun"),
   ingestRunId: ContractIdentifierSchema,
   sourceId: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  status: z14.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
-  recordCount: z14.number().int().nonnegative(),
-  errorCount: z14.number().int().nonnegative(),
+  status: z15.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
+  recordCount: z15.number().int().nonnegative(),
+  errorCount: z15.number().int().nonnegative(),
   startedAt: IsoDateTimeSchema,
   completedAt: IsoDateTimeSchema.optional()
 }).strict();
-var TrendSourceRecordSchema = z14.object({
-  contract: z14.literal("TrendSourceRecord"),
+var TrendSourceRecordSchema = z15.object({
+  contract: z15.literal("TrendSourceRecord"),
   sourceRecordId: ContractIdentifierSchema,
   source: TrendSourceSchema,
   ingestRunRef: EntityRefSchema,
-  recordVersion: z14.number().int().positive(),
+  recordVersion: z15.number().int().positive(),
   contentHash: Sha256Schema,
   payload: JsonValueSchema,
   idempotencyKey: ContractIdentifierSchema,
   collectedAt: IsoDateTimeSchema
 }).strict();
-var HotwordBodySchema = z14.object({
-  contract: z14.literal("HotwordBody"),
+var HotwordBodySchema = z15.object({
+  contract: z15.literal("HotwordBody"),
   hotwordId: ContractIdentifierSchema,
-  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([]),
+  label: z15.string().trim().min(1),
+  normalizedLabel: z15.string().trim().min(1),
+  categories: z15.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z15.array(TrendSourceSchema).min(1),
+  relationRefs: z15.array(EntityRefSchema).default([]),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 }).strict();
 var CommerceBodyFieldsSchema = {
-  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([]),
+  displayName: z15.string().trim().min(1),
+  normalizedName: z15.string().trim().min(1),
+  categories: z15.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z15.array(EntityRefSchema).min(1),
+  relationRefs: z15.array(EntityRefSchema).default([]),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 };
-var BrandBodySchema = z14.object({
-  contract: z14.literal("BrandBody"),
+var BrandBodySchema = z15.object({
+  contract: z15.literal("BrandBody"),
   brandId: ContractIdentifierSchema,
   ...CommerceBodyFieldsSchema
 }).strict();
-var ProductBodySchema = z14.object({
-  contract: z14.literal("ProductBody"),
+var ProductBodySchema = z15.object({
+  contract: z15.literal("ProductBody"),
   productId: ContractIdentifierSchema,
   brandRef: EntityRefSchema.optional(),
   ...CommerceBodyFieldsSchema
 }).strict();
-var TrendMetricSnapshotSchema = z14.object({
-  contract: z14.literal("TrendMetricSnapshot"),
+var TrendMetricSnapshotSchema = z15.object({
+  contract: z15.literal("TrendMetricSnapshot"),
   snapshotId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   observedAt: IsoDateTimeSchema,
-  metrics: z14.record(z14.string(), z14.number().finite()),
-  confidence: z14.number().min(0).max(1),
-  evidenceRefs: z14.array(EntityRefSchema).min(1)
+  metrics: z15.record(z15.string(), z15.number().finite()),
+  confidence: z15.number().min(0).max(1),
+  evidenceRefs: z15.array(EntityRefSchema).min(1)
 }).strict();
-var RadarScoreModelBodySchema = z14.object({
-  contract: z14.literal("RadarScoreModelBody"),
+var RadarScoreModelBodySchema = z15.object({
+  contract: z15.literal("RadarScoreModelBody"),
   modelId: ContractIdentifierSchema,
-  version: z14.number().int().positive(),
+  version: z15.number().int().positive(),
   weights: RadarDecisionMetricsSchema,
-  thresholds: z14.record(z14.string(), z14.number().finite()).default({}),
-  explanationRules: z14.record(z14.string(), z14.string().trim().min(1)).default({}),
+  thresholds: z15.record(z15.string(), z15.number().finite()).default({}),
+  explanationRules: z15.record(z15.string(), z15.string().trim().min(1)).default({}),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarScoreProjectionSchema = z14.object({
-  contract: z14.literal("RadarScoreProjection"),
+var RadarScoreProjectionSchema = z15.object({
+  contract: z15.literal("RadarScoreProjection"),
   projectionId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   modelRef: EntityRefSchema,
-  totalScore: z14.number().finite(),
+  totalScore: z15.number().finite(),
   dimensions: RadarDecisionMetricsSchema,
-  evidenceRefs: z14.array(EntityRefSchema).min(1),
+  evidenceRefs: z15.array(EntityRefSchema).min(1),
   freshnessAt: IsoDateTimeSchema
 }).strict();
-var RadarPanoramaNodeSchema = z14.object({
+var RadarPanoramaNodeSchema = z15.object({
   ref: EntityRefSchema,
-  label: z14.string().trim().min(1),
-  categories: z14.array(ContractIdentifierSchema).default([]),
-  score: z14.number().finite().optional(),
+  label: z15.string().trim().min(1),
+  categories: z15.array(ContractIdentifierSchema).default([]),
+  score: z15.number().finite().optional(),
   freshnessAt: IsoDateTimeSchema.optional()
 }).strict();
-var RadarPanoramaEdgeSchema = z14.object({
+var RadarPanoramaEdgeSchema = z15.object({
   sourceRef: EntityRefSchema,
   targetRef: EntityRefSchema,
   relation: ContractIdentifierSchema,
-  evidenceRefs: z14.array(EntityRefSchema).default([])
+  evidenceRefs: z15.array(EntityRefSchema).default([])
 }).strict();
-var RadarPanoramaSchema = z14.object({
-  contract: z14.literal("RadarPanorama"),
-  nodes: z14.array(RadarPanoramaNodeSchema),
-  edges: z14.array(RadarPanoramaEdgeSchema),
+var RadarPanoramaSchema = z15.object({
+  contract: z15.literal("RadarPanorama"),
+  nodes: z15.array(RadarPanoramaNodeSchema),
+  edges: z15.array(RadarPanoramaEdgeSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
-var BrandGeneticsProfileSchema = z14.object({
-  contract: z14.literal("BrandGeneticsProfile"),
+var BrandGeneticsProfileSchema = z15.object({
+  contract: z15.literal("BrandGeneticsProfile"),
   brandRef: EntityRefSchema,
-  categories: z14.array(ContractIdentifierSchema).default([]),
-  signature: z14.record(ContractIdentifierSchema, z14.number().finite()),
-  relatedRefs: z14.array(EntityRefSchema).default([]),
-  evidenceRefs: z14.array(EntityRefSchema).default([]),
+  categories: z15.array(ContractIdentifierSchema).default([]),
+  signature: z15.record(ContractIdentifierSchema, z15.number().finite()),
+  relatedRefs: z15.array(EntityRefSchema).default([]),
+  evidenceRefs: z15.array(EntityRefSchema).default([]),
   computedAt: IsoDateTimeSchema
 }).strict();
-var RadarOpportunityMatrixPointSchema = z14.object({
+var RadarOpportunityMatrixPointSchema = z15.object({
   subjectRef: EntityRefSchema,
-  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),
+  label: z15.string().trim().min(1),
+  x: z15.number().finite(),
+  y: z15.number().finite(),
+  score: z15.number().finite(),
+  evidenceRefs: z15.array(EntityRefSchema).default([])
+}).strict();
+var RadarOpportunityMatrixSchema = z15.object({
+  contract: z15.literal("RadarOpportunityMatrix"),
+  xMetric: z15.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  yMetric: z15.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  points: z15.array(RadarOpportunityMatrixPointSchema),
   computedAt: IsoDateTimeSchema
 }).strict();
-var RadarQueryBodySchema = z14.object({
-  contract: z14.literal("RadarQueryBody"),
+var RadarQueryBodySchema = z15.object({
+  contract: z15.literal("RadarQueryBody"),
   queryId: ContractIdentifierSchema,
-  filters: z14.record(z14.string(), JsonValueSchema).default({}),
-  sort: z14.object({
+  filters: z15.record(z15.string(), JsonValueSchema).default({}),
+  sort: z15.object({
     field: ContractIdentifierSchema,
-    direction: z14.enum(["asc", "desc"])
+    direction: z15.enum(["asc", "desc"])
   }).strict(),
-  pageSize: z14.number().int().min(1).max(200),
+  pageSize: z15.number().int().min(1).max(200),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var SavedRadarQuerySchema = z14.object({
-  contract: z14.literal("SavedRadarQuery"),
+var SavedRadarQuerySchema = z15.object({
+  contract: z15.literal("SavedRadarQuery"),
   savedQueryId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   ownerRef: EntityRefSchema,
-  name: z14.string().trim().min(1),
+  name: z15.string().trim().min(1),
   queryRef: EntityRefSchema,
-  expectedVersion: z14.number().int().nonnegative(),
+  expectedVersion: z15.number().int().nonnegative(),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var RadarSelectionSchema = z14.object({
-  contract: z14.literal("RadarSelection"),
+var RadarSelectionSchema = z15.object({
+  contract: z15.literal("RadarSelection"),
   selectionId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   ownerRef: EntityRefSchema,
-  subjectRefs: z14.array(EntityRefSchema),
-  status: z14.enum(["stashed", "selected", "rejected", "archived"]),
-  note: z14.string().optional(),
-  expectedVersion: z14.number().int().nonnegative(),
+  subjectRefs: z15.array(EntityRefSchema),
+  status: z15.enum(["stashed", "selected", "rejected", "archived"]),
+  note: z15.string().optional(),
+  expectedVersion: z15.number().int().nonnegative(),
   updatedAt: IsoDateTimeSchema
 }).strict();
 var versionedRefFields = {
   id: ContractIdentifierSchema,
-  version: z14.union([z14.number().int().positive(), z14.string().trim().min(1)]).optional(),
+  version: z15.union([z15.number().int().positive(), z15.string().trim().min(1)]).optional(),
   ownerRepo: ContractIdentifierSchema.optional()
 };
-var TrendRadarCollectionAssetRefSchema = z14.object({
-  kind: z14.literal("asset"),
+var TrendRadarCollectionAssetRefSchema = z15.object({
+  kind: z15.literal("asset"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionSelectionRefSchema = z14.object({
-  kind: z14.literal("radar-selection"),
+var TrendRadarCollectionSelectionRefSchema = z15.object({
+  kind: z15.literal("radar-selection"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionRunRefSchema = z14.object({
-  kind: z14.literal("radar-analysis-run"),
+var TrendRadarCollectionRunRefSchema = z15.object({
+  kind: z15.literal("radar-analysis-run"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionSubjectRefSchema = z14.object({
-  kind: z14.literal("hotword"),
+var TrendRadarCollectionSubjectRefSchema = z15.object({
+  kind: z15.literal("hotword"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionArtifactRefSchema = z14.object({
-  kind: z14.literal("artifact"),
+var TrendRadarCollectionArtifactRefSchema = z15.object({
+  kind: z15.literal("artifact"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionRecipeEntrySchema = z14.object({
+var TrendRadarCollectionRecipeEntrySchema = z15.object({
   subjectRef: TrendRadarCollectionSubjectRefSchema,
-  label: z14.string().trim().min(1).max(200)
+  label: z15.string().trim().min(1).max(200)
 }).strict();
-var TrendRadarCollectionRecipeSchema = z14.object({
-  category: z14.array(TrendRadarCollectionRecipeEntrySchema),
-  design: z14.array(TrendRadarCollectionRecipeEntrySchema),
-  audience: z14.array(TrendRadarCollectionRecipeEntrySchema)
+var TrendRadarCollectionRecipeSchema = z15.object({
+  category: z15.array(TrendRadarCollectionRecipeEntrySchema),
+  design: z15.array(TrendRadarCollectionRecipeEntrySchema),
+  audience: z15.array(TrendRadarCollectionRecipeEntrySchema)
 }).strict().refine(
   (recipe) => recipe.category.length + recipe.design.length + recipe.audience.length > 0,
   "A Trend Radar collection recipe must contain at least one subject."
 );
-var TrendRadarCollectionDecisionAxisSchema = z14.object({
+var TrendRadarCollectionDecisionAxisSchema = z15.object({
   key: ContractIdentifierSchema,
-  label: z14.string().trim().min(1).max(200).optional(),
-  value: z14.number().finite()
-}).strict();
-var TrendRadarCollectionDecisionProjectionSchema = z14.object({
-  axes: z14.array(TrendRadarCollectionDecisionAxisSchema).max(32).optional(),
-  overallScore: z14.number().finite().optional(),
-  itemRank: z14.number().finite().optional(),
-  sourceRefs: z14.array(EntityRefSchema).optional(),
-  outputRefs: z14.array(EntityRefSchema).optional()
+  label: z15.string().trim().min(1).max(200).optional(),
+  value: z15.number().finite()
+}).strict();
+var TrendRadarCollectionDecisionProjectionSchema = z15.object({
+  axes: z15.array(TrendRadarCollectionDecisionAxisSchema).max(32).optional(),
+  overallScore: z15.number().finite().optional(),
+  itemRank: z15.number().finite().optional(),
+  sourceRefs: z15.array(EntityRefSchema).optional(),
+  outputRefs: z15.array(EntityRefSchema).optional()
 }).strict().superRefine((projection, context) => {
   const hasProjection = Boolean(
     projection.axes?.length || projection.overallScore !== void 0 || projection.itemRank !== void 0 || projection.sourceRefs?.length || projection.outputRefs?.length
@@ -11990,20 +12032,20 @@ var TrendRadarCollectionDecisionProjectionSchema = z14.object({
     seenAxisKeys.add(axis.key);
   });
 });
-var TrendRadarCollectionArtifactProjectionSchema = z14.object({
+var TrendRadarCollectionArtifactProjectionSchema = z15.object({
   artifactRef: TrendRadarCollectionArtifactRefSchema,
-  url: z14.string().url().optional(),
-  thumbnailUrl: z14.string().url().optional(),
-  mimeType: z14.string().trim().min(1).optional(),
+  url: z15.string().url().optional(),
+  thumbnailUrl: z15.string().url().optional(),
+  mimeType: z15.string().trim().min(1).optional(),
   metadata: JsonObjectSchema.optional()
 }).strict();
-var TrendRadarCollectionProjectionWritebackSchema = z14.object({
-  status: z14.enum(["PENDING", "APPLIED", "FAILED"]),
+var TrendRadarCollectionProjectionWritebackSchema = z15.object({
+  status: z15.enum(["PENDING", "APPLIED", "FAILED"]),
   updatedAt: IsoDateTimeSchema,
-  error: z14.object({
+  error: z15.object({
     code: ContractIdentifierSchema,
-    message: z14.string().trim().min(1),
-    retryable: z14.boolean()
+    message: z15.string().trim().min(1),
+    retryable: z15.boolean()
   }).strict().optional()
 }).strict().superRefine((writeback, context) => {
   if (writeback.status === "FAILED" && !writeback.error) {
@@ -12021,12 +12063,12 @@ var TrendRadarCollectionProjectionWritebackSchema = z14.object({
     });
   }
 });
-var TrendRadarCollectionItemSchema = z14.object({
-  contract: z14.literal("TrendRadarCollectionItem"),
-  schemaVersion: z14.literal(1),
+var TrendRadarCollectionItemSchema = z15.object({
+  contract: z15.literal("TrendRadarCollectionItem"),
+  schemaVersion: z15.literal(1),
   selectionRef: TrendRadarCollectionSelectionRefSchema,
   recipe: TrendRadarCollectionRecipeSchema,
-  status: z14.enum(["SAVED", "QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
+  status: z15.enum(["SAVED", "QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
   latestRunRef: TrendRadarCollectionRunRefSchema.optional(),
   decisionProjection: TrendRadarCollectionDecisionProjectionSchema.optional(),
   artifactProjection: TrendRadarCollectionArtifactProjectionSchema.optional(),
@@ -12034,8 +12076,8 @@ var TrendRadarCollectionItemSchema = z14.object({
   updatedAt: IsoDateTimeSchema,
   generatedAt: IsoDateTimeSchema.optional()
 }).strict();
-var RadarAnalysisRunSchema = z14.object({
-  contract: z14.literal("RadarAnalysisRun"),
+var RadarAnalysisRunSchema = z15.object({
+  contract: z15.literal("RadarAnalysisRun"),
   runId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   selectionRef: EntityRefSchema,
@@ -12046,66 +12088,66 @@ var RadarAnalysisRunSchema = z14.object({
   collectionAssetRef: TrendRadarCollectionAssetRefSchema.optional(),
   collectionProjectionWriteback: TrendRadarCollectionProjectionWritebackSchema.optional(),
   workflowDefinitionTeamId: ContractIdentifierSchema.optional(),
-  workflowInput: z14.record(z14.string(), JsonValueSchema).default({}),
-  createDesignProject: z14.boolean().default(true),
-  designProjectName: z14.string().trim().min(1).max(200).optional(),
+  workflowInput: z15.record(z15.string(), JsonValueSchema).default({}),
+  createDesignProject: z15.boolean().default(true),
+  designProjectName: z15.string().trim().min(1).max(200).optional(),
   modelRef: EntityRefSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  status: z14.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
-  outputRefs: z14.array(EntityRefSchema).default([]),
-  error: z14.object({
+  status: z15.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
+  outputRefs: z15.array(EntityRefSchema).default([]),
+  error: z15.object({
     code: ContractIdentifierSchema,
-    message: z14.string().trim().min(1),
-    retryable: z14.boolean()
+    message: z15.string().trim().min(1),
+    retryable: z15.boolean()
   }).strict().optional(),
   startedAt: IsoDateTimeSchema.optional(),
   completedAt: IsoDateTimeSchema.optional(),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisAssetSchema = z14.object({
+var RadarAnalysisAssetSchema = z15.object({
   artifactRef: EntityRefSchema,
   kind: ContractIdentifierSchema,
-  mimeType: z14.string().trim().min(1).optional(),
-  url: z14.string().url(),
-  metadata: z14.record(z14.string(), JsonValueSchema).default({}),
+  mimeType: z15.string().trim().min(1).optional(),
+  url: z15.string().url(),
+  metadata: z15.record(z15.string(), JsonValueSchema).default({}),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisDetailSchema = z14.object({
-  contract: z14.literal("RadarAnalysisDetail"),
+var RadarAnalysisDetailSchema = z15.object({
+  contract: z15.literal("RadarAnalysisDetail"),
   run: RadarAnalysisRunSchema,
-  runVersion: z14.number().int().positive(),
+  runVersion: z15.number().int().positive(),
   selection: RadarSelectionSchema,
-  outputs: z14.array(OutputRecordSchema),
-  assets: z14.array(RadarAnalysisAssetSchema),
-  lineage: z14.array(LineageRecordSchema)
+  outputs: z15.array(OutputRecordSchema),
+  assets: z15.array(RadarAnalysisAssetSchema),
+  lineage: z15.array(LineageRecordSchema)
 }).strict();
-var RadarActionRecordSchema = z14.object({
-  contract: z14.literal("RadarActionRecord"),
+var RadarActionRecordSchema = z15.object({
+  contract: z15.literal("RadarActionRecord"),
   actionId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   actorRef: EntityRefSchema,
-  action: z14.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
+  action: z15.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
   targetRef: EntityRefSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  expectedVersion: z14.number().int().nonnegative(),
+  expectedVersion: z15.number().int().nonnegative(),
   occurredAt: IsoDateTimeSchema
 }).strict();
-var RadarWritebackRecordSchema = z14.object({
-  contract: z14.literal("RadarWritebackRecord"),
+var RadarWritebackRecordSchema = z15.object({
+  contract: z15.literal("RadarWritebackRecord"),
   writebackId: ContractIdentifierSchema,
   actionRef: EntityRefSchema,
   targetRef: EntityRefSchema,
-  status: z14.enum(["PENDING", "APPLIED", "FAILED"]),
-  resultingVersion: z14.number().int().nonnegative().optional(),
-  error: z14.string().trim().min(1).optional(),
+  status: z15.enum(["PENDING", "APPLIED", "FAILED"]),
+  resultingVersion: z15.number().int().nonnegative().optional(),
+  error: z15.string().trim().min(1).optional(),
   recordedAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/workflow-definition.ts
-import { z as z15 } from "zod";
-var ConductorTaskTypeSchema = z15.enum([
+import { z as z16 } from "zod";
+var ConductorTaskTypeSchema = z16.enum([
   "SIMPLE",
   "DYNAMIC",
   "FORK_JOIN",
@@ -12154,46 +12196,46 @@ var requiredTaskFields = {
   WAIT: ["inputParameters"],
   TERMINATE: ["inputParameters"]
 };
-var ConductorTaskDefinitionSchema = z15.lazy(
-  () => z15.object({
+var ConductorTaskDefinitionSchema = z16.lazy(
+  () => z16.object({
     name: ContractIdentifierSchema,
     taskReferenceName: ContractIdentifierSchema,
     type: ConductorTaskTypeSchema,
-    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(),
+    inputParameters: z16.record(z16.string(), JsonValueSchema).optional(),
+    startDelay: z16.number().int().nonnegative().optional(),
+    optional: z16.boolean().optional(),
+    asyncComplete: z16.boolean().optional(),
+    rateLimited: z16.boolean().optional(),
+    retryCount: z16.number().int().nonnegative().optional(),
+    taskDefinition: z16.record(z16.string(), JsonValueSchema).optional(),
+    loopCondition: z16.string().optional(),
+    loopOver: z16.array(ConductorTaskDefinitionSchema).optional(),
+    sink: z16.string().optional(),
+    forkTasks: z16.array(z16.array(ConductorTaskDefinitionSchema)).optional(),
+    joinOn: z16.array(ContractIdentifierSchema).optional(),
+    defaultExclusiveJoinTask: z16.array(ContractIdentifierSchema).optional(),
+    dynamicForkTasksParam: z16.string().optional(),
+    dynamicForkTasksInputParamName: z16.string().optional(),
+    subWorkflowParam: z16.object({
+      $ref: z16.string().optional(),
       name: ContractIdentifierSchema,
-      version: z15.number().int().positive().optional(),
-      taskToDomain: z15.record(z15.string(), z15.string()).optional(),
-      workflowDefinition: z15.record(z15.string(), JsonValueSchema).optional()
+      version: z16.number().int().positive().optional(),
+      taskToDomain: z16.record(z16.string(), z16.string()).optional(),
+      workflowDefinition: z16.record(z16.string(), JsonValueSchema).optional()
     }).strict().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(),
+    decisionCases: z16.record(z16.string(), z16.array(ConductorTaskDefinitionSchema)).optional(),
+    defaultCase: z16.array(ConductorTaskDefinitionSchema).optional(),
+    evaluatorType: z16.enum(["value-param", "javascript", "graaljs"]).optional(),
+    expression: z16.string().optional(),
     __alias: JsonValueSchema.optional(),
-    callbackFromWorker: z15.boolean().optional(),
+    callbackFromWorker: z16.boolean().optional(),
     caseExpression: JsonValueSchema.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(),
+    caseValueParam: z16.string().optional(),
+    dependencies: z16.array(JsonValueSchema).optional(),
+    description: z16.string().optional(),
+    dynamicTaskNameParam: z16.string().optional(),
+    joinMode: z16.string().optional(),
+    permissive: z16.boolean().optional(),
     joinTaskRef: ContractIdentifierSchema.optional(),
     forkTaskRef: ContractIdentifierSchema.optional()
   }).strict().superRefine((task, context) => {
@@ -12207,29 +12249,29 @@ var ConductorTaskDefinitionSchema = z15.lazy(
     }
   })
 );
-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(),
+var ConductorWorkflowDefinitionSchema = z16.object({
+  ownerApp: z16.string().optional(),
+  createTime: z16.number().int().nonnegative().optional(),
+  updateTime: z16.number().int().nonnegative().optional(),
+  createdBy: z16.string().optional(),
+  updatedBy: z16.string().optional(),
   name: ContractIdentifierSchema,
-  description: z15.string().optional(),
-  version: z15.number().int().positive(),
-  tasks: z15.array(ConductorTaskDefinitionSchema),
-  inputParameters: z15.array(ContractIdentifierSchema),
-  outputParameters: z15.record(z15.string(), JsonValueSchema).optional(),
+  description: z16.string().optional(),
+  version: z16.number().int().positive(),
+  tasks: z16.array(ConductorTaskDefinitionSchema),
+  inputParameters: z16.array(ContractIdentifierSchema),
+  outputParameters: z16.record(z16.string(), JsonValueSchema).optional(),
   failureWorkflow: ContractIdentifierSchema.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(),
-  timeoutSeconds: z15.number().int().nonnegative(),
-  variables: z15.record(z15.string(), JsonValueSchema).optional(),
-  inputTemplate: z15.record(z15.string(), JsonValueSchema).optional()
-}).strict();
-var WorkflowParameterTypeSchema = z15.enum([
+  schemaVersion: z16.number().int().positive().optional(),
+  restartable: z16.boolean().optional(),
+  workflowStatusListenerEnabled: z16.boolean().optional(),
+  ownerEmail: z16.string().email().optional(),
+  timeoutPolicy: z16.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+  timeoutSeconds: z16.number().int().nonnegative(),
+  variables: z16.record(z16.string(), JsonValueSchema).optional(),
+  inputTemplate: z16.record(z16.string(), JsonValueSchema).optional()
+}).strict();
+var WorkflowParameterTypeSchema = z16.enum([
   "string",
   "file",
   "number",
@@ -12239,213 +12281,213 @@ var WorkflowParameterTypeSchema = z15.enum([
   "notice",
   "canvas-assist"
 ]);
-var WorkflowConditionalStateSchema = z15.object({
-  conditions: z15.array(
-    z15.object({
-      field: z15.string(),
-      operator: z15.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
+var WorkflowConditionalStateSchema = z16.object({
+  conditions: z16.array(
+    z16.object({
+      field: z16.string(),
+      operator: z16.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
       value: JsonValueSchema
     }).strict()
   ),
-  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(),
+  logic: z16.enum(["AND", "OR"]).optional()
+}).strict();
+var ImageSelectMappingAppearanceSchema = z16.object({
+  columns: z16.number().int().min(1).max(4).optional(),
+  cardSize: z16.enum(["sm", "md", "lg"]).optional(),
+  imageAspectRatio: z16.enum(["square", "4:5", "3:4", "16:9"]).optional(),
+  gap: z16.enum(["sm", "md", "lg"]).optional(),
+  radius: z16.enum(["sm", "md", "lg", "xl"]).optional(),
+  borderStyle: z16.enum(["none", "soft", "strong"]).optional(),
+  borderWidth: z16.union([z16.literal(0), z16.literal(1), z16.literal(2)]).optional(),
+  enableScroll: z16.boolean().optional(),
+  maxHeight: z16.number().int().min(160).max(1200).optional(),
+  enableCollapse: z16.boolean().optional(),
+  visibleRows: z16.number().int().min(1).max(6).optional(),
+  hideLabel: z16.boolean().optional(),
+  hideDescription: z16.boolean().optional(),
+  hideValue: z16.boolean().optional()
+}).strict();
+var ComfyWorkflowPortBindingSchema = z16.object({
+  node: z16.union([z16.string(), z16.number()]),
+  key: z16.string().optional()
+}).strict();
+var WorkflowParameterTypeOptionsSchema = z16.object({
+  editor: z16.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
+  editorLanguage: z16.enum(["javaScript", "json", "python", "sql"]).optional(),
+  maxValue: z16.number().optional(),
+  minValue: z16.number().optional(),
+  max: z16.number().optional(),
+  min: z16.number().optional(),
+  multipleValues: z16.boolean().optional(),
+  numberPrecision: z16.number().nonnegative().optional(),
+  password: z16.boolean().optional(),
+  rows: z16.number().int().positive().optional(),
+  assetType: z16.string().optional(),
+  accept: z16.string().optional(),
+  maxSize: z16.number().positive().optional(),
+  fileType: z16.string().optional(),
+  aiMultiShotMainImageField: z16.string().optional(),
+  aiMultiShotWorkflowAppId: z16.string().optional(),
+  aiMultiShotWorkflowId: z16.string().optional(),
+  allowCustomInput: z16.boolean().optional(),
+  allowUploadVideo: z16.boolean().optional(),
+  aspectRatioField: z16.string().optional(),
+  assemblyValueType: z16.string().optional(),
+  autoAnalyzeDesignImage: z16.boolean().optional(),
+  autoDetectAspectRatio: z16.boolean().optional(),
+  autoIncrementId: z16.boolean().optional(),
   comfyOptions: ComfyWorkflowPortBindingSchema.optional(),
-  comfyuiModelServerId: z15.string().optional(),
-  comfyuiModelTypeName: z15.string().optional(),
+  comfyuiModelServerId: z16.string().optional(),
+  comfyuiModelTypeName: z16.string().optional(),
   defaultCustomInput: JsonValueSchema.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(),
+  descriptionAlert: z16.boolean().optional(),
+  disabled: z16.union([z16.boolean(), WorkflowConditionalStateSchema]).optional(),
+  editable: z16.union([z16.boolean(), WorkflowConditionalStateSchema]).optional(),
+  enableAiMultiShot: z16.boolean().optional(),
+  enableBooleanSwitchMode: z16.boolean().optional(),
+  enableClear: z16.boolean().optional(),
+  enableExpand: z16.boolean().optional(),
+  enableImageMask: z16.boolean().optional(),
+  enableImageOverlay: z16.boolean().optional(),
+  enablePopupEditor: z16.boolean().optional(),
+  enablePromptFontSize: z16.boolean().optional(),
+  enableReset: z16.boolean().optional(),
+  enableSelectItemIcon: z16.boolean().optional(),
+  enableSelectList: z16.boolean().optional(),
+  enableSelectSearch: z16.boolean().optional(),
+  enableSliderEnterMode: z16.boolean().optional(),
+  enableVoice: z16.boolean().optional(),
+  expandButtonText: z16.string().optional(),
+  foldUp: z16.boolean().optional(),
+  hidden: z16.boolean().optional(),
+  hideRequiredDot: z16.boolean().optional(),
+  inlineTitleWithSelect: z16.boolean().optional(),
+  knowledgeGraphButtonText: z16.string().optional(),
+  identifyAttributeCount: z16.union([z16.number().nonnegative(), z16.string().min(1), z16.object({ min: z16.number().nonnegative().optional(), max: z16.number().nonnegative().optional() }).strict()]).optional(),
+  identifyAttributes: z16.array(JsonValueSchema).optional(),
+  identifyMaxVariants: z16.number().int().nonnegative().optional(),
+  identifySourceField: z16.string().optional(),
+  imageOverlayBaseField: z16.string().optional(),
+  imageOverlayOverlayField: z16.string().optional(),
   imageSelectMappingAppearance: ImageSelectMappingAppearanceSchema.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(),
+  imageSelectMappingColumns: z16.number().int().min(1).max(4).optional(),
+  imageSelectMappingEnableCustomUpload: z16.boolean().optional(),
+  imageSelectMappingHideLabel: z16.boolean().optional(),
+  imageSelectMappingHideLink: z16.boolean().optional(),
+  imageSelectMappingHideMeta: z16.boolean().optional(),
+  imageSelectMappingInlineUseLargeUploadBox: z16.boolean().optional(),
+  imageSelectMappingPromptField: z16.string().optional(),
+  imageSelectMappingTabOrder: z16.enum(["template-first", "upload-first"]).optional(),
+  imageSelectMappingTabWidthMode: z16.enum(["content", "fill"]).optional(),
   imageSelectMappingTemplatePrompt: LocalizedTextSchema.optional(),
   imageSelectMappingTemplateTabTitle: LocalizedTextSchema.optional(),
-  imageSelectMappingUploadMode: z15.enum(["tabs", "inline"]).optional(),
+  imageSelectMappingUploadMode: z16.enum(["tabs", "inline"]).optional(),
   imageSelectMappingUploadPrompt: LocalizedTextSchema.optional(),
   imageSelectMappingUploadTabTitle: LocalizedTextSchema.optional(),
-  endpoints: z15.array(JsonValueSchema).optional(),
-  examples: z15.array(JsonValueSchema).optional(),
+  endpoints: z16.array(JsonValueSchema).optional(),
+  examples: z16.array(JsonValueSchema).optional(),
   extraData: JsonValueSchema.optional(),
   layer: JsonValueSchema.optional(),
   map: JsonValueSchema.optional(),
-  multiline: z15.boolean().optional(),
-  options: z15.array(JsonValueSchema).optional(),
-  originalFiles: z15.array(JsonValueSchema).optional(),
+  multiline: z16.boolean().optional(),
+  options: z16.array(JsonValueSchema).optional(),
+  originalFiles: z16.array(JsonValueSchema).optional(),
   placeholder: LocalizedTextSchema.optional(),
-  preserveSelectListOrder: z15.boolean().optional(),
+  preserveSelectListOrder: z16.boolean().optional(),
   promptDictionary: JsonValueSchema.optional(),
-  promptFontSize: z15.number().optional(),
+  promptFontSize: z16.number().optional(),
   promptModeToggle: JsonValueSchema.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(),
+  requireActiveSelectFilter: z16.boolean().optional(),
+  restoreDefaultOnEmptyEnter: z16.boolean().optional(),
+  search: z16.boolean().optional(),
+  selectButtonEnableCollapse: z16.boolean().optional(),
+  selectButtonVisibleRows: z16.number().int().positive().optional(),
+  selectList: z16.array(JsonValueSchema).optional(),
+  selectListDisplayMode: z16.string().optional(),
+  selectPromptField: z16.string().optional(),
+  showAddLocalFileButton: z16.boolean().optional(),
+  singleColumn: z16.boolean().optional(),
+  singleFrameForMultiple: z16.boolean().optional(),
+  textSingleLine: z16.boolean().optional(),
+  textareaMiniHeight: z16.number().nonnegative().optional(),
   tips: LocalizedTextSchema.optional(),
   visibility: JsonValueSchema.optional(),
-  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({
+  voiceButtonText: z16.string().optional(),
+  designAnalysisFields: z16.array(JsonValueSchema).optional(),
+  designAnalysisFillStrategy: z16.string().optional(),
+  designAnalysisMaxFields: z16.number().int().nonnegative().optional(),
+  designAnalysisType: z16.string().optional(),
+  designAnalysisFieldPrefix: z16.string().optional()
+}).strict();
+var WorkflowParameterSchema = z16.lazy(
+  () => z16.object({
     displayName: LocalizedTextSchema,
     name: ContractIdentifierSchema,
     type: WorkflowParameterTypeSchema,
     typeOptions: WorkflowParameterTypeOptionsSchema.optional(),
     default: JsonValueSchema.optional(),
     description: LocalizedTextSchema.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()
+    hint: z16.string().optional(),
+    displayOptions: z16.object({
+      hide: z16.record(z16.string(), z16.array(JsonValueSchema)).optional(),
+      show: z16.record(z16.string(), z16.array(JsonValueSchema)).optional()
     }).strict().optional(),
-    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(),
+    options: z16.array(z16.union([
+      z16.object({ name: LocalizedTextSchema, value: z16.union([z16.string(), z16.number(), z16.boolean()]), action: z16.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
       WorkflowParameterSchema,
-      z15.object({ displayName: z15.string(), name: ContractIdentifierSchema, values: z15.array(WorkflowParameterSchema) }).strict()
+      z16.object({ displayName: z16.string(), name: ContractIdentifierSchema, values: z16.array(WorkflowParameterSchema) }).strict()
     ])).optional(),
     placeholder: LocalizedTextSchema.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()
+    isNodeSetting: z16.boolean().optional(),
+    noDataExpression: z16.boolean().optional(),
+    required: z16.boolean().optional(),
+    example: z16.string().optional(),
+    extractValue: z16.object({ type: z16.literal("regex"), regex: z16.string() }).strict().optional(),
+    properties: z16.array(WorkflowParameterSchema).optional(),
+    assetType: z16.string().optional(),
+    flag: z16.boolean().optional(),
+    enableExpand: z16.boolean().optional(),
+    enableVoice: z16.boolean().optional(),
+    expandButtonText: z16.string().optional(),
+    knowledgeGraphButtonText: z16.string().optional(),
+    selectListDisplayMode: z16.string().optional(),
+    voiceButtonText: z16.string().optional()
   }).strict()
 );
-var WorkflowOutputBindingSchema = z15.object({ key: ContractIdentifierSchema, value: z15.string() }).strict();
-var WorkflowNodeSchema = z15.object({
+var WorkflowOutputBindingSchema = z16.object({ key: ContractIdentifierSchema, value: z16.string() }).strict();
+var WorkflowNodeSchema = z16.object({
   id: ContractIdentifierSchema,
   referenceName: ContractIdentifierSchema,
   capabilityRef: ContractIdentifierSchema,
   capabilityVersion: ContractIdentifierSchema.optional(),
-  inputBindings: z15.record(z15.string(), JsonValueSchema).default({}),
-  configuration: z15.object({ executor: z15.literal("conductor"), task: ConductorTaskDefinitionSchema }).strict()
+  inputBindings: z16.record(z16.string(), JsonValueSchema).default({}),
+  configuration: z16.object({ executor: z16.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 = z15.object({
+var WorkflowEdgeSchema = z16.object({
   from: ContractIdentifierSchema,
   to: ContractIdentifierSchema,
   outputPort: ContractIdentifierSchema.optional(),
   inputPort: ContractIdentifierSchema.optional(),
-  condition: z15.string().optional()
+  condition: z16.string().optional()
 }).strict();
-var WorkflowTriggerSchema = z15.object({
+var WorkflowTriggerSchema = z16.object({
   id: ContractIdentifierSchema,
-  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"])
+  type: z16.enum(["manual", "schedule", "webhook", "event", "api"]),
+  enabled: z16.boolean(),
+  schedule: z16.object({ cron: z16.string().trim().min(1) }).strict().optional(),
+  webhook: z16.object({
+    path: z16.string().trim().min(1).optional(),
+    method: z16.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
+    auth: z16.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
+    basicAuth: z16.object({ username: z16.string(), password: z16.string() }).strict().optional(),
+    headerAuth: z16.object({ name: z16.string().trim().min(1), value: z16.string() }).strict().optional(),
+    responseUntil: z16.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
   }).strict().optional(),
-  event: z15.object({
+  event: z16.object({
     eventType: ContractIdentifierSchema,
     configuration: JsonValueSchema.optional()
   }).strict().optional()
@@ -12454,63 +12496,63 @@ var WorkflowTriggerSchema = z15.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 = z15.object({
+var WorkflowValidationIssueSchema = z16.object({
   taskReferenceName: ContractIdentifierSchema,
-  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()
+  issueType: z16.enum(["ERROR", "WARNING"]),
+  detailReason: z16.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
+  humanMessage: z16.object({ en: z16.string(), zh: z16.string() }).strict()
 }).strict();
-var WorkflowDefinitionSchema = z15.object({
-  contract: z15.literal("WorkflowDefinition"),
+var WorkflowDefinitionSchema = z16.object({
+  contract: z16.literal("WorkflowDefinition"),
   metadata: ContractMetadataSchema.omit({ name: true, description: true, labels: true }).extend({
     name: LocalizedTextSchema,
     description: LocalizedTextSchema.optional(),
-    role: z15.enum(["workflow", "template"]),
+    role: z16.enum(["workflow", "template"]),
     teamId: ContractIdentifierSchema,
     creatorRef: EntityRefSchema,
-    tags: z15.array(ContractIdentifierSchema).default([])
+    tags: z16.array(ContractIdentifierSchema).default([])
   }).strict(),
-  revision: z15.object({
-    kind: z15.enum(["release", "backup"]),
-    recordVersion: z15.number().int().positive(),
-    sourceVersion: z15.number().int().positive().optional()
+  revision: z16.object({
+    kind: z16.enum(["release", "backup"]),
+    recordVersion: z16.number().int().positive(),
+    sourceVersion: z16.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: 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) => {
+  presentation: z16.object({ iconUrl: z16.string().optional(), thumbnail: z16.string().optional() }).strict(),
+  ports: z16.object({ inputs: z16.array(ContractPortSchema).default([]), outputs: z16.array(ContractPortSchema).default([]) }).strict(),
+  parameters: z16.object({ variables: z16.array(WorkflowParameterSchema).default([]), outputs: z16.array(WorkflowOutputBindingSchema).default([]) }).strict(),
+  graph: z16.object({ nodes: z16.array(WorkflowNodeSchema), edges: z16.array(WorkflowEdgeSchema).default([]) }).strict(),
+  execution: z16.object({
+    timeoutMs: z16.number().int().positive().optional(),
+    retries: z16.number().int().nonnegative().default(0),
+    concurrencyLimit: z16.number().int().positive().optional(),
+    idempotency: z16.enum(["required", "supported", "none"]),
+    rateLimit: z16.object({ enabled: z16.boolean(), max: z16.number().int().nonnegative(), windowMs: z16.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: 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(),
+    conductor: z16.object({
+      ownerApp: z16.string().optional(),
+      createTime: z16.number().int().nonnegative().optional(),
+      updateTime: z16.number().int().nonnegative().optional(),
+      createdBy: z16.string().optional(),
+      updatedBy: z16.string().optional(),
       failureWorkflow: ContractIdentifierSchema.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()
+      schemaVersion: z16.number().int().positive().optional(),
+      restartable: z16.boolean().optional(),
+      workflowStatusListenerEnabled: z16.boolean().optional(),
+      ownerEmail: z16.string().email().optional(),
+      timeoutPolicy: z16.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+      variables: z16.record(z16.string(), JsonValueSchema).optional(),
+      inputTemplate: z16.record(z16.string(), JsonValueSchema).optional()
     }).strict()
   }).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(),
+  triggers: z16.array(WorkflowTriggerSchema).default([]),
+  views: z16.array(z16.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
+  dataContracts: z16.object({ reads: z16.array(ContractIdentifierSchema).default([]), writes: z16.array(ContractIdentifierSchema).default([]), emits: z16.array(ContractIdentifierSchema).default([]) }).strict(),
+  governance: z16.object({ activated: z16.boolean(), validated: z16.boolean(), validationIssues: z16.array(WorkflowValidationIssueSchema).default([]), hidden: z16.boolean().optional() }).strict(),
+  interfaces: z16.object({
+    openai: z16.object({ enabled: z16.boolean(), modelName: z16.string().trim().min(1).optional() }).strict(),
     shortcutRef: EntityRefSchema.optional(),
     preferredAppId: ContractIdentifierSchema.optional()
   }).strict().superRefine((interfaces, context) => {
@@ -12529,21 +12571,21 @@ var WorkflowDefinitionSchema = z15.object({
 });
 
 // src/contracts/workflow-runtime.ts
-import { z as z16 } from "zod";
-var WorkflowCatalogEntrySchema = z16.object({
-  contract: z16.literal("WorkflowCatalogEntry"),
+import { z as z17 } from "zod";
+var WorkflowCatalogEntrySchema = z17.object({
+  contract: z17.literal("WorkflowCatalogEntry"),
   workflowId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   creatorRef: EntityRefSchema,
   currentDefinitionRef: EntityRefSchema,
-  lifecycle: z16.enum(["ACTIVE", "DELETED"]),
-  asset: z16.object({
-    preset: z16.boolean(),
-    marketplacePublished: z16.boolean(),
+  lifecycle: z17.enum(["ACTIVE", "DELETED"]),
+  asset: z17.object({
+    preset: z17.boolean(),
+    marketplacePublished: z17.boolean(),
     publishConfig: JsonObjectSchema.optional(),
-    sort: z16.number().int(),
+    sort: z17.number().int(),
     forkFromRef: EntityRefSchema.optional(),
-    notAuthorized: z16.boolean()
+    notAuthorized: z17.boolean()
   }).strict(),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema,
@@ -12578,17 +12620,17 @@ var WorkflowCatalogEntrySchema = z16.object({
     });
   }
 });
-var WorkflowPublicationSchema = z16.object({
-  contract: z16.literal("WorkflowPublication"),
+var WorkflowPublicationSchema = z17.object({
+  contract: z17.literal("WorkflowPublication"),
   publicationId: ContractIdentifierSchema,
   definitionRef: EntityRefSchema,
   runtimeDefinitionRef: EntityRefSchema,
   sourceHash: Sha256Schema,
   compiledHash: Sha256Schema,
-  status: z16.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
+  status: z17.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
   publisherRef: EntityRefSchema,
   publishedAt: IsoDateTimeSchema.optional(),
-  failureReason: z16.string().trim().min(1).optional()
+  failureReason: z17.string().trim().min(1).optional()
 }).strict().superRefine((publication, context) => {
   if (publication.definitionRef.kind !== "workflow-definition") {
     context.addIssue({
@@ -12619,12 +12661,12 @@ var WorkflowPublicationSchema = z16.object({
     });
   }
 });
-var WorkflowCompletionCommitSchema = z16.object({
-  contract: z16.literal("WorkflowCompletionCommit"),
+var WorkflowCompletionCommitSchema = z17.object({
+  contract: z17.literal("WorkflowCompletionCommit"),
   commitId: ContractIdentifierSchema,
   run: ApplicationRunSchema,
-  outputs: z16.array(OutputRecordSchema),
-  artifacts: z16.array(ArtifactManifestSchema),
+  outputs: z17.array(OutputRecordSchema),
+  artifacts: z17.array(ArtifactManifestSchema),
   lineage: LineageRecordSchema,
   completedAt: IsoDateTimeSchema
 }).strict().superRefine((commit, context) => {
@@ -12666,15 +12708,15 @@ var WorkflowCompletionCommitSchema = z16.object({
     }
   });
 });
-var WorkflowCompletionReceiptSchema = z16.object({
-  contract: z16.literal("WorkflowCompletionReceipt"),
+var WorkflowCompletionReceiptSchema = z17.object({
+  contract: z17.literal("WorkflowCompletionReceipt"),
   commitId: ContractIdentifierSchema,
   runRef: EntityRefSchema,
-  outputRefs: z16.array(EntityRefSchema),
-  artifactRefs: z16.array(EntityRefSchema),
+  outputRefs: z17.array(EntityRefSchema),
+  artifactRefs: z17.array(EntityRefSchema),
   contentHash: Sha256Schema,
   committedAt: IsoDateTimeSchema,
-  idempotentReplay: z16.boolean()
+  idempotentReplay: z17.boolean()
 }).strict().superRefine((receipt, context) => {
   if (receipt.runRef.kind !== "application-run") {
     context.addIssue({
@@ -12908,6 +12950,9 @@ export {
   PageRuntimeProjectionSchema,
   PageTypeSchema,
   PageVisibilitySchema,
+  PermissionBundleSchema,
+  PermissionDefinitionSchema,
+  ProductAccessDeclarationSchema,
   ProductBodySchema,
   ProductContextSchema,
   ProductDeclarationSchema,
@@ -12943,6 +12988,7 @@ export {
   SourceRecordRefSchema,
   StorageLocatorSchema,
   StudioAgentModeSchema,
+  SystemGroupDefinitionSchema,
   TenantApplicationConfigSchema,
   TenantLandingPageConfigSchema,
   TenantProductConfigSchema,