@inf-monkeys-tech/monkeys 1.1.32 → 1.1.34

package/lib/esm/{chunk-BQ77E4VU.mjs → chunk-L5CYU6K4.mjs}

@@ -7767,9 +7767,10 @@ var RecursivePageExpressionSchema = z4.lazy(() => z4.discriminatedUnion("kind",
   ...["map", "filter", "sum"].map((kind) => z4.object({ kind: z4.literal(kind), source: RecursivePageExpressionSchema, value: RecursivePageExpressionSchema }).strict())
 ]));
 var PAGE_EXPRESSION_LIMITS = Object.freeze({ depth: 32, nodes: 4096, operations: 2e4, collection: 1e3, bytes: 1048576 });
-var assertPageValueBudget = (value) => {
+var PAGE_EXPRESSION_VALUE_LIMITS = Object.freeze({ depth: 32, nodes: 262144, collection: 1e3, bytes: 16777216 });
+var assertValueBudget = (value, limits) => {
   if (value === null || typeof value !== "object") {
-    if (typeof value === "string" && value.length * 2 > PAGE_EXPRESSION_LIMITS.bytes) throw new Error("PAGE_EXPRESSION_BUDGET");
+    if (typeof value === "string" && value.length * 2 > limits.bytes) throw new Error("PAGE_EXPRESSION_BUDGET");
     return;
   }
   const queue = [{ value, depth: 0 }];
@@ -7777,19 +7778,22 @@ var assertPageValueBudget = (value) => {
   let bytes = 0;
   while (queue.length) {
     const item = queue.pop();
-    if (++nodes > PAGE_EXPRESSION_LIMITS.nodes || item.depth > PAGE_EXPRESSION_LIMITS.depth) throw new Error("PAGE_EXPRESSION_BUDGET");
+    if (++nodes > limits.nodes || item.depth > limits.depth) throw new Error("PAGE_EXPRESSION_BUDGET");
+    if (limits === PAGE_EXPRESSION_VALUE_LIMITS && Array.isArray(item.value) && item.value.length > limits.collection) throw new Error("PAGE_EXPRESSION_BUDGET");
     if (typeof item.value === "string") bytes += item.value.length * 2;
     if (item.value && typeof item.value === "object") {
       for (const [key, child] of Object.entries(item.value)) {
         bytes += key.length * 2;
         if (["__proto__", "prototype", "constructor"].includes(key)) throw new Error("PAGE_EXPRESSION_UNSAFE_PATH");
-        if (queue.length >= PAGE_EXPRESSION_LIMITS.nodes) throw new Error("PAGE_EXPRESSION_BUDGET");
+        if (queue.length >= limits.nodes) throw new Error("PAGE_EXPRESSION_BUDGET");
         queue.push({ value: child, depth: item.depth + 1 });
       }
     }
-    if (bytes > PAGE_EXPRESSION_LIMITS.bytes) throw new Error("PAGE_EXPRESSION_BUDGET");
+    if (bytes > limits.bytes) throw new Error("PAGE_EXPRESSION_BUDGET");
   }
 };
+var assertPageValueBudget = (value) => assertValueBudget(value, PAGE_EXPRESSION_LIMITS);
+var assertPageExpressionValueBudget = (value) => assertValueBudget(value, PAGE_EXPRESSION_VALUE_LIMITS);
 var PageExpressionSchema = z4.unknown().superRefine((value, context) => {
   try {
     assertPageValueBudget(value);
@@ -19019,6 +19023,7 @@ var TenantApplicationConfigSchema = z17.object({
   landingPage: TenantLandingPageConfigSchema.optional(),
   auth: z17.object({
     enabled: z17.array(ContractIdentifierSchema).default([]),
+    defaultLoginMethod: z17.string().max(128).optional(),
     oidc: z17.object({
       buttonText: z17.string().optional(),
       autoSignin: z17.boolean().optional()
@@ -19231,9 +19236,40 @@ var TenantRuntimeConfigSchema = z17.object({
   declarativeRuntime: DeclarativeRuntimeRolloutCapabilitySchema.optional()
 }).strict();
 
-// src/contracts/workflow-definition.ts
+// src/contracts/workflow-canvas.ts
 import { z as z18 } from "zod";
-var ConductorTaskTypeSchema = z18.enum([
+var WorkflowCanvasElementSchema = z18.object({
+  id: z18.string().min(1),
+  type: z18.enum(["rectangle", "diamond", "ellipse", "text", "arrow", "line", "freedraw", "image", "frame", "magicframe", "embeddable", "iframe"]),
+  x: z18.number().finite(),
+  y: z18.number().finite(),
+  width: z18.number().finite().nonnegative(),
+  height: z18.number().finite().nonnegative(),
+  customData: z18.object({
+    workflow: z18.object({
+      nodeRef: z18.string().min(1).optional(),
+      edgeRef: z18.string().min(1).optional()
+    }).strict().optional()
+  }).strict().optional()
+}).catchall(JsonValueSchema);
+var WorkflowCanvasSchema = z18.object({
+  engine: z18.literal("excalidraw"),
+  schemaVersion: z18.literal(1),
+  elements: z18.array(WorkflowCanvasElementSchema).max(2e4),
+  files: z18.record(z18.string(), z18.object({
+    reference: z18.string().regex(/^file:\/\/[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/),
+    mimeType: z18.enum(["image/png", "image/jpeg", "image/webp", "image/gif", "image/svg+xml"]),
+    created: z18.number().finite().nonnegative()
+  }).strict())
+}).strict().superRefine((canvas, context) => {
+  if (new Set(canvas.elements.map((element) => element.id)).size !== canvas.elements.length) {
+    context.addIssue({ code: "custom", path: ["elements"], message: "Canvas element identities must be unique." });
+  }
+});
+
+// src/contracts/workflow-definition.ts
+import { z as z19 } from "zod";
+var ConductorTaskTypeSchema = z19.enum([
   "SIMPLE",
   "DYNAMIC",
   "FORK_JOIN",
@@ -19282,46 +19318,46 @@ var requiredTaskFields = {
   WAIT: ["inputParameters"],
   TERMINATE: ["inputParameters"]
 };
-var ConductorTaskDefinitionSchema = z18.lazy(
-  () => z18.object({
+var ConductorTaskDefinitionSchema = z19.lazy(
+  () => z19.object({
     name: ContractIdentifierSchema,
     taskReferenceName: ContractIdentifierSchema,
     type: ConductorTaskTypeSchema,
-    inputParameters: z18.record(z18.string(), JsonValueSchema).optional(),
-    startDelay: z18.number().int().nonnegative().optional(),
-    optional: z18.boolean().optional(),
-    asyncComplete: z18.boolean().optional(),
-    rateLimited: z18.boolean().optional(),
-    retryCount: z18.number().int().nonnegative().optional(),
-    taskDefinition: z18.record(z18.string(), JsonValueSchema).optional(),
-    loopCondition: z18.string().optional(),
-    loopOver: z18.array(ConductorTaskDefinitionSchema).optional(),
-    sink: z18.string().optional(),
-    forkTasks: z18.array(z18.array(ConductorTaskDefinitionSchema)).optional(),
-    joinOn: z18.array(ContractIdentifierSchema).optional(),
-    defaultExclusiveJoinTask: z18.array(ContractIdentifierSchema).optional(),
-    dynamicForkTasksParam: z18.string().optional(),
-    dynamicForkTasksInputParamName: z18.string().optional(),
-    subWorkflowParam: z18.object({
-      $ref: z18.string().optional(),
+    inputParameters: z19.record(z19.string(), JsonValueSchema).optional(),
+    startDelay: z19.number().int().nonnegative().optional(),
+    optional: z19.boolean().optional(),
+    asyncComplete: z19.boolean().optional(),
+    rateLimited: z19.boolean().optional(),
+    retryCount: z19.number().int().nonnegative().optional(),
+    taskDefinition: z19.record(z19.string(), JsonValueSchema).optional(),
+    loopCondition: z19.string().optional(),
+    loopOver: z19.array(ConductorTaskDefinitionSchema).optional(),
+    sink: z19.string().optional(),
+    forkTasks: z19.array(z19.array(ConductorTaskDefinitionSchema)).optional(),
+    joinOn: z19.array(ContractIdentifierSchema).optional(),
+    defaultExclusiveJoinTask: z19.array(ContractIdentifierSchema).optional(),
+    dynamicForkTasksParam: z19.string().optional(),
+    dynamicForkTasksInputParamName: z19.string().optional(),
+    subWorkflowParam: z19.object({
+      $ref: z19.string().optional(),
       name: ContractIdentifierSchema,
-      version: z18.number().int().positive().optional(),
-      taskToDomain: z18.record(z18.string(), z18.string()).optional(),
-      workflowDefinition: z18.record(z18.string(), JsonValueSchema).optional()
+      version: z19.number().int().positive().optional(),
+      taskToDomain: z19.record(z19.string(), z19.string()).optional(),
+      workflowDefinition: z19.record(z19.string(), JsonValueSchema).optional()
     }).strict().optional(),
-    decisionCases: z18.record(z18.string(), z18.array(ConductorTaskDefinitionSchema)).optional(),
-    defaultCase: z18.array(ConductorTaskDefinitionSchema).optional(),
-    evaluatorType: z18.enum(["value-param", "javascript", "graaljs"]).optional(),
-    expression: z18.string().optional(),
+    decisionCases: z19.record(z19.string(), z19.array(ConductorTaskDefinitionSchema)).optional(),
+    defaultCase: z19.array(ConductorTaskDefinitionSchema).optional(),
+    evaluatorType: z19.enum(["value-param", "javascript", "graaljs"]).optional(),
+    expression: z19.string().optional(),
     __alias: JsonValueSchema.optional(),
-    callbackFromWorker: z18.boolean().optional(),
+    callbackFromWorker: z19.boolean().optional(),
     caseExpression: JsonValueSchema.optional(),
-    caseValueParam: z18.string().optional(),
-    dependencies: z18.array(JsonValueSchema).optional(),
-    description: z18.string().optional(),
-    dynamicTaskNameParam: z18.string().optional(),
-    joinMode: z18.string().optional(),
-    permissive: z18.boolean().optional(),
+    caseValueParam: z19.string().optional(),
+    dependencies: z19.array(JsonValueSchema).optional(),
+    description: z19.string().optional(),
+    dynamicTaskNameParam: z19.string().optional(),
+    joinMode: z19.string().optional(),
+    permissive: z19.boolean().optional(),
     joinTaskRef: ContractIdentifierSchema.optional(),
     forkTaskRef: ContractIdentifierSchema.optional()
   }).strict().superRefine((task, context) => {
@@ -19335,29 +19371,29 @@ var ConductorTaskDefinitionSchema = z18.lazy(
     }
   })
 );
-var ConductorWorkflowDefinitionSchema = z18.object({
-  ownerApp: z18.string().optional(),
-  createTime: z18.number().int().nonnegative().optional(),
-  updateTime: z18.number().int().nonnegative().optional(),
-  createdBy: z18.string().optional(),
-  updatedBy: z18.string().optional(),
+var ConductorWorkflowDefinitionSchema = z19.object({
+  ownerApp: z19.string().optional(),
+  createTime: z19.number().int().nonnegative().optional(),
+  updateTime: z19.number().int().nonnegative().optional(),
+  createdBy: z19.string().optional(),
+  updatedBy: z19.string().optional(),
   name: ContractIdentifierSchema,
-  description: z18.string().optional(),
-  version: z18.number().int().positive(),
-  tasks: z18.array(ConductorTaskDefinitionSchema),
-  inputParameters: z18.array(ContractIdentifierSchema),
-  outputParameters: z18.record(z18.string(), JsonValueSchema).optional(),
+  description: z19.string().optional(),
+  version: z19.number().int().positive(),
+  tasks: z19.array(ConductorTaskDefinitionSchema),
+  inputParameters: z19.array(ContractIdentifierSchema),
+  outputParameters: z19.record(z19.string(), JsonValueSchema).optional(),
   failureWorkflow: ContractIdentifierSchema.optional(),
-  schemaVersion: z18.number().int().positive().optional(),
-  restartable: z18.boolean().optional(),
-  workflowStatusListenerEnabled: z18.boolean().optional(),
-  ownerEmail: z18.string().email().optional(),
-  timeoutPolicy: z18.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
-  timeoutSeconds: z18.number().int().nonnegative(),
-  variables: z18.record(z18.string(), JsonValueSchema).optional(),
-  inputTemplate: z18.record(z18.string(), JsonValueSchema).optional()
+  schemaVersion: z19.number().int().positive().optional(),
+  restartable: z19.boolean().optional(),
+  workflowStatusListenerEnabled: z19.boolean().optional(),
+  ownerEmail: z19.string().email().optional(),
+  timeoutPolicy: z19.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+  timeoutSeconds: z19.number().int().nonnegative(),
+  variables: z19.record(z19.string(), JsonValueSchema).optional(),
+  inputTemplate: z19.record(z19.string(), JsonValueSchema).optional()
 }).strict();
-var WorkflowParameterTypeSchema = z18.enum([
+var WorkflowParameterTypeSchema = z19.enum([
   "string",
   "file",
   "number",
@@ -19367,214 +19403,214 @@ var WorkflowParameterTypeSchema = z18.enum([
   "notice",
   "canvas-assist"
 ]);
-var WorkflowConditionalStateSchema = z18.object({
-  conditions: z18.array(
-    z18.object({
-      field: z18.string(),
-      operator: z18.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
+var WorkflowConditionalStateSchema = z19.object({
+  conditions: z19.array(
+    z19.object({
+      field: z19.string(),
+      operator: z19.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
       value: JsonValueSchema
     }).strict()
   ),
-  logic: z18.enum(["AND", "OR"]).optional()
+  logic: z19.enum(["AND", "OR"]).optional()
 }).strict();
-var ImageSelectMappingAppearanceSchema = z18.object({
-  columns: z18.number().int().min(1).max(4).optional(),
-  cardSize: z18.enum(["sm", "md", "lg"]).optional(),
-  imageAspectRatio: z18.enum(["square", "4:5", "3:4", "16:9"]).optional(),
-  gap: z18.enum(["sm", "md", "lg"]).optional(),
-  radius: z18.enum(["sm", "md", "lg", "xl"]).optional(),
-  borderStyle: z18.enum(["none", "soft", "strong"]).optional(),
-  borderWidth: z18.union([z18.literal(0), z18.literal(1), z18.literal(2)]).optional(),
-  enableScroll: z18.boolean().optional(),
-  maxHeight: z18.number().int().min(160).max(1200).optional(),
-  enableCollapse: z18.boolean().optional(),
-  visibleRows: z18.number().int().min(1).max(6).optional(),
-  hideLabel: z18.boolean().optional(),
-  hideDescription: z18.boolean().optional(),
-  hideValue: z18.boolean().optional()
+var ImageSelectMappingAppearanceSchema = z19.object({
+  columns: z19.number().int().min(1).max(4).optional(),
+  cardSize: z19.enum(["sm", "md", "lg"]).optional(),
+  imageAspectRatio: z19.enum(["square", "4:5", "3:4", "16:9"]).optional(),
+  gap: z19.enum(["sm", "md", "lg"]).optional(),
+  radius: z19.enum(["sm", "md", "lg", "xl"]).optional(),
+  borderStyle: z19.enum(["none", "soft", "strong"]).optional(),
+  borderWidth: z19.union([z19.literal(0), z19.literal(1), z19.literal(2)]).optional(),
+  enableScroll: z19.boolean().optional(),
+  maxHeight: z19.number().int().min(160).max(1200).optional(),
+  enableCollapse: z19.boolean().optional(),
+  visibleRows: z19.number().int().min(1).max(6).optional(),
+  hideLabel: z19.boolean().optional(),
+  hideDescription: z19.boolean().optional(),
+  hideValue: z19.boolean().optional()
 }).strict();
-var ComfyWorkflowPortBindingSchema = z18.object({
-  node: z18.union([z18.string(), z18.number()]),
-  key: z18.string().optional()
+var ComfyWorkflowPortBindingSchema = z19.object({
+  node: z19.union([z19.string(), z19.number()]),
+  key: z19.string().optional()
 }).strict();
-var WorkflowParameterTypeOptionsSchema = z18.object({
-  editor: z18.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
-  editorLanguage: z18.enum(["javaScript", "json", "python", "sql"]).optional(),
-  maxValue: z18.number().optional(),
-  minValue: z18.number().optional(),
-  max: z18.number().optional(),
-  min: z18.number().optional(),
-  multipleValues: z18.boolean().optional(),
-  numberPrecision: z18.number().nonnegative().optional(),
-  password: z18.boolean().optional(),
-  rows: z18.number().int().positive().optional(),
-  assetType: z18.string().optional(),
-  accept: z18.string().optional(),
-  maxSize: z18.number().positive().optional(),
-  fileType: z18.string().optional(),
-  aiMultiShotMainImageField: z18.string().optional(),
-  aiMultiShotWorkflowAppId: z18.string().optional(),
-  aiMultiShotWorkflowId: z18.string().optional(),
-  allowCustomInput: z18.boolean().optional(),
-  allowUploadVideo: z18.boolean().optional(),
-  aspectRatioField: z18.string().optional(),
-  assemblyValueType: z18.string().optional(),
-  autoAnalyzeDesignImage: z18.boolean().optional(),
-  autoDetectAspectRatio: z18.boolean().optional(),
-  autoIncrementId: z18.boolean().optional(),
+var WorkflowParameterTypeOptionsSchema = z19.object({
+  editor: z19.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
+  editorLanguage: z19.enum(["javaScript", "json", "python", "sql"]).optional(),
+  maxValue: z19.number().optional(),
+  minValue: z19.number().optional(),
+  max: z19.number().optional(),
+  min: z19.number().optional(),
+  multipleValues: z19.boolean().optional(),
+  numberPrecision: z19.number().nonnegative().optional(),
+  password: z19.boolean().optional(),
+  rows: z19.number().int().positive().optional(),
+  assetType: z19.string().optional(),
+  accept: z19.string().optional(),
+  maxSize: z19.number().positive().optional(),
+  fileType: z19.string().optional(),
+  aiMultiShotMainImageField: z19.string().optional(),
+  aiMultiShotWorkflowAppId: z19.string().optional(),
+  aiMultiShotWorkflowId: z19.string().optional(),
+  allowCustomInput: z19.boolean().optional(),
+  allowUploadVideo: z19.boolean().optional(),
+  aspectRatioField: z19.string().optional(),
+  assemblyValueType: z19.string().optional(),
+  autoAnalyzeDesignImage: z19.boolean().optional(),
+  autoDetectAspectRatio: z19.boolean().optional(),
+  autoIncrementId: z19.boolean().optional(),
   comfyOptions: ComfyWorkflowPortBindingSchema.optional(),
-  comfyuiModelServerId: z18.string().optional(),
-  comfyuiModelTypeName: z18.string().optional(),
+  comfyuiModelServerId: z19.string().optional(),
+  comfyuiModelTypeName: z19.string().optional(),
   defaultCustomInput: JsonValueSchema.optional(),
-  descriptionAlert: z18.boolean().optional(),
-  disabled: z18.union([z18.boolean(), WorkflowConditionalStateSchema]).optional(),
-  editable: z18.union([z18.boolean(), WorkflowConditionalStateSchema]).optional(),
-  enableAiMultiShot: z18.boolean().optional(),
-  enableBooleanSwitchMode: z18.boolean().optional(),
-  enableClear: z18.boolean().optional(),
-  enableExpand: z18.boolean().optional(),
-  enableImageCrop: z18.boolean().optional(),
-  enableImageMask: z18.boolean().optional(),
-  enableImageOverlay: z18.boolean().optional(),
-  enablePopupEditor: z18.boolean().optional(),
-  enablePromptFontSize: z18.boolean().optional(),
-  enableReset: z18.boolean().optional(),
-  enableSelectItemIcon: z18.boolean().optional(),
-  enableSelectList: z18.boolean().optional(),
-  enableSelectSearch: z18.boolean().optional(),
-  enableSliderEnterMode: z18.boolean().optional(),
-  enableVoice: z18.boolean().optional(),
-  expandButtonText: z18.string().optional(),
-  foldUp: z18.boolean().optional(),
-  hidden: z18.boolean().optional(),
-  hideRequiredDot: z18.boolean().optional(),
-  inlineTitleWithSelect: z18.boolean().optional(),
-  knowledgeGraphButtonText: z18.string().optional(),
-  identifyAttributeCount: z18.union([z18.number().nonnegative(), z18.string().min(1), z18.object({ min: z18.number().nonnegative().optional(), max: z18.number().nonnegative().optional() }).strict()]).optional(),
-  identifyAttributes: z18.array(JsonValueSchema).optional(),
-  identifyMaxVariants: z18.number().int().nonnegative().optional(),
-  identifySourceField: z18.string().optional(),
-  imageOverlayBaseField: z18.string().optional(),
-  imageOverlayOverlayField: z18.string().optional(),
+  descriptionAlert: z19.boolean().optional(),
+  disabled: z19.union([z19.boolean(), WorkflowConditionalStateSchema]).optional(),
+  editable: z19.union([z19.boolean(), WorkflowConditionalStateSchema]).optional(),
+  enableAiMultiShot: z19.boolean().optional(),
+  enableBooleanSwitchMode: z19.boolean().optional(),
+  enableClear: z19.boolean().optional(),
+  enableExpand: z19.boolean().optional(),
+  enableImageCrop: z19.boolean().optional(),
+  enableImageMask: z19.boolean().optional(),
+  enableImageOverlay: z19.boolean().optional(),
+  enablePopupEditor: z19.boolean().optional(),
+  enablePromptFontSize: z19.boolean().optional(),
+  enableReset: z19.boolean().optional(),
+  enableSelectItemIcon: z19.boolean().optional(),
+  enableSelectList: z19.boolean().optional(),
+  enableSelectSearch: z19.boolean().optional(),
+  enableSliderEnterMode: z19.boolean().optional(),
+  enableVoice: z19.boolean().optional(),
+  expandButtonText: z19.string().optional(),
+  foldUp: z19.boolean().optional(),
+  hidden: z19.boolean().optional(),
+  hideRequiredDot: z19.boolean().optional(),
+  inlineTitleWithSelect: z19.boolean().optional(),
+  knowledgeGraphButtonText: z19.string().optional(),
+  identifyAttributeCount: z19.union([z19.number().nonnegative(), z19.string().min(1), z19.object({ min: z19.number().nonnegative().optional(), max: z19.number().nonnegative().optional() }).strict()]).optional(),
+  identifyAttributes: z19.array(JsonValueSchema).optional(),
+  identifyMaxVariants: z19.number().int().nonnegative().optional(),
+  identifySourceField: z19.string().optional(),
+  imageOverlayBaseField: z19.string().optional(),
+  imageOverlayOverlayField: z19.string().optional(),
   imageSelectMappingAppearance: ImageSelectMappingAppearanceSchema.optional(),
-  imageSelectMappingColumns: z18.number().int().min(1).max(4).optional(),
-  imageSelectMappingEnableCustomUpload: z18.boolean().optional(),
-  imageSelectMappingHideLabel: z18.boolean().optional(),
-  imageSelectMappingHideLink: z18.boolean().optional(),
-  imageSelectMappingHideMeta: z18.boolean().optional(),
-  imageSelectMappingInlineUseLargeUploadBox: z18.boolean().optional(),
-  imageSelectMappingPromptField: z18.string().optional(),
-  imageSelectMappingTabOrder: z18.enum(["template-first", "upload-first"]).optional(),
-  imageSelectMappingTabWidthMode: z18.enum(["content", "fill"]).optional(),
+  imageSelectMappingColumns: z19.number().int().min(1).max(4).optional(),
+  imageSelectMappingEnableCustomUpload: z19.boolean().optional(),
+  imageSelectMappingHideLabel: z19.boolean().optional(),
+  imageSelectMappingHideLink: z19.boolean().optional(),
+  imageSelectMappingHideMeta: z19.boolean().optional(),
+  imageSelectMappingInlineUseLargeUploadBox: z19.boolean().optional(),
+  imageSelectMappingPromptField: z19.string().optional(),
+  imageSelectMappingTabOrder: z19.enum(["template-first", "upload-first"]).optional(),
+  imageSelectMappingTabWidthMode: z19.enum(["content", "fill"]).optional(),
   imageSelectMappingTemplatePrompt: LocalizedTextSchema.optional(),
   imageSelectMappingTemplateTabTitle: LocalizedTextSchema.optional(),
-  imageSelectMappingUploadMode: z18.enum(["tabs", "inline"]).optional(),
+  imageSelectMappingUploadMode: z19.enum(["tabs", "inline"]).optional(),
   imageSelectMappingUploadPrompt: LocalizedTextSchema.optional(),
   imageSelectMappingUploadTabTitle: LocalizedTextSchema.optional(),
-  endpoints: z18.array(JsonValueSchema).optional(),
-  examples: z18.array(JsonValueSchema).optional(),
+  endpoints: z19.array(JsonValueSchema).optional(),
+  examples: z19.array(JsonValueSchema).optional(),
   extraData: JsonValueSchema.optional(),
   layer: JsonValueSchema.optional(),
   map: JsonValueSchema.optional(),
-  multiline: z18.boolean().optional(),
-  options: z18.array(JsonValueSchema).optional(),
-  originalFiles: z18.array(JsonValueSchema).optional(),
+  multiline: z19.boolean().optional(),
+  options: z19.array(JsonValueSchema).optional(),
+  originalFiles: z19.array(JsonValueSchema).optional(),
   placeholder: LocalizedTextSchema.optional(),
-  preserveSelectListOrder: z18.boolean().optional(),
+  preserveSelectListOrder: z19.boolean().optional(),
   promptDictionary: JsonValueSchema.optional(),
-  promptFontSize: z18.number().optional(),
+  promptFontSize: z19.number().optional(),
   promptModeToggle: JsonValueSchema.optional(),
-  requireActiveSelectFilter: z18.boolean().optional(),
-  restoreDefaultOnEmptyEnter: z18.boolean().optional(),
-  search: z18.boolean().optional(),
-  selectButtonEnableCollapse: z18.boolean().optional(),
-  selectButtonVisibleRows: z18.number().int().positive().optional(),
-  selectList: z18.array(JsonValueSchema).optional(),
-  selectListDisplayMode: z18.string().optional(),
-  selectPromptField: z18.string().optional(),
-  showAddLocalFileButton: z18.boolean().optional(),
-  singleColumn: z18.boolean().optional(),
-  singleFrameForMultiple: z18.boolean().optional(),
-  textSingleLine: z18.boolean().optional(),
-  textareaMiniHeight: z18.number().nonnegative().optional(),
+  requireActiveSelectFilter: z19.boolean().optional(),
+  restoreDefaultOnEmptyEnter: z19.boolean().optional(),
+  search: z19.boolean().optional(),
+  selectButtonEnableCollapse: z19.boolean().optional(),
+  selectButtonVisibleRows: z19.number().int().positive().optional(),
+  selectList: z19.array(JsonValueSchema).optional(),
+  selectListDisplayMode: z19.string().optional(),
+  selectPromptField: z19.string().optional(),
+  showAddLocalFileButton: z19.boolean().optional(),
+  singleColumn: z19.boolean().optional(),
+  singleFrameForMultiple: z19.boolean().optional(),
+  textSingleLine: z19.boolean().optional(),
+  textareaMiniHeight: z19.number().nonnegative().optional(),
   tips: LocalizedTextSchema.optional(),
   visibility: JsonValueSchema.optional(),
-  voiceButtonText: z18.string().optional(),
-  designAnalysisFields: z18.array(JsonValueSchema).optional(),
-  designAnalysisFillStrategy: z18.string().optional(),
-  designAnalysisMaxFields: z18.number().int().nonnegative().optional(),
-  designAnalysisType: z18.string().optional(),
-  designAnalysisFieldPrefix: z18.string().optional()
+  voiceButtonText: z19.string().optional(),
+  designAnalysisFields: z19.array(JsonValueSchema).optional(),
+  designAnalysisFillStrategy: z19.string().optional(),
+  designAnalysisMaxFields: z19.number().int().nonnegative().optional(),
+  designAnalysisType: z19.string().optional(),
+  designAnalysisFieldPrefix: z19.string().optional()
 }).strict();
-var WorkflowParameterSchema = z18.lazy(
-  () => z18.object({
+var WorkflowParameterSchema = z19.lazy(
+  () => z19.object({
     displayName: LocalizedTextSchema,
     name: ContractIdentifierSchema,
     type: WorkflowParameterTypeSchema,
     typeOptions: WorkflowParameterTypeOptionsSchema.optional(),
     default: JsonValueSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    hint: z18.string().optional(),
-    displayOptions: z18.object({
-      hide: z18.record(z18.string(), z18.array(JsonValueSchema)).optional(),
-      show: z18.record(z18.string(), z18.array(JsonValueSchema)).optional()
+    hint: z19.string().optional(),
+    displayOptions: z19.object({
+      hide: z19.record(z19.string(), z19.array(JsonValueSchema)).optional(),
+      show: z19.record(z19.string(), z19.array(JsonValueSchema)).optional()
     }).strict().optional(),
-    options: z18.array(z18.union([
-      z18.object({ name: LocalizedTextSchema, value: z18.union([z18.string(), z18.number(), z18.boolean()]), action: z18.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
+    options: z19.array(z19.union([
+      z19.object({ name: LocalizedTextSchema, value: z19.union([z19.string(), z19.number(), z19.boolean()]), action: z19.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
       WorkflowParameterSchema,
-      z18.object({ displayName: z18.string(), name: ContractIdentifierSchema, values: z18.array(WorkflowParameterSchema) }).strict()
+      z19.object({ displayName: z19.string(), name: ContractIdentifierSchema, values: z19.array(WorkflowParameterSchema) }).strict()
     ])).optional(),
     placeholder: LocalizedTextSchema.optional(),
-    isNodeSetting: z18.boolean().optional(),
-    noDataExpression: z18.boolean().optional(),
-    required: z18.boolean().optional(),
-    example: z18.string().optional(),
-    extractValue: z18.object({ type: z18.literal("regex"), regex: z18.string() }).strict().optional(),
-    properties: z18.array(WorkflowParameterSchema).optional(),
-    assetType: z18.string().optional(),
-    flag: z18.boolean().optional(),
-    enableExpand: z18.boolean().optional(),
-    enableVoice: z18.boolean().optional(),
-    expandButtonText: z18.string().optional(),
-    knowledgeGraphButtonText: z18.string().optional(),
-    selectListDisplayMode: z18.string().optional(),
-    voiceButtonText: z18.string().optional()
+    isNodeSetting: z19.boolean().optional(),
+    noDataExpression: z19.boolean().optional(),
+    required: z19.boolean().optional(),
+    example: z19.string().optional(),
+    extractValue: z19.object({ type: z19.literal("regex"), regex: z19.string() }).strict().optional(),
+    properties: z19.array(WorkflowParameterSchema).optional(),
+    assetType: z19.string().optional(),
+    flag: z19.boolean().optional(),
+    enableExpand: z19.boolean().optional(),
+    enableVoice: z19.boolean().optional(),
+    expandButtonText: z19.string().optional(),
+    knowledgeGraphButtonText: z19.string().optional(),
+    selectListDisplayMode: z19.string().optional(),
+    voiceButtonText: z19.string().optional()
   }).strict()
 );
-var WorkflowOutputBindingSchema = z18.object({ key: ContractIdentifierSchema, value: z18.string() }).strict();
-var WorkflowNodeSchema = z18.object({
+var WorkflowOutputBindingSchema = z19.object({ key: ContractIdentifierSchema, value: z19.string() }).strict();
+var WorkflowNodeSchema = z19.object({
   id: ContractIdentifierSchema,
   referenceName: ContractIdentifierSchema,
   capabilityRef: ContractIdentifierSchema,
   capabilityVersion: ContractIdentifierSchema.optional(),
-  inputBindings: z18.record(z18.string(), JsonValueSchema).default({}),
-  configuration: z18.object({ executor: z18.literal("conductor"), task: ConductorTaskDefinitionSchema }).strict()
+  inputBindings: z19.record(z19.string(), JsonValueSchema).default({}),
+  configuration: z19.object({ executor: z19.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 = z18.object({
+var WorkflowEdgeSchema = z19.object({
   from: ContractIdentifierSchema,
   to: ContractIdentifierSchema,
   outputPort: ContractIdentifierSchema.optional(),
   inputPort: ContractIdentifierSchema.optional(),
-  condition: z18.string().optional()
+  condition: z19.string().optional()
 }).strict();
-var WorkflowTriggerSchema = z18.object({
+var WorkflowTriggerSchema = z19.object({
   id: ContractIdentifierSchema,
-  type: z18.enum(["manual", "schedule", "webhook", "event", "api"]),
-  enabled: z18.boolean(),
-  schedule: z18.object({ cron: z18.string().trim().min(1) }).strict().optional(),
-  webhook: z18.object({
-    path: z18.string().trim().min(1).optional(),
-    method: z18.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
-    auth: z18.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
-    basicAuth: z18.object({ username: z18.string(), password: z18.string() }).strict().optional(),
-    headerAuth: z18.object({ name: z18.string().trim().min(1), value: z18.string() }).strict().optional(),
-    responseUntil: z18.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
+  type: z19.enum(["manual", "schedule", "webhook", "event", "api"]),
+  enabled: z19.boolean(),
+  schedule: z19.object({ cron: z19.string().trim().min(1) }).strict().optional(),
+  webhook: z19.object({
+    path: z19.string().trim().min(1).optional(),
+    method: z19.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
+    auth: z19.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
+    basicAuth: z19.object({ username: z19.string(), password: z19.string() }).strict().optional(),
+    headerAuth: z19.object({ name: z19.string().trim().min(1), value: z19.string() }).strict().optional(),
+    responseUntil: z19.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
   }).strict().optional(),
-  event: z18.object({
+  event: z19.object({
     eventType: ContractIdentifierSchema,
     configuration: JsonValueSchema.optional()
   }).strict().optional()
@@ -19583,63 +19619,63 @@ var WorkflowTriggerSchema = z18.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 = z18.object({
+var WorkflowValidationIssueSchema = z19.object({
   taskReferenceName: ContractIdentifierSchema,
-  issueType: z18.enum(["ERROR", "WARNING"]),
-  detailReason: z18.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
-  humanMessage: z18.object({ en: z18.string(), zh: z18.string() }).strict()
+  issueType: z19.enum(["ERROR", "WARNING"]),
+  detailReason: z19.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
+  humanMessage: z19.object({ en: z19.string(), zh: z19.string() }).strict()
 }).strict();
-var WorkflowDefinitionSchema = z18.object({
-  contract: z18.literal("WorkflowDefinition"),
+var WorkflowDefinitionSchema = z19.object({
+  contract: z19.literal("WorkflowDefinition"),
   metadata: ContractMetadataSchema.omit({ name: true, description: true, labels: true }).extend({
     name: LocalizedTextSchema,
     description: LocalizedTextSchema.optional(),
-    role: z18.enum(["workflow", "template"]),
+    role: z19.enum(["workflow", "template"]),
     teamId: ContractIdentifierSchema,
     creatorRef: EntityRefSchema,
-    tags: z18.array(ContractIdentifierSchema).default([])
+    tags: z19.array(ContractIdentifierSchema).default([])
   }).strict(),
-  revision: z18.object({
-    kind: z18.enum(["release", "backup"]),
-    recordVersion: z18.number().int().positive(),
-    sourceVersion: z18.number().int().positive().optional()
+  revision: z19.object({
+    kind: z19.enum(["release", "backup"]),
+    recordVersion: z19.number().int().positive(),
+    sourceVersion: z19.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: z18.object({ iconUrl: z18.string().optional(), thumbnail: z18.string().optional() }).strict(),
-  ports: z18.object({ inputs: z18.array(ContractPortSchema).default([]), outputs: z18.array(ContractPortSchema).default([]) }).strict(),
-  parameters: z18.object({ variables: z18.array(WorkflowParameterSchema).default([]), outputs: z18.array(WorkflowOutputBindingSchema).default([]) }).strict(),
-  graph: z18.object({ nodes: z18.array(WorkflowNodeSchema), edges: z18.array(WorkflowEdgeSchema).default([]) }).strict(),
-  execution: z18.object({
-    timeoutMs: z18.number().int().positive().optional(),
-    retries: z18.number().int().nonnegative().default(0),
-    concurrencyLimit: z18.number().int().positive().optional(),
-    idempotency: z18.enum(["required", "supported", "none"]),
-    rateLimit: z18.object({ enabled: z18.boolean(), max: z18.number().int().nonnegative(), windowMs: z18.number().int().nonnegative() }).strict().superRefine((rateLimit, context) => {
+  presentation: z19.object({ iconUrl: z19.string().optional(), thumbnail: z19.string().optional(), canvas: WorkflowCanvasSchema.optional() }).strict(),
+  ports: z19.object({ inputs: z19.array(ContractPortSchema).default([]), outputs: z19.array(ContractPortSchema).default([]) }).strict(),
+  parameters: z19.object({ variables: z19.array(WorkflowParameterSchema).default([]), outputs: z19.array(WorkflowOutputBindingSchema).default([]) }).strict(),
+  graph: z19.object({ nodes: z19.array(WorkflowNodeSchema), edges: z19.array(WorkflowEdgeSchema).default([]) }).strict(),
+  execution: z19.object({
+    timeoutMs: z19.number().int().positive().optional(),
+    retries: z19.number().int().nonnegative().default(0),
+    concurrencyLimit: z19.number().int().positive().optional(),
+    idempotency: z19.enum(["required", "supported", "none"]),
+    rateLimit: z19.object({ enabled: z19.boolean(), max: z19.number().int().nonnegative(), windowMs: z19.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: z18.object({
-      ownerApp: z18.string().optional(),
-      createTime: z18.number().int().nonnegative().optional(),
-      updateTime: z18.number().int().nonnegative().optional(),
-      createdBy: z18.string().optional(),
-      updatedBy: z18.string().optional(),
+    conductor: z19.object({
+      ownerApp: z19.string().optional(),
+      createTime: z19.number().int().nonnegative().optional(),
+      updateTime: z19.number().int().nonnegative().optional(),
+      createdBy: z19.string().optional(),
+      updatedBy: z19.string().optional(),
       failureWorkflow: ContractIdentifierSchema.optional(),
-      schemaVersion: z18.number().int().positive().optional(),
-      restartable: z18.boolean().optional(),
-      workflowStatusListenerEnabled: z18.boolean().optional(),
-      ownerEmail: z18.string().email().optional(),
-      timeoutPolicy: z18.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
-      variables: z18.record(z18.string(), JsonValueSchema).optional(),
-      inputTemplate: z18.record(z18.string(), JsonValueSchema).optional()
+      schemaVersion: z19.number().int().positive().optional(),
+      restartable: z19.boolean().optional(),
+      workflowStatusListenerEnabled: z19.boolean().optional(),
+      ownerEmail: z19.string().email().optional(),
+      timeoutPolicy: z19.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+      variables: z19.record(z19.string(), JsonValueSchema).optional(),
+      inputTemplate: z19.record(z19.string(), JsonValueSchema).optional()
     }).strict()
   }).strict(),
-  triggers: z18.array(WorkflowTriggerSchema).default([]),
-  views: z18.array(z18.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
-  dataContracts: z18.object({ reads: z18.array(ContractIdentifierSchema).default([]), writes: z18.array(ContractIdentifierSchema).default([]), emits: z18.array(ContractIdentifierSchema).default([]) }).strict(),
-  governance: z18.object({ activated: z18.boolean(), validated: z18.boolean(), validationIssues: z18.array(WorkflowValidationIssueSchema).default([]), hidden: z18.boolean().optional() }).strict(),
-  interfaces: z18.object({
-    openai: z18.object({ enabled: z18.boolean(), modelName: z18.string().trim().min(1).optional() }).strict(),
+  triggers: z19.array(WorkflowTriggerSchema).default([]),
+  views: z19.array(z19.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
+  dataContracts: z19.object({ reads: z19.array(ContractIdentifierSchema).default([]), writes: z19.array(ContractIdentifierSchema).default([]), emits: z19.array(ContractIdentifierSchema).default([]) }).strict(),
+  governance: z19.object({ activated: z19.boolean(), validated: z19.boolean(), validationIssues: z19.array(WorkflowValidationIssueSchema).default([]), hidden: z19.boolean().optional() }).strict(),
+  interfaces: z19.object({
+    openai: z19.object({ enabled: z19.boolean(), modelName: z19.string().trim().min(1).optional() }).strict(),
     shortcutRef: EntityRefSchema.optional(),
     preferredAppId: ContractIdentifierSchema.optional()
   }).strict().superRefine((interfaces, context) => {
@@ -19656,101 +19692,110 @@ var WorkflowDefinitionSchema = z18.object({
   });
   if (definition.revision.kind === "release" && definition.metadata.version !== definition.revision.recordVersion) context.addIssue({ code: "custom", path: ["revision", "recordVersion"], message: "Release recordVersion must equal metadata.version." });
 });
+var WorkflowEditorCommandSchema = z19.object({
+  expectedRecordVersion: z19.number().int().positive(),
+  requestId: z19.string().min(1).max(128),
+  definition: WorkflowDefinitionSchema
+}).strict();
+var WorkflowEditorDocumentSchema = z19.object({
+  recordVersion: z19.number().int().positive(),
+  definition: WorkflowDefinitionSchema
+}).strict();
 
 // src/contracts/workflow-column.ts
-import { z as z19 } from "zod";
-var WorkflowColumnFieldRefSchema = z19.object({
+import { z as z20 } from "zod";
+var WorkflowColumnFieldRefSchema = z20.object({
   ontologyId: ContractIdentifierSchema,
   fieldKey: ContractIdentifierSchema
 }).strict();
-var WorkflowColumnInputSchema = z19.discriminatedUnion("kind", [
-  z19.object({ kind: z19.literal("default") }).strict(),
-  z19.object({ kind: z19.literal("constant"), value: JsonValueSchema }).strict(),
-  z19.object({ kind: z19.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
-  z19.object({
-    kind: z19.literal("context"),
-    field: z19.enum(["assetId", "teamId", "ontologyId", "columnId"])
+var WorkflowColumnInputSchema = z20.discriminatedUnion("kind", [
+  z20.object({ kind: z20.literal("default") }).strict(),
+  z20.object({ kind: z20.literal("constant"), value: JsonValueSchema }).strict(),
+  z20.object({ kind: z20.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
+  z20.object({
+    kind: z20.literal("context"),
+    field: z20.enum(["assetId", "teamId", "ontologyId", "columnId"])
   }).strict()
 ]);
-var WorkflowColumnDependencySchema = z19.discriminatedUnion("kind", [
-  z19.object({ kind: z19.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
-  z19.object({
-    kind: z19.literal("relation"),
+var WorkflowColumnDependencySchema = z20.discriminatedUnion("kind", [
+  z20.object({ kind: z20.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
+  z20.object({
+    kind: z20.literal("relation"),
     relation: WorkflowColumnFieldRefSchema,
-    direction: z19.enum(["incoming", "outgoing"]),
-    fields: z19.array(WorkflowColumnFieldRefSchema).max(100)
+    direction: z20.enum(["incoming", "outgoing"]),
+    fields: z20.array(WorkflowColumnFieldRefSchema).max(100)
   }).strict()
 ]);
-var WorkflowColumnOutputPathSchema = z19.array(z19.string().min(1).max(256)).max(20);
-var WorkflowColumnOutputSchema = z19.object({
-  type: z19.enum(["number", "text", "json"]),
+var WorkflowColumnOutputPathSchema = z20.array(z20.string().min(1).max(256)).max(20);
+var WorkflowColumnOutputSchema = z20.object({
+  type: z20.enum(["number", "text", "json"]),
   path: WorkflowColumnOutputPathSchema,
-  nullable: z19.boolean().default(false)
+  nullable: z20.boolean().default(false)
 }).strict();
-var WorkflowColumnBindingSchema = z19.object({
-  contract: z19.literal("WorkflowColumnBinding"),
-  version: z19.literal(1),
-  enabled: z19.boolean(),
-  paused: z19.boolean().default(false),
-  workflow: z19.object({
+var WorkflowColumnBindingSchema = z20.object({
+  contract: z20.literal("WorkflowColumnBinding"),
+  version: z20.literal(1),
+  enabled: z20.boolean(),
+  paused: z20.boolean().default(false),
+  workflow: z20.object({
     id: ContractIdentifierSchema,
-    version: z19.number().int().positive(),
+    version: z20.number().int().positive(),
     inputSchemaHash: Sha256Schema
   }).strict(),
-  inputs: z19.record(z19.string().min(1).max(128), WorkflowColumnInputSchema),
-  dependencies: z19.array(WorkflowColumnDependencySchema).max(100).default([]),
+  inputs: z20.record(z20.string().min(1).max(128), WorkflowColumnInputSchema),
+  dependencies: z20.array(WorkflowColumnDependencySchema).max(100).default([]),
   output: WorkflowColumnOutputSchema,
-  policy: z19.object({
-    debounceMs: z19.number().int().min(0).max(3e4).default(5e3),
-    maxDelayMs: z19.number().int().min(0).max(3e4).default(3e4),
-    concurrency: z19.number().int().min(1).max(32).default(2),
+  policy: z20.object({
+    debounceMs: z20.number().int().min(0).max(3e4).default(5e3),
+    maxDelayMs: z20.number().int().min(0).max(3e4).default(3e4),
+    concurrency: z20.number().int().min(1).max(32).default(2),
     // Indexed queries need visible projections of their declared sources before execution.
-    requireSearchProjection: z19.boolean().optional()
+    requireSearchProjection: z20.boolean().optional()
   }).strict().default({ debounceMs: 5e3, maxDelayMs: 3e4, concurrency: 2 }),
   // The workflow supplies an ISO datetime with offset for one future expiry.
   // Scheduling infrastructure needs no knowledge of months or business periods.
-  expiry: z19.object({ path: WorkflowColumnOutputPathSchema }).strict().optional()
+  expiry: z20.object({ path: WorkflowColumnOutputPathSchema }).strict().optional()
 }).strict();
 
 // src/contracts/component-assembly.ts
-import { z as z20 } from "zod";
-var member = z20.string().min(1).max(256).refine(
+import { z as z21 } from "zod";
+var member = z21.string().min(1).max(256).refine(
   (value) => !["__proto__", "prototype", "constructor"].includes(value),
   "Unsafe component member."
 );
-var ComponentEventArgumentSchema = z20.object({
-  argument: z20.number().int().min(0).max(31),
-  path: z20.array(member).max(16).default([])
+var ComponentEventArgumentSchema = z21.object({
+  argument: z21.number().int().min(0).max(31),
+  path: z21.array(member).max(16).default([])
 }).strict();
-var ComponentEventBindingSchema = z20.object({
+var ComponentEventBindingSchema = z21.object({
   port: ContractIdentifierSchema,
-  arguments: z20.array(ComponentEventArgumentSchema).max(32).default([]),
-  preventDefault: z20.boolean().default(false),
-  stopPropagation: z20.boolean().default(false)
+  arguments: z21.array(ComponentEventArgumentSchema).max(32).default([]),
+  preventDefault: z21.boolean().default(false),
+  stopPropagation: z21.boolean().default(false)
 }).strict();
-var ComponentMessageSchema = z20.union([
+var ComponentMessageSchema = z21.union([
   ContractIdentifierSchema,
-  z20.object({ textI18n: I18nTextSchema }).strict(),
-  z20.object({ key: ContractIdentifierSchema, values: z20.record(member, z20.union([z20.string(), z20.number().finite(), z20.boolean()])).default({}) }).strict()
+  z21.object({ textI18n: I18nTextSchema }).strict(),
+  z21.object({ key: ContractIdentifierSchema, values: z21.record(member, z21.union([z21.string(), z21.number().finite(), z21.boolean()])).default({}) }).strict()
 ]);
-var ComponentMessageBindingSchema = z20.object({
-  path: z20.array(z20.union([
+var ComponentMessageBindingSchema = z21.object({
+  path: z21.array(z21.union([
     member.refine((value) => !/[\u0000-\u001f\u007f-\u009f]/.test(value), "Invalid component path member."),
-    z20.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
+    z21.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
   ])).min(1).max(16),
   message: ComponentMessageSchema
 }).strict();
-var ComponentAssemblySchema = z20.object({
-  contract: z20.literal("ComponentAssembly"),
-  schemaVersion: z20.literal(1),
+var ComponentAssemblySchema = z21.object({
+  contract: z21.literal("ComponentAssembly"),
+  schemaVersion: z21.literal(1),
   props: JsonObjectSchema.default({}),
-  events: z20.record(member, ComponentEventBindingSchema).default({}),
+  events: z21.record(member, ComponentEventBindingSchema).default({}),
   // Each name remains an explicit RenderTree slot; array order controls composition.
-  slots: z20.record(member, z20.union([ContractIdentifierSchema, z20.array(ContractIdentifierSchema).min(1).max(256).refine((names) => new Set(names).size === names.length, "Component slot names must be unique.")])).default({}),
-  renderers: z20.record(member, ContractIdentifierSchema).default({}),
-  hosts: z20.record(member, ContractIdentifierSchema).default({}),
-  messages: z20.record(member, ComponentMessageSchema).default({}),
-  messageBindings: z20.array(ComponentMessageBindingSchema).max(256).optional()
+  slots: z21.record(member, z21.union([ContractIdentifierSchema, z21.array(ContractIdentifierSchema).min(1).max(256).refine((names) => new Set(names).size === names.length, "Component slot names must be unique.")])).default({}),
+  renderers: z21.record(member, ContractIdentifierSchema).default({}),
+  hosts: z21.record(member, ContractIdentifierSchema).default({}),
+  messages: z21.record(member, ComponentMessageSchema).default({}),
+  messageBindings: z21.array(ComponentMessageBindingSchema).max(256).optional()
 }).strict().superRefine((value, context) => {
   const paths = value.messageBindings?.map((binding) => binding.path) ?? [];
   for (const [index, path] of paths.entries()) {
@@ -19770,32 +19815,32 @@ var ComponentAssemblySchema = z20.object({
 });
 
 // src/contracts/record-editor-draft.ts
-import { z as z21 } from "zod";
-var member2 = z21.string().min(1).max(256).refine((value) => !["__proto__", "prototype", "constructor"].includes(value), "Unsafe editor path.");
-var RecordEditorPathSchema = z21.array(z21.union([member2, z21.object({ itemId: z21.string().min(1).max(256), idKey: member2.default("id") }).strict()])).max(32);
-var RecordEditorFieldErrorSchema = z21.object({ path: RecordEditorPathSchema, code: z21.string().min(1).max(256) }).strict();
-var RecordEditorDraftSchema = z21.object({
-  revision: z21.string().min(1).max(256),
+import { z as z22 } from "zod";
+var member2 = z22.string().min(1).max(256).refine((value) => !["__proto__", "prototype", "constructor"].includes(value), "Unsafe editor path.");
+var RecordEditorPathSchema = z22.array(z22.union([member2, z22.object({ itemId: z22.string().min(1).max(256), idKey: member2.default("id") }).strict()])).max(32);
+var RecordEditorFieldErrorSchema = z22.object({ path: RecordEditorPathSchema, code: z22.string().min(1).max(256) }).strict();
+var RecordEditorDraftSchema = z22.object({
+  revision: z22.string().min(1).max(256),
   original: JsonObjectSchema,
   value: JsonObjectSchema,
-  touched: z21.array(RecordEditorPathSchema).max(4096),
-  errors: z21.array(RecordEditorFieldErrorSchema).max(4096)
+  touched: z22.array(RecordEditorPathSchema).max(4096),
+  errors: z22.array(RecordEditorFieldErrorSchema).max(4096)
 }).strict();
-var RecordEditorDraftOperationSchema = z21.discriminatedUnion("kind", [
-  z21.object({ kind: z21.literal("set"), path: RecordEditorPathSchema, value: JsonValueSchema }).strict(),
-  z21.object({ kind: z21.literal("touch"), path: RecordEditorPathSchema }).strict(),
-  z21.object({ kind: z21.literal("reset"), revision: z21.string().min(1).max(256), value: JsonObjectSchema }).strict(),
-  z21.object({ kind: z21.literal("insert"), path: RecordEditorPathSchema, idKey: member2.default("id"), value: JsonObjectSchema, beforeId: z21.string().min(1).optional() }).strict(),
-  z21.object({ kind: z21.literal("remove"), path: RecordEditorPathSchema, idKey: member2.default("id"), itemId: z21.string().min(1) }).strict(),
-  z21.object({ kind: z21.literal("move"), path: RecordEditorPathSchema, idKey: member2.default("id"), itemId: z21.string().min(1), beforeId: z21.string().min(1).optional() }).strict()
+var RecordEditorDraftOperationSchema = z22.discriminatedUnion("kind", [
+  z22.object({ kind: z22.literal("set"), path: RecordEditorPathSchema, value: JsonValueSchema }).strict(),
+  z22.object({ kind: z22.literal("touch"), path: RecordEditorPathSchema }).strict(),
+  z22.object({ kind: z22.literal("reset"), revision: z22.string().min(1).max(256), value: JsonObjectSchema }).strict(),
+  z22.object({ kind: z22.literal("insert"), path: RecordEditorPathSchema, idKey: member2.default("id"), value: JsonObjectSchema, beforeId: z22.string().min(1).optional() }).strict(),
+  z22.object({ kind: z22.literal("remove"), path: RecordEditorPathSchema, idKey: member2.default("id"), itemId: z22.string().min(1) }).strict(),
+  z22.object({ kind: z22.literal("move"), path: RecordEditorPathSchema, idKey: member2.default("id"), itemId: z22.string().min(1), beforeId: z22.string().min(1).optional() }).strict()
 ]);
-var RecordEditorValidationDetailsSchema = z21.object({
-  contract: z21.literal("RecordEditorValidation"),
-  schemaVersion: z21.literal(1),
-  errors: z21.array(RecordEditorFieldErrorSchema).min(1).max(256)
+var RecordEditorValidationDetailsSchema = z22.object({
+  contract: z22.literal("RecordEditorValidation"),
+  schemaVersion: z22.literal(1),
+  errors: z22.array(RecordEditorFieldErrorSchema).min(1).max(256)
 }).strict();
-var RecordEditorSubmissionSnapshotSchema = z21.object({
-  revision: z21.string().min(1).max(256),
+var RecordEditorSubmissionSnapshotSchema = z22.object({
+  revision: z22.string().min(1).max(256),
   value: JsonObjectSchema
 }).strict();
 
@@ -19895,7 +19940,9 @@ export {
   PageExpressionRootSchema,
   PageOperatorSchema,
   PAGE_EXPRESSION_LIMITS,
+  PAGE_EXPRESSION_VALUE_LIMITS,
   assertPageValueBudget,
+  assertPageExpressionValueBudget,
   PageExpressionSchema,
   PagePropertyBindingSchema,
   visitPageExpression,
@@ -20277,6 +20324,8 @@ export {
   DeclarativeRuntimeRolloutCapabilitySchema,
   TenantProductConfigSchema,
   TenantRuntimeConfigSchema,
+  WorkflowCanvasElementSchema,
+  WorkflowCanvasSchema,
   ConductorTaskTypeSchema,
   ConductorTaskDefinitionSchema,
   ConductorWorkflowDefinitionSchema,
@@ -20288,6 +20337,8 @@ export {
   WorkflowTriggerSchema,
   WorkflowValidationIssueSchema,
   WorkflowDefinitionSchema,
+  WorkflowEditorCommandSchema,
+  WorkflowEditorDocumentSchema,
   WorkflowColumnFieldRefSchema,
   WorkflowColumnInputSchema,
   WorkflowColumnDependencySchema,
@@ -20306,4 +20357,4 @@ export {
   RecordEditorValidationDetailsSchema,
   RecordEditorSubmissionSnapshotSchema
 };
-//# sourceMappingURL=chunk-BQ77E4VU.mjs.map
+//# sourceMappingURL=chunk-L5CYU6K4.mjs.map