@inf-monkeys-tech/monkeys 1.1.9 → 1.1.10

package/lib/esm/index.mjs

@@ -15009,6 +15009,8 @@ var DeclarativeAuthoringActionSchema = z18.enum([
 ]);
 var encodePath = (value) => encodeURIComponent(value);
 var declarativeControlRoutes = {
+  prepareDocumentImport: (kind) => `${DECLARATIVE_CONTROL_API_PREFIX}/authoring/documents/${kind}/prepare`,
+  importDocument: (kind) => `${DECLARATIVE_CONTROL_API_PREFIX}/authoring/documents/${kind}/import`,
   validate: (kind, resourceId) => `${DECLARATIVE_CONTROL_API_PREFIX}/resources/${kind}/${encodePath(resourceId)}/validate`,
   preview: (kind, resourceId) => `${DECLARATIVE_CONTROL_API_PREFIX}/resources/${kind}/${encodePath(resourceId)}/preview`,
   publish: (kind, resourceId) => `${DECLARATIVE_CONTROL_API_PREFIX}/resources/${kind}/${encodePath(resourceId)}/publish`,
@@ -16969,11 +16971,108 @@ var DeclarativeRuntimeRouteOwnerSchema = z18.object({
 }).strict();
 var DeclarativeRouteClaimIntentSchema = RouteClaimSchema;
 
+// src/contracts/declarative-document-import.ts
+import { z as z19 } from "zod";
+var sameScope = (left, right) => ["tenantRef", "dataSpaceRef", "teamRef"].every(
+  (key) => left[key]?.kind === right[key]?.kind && left[key]?.id === right[key]?.id && left[key]?.ownerRepo === right[key]?.ownerRepo
+);
+var DeclarativeImportDocumentSchema = z19.union([
+  PageSchema,
+  NavigationSchema
+]);
+var requestShape = {
+  document: DeclarativeImportDocumentSchema,
+  surface: ProductSurfaceSchema,
+  environmentId: ContractIdentifierSchema.optional()
+};
+function supportsSurface(value) {
+  return value.document.contract === "Page" ? value.document.surface === value.surface : value.document.supportedSurfaces.includes(value.surface);
+}
+var DeclarativeDocumentImportRequestSchema = z19.object(requestShape).strict().refine(supportsSurface, {
+  path: ["surface"],
+  message: "The document does not support the selected surface."
+});
+var DeclarativeDocumentImportIntentSchema = z19.object({
+  ...requestShape,
+  expectedVersion: z19.number().int().nonnegative(),
+  expectedPlanHash: Sha256Schema,
+  idempotencyKey: z19.string().trim().min(1).max(256)
+}).strict().refine(supportsSurface, {
+  path: ["surface"],
+  message: "The document does not support the selected surface."
+});
+var DeclarativeDocumentImportPlanSchema = z19.object({
+  contract: z19.literal("DeclarativeDocumentImportPlan"),
+  schemaVersion: z19.literal(1),
+  resourceKind: z19.enum(["page", "navigation"]),
+  resourceId: ContractIdentifierSchema,
+  surface: ProductSurfaceSchema,
+  sourceContentHash: Sha256Schema,
+  environmentRevisionRef: RevisionRefSchema,
+  document: DeclarativeImportDocumentSchema,
+  tenantScope: TenantScopeSchema.nullable(),
+  requiresInitialization: z19.boolean(),
+  expectedVersion: z19.number().int().nonnegative(),
+  currentContentHash: Sha256Schema.nullable(),
+  changed: z19.boolean(),
+  diagnostics: z19.array(
+    z19.object({
+      code: z19.string().min(1),
+      path: z19.string(),
+      message: z19.string(),
+      blocking: z19.boolean()
+    }).strict()
+  ),
+  dependencyContentHash: Sha256Schema,
+  planHash: Sha256Schema
+}).strict().superRefine((value, context) => {
+  const kind = value.document.contract === "Page" ? "page" : "navigation";
+  const id = value.document.contract === "Page" ? value.document.pageId : value.document.navigationId;
+  if (kind !== value.resourceKind || id !== value.resourceId || !supportsSurface(value))
+    context.addIssue({
+      code: "custom",
+      path: ["document"],
+      message: "The plan must identify its document and supported surface."
+    });
+  if (value.requiresInitialization !== (value.tenantScope === null))
+    context.addIssue({
+      code: "custom",
+      path: ["requiresInitialization"],
+      message: "Only an uninitialized target may omit tenantScope."
+    });
+  if (value.environmentRevisionRef.kind !== "environment")
+    context.addIssue({
+      code: "custom",
+      path: ["environmentRevisionRef"],
+      message: "The import plan must pin an environment revision."
+    });
+  if (value.tenantScope && !sameScope(value.tenantScope, value.document.tenantScope))
+    context.addIssue({
+      code: "custom",
+      path: ["tenantScope"],
+      message: "The plan and bound document must belong to the same scope."
+    });
+});
+var DeclarativeDocumentImportResultSchema = z19.object({
+  action: z19.literal("import"),
+  changed: z19.boolean(),
+  plan: DeclarativeDocumentImportPlanSchema,
+  revisionRef: RevisionRefSchema
+}).strict().superRefine((value, context) => {
+  if (value.changed !== value.plan.changed || value.revisionRef.kind !== value.plan.resourceKind || value.revisionRef.id !== value.plan.resourceId || value.revisionRef.revision !== value.plan.expectedVersion + Number(value.changed) || !value.revisionRef.tenantScope || !sameScope(value.revisionRef.tenantScope, value.plan.document.tenantScope)) {
+    context.addIssue({
+      code: "custom",
+      path: ["revisionRef"],
+      message: "The import result must identify the exact saved or unchanged draft revision."
+    });
+  }
+});
+
 // src/contracts/tenant.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/contracts/theme.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/theme-tokens/core.ts
 var import_ajv = __toESM(require_ajv());
@@ -19200,20 +19299,20 @@ function assertMonkeysThemeTokensComplete(input) {
 }
 
 // src/contracts/theme.ts
-var ThemeTokenTypeSchema = z19.enum(THEME_TOKEN_TYPES);
-var ThemeTokenSchema = z19.record(z19.string(), z19.unknown()).superRefine((input, context) => {
+var ThemeTokenTypeSchema = z20.enum(THEME_TOKEN_TYPES);
+var ThemeTokenSchema = z20.record(z20.string(), z20.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 = z19.record(z19.string(), z19.unknown()).superRefine((input, context) => {
+var ThemeTokenGroupSchema = z20.record(z20.string(), z20.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocumentStructure(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
   }
 });
-var ThemeTokensSchema = z19.record(z19.string(), z19.unknown()).superRefine((input, context) => {
+var ThemeTokensSchema = z20.record(z20.string(), z20.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocument(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
@@ -19240,9 +19339,9 @@ var ResolvedThemeTokensSchema = ThemeTokensSchema.superRefine((input, context) =
 });
 
 // src/contracts/tenant.ts
-var DesignTokenFileSourceSchema = z20.object({
-  type: z20.literal("file"),
-  path: z20.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenFileSourceSchema = z21.object({
+  type: z21.literal("file"),
+  path: z21.string().trim().min(1).superRefine((source, context) => {
     const isWindowsDrivePath = /^[a-z]:[\\/]/i.test(source);
     if (!isWindowsDrivePath && /^[a-z][a-z\d+.-]*:/i.test(source)) {
       context.addIssue({
@@ -19252,9 +19351,9 @@ var DesignTokenFileSourceSchema = z20.object({
     }
   })
 }).strict();
-var DesignTokenUrlSourceSchema = z20.object({
-  type: z20.literal("url"),
-  url: z20.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenUrlSourceSchema = z21.object({
+  type: z21.literal("url"),
+  url: z21.string().trim().min(1).superRefine((source, context) => {
     if (!/^https?:\/\//i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -19263,45 +19362,45 @@ var DesignTokenUrlSourceSchema = z20.object({
     }
   })
 }).strict();
-var DesignTokenInlineSourceSchema = z20.object({
-  type: z20.literal("inline"),
+var DesignTokenInlineSourceSchema = z21.object({
+  type: z21.literal("inline"),
   document: ThemeTokensSchema
 }).strict();
-var DesignTokenSourceSchema = z20.discriminatedUnion("type", [DesignTokenFileSourceSchema, DesignTokenUrlSourceSchema, DesignTokenInlineSourceSchema]);
-var TenantDesignTokensConfigSchema = z20.object({
+var DesignTokenSourceSchema = z21.discriminatedUnion("type", [DesignTokenFileSourceSchema, DesignTokenUrlSourceSchema, DesignTokenInlineSourceSchema]);
+var TenantDesignTokensConfigSchema = z21.object({
   /** Ordered tenant overrides. The backend always applies the product default first. */
-  tokenSources: z20.array(DesignTokenSourceSchema)
+  tokenSources: z21.array(DesignTokenSourceSchema)
 }).strict();
-var TenantAuthBindingSchema = z20.object({
-  kind: z20.literal("auth-provider"),
+var TenantAuthBindingSchema = z21.object({
+  kind: z21.literal("auth-provider"),
   providerId: ContractIdentifierSchema,
   policyRef: ContractIdentifierSchema.optional()
 }).strict();
-var TenantDataBindingSchema = z20.discriminatedUnion("kind", [
-  z20.object({
-    kind: z20.literal("data-provider"),
+var TenantDataBindingSchema = z21.discriminatedUnion("kind", [
+  z21.object({
+    kind: z21.literal("data-provider"),
     providerId: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict(),
-  z20.object({
-    kind: z20.literal("projection"),
+  z21.object({
+    kind: z21.literal("projection"),
     projectionRef: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict()
 ]);
-var TenantAuthBindingsSchema = z20.record(ContractIdentifierSchema, TenantAuthBindingSchema);
-var TenantDataBindingsSchema = z20.record(ContractIdentifierSchema, TenantDataBindingSchema);
-var TenantTrendRadarSourceSchema = z20.object({
+var TenantAuthBindingsSchema = z21.record(ContractIdentifierSchema, TenantAuthBindingSchema);
+var TenantDataBindingsSchema = z21.record(ContractIdentifierSchema, TenantDataBindingSchema);
+var TenantTrendRadarSourceSchema = z21.object({
   ontologyId: ContractIdentifierSchema,
   viewId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarCollectionTargetSchema = z20.object({
+var TenantTrendRadarCollectionTargetSchema = z21.object({
   ontologyId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarEvaluationSchema = z20.object({
+var TenantTrendRadarEvaluationSchema = z21.object({
   workflowId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarDerivedMetricsSchema = z20.object({
+var TenantTrendRadarDerivedMetricsSchema = z21.object({
   productCountFieldKey: ContractIdentifierSchema,
   salesValueCountFieldKey: ContractIdentifierSchema,
   salesSumFieldKey: ContractIdentifierSchema
@@ -19309,7 +19408,7 @@ var TenantTrendRadarDerivedMetricsSchema = z20.object({
   ({ productCountFieldKey, salesValueCountFieldKey, salesSumFieldKey }) => (/* @__PURE__ */ new Set([productCountFieldKey, salesValueCountFieldKey, salesSumFieldKey])).size === 3,
   { message: "Trend Radar derived metric Field Keys must be distinct." }
 );
-var TenantTrendRadarSourcesSchema = z20.object({
+var TenantTrendRadarSourcesSchema = z21.object({
   products: TenantTrendRadarSourceSchema.optional(),
   hotwords: TenantTrendRadarSourceSchema.optional(),
   brands: TenantTrendRadarSourceSchema.optional(),
@@ -19317,54 +19416,54 @@ var TenantTrendRadarSourcesSchema = z20.object({
   derivedMetrics: TenantTrendRadarDerivedMetricsSchema.optional(),
   evaluation: TenantTrendRadarEvaluationSchema.optional()
 }).strict();
-var AssetVariantsSchema = z20.object({
-  light: z20.string().optional(),
-  dark: z20.string().optional()
+var AssetVariantsSchema = z21.object({
+  light: z21.string().optional(),
+  dark: z21.string().optional()
 }).strict();
-var TenantAgentThemeConfigSchema = z20.object({
+var TenantAgentThemeConfigSchema = z21.object({
   logo: AssetVariantsSchema.optional(),
-  brandDisplayMode: z20.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
-  density: z20.enum(["compact", "default", "comfortable"]).optional(),
+  brandDisplayMode: z21.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
+  density: z21.enum(["compact", "default", "comfortable"]).optional(),
   sidebar: AgentWorkbenchSidebarConfigSchema.optional(),
   /** @deprecated Use sidebar.navigationMode. */
-  navigationMode: z20.enum(["default", "session", "trend"]).optional(),
+  navigationMode: z21.enum(["default", "session", "trend"]).optional(),
   /** @deprecated Use sidebar.quickStartEnabled. */
-  quickStartEnabled: z20.boolean().optional()
+  quickStartEnabled: z21.boolean().optional()
 }).strict();
 var LEGACY_CURRENT_USER_MENU_ITEM_IDS = ["dark-mode", "language", "settings", "logout"];
 var CURRENT_USER_MENU_CONTROL_REFS = ["dark-mode", "language"];
 var CURRENT_USER_MENU_ACTION_REFS = ["logout"];
-var CurrentUserMenuIdentifierSchema = z20.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/, "Expected a stable current-user menu identifier.");
-var CurrentUserMenuDisplayTextSchema = z20.union([
-  z20.string().trim().min(1),
-  z20.record(z20.string().trim().min(1), z20.string().trim().min(1)).refine((value) => Object.keys(value).length > 0, "Localized menu text must contain at least one locale.")
+var CurrentUserMenuIdentifierSchema = z21.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/, "Expected a stable current-user menu identifier.");
+var CurrentUserMenuDisplayTextSchema = z21.union([
+  z21.string().trim().min(1),
+  z21.record(z21.string().trim().min(1), z21.string().trim().min(1)).refine((value) => Object.keys(value).length > 0, "Localized menu text must contain at least one locale.")
 ]);
-var CurrentUserMenuNavigationItemSchema = z20.object({
+var CurrentUserMenuNavigationItemSchema = z21.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z20.literal("navigation"),
+  kind: z21.literal("navigation"),
   ref: CurrentUserMenuIdentifierSchema
 }).strict();
-var CurrentUserMenuControlItemSchema = z20.object({
+var CurrentUserMenuControlItemSchema = z21.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z20.literal("control"),
-  ref: z20.enum(CURRENT_USER_MENU_CONTROL_REFS)
+  kind: z21.literal("control"),
+  ref: z21.enum(CURRENT_USER_MENU_CONTROL_REFS)
 }).strict();
-var CurrentUserMenuActionItemSchema = z20.object({
+var CurrentUserMenuActionItemSchema = z21.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z20.literal("action"),
-  ref: z20.enum(CURRENT_USER_MENU_ACTION_REFS),
-  tone: z20.enum(["default", "danger"]).optional()
+  kind: z21.literal("action"),
+  ref: z21.enum(CURRENT_USER_MENU_ACTION_REFS),
+  tone: z21.enum(["default", "danger"]).optional()
 }).strict();
-var CurrentUserMenuItemSchema = z20.discriminatedUnion("kind", [CurrentUserMenuNavigationItemSchema, CurrentUserMenuControlItemSchema, CurrentUserMenuActionItemSchema]);
-var CurrentUserMenuSectionSchema = z20.object({
+var CurrentUserMenuItemSchema = z21.discriminatedUnion("kind", [CurrentUserMenuNavigationItemSchema, CurrentUserMenuControlItemSchema, CurrentUserMenuActionItemSchema]);
+var CurrentUserMenuSectionSchema = z21.object({
   id: CurrentUserMenuIdentifierSchema,
   label: CurrentUserMenuDisplayTextSchema.optional(),
-  dividerBefore: z20.boolean().optional(),
-  items: z20.array(CurrentUserMenuItemSchema)
+  dividerBefore: z21.boolean().optional(),
+  items: z21.array(CurrentUserMenuItemSchema)
 }).strict();
-var CurrentUserMenuConfigSchema = z20.object({
-  version: z20.literal(1),
-  sections: z20.array(CurrentUserMenuSectionSchema).max(20)
+var CurrentUserMenuConfigSchema = z21.object({
+  version: z21.literal(1),
+  sections: z21.array(CurrentUserMenuSectionSchema).max(20)
 }).strict().superRefine((value, context) => {
   const sectionIds = /* @__PURE__ */ new Set();
   const itemIds = /* @__PURE__ */ new Set();
@@ -19398,7 +19497,7 @@ var CurrentUserMenuConfigSchema = z20.object({
     });
   }
 });
-var LegacyCurrentUserMenuProfileSchema = z20.array(z20.enum(LEGACY_CURRENT_USER_MENU_ITEM_IDS)).superRefine((value, context) => {
+var LegacyCurrentUserMenuProfileSchema = z21.array(z21.enum(LEGACY_CURRENT_USER_MENU_ITEM_IDS)).superRefine((value, context) => {
   const seen = /* @__PURE__ */ new Set();
   value.forEach((item, index) => {
     if (seen.has(item)) {
@@ -19411,69 +19510,69 @@ var LegacyCurrentUserMenuProfileSchema = z20.array(z20.enum(LEGACY_CURRENT_USER_
     seen.add(item);
   });
 });
-var CurrentUserMenuProfileSchema = z20.union([z20.literal("*"), LegacyCurrentUserMenuProfileSchema, CurrentUserMenuConfigSchema]);
-var ThemeHeadbarSchema = z20.object({
-  theme: z20.enum(["card", "glassy", "ghost"]).optional(),
-  navPosition: z20.enum(["left", "center", "right"]).optional(),
-  actions: z20.union([z20.literal("*"), z20.array(ContractIdentifierSchema)]).optional(),
+var CurrentUserMenuProfileSchema = z21.union([z21.literal("*"), LegacyCurrentUserMenuProfileSchema, CurrentUserMenuConfigSchema]);
+var ThemeHeadbarSchema = z21.object({
+  theme: z21.enum(["card", "glassy", "ghost"]).optional(),
+  navPosition: z21.enum(["left", "center", "right"]).optional(),
+  actions: z21.union([z21.literal("*"), z21.array(ContractIdentifierSchema)]).optional(),
   profile: CurrentUserMenuProfileSchema.optional(),
-  showTeamQuota: z20.boolean().optional()
+  showTeamQuota: z21.boolean().optional()
 }).strict();
-var TenantHeadbarModuleLeafSchema = z20.object({
+var TenantHeadbarModuleLeafSchema = z21.object({
   id: ContractIdentifierSchema,
-  extraInfo: z20.boolean().optional(),
-  displayName: z20.union([z20.string(), z20.record(LocaleIdentifierSchema, z20.string())]).optional(),
-  visible: z20.boolean().optional(),
-  disabled: z20.boolean().optional(),
-  icon: z20.string().optional(),
-  showQuickSwitcher: z20.boolean().optional(),
-  showSidebar: z20.boolean().optional(),
-  showContentFrame: z20.boolean().optional()
+  extraInfo: z21.boolean().optional(),
+  displayName: z21.union([z21.string(), z21.record(LocaleIdentifierSchema, z21.string())]).optional(),
+  visible: z21.boolean().optional(),
+  disabled: z21.boolean().optional(),
+  icon: z21.string().optional(),
+  showQuickSwitcher: z21.boolean().optional(),
+  showSidebar: z21.boolean().optional(),
+  showContentFrame: z21.boolean().optional()
 }).strict();
 var TenantHeadbarModuleItemSchema = TenantHeadbarModuleLeafSchema.extend({
-  children: z20.array(TenantHeadbarModuleLeafSchema).optional()
-}).strict();
-var KernelHeadbarSchema = z20.object({
-  theme: z20.literal("card").optional(),
-  layoutMode: z20.enum(["boxed", "full-bleed"]).optional(),
-  heightPx: z20.number().positive().optional(),
-  navPosition: z20.enum(["left", "center", "right"]).optional(),
-  brandTitle: z20.string().optional(),
-  menuRadius: z20.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
-}).strict();
-var CustomIconSchema = z20.object({
-  color: z20.string().optional(),
-  url: z20.string().optional(),
-  type: z20.enum(["svg", "image"]).optional(),
-  hintTextColor: z20.string().optional()
-}).strict();
-var WorkbenchCustomerToolSchema = z20.object({
+  children: z21.array(TenantHeadbarModuleLeafSchema).optional()
+}).strict();
+var KernelHeadbarSchema = z21.object({
+  theme: z21.literal("card").optional(),
+  layoutMode: z21.enum(["boxed", "full-bleed"]).optional(),
+  heightPx: z21.number().positive().optional(),
+  navPosition: z21.enum(["left", "center", "right"]).optional(),
+  brandTitle: z21.string().optional(),
+  menuRadius: z21.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
+}).strict();
+var CustomIconSchema = z21.object({
+  color: z21.string().optional(),
+  url: z21.string().optional(),
+  type: z21.enum(["svg", "image"]).optional(),
+  hintTextColor: z21.string().optional()
+}).strict();
+var WorkbenchCustomerToolSchema = z21.object({
   id: ContractIdentifierSchema,
-  label: z20.union([z20.string(), z20.record(LocaleIdentifierSchema, z20.string())]).optional(),
-  fixed: z20.boolean().optional()
+  label: z21.union([z21.string(), z21.record(LocaleIdentifierSchema, z21.string())]).optional(),
+  fixed: z21.boolean().optional()
 }).strict();
-var WorkbenchStudioOverrideSchema = z20.object({
-  studioName: z20.string().trim().min(1),
-  dropdownToolsDefault: z20.array(ContractIdentifierSchema).optional(),
-  existingToolsDefault: z20.array(ContractIdentifierSchema).optional(),
-  historyColumnsDefault: z20.number().int().min(1).max(6).optional()
+var WorkbenchStudioOverrideSchema = z21.object({
+  studioName: z21.string().trim().min(1),
+  dropdownToolsDefault: z21.array(ContractIdentifierSchema).optional(),
+  existingToolsDefault: z21.array(ContractIdentifierSchema).optional(),
+  historyColumnsDefault: z21.number().int().min(1).max(6).optional()
 }).strict();
-var TenantWorkbenchPageContextSchema = z20.object({
+var TenantWorkbenchPageContextSchema = z21.object({
   workflow: JsonObjectSchema.optional(),
   agent: JsonObjectSchema.optional(),
   agentId: ContractIdentifierSchema.optional(),
   designProject: JsonObjectSchema.optional(),
   designMetadataId: ContractIdentifierSchema.optional(),
-  iframeUrl: z20.string().trim().min(1).optional(),
-  info: z20.object({
+  iframeUrl: z21.string().trim().min(1).optional(),
+  info: z21.object({
     displayName: LocalizedTextSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    iconUrl: z20.string().trim().min(1).optional()
+    iconUrl: z21.string().trim().min(1).optional()
   }).strict().optional(),
-  isBuiltinPinned: z20.boolean().optional(),
-  isBuiltinReadonly: z20.boolean().optional()
+  isBuiltinPinned: z21.boolean().optional(),
+  isBuiltinReadonly: z21.boolean().optional()
 }).strict();
-var TenantWorkbenchPageEnvelopeSchema = z20.object({
+var TenantWorkbenchPageEnvelopeSchema = z21.object({
   definition: PageDefinitionSchema,
   context: TenantWorkbenchPageContextSchema
 }).strict().superRefine(({ definition }, context) => {
@@ -19506,59 +19605,59 @@ var TenantWorkbenchPageEnvelopeSchema = z20.object({
     });
   }
 });
-var TenantWorkbenchPageGroupSchema = z20.object({
+var TenantWorkbenchPageGroupSchema = z21.object({
   id: ContractIdentifierSchema,
-  pageIds: z20.array(ContractIdentifierSchema),
+  pageIds: z21.array(ContractIdentifierSchema),
   displayName: LocalizedTextSchema,
-  isBuiltIn: z20.boolean(),
-  iconUrl: z20.string().optional(),
-  sortIndex: z20.number().int().nullable().optional(),
+  isBuiltIn: z21.boolean(),
+  iconUrl: z21.string().optional(),
+  sortIndex: z21.number().int().nullable().optional(),
   presetRelationId: ContractIdentifierSchema.optional(),
   relationKey: ContractIdentifierSchema.nullable().optional(),
   studioId: ContractIdentifierSchema.optional()
 }).strict();
-var TenantWorkbenchConfigSchema = z20.object({
-  pages: z20.array(TenantWorkbenchPageEnvelopeSchema),
-  pageGroups: z20.array(TenantWorkbenchPageGroupSchema),
-  catalog: z20.object({
-    enabled: z20.boolean().optional(),
-    defaultEntry: z20.boolean().optional()
+var TenantWorkbenchConfigSchema = z21.object({
+  pages: z21.array(TenantWorkbenchPageEnvelopeSchema),
+  pageGroups: z21.array(TenantWorkbenchPageGroupSchema),
+  catalog: z21.object({
+    enabled: z21.boolean().optional(),
+    defaultEntry: z21.boolean().optional()
   }).strict().optional(),
-  quickSwitcherMaxItems: z20.number().int().nonnegative().optional(),
-  defaultOrder: z20.object({
-    groups: z20.array(ContractIdentifierSchema),
-    pages: z20.record(ContractIdentifierSchema, z20.array(ContractIdentifierSchema))
+  quickSwitcherMaxItems: z21.number().int().nonnegative().optional(),
+  defaultOrder: z21.object({
+    groups: z21.array(ContractIdentifierSchema),
+    pages: z21.record(ContractIdentifierSchema, z21.array(ContractIdentifierSchema))
   }).strict().optional(),
-  customers: z20.object({
-    dropdownToolsDefault: z20.array(ContractIdentifierSchema).optional(),
-    layoutManagerTools: z20.array(WorkbenchCustomerToolSchema).optional(),
-    studioTabsMode: z20.enum(["dropdown", "tabs"]).optional(),
-    historyWatermark: z20.object({
-      svgUrl: z20.string().optional(),
-      coverage: z20.array(z20.enum(["list", "detail", "download"])).optional(),
-      maxLongEdgeRatio: z20.number().positive().optional(),
-      sizing: z20.object({
+  customers: z21.object({
+    dropdownToolsDefault: z21.array(ContractIdentifierSchema).optional(),
+    layoutManagerTools: z21.array(WorkbenchCustomerToolSchema).optional(),
+    studioTabsMode: z21.enum(["dropdown", "tabs"]).optional(),
+    historyWatermark: z21.object({
+      svgUrl: z21.string().optional(),
+      coverage: z21.array(z21.enum(["list", "detail", "download"])).optional(),
+      maxLongEdgeRatio: z21.number().positive().optional(),
+      sizing: z21.object({
         mode: ContractIdentifierSchema,
-        heightRatio: z20.number().positive().optional(),
-        minHeightPx: z20.number().nonnegative().optional(),
-        maxHeightPx: z20.number().nonnegative().optional()
+        heightRatio: z21.number().positive().optional(),
+        minHeightPx: z21.number().nonnegative().optional(),
+        maxHeightPx: z21.number().nonnegative().optional()
       }).strict().optional(),
-      enhance: z20.object({
-        enabled: z20.boolean().optional(),
-        backgroundLumaThreshold: z20.number().min(0).max(1).optional(),
-        stroke: z20.object({
-          color: z20.string().optional(),
-          opacity: z20.number().min(0).max(1).optional(),
-          widthRatio: z20.number().nonnegative().optional(),
-          blurRatio: z20.number().nonnegative().optional(),
-          steps: z20.number().int().positive().optional()
+      enhance: z21.object({
+        enabled: z21.boolean().optional(),
+        backgroundLumaThreshold: z21.number().min(0).max(1).optional(),
+        stroke: z21.object({
+          color: z21.string().optional(),
+          opacity: z21.number().min(0).max(1).optional(),
+          widthRatio: z21.number().nonnegative().optional(),
+          blurRatio: z21.number().nonnegative().optional(),
+          steps: z21.number().int().positive().optional()
         }).strict().optional()
       }).strict().optional()
     }).strict().optional(),
-    layoutManagerEnabled: z20.boolean().optional(),
-    existingToolsDefault: z20.array(ContractIdentifierSchema).optional(),
-    historyColumnsDefault: z20.number().int().min(1).max(6).optional(),
-    studioOverrides: z20.array(WorkbenchStudioOverrideSchema).optional()
+    layoutManagerEnabled: z21.boolean().optional(),
+    existingToolsDefault: z21.array(ContractIdentifierSchema).optional(),
+    historyColumnsDefault: z21.number().int().min(1).max(6).optional(),
+    studioOverrides: z21.array(WorkbenchStudioOverrideSchema).optional()
   }).strict().optional()
 }).strict().superRefine(({ pages, pageGroups }, context) => {
   const pageIds = pages.map(({ definition }) => definition.pageId);
@@ -19590,41 +19689,41 @@ var TenantWorkbenchConfigSchema = z20.object({
     });
   });
 });
-var LoginPageSchema = z20.object({
-  background: z20.object({
-    imageUrl: z20.string().optional(),
-    gradient: z20.string().optional()
+var LoginPageSchema = z21.object({
+  background: z21.object({
+    imageUrl: z21.string().optional(),
+    gradient: z21.string().optional()
   }).strict().optional(),
-  logo: z20.object({
-    url: z20.string().optional(),
-    lightUrl: z20.string().optional(),
-    darkUrl: z20.string().optional(),
-    position: z20.enum(["top", "middle", "bottom"]).optional(),
-    scale: z20.number().positive().optional()
+  logo: z21.object({
+    url: z21.string().optional(),
+    lightUrl: z21.string().optional(),
+    darkUrl: z21.string().optional(),
+    position: z21.enum(["top", "middle", "bottom"]).optional(),
+    scale: z21.number().positive().optional()
   }).strict().optional(),
-  customCss: z20.string().optional()
+  customCss: z21.string().optional()
 }).strict();
 var LandingPageHeadbarConfigShape = {
-  headbarMode: z20.enum(["shared", "hidden"]).optional()
+  headbarMode: z21.enum(["shared", "hidden"]).optional()
 };
-var LandingPageDefaultConfigSchema = z20.object({
-  mode: z20.literal("default"),
+var LandingPageDefaultConfigSchema = z21.object({
+  mode: z21.literal("default"),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageMarkdownConfigSchema = z20.object({
-  mode: z20.literal("markdown"),
-  content: z20.string(),
+var LandingPageMarkdownConfigSchema = z21.object({
+  mode: z21.literal("markdown"),
+  content: z21.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageHtmlConfigSchema = z20.object({
-  mode: z20.literal("html"),
-  content: z20.string(),
+var LandingPageHtmlConfigSchema = z21.object({
+  mode: z21.literal("html"),
+  content: z21.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageIframeConfigSchema = z20.object({
-  mode: z20.literal("iframe"),
+var LandingPageIframeConfigSchema = z21.object({
+  mode: z21.literal("iframe"),
   ...LandingPageHeadbarConfigShape,
-  url: z20.string().refine((value) => {
+  url: z21.string().refine((value) => {
     if (/^\/(?!\/)/.test(value)) {
       return !value.includes("\\");
     }
@@ -19636,13 +19735,13 @@ var LandingPageIframeConfigSchema = z20.object({
     }
   }, "Landing page iframe URL must use a root-relative path or HTTP(S) without embedded credentials.")
 }).strict();
-var TenantLandingPageConfigSchema = z20.discriminatedUnion("mode", [
+var TenantLandingPageConfigSchema = z21.discriminatedUnion("mode", [
   LandingPageDefaultConfigSchema,
   LandingPageMarkdownConfigSchema,
   LandingPageHtmlConfigSchema,
   LandingPageIframeConfigSchema
 ]);
-var ListFooterPageSizeOptionsSchema = z20.array(z20.number().int().positive().max(1e3)).min(1).max(10).superRefine((options, context) => {
+var ListFooterPageSizeOptionsSchema = z21.array(z21.number().int().positive().max(1e3)).min(1).max(10).superRefine((options, context) => {
   const seen = /* @__PURE__ */ new Set();
   options.forEach((option, index) => {
     if (seen.has(option)) {
@@ -19655,578 +19754,578 @@ var ListFooterPageSizeOptionsSchema = z20.array(z20.number().int().positive().ma
     seen.add(option);
   });
 });
-var TenantListFooterConfigSchema = z20.object({
-  showTotal: z20.boolean().optional(),
-  showPageSize: z20.boolean().optional(),
+var TenantListFooterConfigSchema = z21.object({
+  showTotal: z21.boolean().optional(),
+  showPageSize: z21.boolean().optional(),
   pageSizeOptions: ListFooterPageSizeOptionsSchema.optional(),
-  paginationMode: z20.enum(["auto", "pages", "compact"]).optional(),
-  alignment: z20.enum(["start", "end", "space-between"]).optional(),
-  density: z20.enum(["compact", "default", "comfortable"]).optional()
-}).strict();
-var TenantApplicationConfigSchema = z20.object({
-  theme: z20.object({
-    id: z20.string().optional(),
-    name: z20.string().optional(),
-    title: z20.string().optional(),
+  paginationMode: z21.enum(["auto", "pages", "compact"]).optional(),
+  alignment: z21.enum(["start", "end", "space-between"]).optional(),
+  density: z21.enum(["compact", "default", "comfortable"]).optional()
+}).strict();
+var TenantApplicationConfigSchema = z21.object({
+  theme: z21.object({
+    id: z21.string().optional(),
+    name: z21.string().optional(),
+    title: z21.string().optional(),
     favicon: AssetVariantsSchema.optional(),
     logo: AssetVariantsSchema.optional(),
-    pwaIcon: z20.string().optional(),
-    form: z20.object({ variant: z20.enum(["bento", "ghost"]) }).strict().optional(),
-    toast: z20.object({
-      position: z20.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
+    pwaIcon: z21.string().optional(),
+    form: z21.object({ variant: z21.enum(["bento", "ghost"]) }).strict().optional(),
+    toast: z21.object({
+      position: z21.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
     }).strict().optional(),
-    icons: z20.object({
+    icons: z21.object({
       error: CustomIconSchema.optional(),
       empty: CustomIconSchema.optional()
     }).strict().optional(),
-    views: z20.object({
-      form: z20.object({
-        toast: z20.object({
-          afterCreate: z20.boolean(),
-          afterDelete: z20.boolean()
+    views: z21.object({
+      form: z21.object({
+        toast: z21.object({
+          afterCreate: z21.boolean(),
+          afterDelete: z21.boolean()
         }).strict(),
-        progress: z20.enum(["estimate", "infinite"]),
-        onlyResult: z20.boolean(),
-        tabular: z20.object({ theme: z20.enum(["default", "tentiary", "primary"]) }).strict()
+        progress: z21.enum(["estimate", "infinite"]),
+        onlyResult: z21.boolean(),
+        tabular: z21.object({ theme: z21.enum(["default", "tentiary", "primary"]) }).strict()
       }).strict()
     }).strict().optional(),
     loginPage: LoginPageSchema.optional(),
-    extraLanguageURL: z20.record(z20.string(), z20.string()).optional(),
-    hideSpaceHeader: z20.boolean().optional(),
-    showSidebarTeamSelector: z20.boolean().optional(),
-    showWorkbenchSidebar: z20.boolean().optional(),
-    workbenchViewTheme: z20.enum(["default", "bsd-blue"]).optional(),
-    defaults: z20.object({
-      showFormInImageDetail: z20.boolean().optional(),
-      darkMode: z20.enum(["light", "dark", "auto"]).optional(),
-      language: z20.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
-      showDarkModeToggle: z20.boolean().optional(),
-      showLanguageToggle: z20.boolean().optional()
+    extraLanguageURL: z21.record(z21.string(), z21.string()).optional(),
+    hideSpaceHeader: z21.boolean().optional(),
+    showSidebarTeamSelector: z21.boolean().optional(),
+    showWorkbenchSidebar: z21.boolean().optional(),
+    workbenchViewTheme: z21.enum(["default", "bsd-blue"]).optional(),
+    defaults: z21.object({
+      showFormInImageDetail: z21.boolean().optional(),
+      darkMode: z21.enum(["light", "dark", "auto"]).optional(),
+      language: z21.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
+      showDarkModeToggle: z21.boolean().optional(),
+      showLanguageToggle: z21.boolean().optional()
     }).strict().optional(),
-    modules: z20.object({
-      monkeysSpaceSidebar: z20.union([z20.literal("*"), z20.array(ContractIdentifierSchema)]).optional(),
-      monkeysSpaceHeadbar: z20.union([z20.literal("*"), z20.array(TenantHeadbarModuleItemSchema)]).optional(),
-      settingsSidebar: z20.union([z20.literal("*"), z20.array(ContractIdentifierSchema)]).optional()
+    modules: z21.object({
+      monkeysSpaceSidebar: z21.union([z21.literal("*"), z21.array(ContractIdentifierSchema)]).optional(),
+      monkeysSpaceHeadbar: z21.union([z21.literal("*"), z21.array(TenantHeadbarModuleItemSchema)]).optional(),
+      settingsSidebar: z21.union([z21.literal("*"), z21.array(ContractIdentifierSchema)]).optional()
     }).strict().optional(),
     headbar: ThemeHeadbarSchema.optional(),
-    kernelLayout: z20.object({
-      navigationMode: z20.enum(["sidebar", "topbar"]).optional(),
-      allowNavigationModeSwitch: z20.boolean().optional(),
+    kernelLayout: z21.object({
+      navigationMode: z21.enum(["sidebar", "topbar"]).optional(),
+      allowNavigationModeSwitch: z21.boolean().optional(),
       headbar: KernelHeadbarSchema.optional()
     }).strict().optional(),
-    paginationPosition: z20.enum(["left", "right"]).optional(),
+    paginationPosition: z21.enum(["left", "right"]).optional(),
     listFooter: TenantListFooterConfigSchema.optional(),
-    ugcViewIconOnlyMode: z20.boolean().optional(),
-    workflowPreviewExecutionGrid: z20.object({
-      selectionModeDisplayType: z20.enum(["operation-button", "dropdown-menu"]).optional(),
-      clickBehavior: z20.enum(["preview", "select", "fill-form", "none"]).optional(),
-      showErrorFilter: z20.boolean().optional(),
-      displayType: z20.enum(["grid", "masonry"]).optional(),
-      showDetailButton: z20.boolean().optional(),
-      aspectRatio: z20.enum(["1:1", "4:3", "3:4", "16:9", "9:16"]).optional()
+    ugcViewIconOnlyMode: z21.boolean().optional(),
+    workflowPreviewExecutionGrid: z21.object({
+      selectionModeDisplayType: z21.enum(["operation-button", "dropdown-menu"]).optional(),
+      clickBehavior: z21.enum(["preview", "select", "fill-form", "none"]).optional(),
+      showErrorFilter: z21.boolean().optional(),
+      displayType: z21.enum(["grid", "masonry"]).optional(),
+      showDetailButton: z21.boolean().optional(),
+      aspectRatio: z21.enum(["1:1", "4:3", "3:4", "16:9", "9:16"]).optional()
     }).strict().optional(),
-    workbenchSidebarDefaultOpen: z20.boolean().optional(),
-    workbenchSidebarMoreAction: z20.boolean().optional(),
-    workbenchSidebarApart: z20.boolean().optional(),
-    workbenchSidebarToggleGroupDetail: z20.boolean().optional(),
-    workbenchSidebarViewType: z20.boolean().optional(),
-    workbenchSidebarFormViewEmbed: z20.boolean().optional(),
-    workbenchSidebarModernMode: z20.boolean().optional(),
-    ugc: z20.object({
-      onItemClick: z20.boolean(),
-      subtitle: z20.boolean().optional()
+    workbenchSidebarDefaultOpen: z21.boolean().optional(),
+    workbenchSidebarMoreAction: z21.boolean().optional(),
+    workbenchSidebarApart: z21.boolean().optional(),
+    workbenchSidebarToggleGroupDetail: z21.boolean().optional(),
+    workbenchSidebarViewType: z21.boolean().optional(),
+    workbenchSidebarFormViewEmbed: z21.boolean().optional(),
+    workbenchSidebarModernMode: z21.boolean().optional(),
+    ugc: z21.object({
+      onItemClick: z21.boolean(),
+      subtitle: z21.boolean().optional()
     }).strict().optional(),
-    uniImagePreview: z20.boolean().optional(),
-    imagePreviewStyle: z20.union([z20.literal(false), z20.enum(["simple", "normal", "uni"])]).optional(),
-    teamAsUser: z20.boolean().optional(),
-    themeMode: z20.enum(["shadow", "border"]).optional(),
-    density: z20.enum(["compact", "default", "comfortable"]).optional(),
-    statusStates: z20.object({
-      loading: z20.object({ variant: z20.enum(["spinner", "skeleton"]).optional() }).strict().optional(),
-      empty: z20.object({ variant: z20.enum(["default", "compact"]).optional() }).strict().optional(),
-      error: z20.object({ showRetry: z20.boolean().optional() }).strict().optional(),
-      permission: z20.object({ showRequestAccess: z20.boolean().optional() }).strict().optional(),
-      density: z20.enum(["compact", "default", "comfortable"]).optional()
+    uniImagePreview: z21.boolean().optional(),
+    imagePreviewStyle: z21.union([z21.literal(false), z21.enum(["simple", "normal", "uni"])]).optional(),
+    teamAsUser: z21.boolean().optional(),
+    themeMode: z21.enum(["shadow", "border"]).optional(),
+    density: z21.enum(["compact", "default", "comfortable"]).optional(),
+    statusStates: z21.object({
+      loading: z21.object({ variant: z21.enum(["spinner", "skeleton"]).optional() }).strict().optional(),
+      empty: z21.object({ variant: z21.enum(["default", "compact"]).optional() }).strict().optional(),
+      error: z21.object({ showRetry: z21.boolean().optional() }).strict().optional(),
+      permission: z21.object({ showRequestAccess: z21.boolean().optional() }).strict().optional(),
+      density: z21.enum(["compact", "default", "comfortable"]).optional()
     }).strict().optional(),
-    pageZoom: z20.number().positive().optional(),
-    miniMode: z20.object({ showPreviewViewExecutionResultGrid: z20.boolean() }).strict().optional(),
-    workflow: z20.object({ allowConcurrentRuns: z20.boolean() }).strict().optional(),
-    historyResult: z20.object({ display: z20.boolean() }).strict().optional(),
-    uploader: z20.object({
-      orientation: z20.enum(["vertical", "horizontal"]),
-      pasteButton: z20.boolean(),
-      statusText: z20.boolean()
+    pageZoom: z21.number().positive().optional(),
+    miniMode: z21.object({ showPreviewViewExecutionResultGrid: z21.boolean() }).strict().optional(),
+    workflow: z21.object({ allowConcurrentRuns: z21.boolean() }).strict().optional(),
+    historyResult: z21.object({ display: z21.boolean() }).strict().optional(),
+    uploader: z21.object({
+      orientation: z21.enum(["vertical", "horizontal"]),
+      pasteButton: z21.boolean(),
+      statusText: z21.boolean()
     }).strict().optional(),
-    designProjects: z20.object({
-      oneOnOne: z20.boolean(),
-      newTabOpenBoard: z20.boolean(),
-      defaultShowGrid: z20.boolean().optional(),
-      createDefaultFrame: z20.boolean(),
-      showPageMenu: z20.boolean(),
-      showMainMenu: z20.boolean(),
-      showStylePanel: z20.boolean(),
-      showToolbar: z20.boolean(),
-      toolbarPosition: z20.enum(["bottom", "left"]).optional(),
-      showContextMenu: z20.boolean(),
-      showActionsMenu: z20.boolean(),
-      showPageAndLayerSidebar: z20.boolean().optional(),
-      showBoardOperationSidebar: z20.boolean().optional(),
-      showMiniToolsToolbar: z20.boolean().optional(),
-      showRightSidebar: z20.boolean().optional(),
-      showRealtimeDrawing: z20.boolean().optional(),
-      showWorkflow: z20.boolean().optional(),
-      showVersionManager: z20.boolean().optional(),
-      showAgent: z20.boolean().optional(),
-      AgentTools: z20.array(ContractIdentifierSchema).optional()
+    designProjects: z21.object({
+      oneOnOne: z21.boolean(),
+      newTabOpenBoard: z21.boolean(),
+      defaultShowGrid: z21.boolean().optional(),
+      createDefaultFrame: z21.boolean(),
+      showPageMenu: z21.boolean(),
+      showMainMenu: z21.boolean(),
+      showStylePanel: z21.boolean(),
+      showToolbar: z21.boolean(),
+      toolbarPosition: z21.enum(["bottom", "left"]).optional(),
+      showContextMenu: z21.boolean(),
+      showActionsMenu: z21.boolean(),
+      showPageAndLayerSidebar: z21.boolean().optional(),
+      showBoardOperationSidebar: z21.boolean().optional(),
+      showMiniToolsToolbar: z21.boolean().optional(),
+      showRightSidebar: z21.boolean().optional(),
+      showRealtimeDrawing: z21.boolean().optional(),
+      showWorkflow: z21.boolean().optional(),
+      showVersionManager: z21.boolean().optional(),
+      showAgent: z21.boolean().optional(),
+      AgentTools: z21.array(ContractIdentifierSchema).optional()
     }).strict().optional(),
     workbench: TenantWorkbenchConfigSchema.optional(),
-    visionProWorkflows: z20.array(ContractIdentifierSchema).optional(),
-    initTeam: z20.boolean().optional(),
-    imageThumbnail: z20.boolean().optional(),
-    pages: z20.object({
-      allowPageKeys: z20.union([z20.literal("*"), z20.array(ContractIdentifierSchema)]),
+    visionProWorkflows: z21.array(ContractIdentifierSchema).optional(),
+    initTeam: z21.boolean().optional(),
+    imageThumbnail: z21.boolean().optional(),
+    pages: z21.object({
+      allowPageKeys: z21.union([z21.literal("*"), z21.array(ContractIdentifierSchema)]),
       defaultPageKey: ContractIdentifierSchema.optional(),
-      homeEntryEnabled: z20.boolean().optional()
+      homeEntryEnabled: z21.boolean().optional()
     }).strict().optional(),
     agent: TenantAgentThemeConfigSchema.optional()
   }).strict(),
   landingPage: TenantLandingPageConfigSchema.optional(),
-  auth: z20.object({
-    enabled: z20.array(ContractIdentifierSchema).default([]),
-    oidc: z20.object({
-      buttonText: z20.string().optional(),
-      autoSignin: z20.boolean().optional()
+  auth: z21.object({
+    enabled: z21.array(ContractIdentifierSchema).default([]),
+    oidc: z21.object({
+      buttonText: z21.string().optional(),
+      autoSignin: z21.boolean().optional()
     }).strict().optional(),
-    password: z20.object({
-      registrationEnabled: z20.boolean().optional(),
-      disableAutoRegister: z20.boolean().optional()
+    password: z21.object({
+      registrationEnabled: z21.boolean().optional(),
+      disableAutoRegister: z21.boolean().optional()
     }).strict().optional(),
-    registrationApproval: z20.object({
-      enabled: z20.boolean().optional()
+    registrationApproval: z21.object({
+      enabled: z21.boolean().optional()
     }).strict().optional(),
-    hideAuthToast: z20.boolean().optional(),
-    autoReload: z20.boolean().optional(),
-    defaultOtherTeam: z20.boolean().optional()
+    hideAuthToast: z21.boolean().optional(),
+    autoReload: z21.boolean().optional(),
+    defaultOtherTeam: z21.boolean().optional()
   }).strict(),
-  endpoints: z20.record(ContractIdentifierSchema, z20.string()),
-  module: z20.union([z20.literal("*"), z20.array(ContractIdentifierSchema)]),
-  behavior: z20.object({
-    clearWorkflowFormStorageAfterUpdate: z20.boolean().optional(),
-    autoApproveOAuth: z20.boolean().optional(),
-    rememberWorkflowModelSelection: z20.boolean().optional()
+  endpoints: z21.record(ContractIdentifierSchema, z21.string()),
+  module: z21.union([z21.literal("*"), z21.array(ContractIdentifierSchema)]),
+  behavior: z21.object({
+    clearWorkflowFormStorageAfterUpdate: z21.boolean().optional(),
+    autoApproveOAuth: z21.boolean().optional(),
+    rememberWorkflowModelSelection: z21.boolean().optional()
   }).strict(),
-  dataManagement: z20.object({
-    favoriteOntologyId: z20.string().optional(),
-    pairedOntologyId: z20.string().optional(),
-    galleryOntologyIds: z20.array(ContractIdentifierSchema).max(20).optional(),
-    galleryOntologyId: z20.string().optional(),
-    dataBrowserDefaultOntologyId: z20.string().optional(),
-    workflowResultOntologyId: z20.string().optional(),
-    homeAdvertisement: z20.object({
+  dataManagement: z21.object({
+    favoriteOntologyId: z21.string().optional(),
+    pairedOntologyId: z21.string().optional(),
+    galleryOntologyIds: z21.array(ContractIdentifierSchema).max(20).optional(),
+    galleryOntologyId: z21.string().optional(),
+    dataBrowserDefaultOntologyId: z21.string().optional(),
+    workflowResultOntologyId: z21.string().optional(),
+    homeAdvertisement: z21.object({
       ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
-      viewType: z20.enum(["filter", "container", "share_link"]).optional(),
+      viewType: z21.enum(["filter", "container", "share_link"]).optional(),
       teamId: ContractIdentifierSchema.optional(),
-      teamOnly: z20.boolean().optional(),
-      pageSize: z20.number().int().positive().optional(),
-      sortBy: z20.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
-      sortOrder: z20.enum(["asc", "desc"]).optional(),
-      fieldMap: z20.record(z20.string(), z20.string()).optional(),
-      columnIds: z20.record(z20.string(), z20.string()).optional()
+      teamOnly: z21.boolean().optional(),
+      pageSize: z21.number().int().positive().optional(),
+      sortBy: z21.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
+      sortOrder: z21.enum(["asc", "desc"]).optional(),
+      fieldMap: z21.record(z21.string(), z21.string()).optional(),
+      columnIds: z21.record(z21.string(), z21.string()).optional()
     }).strict().optional(),
-    homeShortcutBackground: z20.object({
+    homeShortcutBackground: z21.object({
       ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
-      viewType: z20.enum(["filter", "container", "share_link"]).optional(),
+      viewType: z21.enum(["filter", "container", "share_link"]).optional(),
       teamId: ContractIdentifierSchema.optional(),
-      teamOnly: z20.boolean().optional(),
-      pageSize: z20.number().int().positive().optional(),
-      sortBy: z20.enum(["pin_order", "asset_id", "updated_timestamp"]).optional(),
-      sortOrder: z20.enum(["asc", "desc"]).optional(),
-      fieldMap: z20.record(z20.string(), z20.string()).optional(),
-      columnIds: z20.record(z20.string(), z20.string()).optional()
+      teamOnly: z21.boolean().optional(),
+      pageSize: z21.number().int().positive().optional(),
+      sortBy: z21.enum(["pin_order", "asset_id", "updated_timestamp"]).optional(),
+      sortOrder: z21.enum(["asc", "desc"]).optional(),
+      fieldMap: z21.record(z21.string(), z21.string()).optional(),
+      columnIds: z21.record(z21.string(), z21.string()).optional()
     }).strict().optional(),
-    homeTrendAssistant: z20.object({
+    homeTrendAssistant: z21.object({
       ontologyId: ContractIdentifierSchema.optional(),
       viewId: ContractIdentifierSchema.optional(),
       viewInstanceId: ContractIdentifierSchema.optional(),
-      viewName: z20.string().optional(),
+      viewName: z21.string().optional(),
       teamId: ContractIdentifierSchema.optional(),
       designOptionsWorkflowId: ContractIdentifierSchema.optional(),
-      tep: z20.object({
-        baseUrl: z20.string().optional(),
-        timeoutMs: z20.number().int().positive().optional()
+      tep: z21.object({
+        baseUrl: z21.string().optional(),
+        timeoutMs: z21.number().int().positive().optional()
       }).strict().optional(),
-      runtime: z20.object({
+      runtime: z21.object({
         appId: ContractIdentifierSchema,
-        tepBaseUrlConfigured: z20.boolean(),
-        tepAuthorizationConfigured: z20.boolean(),
-        tepCookieConfigured: z20.boolean()
+        tepBaseUrlConfigured: z21.boolean(),
+        tepAuthorizationConfigured: z21.boolean(),
+        tepCookieConfigured: z21.boolean()
       }).strict().optional()
     }).strict().optional(),
-    staticTrendReport: z20.object({
+    staticTrendReport: z21.object({
       ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
       teamId: ContractIdentifierSchema.optional()
     }).strict().optional(),
     trendRadar: TenantTrendRadarSourcesSchema.optional(),
-    sharing: z20.object({
-      silentViewLinks: z20.object({
-        enabled: z20.boolean().optional(),
-        placement: z20.object({
-          mode: z20.enum(["sourceOntology", "ontology"]).optional(),
+    sharing: z21.object({
+      silentViewLinks: z21.object({
+        enabled: z21.boolean().optional(),
+        placement: z21.object({
+          mode: z21.enum(["sourceOntology", "ontology"]).optional(),
           ontologyId: ContractIdentifierSchema.optional(),
           parentId: ContractIdentifierSchema.optional(),
           navId: ContractIdentifierSchema.optional()
         }).strict().optional()
       }).strict().optional(),
-      shareAccess: z20.object({
-        publicLinksEnabled: z20.boolean().optional(),
-        passwordGateEnabled: z20.boolean().optional(),
-        passwordAccessTtlSeconds: z20.number().int().positive().optional(),
-        defaultViewTreeDelivery: z20.enum(["manual", "auto"]).optional()
+      shareAccess: z21.object({
+        publicLinksEnabled: z21.boolean().optional(),
+        passwordGateEnabled: z21.boolean().optional(),
+        passwordAccessTtlSeconds: z21.number().int().positive().optional(),
+        defaultViewTreeDelivery: z21.enum(["manual", "auto"]).optional()
       }).strict().optional(),
-      shareDialog: z20.object({
-        uiVersion: z20.enum(["legacy", "simplified"]).optional(),
-        audience: z20.object({
-          enabled: z20.boolean().optional(),
-          allowed: z20.array(z20.enum(["user", "team", "public"])).optional(),
-          default: z20.enum(["user", "team", "public"]).optional()
+      shareDialog: z21.object({
+        uiVersion: z21.enum(["legacy", "simplified"]).optional(),
+        audience: z21.object({
+          enabled: z21.boolean().optional(),
+          allowed: z21.array(z21.enum(["user", "team", "public"])).optional(),
+          default: z21.enum(["user", "team", "public"]).optional()
         }).strict().optional(),
-        accessLevel: z20.object({
-          enabled: z20.boolean().optional(),
-          allowed: z20.array(z20.enum(["read", "write"])).optional(),
-          default: z20.enum(["read", "write"]).optional()
+        accessLevel: z21.object({
+          enabled: z21.boolean().optional(),
+          allowed: z21.array(z21.enum(["read", "write"])).optional(),
+          default: z21.enum(["read", "write"]).optional()
         }).strict().optional(),
-        viewTreeDelivery: z20.object({
-          enabled: z20.boolean().optional(),
-          allowed: z20.array(z20.enum(["manual", "auto"])).optional(),
-          default: z20.enum(["manual", "auto"]).optional()
+        viewTreeDelivery: z21.object({
+          enabled: z21.boolean().optional(),
+          allowed: z21.array(z21.enum(["manual", "auto"])).optional(),
+          default: z21.enum(["manual", "auto"]).optional()
         }).strict().optional()
       }).strict().optional(),
-      personalNotifications: z20.object({ supported: z20.boolean() }).strict().optional()
+      personalNotifications: z21.object({ supported: z21.boolean() }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  kernelRuntime: z20.object({
-    integrations: z20.object({
-      harbor: z20.object({
-        endpoint: z20.string().optional(),
-        projectScopes: z20.array(z20.string()).optional(),
-        authMode: z20.string().optional(),
-        principal: z20.string().optional(),
-        autoSync: z20.boolean().optional(),
-        proxyUrl: z20.string().optional()
+  kernelRuntime: z21.object({
+    integrations: z21.object({
+      harbor: z21.object({
+        endpoint: z21.string().optional(),
+        projectScopes: z21.array(z21.string()).optional(),
+        authMode: z21.string().optional(),
+        principal: z21.string().optional(),
+        autoSync: z21.boolean().optional(),
+        proxyUrl: z21.string().optional()
       }).strict().optional(),
-      gitlab: z20.object({
-        baseUrl: z20.string().optional(),
-        groupScopes: z20.array(z20.string()).optional(),
-        tokenMode: z20.string().optional(),
-        deployProjectPath: z20.string().optional(),
-        deploymentReportsEnabled: z20.boolean().optional(),
-        proxyUrl: z20.string().optional()
+      gitlab: z21.object({
+        baseUrl: z21.string().optional(),
+        groupScopes: z21.array(z21.string()).optional(),
+        tokenMode: z21.string().optional(),
+        deployProjectPath: z21.string().optional(),
+        deploymentReportsEnabled: z21.boolean().optional(),
+        proxyUrl: z21.string().optional()
       }).strict().optional(),
-      kubernetes: z20.object({
-        accessMode: z20.string().optional(),
-        clusterAlias: z20.string().optional(),
-        agentProjectPath: z20.string().optional(),
-        agentName: z20.string().optional(),
-        namespaceScopes: z20.array(z20.string()).optional(),
-        rolloutObserverEnabled: z20.boolean().optional(),
-        proxyUrl: z20.string().optional()
+      kubernetes: z21.object({
+        accessMode: z21.string().optional(),
+        clusterAlias: z21.string().optional(),
+        agentProjectPath: z21.string().optional(),
+        agentName: z21.string().optional(),
+        namespaceScopes: z21.array(z21.string()).optional(),
+        rolloutObserverEnabled: z21.boolean().optional(),
+        proxyUrl: z21.string().optional()
       }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  data: z20.object({}).strict().optional(),
-  storage: z20.object({
-    presignMode: z20.enum(["frontend", "backend", "both"]).optional(),
-    presign: z20.object({
-      expiresInSeconds: z20.number().int().positive(),
-      buckets: z20.array(
-        z20.object({
+  data: z21.object({}).strict().optional(),
+  storage: z21.object({
+    presignMode: z21.enum(["frontend", "backend", "both"]).optional(),
+    presign: z21.object({
+      expiresInSeconds: z21.number().int().positive(),
+      buckets: z21.array(
+        z21.object({
           id: ContractIdentifierSchema,
           provider: ContractIdentifierSchema,
           preferredUrlPatternId: ContractIdentifierSchema,
-          urlPatterns: z20.array(
-            z20.object({
+          urlPatterns: z21.array(
+            z21.object({
               id: ContractIdentifierSchema,
-              type: z20.enum(["bucket-hostname", "provider-hostname"]),
-              hostname: z20.string().trim().min(1),
-              preferred: z20.boolean().optional(),
-              bucketSegment: z20.string().optional()
+              type: z21.enum(["bucket-hostname", "provider-hostname"]),
+              hostname: z21.string().trim().min(1),
+              preferred: z21.boolean().optional(),
+              bucketSegment: z21.string().optional()
             }).strict()
           )
         }).strict()
       )
     }).strict().optional()
   }).strict().optional(),
-  monkeyData: z20.object({ baseUrl: z20.string().optional() }).strict().optional()
+  monkeyData: z21.object({ baseUrl: z21.string().optional() }).strict().optional()
 }).strict();
-var DeclarativeRuntimeRolloutCapabilitySchema = z20.object({
-  contract: z20.literal("DeclarativeRuntimeRolloutCapability"),
-  schemaVersion: z20.literal(1),
-  state: z20.enum(["disabled", "enabled"]),
+var DeclarativeRuntimeRolloutCapabilitySchema = z21.object({
+  contract: z21.literal("DeclarativeRuntimeRolloutCapability"),
+  schemaVersion: z21.literal(1),
+  state: z21.enum(["disabled", "enabled"]),
   apiVersion: ContractIdentifierSchema,
-  enabledSurfaces: z20.array(z20.enum(["studio", "kernel"])),
-  generation: z20.number().int().nonnegative(),
-  etag: z20.string().trim().min(1)
+  enabledSurfaces: z21.array(z21.enum(["studio", "kernel"])),
+  generation: z21.number().int().nonnegative(),
+  etag: z21.string().trim().min(1)
 }).strict();
-var TenantProductConfigSchema = z20.object({
-  contract: z20.literal("TenantProductConfig"),
+var TenantProductConfigSchema = z21.object({
+  contract: z21.literal("TenantProductConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: TenantDesignTokensConfigSchema,
-  moduleRefs: z20.array(ContractIdentifierSchema).default([]),
-  pageRefs: z20.array(ContractIdentifierSchema).default([]),
-  featureFlags: z20.record(z20.string(), z20.boolean()).default({}),
+  moduleRefs: z21.array(ContractIdentifierSchema).default([]),
+  pageRefs: z21.array(ContractIdentifierSchema).default([]),
+  featureFlags: z21.record(z21.string(), z21.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z20.record(z20.string(), ContractIdentifierSchema),
-  warnings: z20.array(z20.string()).default([]),
+  sourceMap: z21.record(z21.string(), ContractIdentifierSchema),
+  warnings: z21.array(z21.string()).default([]),
   menus: MenuDefinitionSetSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema,
   declarativeRuntime: DeclarativeRuntimeRolloutCapabilitySchema.optional()
 }).strict();
-var TenantRuntimeConfigSchema = z20.object({
-  contract: z20.literal("TenantRuntimeConfig"),
+var TenantRuntimeConfigSchema = z21.object({
+  contract: z21.literal("TenantRuntimeConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: ResolvedThemeTokensSchema,
-  moduleRefs: z20.array(ContractIdentifierSchema).default([]),
-  pageRefs: z20.array(ContractIdentifierSchema).default([]),
-  featureFlags: z20.record(z20.string(), z20.boolean()).default({}),
+  moduleRefs: z21.array(ContractIdentifierSchema).default([]),
+  pageRefs: z21.array(ContractIdentifierSchema).default([]),
+  featureFlags: z21.record(z21.string(), z21.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z20.record(z20.string(), ContractIdentifierSchema),
-  warnings: z20.array(z20.string()).default([]),
+  sourceMap: z21.record(z21.string(), ContractIdentifierSchema),
+  warnings: z21.array(z21.string()).default([]),
   menuBundle: MenuRuntimeBundleSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema,
   declarativeRuntime: DeclarativeRuntimeRolloutCapabilitySchema.optional()
 }).strict();
 
 // src/contracts/trend.ts
-import { z as z21 } from "zod";
-var RadarDecisionMetricsSchema = z21.object({
-  currentSales: z21.number().finite(),
-  forecastSales: z21.number().finite(),
-  searchHeat: z21.number().finite(),
-  socialHeat: z21.number().finite(),
-  confidence: z21.number().min(0).max(1)
-}).strict();
-var TrendSourceSchema = z21.object({
+import { z as z22 } from "zod";
+var RadarDecisionMetricsSchema = z22.object({
+  currentSales: z22.number().finite(),
+  forecastSales: z22.number().finite(),
+  searchHeat: z22.number().finite(),
+  socialHeat: z22.number().finite(),
+  confidence: z22.number().min(0).max(1)
+}).strict();
+var TrendSourceSchema = z22.object({
   sourceId: ContractIdentifierSchema,
   provider: ContractIdentifierSchema,
-  channel: z21.enum(["trend", "ecommerce", "social", "search", "internal"]),
+  channel: z22.enum(["trend", "ecommerce", "social", "search", "internal"]),
   collectedAt: IsoDateTimeSchema,
-  sourceUrl: z21.string().url().optional(),
-  evidenceRefs: z21.array(EntityRefSchema).default([])
+  sourceUrl: z22.string().url().optional(),
+  evidenceRefs: z22.array(EntityRefSchema).default([])
 }).strict();
-var TrendIngestRunSchema = z21.object({
-  contract: z21.literal("TrendIngestRun"),
+var TrendIngestRunSchema = z22.object({
+  contract: z22.literal("TrendIngestRun"),
   ingestRunId: ContractIdentifierSchema,
   sourceId: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  status: z21.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
-  recordCount: z21.number().int().nonnegative(),
-  errorCount: z21.number().int().nonnegative(),
+  status: z22.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
+  recordCount: z22.number().int().nonnegative(),
+  errorCount: z22.number().int().nonnegative(),
   startedAt: IsoDateTimeSchema,
   completedAt: IsoDateTimeSchema.optional()
 }).strict();
-var TrendSourceRecordSchema = z21.object({
-  contract: z21.literal("TrendSourceRecord"),
+var TrendSourceRecordSchema = z22.object({
+  contract: z22.literal("TrendSourceRecord"),
   sourceRecordId: ContractIdentifierSchema,
   source: TrendSourceSchema,
   ingestRunRef: EntityRefSchema,
-  recordVersion: z21.number().int().positive(),
+  recordVersion: z22.number().int().positive(),
   contentHash: Sha256Schema,
   payload: JsonValueSchema,
   idempotencyKey: ContractIdentifierSchema,
   collectedAt: IsoDateTimeSchema
 }).strict();
-var HotwordBodySchema = z21.object({
-  contract: z21.literal("HotwordBody"),
+var HotwordBodySchema = z22.object({
+  contract: z22.literal("HotwordBody"),
   hotwordId: ContractIdentifierSchema,
-  label: z21.string().trim().min(1),
-  normalizedLabel: z21.string().trim().min(1),
-  categories: z21.array(ContractIdentifierSchema).default([]),
-  sourceRefs: z21.array(TrendSourceSchema).min(1),
-  relationRefs: z21.array(EntityRefSchema).default([]),
+  label: z22.string().trim().min(1),
+  normalizedLabel: z22.string().trim().min(1),
+  categories: z22.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z22.array(TrendSourceSchema).min(1),
+  relationRefs: z22.array(EntityRefSchema).default([]),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 }).strict();
 var CommerceBodyFieldsSchema = {
-  displayName: z21.string().trim().min(1),
-  normalizedName: z21.string().trim().min(1),
-  categories: z21.array(ContractIdentifierSchema).default([]),
-  sourceRefs: z21.array(EntityRefSchema).min(1),
-  relationRefs: z21.array(EntityRefSchema).default([]),
+  displayName: z22.string().trim().min(1),
+  normalizedName: z22.string().trim().min(1),
+  categories: z22.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z22.array(EntityRefSchema).min(1),
+  relationRefs: z22.array(EntityRefSchema).default([]),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 };
-var BrandBodySchema = z21.object({
-  contract: z21.literal("BrandBody"),
+var BrandBodySchema = z22.object({
+  contract: z22.literal("BrandBody"),
   brandId: ContractIdentifierSchema,
   ...CommerceBodyFieldsSchema
 }).strict();
-var ProductBodySchema = z21.object({
-  contract: z21.literal("ProductBody"),
+var ProductBodySchema = z22.object({
+  contract: z22.literal("ProductBody"),
   productId: ContractIdentifierSchema,
   brandRef: EntityRefSchema.optional(),
   ...CommerceBodyFieldsSchema
 }).strict();
-var TrendMetricSnapshotSchema = z21.object({
-  contract: z21.literal("TrendMetricSnapshot"),
+var TrendMetricSnapshotSchema = z22.object({
+  contract: z22.literal("TrendMetricSnapshot"),
   snapshotId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   observedAt: IsoDateTimeSchema,
-  metrics: z21.record(z21.string(), z21.number().finite()),
-  confidence: z21.number().min(0).max(1),
-  evidenceRefs: z21.array(EntityRefSchema).min(1)
+  metrics: z22.record(z22.string(), z22.number().finite()),
+  confidence: z22.number().min(0).max(1),
+  evidenceRefs: z22.array(EntityRefSchema).min(1)
 }).strict();
-var RadarScoreModelBodySchema = z21.object({
-  contract: z21.literal("RadarScoreModelBody"),
+var RadarScoreModelBodySchema = z22.object({
+  contract: z22.literal("RadarScoreModelBody"),
   modelId: ContractIdentifierSchema,
-  version: z21.number().int().positive(),
+  version: z22.number().int().positive(),
   weights: RadarDecisionMetricsSchema,
-  thresholds: z21.record(z21.string(), z21.number().finite()).default({}),
-  explanationRules: z21.record(z21.string(), z21.string().trim().min(1)).default({}),
+  thresholds: z22.record(z22.string(), z22.number().finite()).default({}),
+  explanationRules: z22.record(z22.string(), z22.string().trim().min(1)).default({}),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarScoreProjectionSchema = z21.object({
-  contract: z21.literal("RadarScoreProjection"),
+var RadarScoreProjectionSchema = z22.object({
+  contract: z22.literal("RadarScoreProjection"),
   projectionId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   modelRef: EntityRefSchema,
-  totalScore: z21.number().finite(),
+  totalScore: z22.number().finite(),
   dimensions: RadarDecisionMetricsSchema,
-  evidenceRefs: z21.array(EntityRefSchema).min(1),
+  evidenceRefs: z22.array(EntityRefSchema).min(1),
   freshnessAt: IsoDateTimeSchema
 }).strict();
-var RadarPanoramaNodeSchema = z21.object({
+var RadarPanoramaNodeSchema = z22.object({
   ref: EntityRefSchema,
-  label: z21.string().trim().min(1),
-  categories: z21.array(ContractIdentifierSchema).default([]),
-  score: z21.number().finite().optional(),
+  label: z22.string().trim().min(1),
+  categories: z22.array(ContractIdentifierSchema).default([]),
+  score: z22.number().finite().optional(),
   freshnessAt: IsoDateTimeSchema.optional()
 }).strict();
-var RadarPanoramaEdgeSchema = z21.object({
+var RadarPanoramaEdgeSchema = z22.object({
   sourceRef: EntityRefSchema,
   targetRef: EntityRefSchema,
   relation: ContractIdentifierSchema,
-  evidenceRefs: z21.array(EntityRefSchema).default([])
+  evidenceRefs: z22.array(EntityRefSchema).default([])
 }).strict();
-var RadarPanoramaSchema = z21.object({
-  contract: z21.literal("RadarPanorama"),
-  nodes: z21.array(RadarPanoramaNodeSchema),
-  edges: z21.array(RadarPanoramaEdgeSchema),
+var RadarPanoramaSchema = z22.object({
+  contract: z22.literal("RadarPanorama"),
+  nodes: z22.array(RadarPanoramaNodeSchema),
+  edges: z22.array(RadarPanoramaEdgeSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
-var BrandGeneticsProfileSchema = z21.object({
-  contract: z21.literal("BrandGeneticsProfile"),
+var BrandGeneticsProfileSchema = z22.object({
+  contract: z22.literal("BrandGeneticsProfile"),
   brandRef: EntityRefSchema,
-  categories: z21.array(ContractIdentifierSchema).default([]),
-  signature: z21.record(ContractIdentifierSchema, z21.number().finite()),
-  relatedRefs: z21.array(EntityRefSchema).default([]),
-  evidenceRefs: z21.array(EntityRefSchema).default([]),
+  categories: z22.array(ContractIdentifierSchema).default([]),
+  signature: z22.record(ContractIdentifierSchema, z22.number().finite()),
+  relatedRefs: z22.array(EntityRefSchema).default([]),
+  evidenceRefs: z22.array(EntityRefSchema).default([]),
   computedAt: IsoDateTimeSchema
 }).strict();
-var RadarOpportunityMatrixPointSchema = z21.object({
+var RadarOpportunityMatrixPointSchema = z22.object({
   subjectRef: EntityRefSchema,
-  label: z21.string().trim().min(1),
-  x: z21.number().finite(),
-  y: z21.number().finite(),
-  score: z21.number().finite(),
-  evidenceRefs: z21.array(EntityRefSchema).default([])
-}).strict();
-var RadarOpportunityMatrixSchema = z21.object({
-  contract: z21.literal("RadarOpportunityMatrix"),
-  xMetric: z21.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
-  yMetric: z21.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
-  points: z21.array(RadarOpportunityMatrixPointSchema),
+  label: z22.string().trim().min(1),
+  x: z22.number().finite(),
+  y: z22.number().finite(),
+  score: z22.number().finite(),
+  evidenceRefs: z22.array(EntityRefSchema).default([])
+}).strict();
+var RadarOpportunityMatrixSchema = z22.object({
+  contract: z22.literal("RadarOpportunityMatrix"),
+  xMetric: z22.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  yMetric: z22.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  points: z22.array(RadarOpportunityMatrixPointSchema),
   computedAt: IsoDateTimeSchema
 }).strict();
-var RadarQueryBodySchema = z21.object({
-  contract: z21.literal("RadarQueryBody"),
+var RadarQueryBodySchema = z22.object({
+  contract: z22.literal("RadarQueryBody"),
   queryId: ContractIdentifierSchema,
-  filters: z21.record(z21.string(), JsonValueSchema).default({}),
-  sort: z21.object({
+  filters: z22.record(z22.string(), JsonValueSchema).default({}),
+  sort: z22.object({
     field: ContractIdentifierSchema,
-    direction: z21.enum(["asc", "desc"])
+    direction: z22.enum(["asc", "desc"])
   }).strict(),
-  pageSize: z21.number().int().min(1).max(200),
+  pageSize: z22.number().int().min(1).max(200),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var SavedRadarQuerySchema = z21.object({
-  contract: z21.literal("SavedRadarQuery"),
+var SavedRadarQuerySchema = z22.object({
+  contract: z22.literal("SavedRadarQuery"),
   savedQueryId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   ownerRef: EntityRefSchema,
-  name: z21.string().trim().min(1),
+  name: z22.string().trim().min(1),
   queryRef: EntityRefSchema,
-  expectedVersion: z21.number().int().nonnegative(),
+  expectedVersion: z22.number().int().nonnegative(),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var RadarSelectionSchema = z21.object({
-  contract: z21.literal("RadarSelection"),
+var RadarSelectionSchema = z22.object({
+  contract: z22.literal("RadarSelection"),
   selectionId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   ownerRef: EntityRefSchema,
-  subjectRefs: z21.array(EntityRefSchema),
-  status: z21.enum(["stashed", "selected", "rejected", "archived"]),
-  note: z21.string().optional(),
-  expectedVersion: z21.number().int().nonnegative(),
+  subjectRefs: z22.array(EntityRefSchema),
+  status: z22.enum(["stashed", "selected", "rejected", "archived"]),
+  note: z22.string().optional(),
+  expectedVersion: z22.number().int().nonnegative(),
   updatedAt: IsoDateTimeSchema
 }).strict();
 var versionedRefFields = {
   id: ContractIdentifierSchema,
-  version: z21.union([z21.number().int().positive(), z21.string().trim().min(1)]).optional(),
+  version: z22.union([z22.number().int().positive(), z22.string().trim().min(1)]).optional(),
   ownerRepo: ContractIdentifierSchema.optional()
 };
-var TrendRadarCollectionAssetRefSchema = z21.object({
-  kind: z21.literal("asset"),
+var TrendRadarCollectionAssetRefSchema = z22.object({
+  kind: z22.literal("asset"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionSelectionRefSchema = z21.object({
-  kind: z21.literal("radar-selection"),
+var TrendRadarCollectionSelectionRefSchema = z22.object({
+  kind: z22.literal("radar-selection"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionRunRefSchema = z21.object({
-  kind: z21.literal("radar-analysis-run"),
+var TrendRadarCollectionRunRefSchema = z22.object({
+  kind: z22.literal("radar-analysis-run"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionSubjectRefSchema = z21.object({
-  kind: z21.literal("hotword"),
+var TrendRadarCollectionSubjectRefSchema = z22.object({
+  kind: z22.literal("hotword"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionArtifactRefSchema = z21.object({
-  kind: z21.literal("artifact"),
+var TrendRadarCollectionArtifactRefSchema = z22.object({
+  kind: z22.literal("artifact"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionRecipeEntrySchema = z21.object({
+var TrendRadarCollectionRecipeEntrySchema = z22.object({
   subjectRef: TrendRadarCollectionSubjectRefSchema,
-  label: z21.string().trim().min(1).max(200)
+  label: z22.string().trim().min(1).max(200)
 }).strict();
-var TrendRadarCollectionRecipeSchema = z21.object({
-  category: z21.array(TrendRadarCollectionRecipeEntrySchema),
-  design: z21.array(TrendRadarCollectionRecipeEntrySchema),
-  audience: z21.array(TrendRadarCollectionRecipeEntrySchema)
+var TrendRadarCollectionRecipeSchema = z22.object({
+  category: z22.array(TrendRadarCollectionRecipeEntrySchema),
+  design: z22.array(TrendRadarCollectionRecipeEntrySchema),
+  audience: z22.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 = z21.object({
+var TrendRadarCollectionDecisionAxisSchema = z22.object({
   key: ContractIdentifierSchema,
-  label: z21.string().trim().min(1).max(200).optional(),
-  value: z21.number().finite()
-}).strict();
-var TrendRadarCollectionDecisionProjectionSchema = z21.object({
-  axes: z21.array(TrendRadarCollectionDecisionAxisSchema).max(32).optional(),
-  overallScore: z21.number().finite().optional(),
-  itemRank: z21.number().finite().optional(),
-  sourceRefs: z21.array(EntityRefSchema).optional(),
-  outputRefs: z21.array(EntityRefSchema).optional()
+  label: z22.string().trim().min(1).max(200).optional(),
+  value: z22.number().finite()
+}).strict();
+var TrendRadarCollectionDecisionProjectionSchema = z22.object({
+  axes: z22.array(TrendRadarCollectionDecisionAxisSchema).max(32).optional(),
+  overallScore: z22.number().finite().optional(),
+  itemRank: z22.number().finite().optional(),
+  sourceRefs: z22.array(EntityRefSchema).optional(),
+  outputRefs: z22.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
@@ -20249,20 +20348,20 @@ var TrendRadarCollectionDecisionProjectionSchema = z21.object({
     seenAxisKeys.add(axis.key);
   });
 });
-var TrendRadarCollectionArtifactProjectionSchema = z21.object({
+var TrendRadarCollectionArtifactProjectionSchema = z22.object({
   artifactRef: TrendRadarCollectionArtifactRefSchema,
-  url: z21.string().url().optional(),
-  thumbnailUrl: z21.string().url().optional(),
-  mimeType: z21.string().trim().min(1).optional(),
+  url: z22.string().url().optional(),
+  thumbnailUrl: z22.string().url().optional(),
+  mimeType: z22.string().trim().min(1).optional(),
   metadata: JsonObjectSchema.optional()
 }).strict();
-var TrendRadarCollectionProjectionWritebackSchema = z21.object({
-  status: z21.enum(["PENDING", "APPLIED", "FAILED"]),
+var TrendRadarCollectionProjectionWritebackSchema = z22.object({
+  status: z22.enum(["PENDING", "APPLIED", "FAILED"]),
   updatedAt: IsoDateTimeSchema,
-  error: z21.object({
+  error: z22.object({
     code: ContractIdentifierSchema,
-    message: z21.string().trim().min(1),
-    retryable: z21.boolean()
+    message: z22.string().trim().min(1),
+    retryable: z22.boolean()
   }).strict().optional()
 }).strict().superRefine((writeback, context) => {
   if (writeback.status === "FAILED" && !writeback.error) {
@@ -20280,12 +20379,12 @@ var TrendRadarCollectionProjectionWritebackSchema = z21.object({
     });
   }
 });
-var TrendRadarCollectionItemSchema = z21.object({
-  contract: z21.literal("TrendRadarCollectionItem"),
-  schemaVersion: z21.literal(1),
+var TrendRadarCollectionItemSchema = z22.object({
+  contract: z22.literal("TrendRadarCollectionItem"),
+  schemaVersion: z22.literal(1),
   selectionRef: TrendRadarCollectionSelectionRefSchema,
   recipe: TrendRadarCollectionRecipeSchema,
-  status: z21.enum(["SAVED", "QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
+  status: z22.enum(["SAVED", "QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
   latestRunRef: TrendRadarCollectionRunRefSchema.optional(),
   decisionProjection: TrendRadarCollectionDecisionProjectionSchema.optional(),
   artifactProjection: TrendRadarCollectionArtifactProjectionSchema.optional(),
@@ -20293,8 +20392,8 @@ var TrendRadarCollectionItemSchema = z21.object({
   updatedAt: IsoDateTimeSchema,
   generatedAt: IsoDateTimeSchema.optional()
 }).strict();
-var RadarAnalysisRunSchema = z21.object({
-  contract: z21.literal("RadarAnalysisRun"),
+var RadarAnalysisRunSchema = z22.object({
+  contract: z22.literal("RadarAnalysisRun"),
   runId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   selectionRef: EntityRefSchema,
@@ -20305,66 +20404,66 @@ var RadarAnalysisRunSchema = z21.object({
   collectionAssetRef: TrendRadarCollectionAssetRefSchema.optional(),
   collectionProjectionWriteback: TrendRadarCollectionProjectionWritebackSchema.optional(),
   workflowDefinitionTeamId: ContractIdentifierSchema.optional(),
-  workflowInput: z21.record(z21.string(), JsonValueSchema).default({}),
-  createDesignProject: z21.boolean().default(true),
-  designProjectName: z21.string().trim().min(1).max(200).optional(),
+  workflowInput: z22.record(z22.string(), JsonValueSchema).default({}),
+  createDesignProject: z22.boolean().default(true),
+  designProjectName: z22.string().trim().min(1).max(200).optional(),
   modelRef: EntityRefSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  status: z21.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
-  outputRefs: z21.array(EntityRefSchema).default([]),
-  error: z21.object({
+  status: z22.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
+  outputRefs: z22.array(EntityRefSchema).default([]),
+  error: z22.object({
     code: ContractIdentifierSchema,
-    message: z21.string().trim().min(1),
-    retryable: z21.boolean()
+    message: z22.string().trim().min(1),
+    retryable: z22.boolean()
   }).strict().optional(),
   startedAt: IsoDateTimeSchema.optional(),
   completedAt: IsoDateTimeSchema.optional(),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisAssetSchema = z21.object({
+var RadarAnalysisAssetSchema = z22.object({
   artifactRef: EntityRefSchema,
   kind: ContractIdentifierSchema,
-  mimeType: z21.string().trim().min(1).optional(),
-  url: z21.string().url(),
-  metadata: z21.record(z21.string(), JsonValueSchema).default({}),
+  mimeType: z22.string().trim().min(1).optional(),
+  url: z22.string().url(),
+  metadata: z22.record(z22.string(), JsonValueSchema).default({}),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisDetailSchema = z21.object({
-  contract: z21.literal("RadarAnalysisDetail"),
+var RadarAnalysisDetailSchema = z22.object({
+  contract: z22.literal("RadarAnalysisDetail"),
   run: RadarAnalysisRunSchema,
-  runVersion: z21.number().int().positive(),
+  runVersion: z22.number().int().positive(),
   selection: RadarSelectionSchema,
-  outputs: z21.array(OutputRecordSchema),
-  assets: z21.array(RadarAnalysisAssetSchema),
-  lineage: z21.array(LineageRecordSchema)
+  outputs: z22.array(OutputRecordSchema),
+  assets: z22.array(RadarAnalysisAssetSchema),
+  lineage: z22.array(LineageRecordSchema)
 }).strict();
-var RadarActionRecordSchema = z21.object({
-  contract: z21.literal("RadarActionRecord"),
+var RadarActionRecordSchema = z22.object({
+  contract: z22.literal("RadarActionRecord"),
   actionId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   actorRef: EntityRefSchema,
-  action: z21.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
+  action: z22.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
   targetRef: EntityRefSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  expectedVersion: z21.number().int().nonnegative(),
+  expectedVersion: z22.number().int().nonnegative(),
   occurredAt: IsoDateTimeSchema
 }).strict();
-var RadarWritebackRecordSchema = z21.object({
-  contract: z21.literal("RadarWritebackRecord"),
+var RadarWritebackRecordSchema = z22.object({
+  contract: z22.literal("RadarWritebackRecord"),
   writebackId: ContractIdentifierSchema,
   actionRef: EntityRefSchema,
   targetRef: EntityRefSchema,
-  status: z21.enum(["PENDING", "APPLIED", "FAILED"]),
-  resultingVersion: z21.number().int().nonnegative().optional(),
-  error: z21.string().trim().min(1).optional(),
+  status: z22.enum(["PENDING", "APPLIED", "FAILED"]),
+  resultingVersion: z22.number().int().nonnegative().optional(),
+  error: z22.string().trim().min(1).optional(),
   recordedAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/workflow-definition.ts
-import { z as z22 } from "zod";
-var ConductorTaskTypeSchema = z22.enum([
+import { z as z23 } from "zod";
+var ConductorTaskTypeSchema = z23.enum([
   "SIMPLE",
   "DYNAMIC",
   "FORK_JOIN",
@@ -20413,46 +20512,46 @@ var requiredTaskFields = {
   WAIT: ["inputParameters"],
   TERMINATE: ["inputParameters"]
 };
-var ConductorTaskDefinitionSchema = z22.lazy(
-  () => z22.object({
+var ConductorTaskDefinitionSchema = z23.lazy(
+  () => z23.object({
     name: ContractIdentifierSchema,
     taskReferenceName: ContractIdentifierSchema,
     type: ConductorTaskTypeSchema,
-    inputParameters: z22.record(z22.string(), JsonValueSchema).optional(),
-    startDelay: z22.number().int().nonnegative().optional(),
-    optional: z22.boolean().optional(),
-    asyncComplete: z22.boolean().optional(),
-    rateLimited: z22.boolean().optional(),
-    retryCount: z22.number().int().nonnegative().optional(),
-    taskDefinition: z22.record(z22.string(), JsonValueSchema).optional(),
-    loopCondition: z22.string().optional(),
-    loopOver: z22.array(ConductorTaskDefinitionSchema).optional(),
-    sink: z22.string().optional(),
-    forkTasks: z22.array(z22.array(ConductorTaskDefinitionSchema)).optional(),
-    joinOn: z22.array(ContractIdentifierSchema).optional(),
-    defaultExclusiveJoinTask: z22.array(ContractIdentifierSchema).optional(),
-    dynamicForkTasksParam: z22.string().optional(),
-    dynamicForkTasksInputParamName: z22.string().optional(),
-    subWorkflowParam: z22.object({
-      $ref: z22.string().optional(),
+    inputParameters: z23.record(z23.string(), JsonValueSchema).optional(),
+    startDelay: z23.number().int().nonnegative().optional(),
+    optional: z23.boolean().optional(),
+    asyncComplete: z23.boolean().optional(),
+    rateLimited: z23.boolean().optional(),
+    retryCount: z23.number().int().nonnegative().optional(),
+    taskDefinition: z23.record(z23.string(), JsonValueSchema).optional(),
+    loopCondition: z23.string().optional(),
+    loopOver: z23.array(ConductorTaskDefinitionSchema).optional(),
+    sink: z23.string().optional(),
+    forkTasks: z23.array(z23.array(ConductorTaskDefinitionSchema)).optional(),
+    joinOn: z23.array(ContractIdentifierSchema).optional(),
+    defaultExclusiveJoinTask: z23.array(ContractIdentifierSchema).optional(),
+    dynamicForkTasksParam: z23.string().optional(),
+    dynamicForkTasksInputParamName: z23.string().optional(),
+    subWorkflowParam: z23.object({
+      $ref: z23.string().optional(),
       name: ContractIdentifierSchema,
-      version: z22.number().int().positive().optional(),
-      taskToDomain: z22.record(z22.string(), z22.string()).optional(),
-      workflowDefinition: z22.record(z22.string(), JsonValueSchema).optional()
+      version: z23.number().int().positive().optional(),
+      taskToDomain: z23.record(z23.string(), z23.string()).optional(),
+      workflowDefinition: z23.record(z23.string(), JsonValueSchema).optional()
     }).strict().optional(),
-    decisionCases: z22.record(z22.string(), z22.array(ConductorTaskDefinitionSchema)).optional(),
-    defaultCase: z22.array(ConductorTaskDefinitionSchema).optional(),
-    evaluatorType: z22.enum(["value-param", "javascript", "graaljs"]).optional(),
-    expression: z22.string().optional(),
+    decisionCases: z23.record(z23.string(), z23.array(ConductorTaskDefinitionSchema)).optional(),
+    defaultCase: z23.array(ConductorTaskDefinitionSchema).optional(),
+    evaluatorType: z23.enum(["value-param", "javascript", "graaljs"]).optional(),
+    expression: z23.string().optional(),
     __alias: JsonValueSchema.optional(),
-    callbackFromWorker: z22.boolean().optional(),
+    callbackFromWorker: z23.boolean().optional(),
     caseExpression: JsonValueSchema.optional(),
-    caseValueParam: z22.string().optional(),
-    dependencies: z22.array(JsonValueSchema).optional(),
-    description: z22.string().optional(),
-    dynamicTaskNameParam: z22.string().optional(),
-    joinMode: z22.string().optional(),
-    permissive: z22.boolean().optional(),
+    caseValueParam: z23.string().optional(),
+    dependencies: z23.array(JsonValueSchema).optional(),
+    description: z23.string().optional(),
+    dynamicTaskNameParam: z23.string().optional(),
+    joinMode: z23.string().optional(),
+    permissive: z23.boolean().optional(),
     joinTaskRef: ContractIdentifierSchema.optional(),
     forkTaskRef: ContractIdentifierSchema.optional()
   }).strict().superRefine((task, context) => {
@@ -20466,29 +20565,29 @@ var ConductorTaskDefinitionSchema = z22.lazy(
     }
   })
 );
-var ConductorWorkflowDefinitionSchema = z22.object({
-  ownerApp: z22.string().optional(),
-  createTime: z22.number().int().nonnegative().optional(),
-  updateTime: z22.number().int().nonnegative().optional(),
-  createdBy: z22.string().optional(),
-  updatedBy: z22.string().optional(),
+var ConductorWorkflowDefinitionSchema = z23.object({
+  ownerApp: z23.string().optional(),
+  createTime: z23.number().int().nonnegative().optional(),
+  updateTime: z23.number().int().nonnegative().optional(),
+  createdBy: z23.string().optional(),
+  updatedBy: z23.string().optional(),
   name: ContractIdentifierSchema,
-  description: z22.string().optional(),
-  version: z22.number().int().positive(),
-  tasks: z22.array(ConductorTaskDefinitionSchema),
-  inputParameters: z22.array(ContractIdentifierSchema),
-  outputParameters: z22.record(z22.string(), JsonValueSchema).optional(),
+  description: z23.string().optional(),
+  version: z23.number().int().positive(),
+  tasks: z23.array(ConductorTaskDefinitionSchema),
+  inputParameters: z23.array(ContractIdentifierSchema),
+  outputParameters: z23.record(z23.string(), JsonValueSchema).optional(),
   failureWorkflow: ContractIdentifierSchema.optional(),
-  schemaVersion: z22.number().int().positive().optional(),
-  restartable: z22.boolean().optional(),
-  workflowStatusListenerEnabled: z22.boolean().optional(),
-  ownerEmail: z22.string().email().optional(),
-  timeoutPolicy: z22.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
-  timeoutSeconds: z22.number().int().nonnegative(),
-  variables: z22.record(z22.string(), JsonValueSchema).optional(),
-  inputTemplate: z22.record(z22.string(), JsonValueSchema).optional()
-}).strict();
-var WorkflowParameterTypeSchema = z22.enum([
+  schemaVersion: z23.number().int().positive().optional(),
+  restartable: z23.boolean().optional(),
+  workflowStatusListenerEnabled: z23.boolean().optional(),
+  ownerEmail: z23.string().email().optional(),
+  timeoutPolicy: z23.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+  timeoutSeconds: z23.number().int().nonnegative(),
+  variables: z23.record(z23.string(), JsonValueSchema).optional(),
+  inputTemplate: z23.record(z23.string(), JsonValueSchema).optional()
+}).strict();
+var WorkflowParameterTypeSchema = z23.enum([
   "string",
   "file",
   "number",
@@ -20498,214 +20597,214 @@ var WorkflowParameterTypeSchema = z22.enum([
   "notice",
   "canvas-assist"
 ]);
-var WorkflowConditionalStateSchema = z22.object({
-  conditions: z22.array(
-    z22.object({
-      field: z22.string(),
-      operator: z22.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
+var WorkflowConditionalStateSchema = z23.object({
+  conditions: z23.array(
+    z23.object({
+      field: z23.string(),
+      operator: z23.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
       value: JsonValueSchema
     }).strict()
   ),
-  logic: z22.enum(["AND", "OR"]).optional()
-}).strict();
-var ImageSelectMappingAppearanceSchema = z22.object({
-  columns: z22.number().int().min(1).max(4).optional(),
-  cardSize: z22.enum(["sm", "md", "lg"]).optional(),
-  imageAspectRatio: z22.enum(["square", "4:5", "3:4", "16:9"]).optional(),
-  gap: z22.enum(["sm", "md", "lg"]).optional(),
-  radius: z22.enum(["sm", "md", "lg", "xl"]).optional(),
-  borderStyle: z22.enum(["none", "soft", "strong"]).optional(),
-  borderWidth: z22.union([z22.literal(0), z22.literal(1), z22.literal(2)]).optional(),
-  enableScroll: z22.boolean().optional(),
-  maxHeight: z22.number().int().min(160).max(1200).optional(),
-  enableCollapse: z22.boolean().optional(),
-  visibleRows: z22.number().int().min(1).max(6).optional(),
-  hideLabel: z22.boolean().optional(),
-  hideDescription: z22.boolean().optional(),
-  hideValue: z22.boolean().optional()
-}).strict();
-var ComfyWorkflowPortBindingSchema = z22.object({
-  node: z22.union([z22.string(), z22.number()]),
-  key: z22.string().optional()
-}).strict();
-var WorkflowParameterTypeOptionsSchema = z22.object({
-  editor: z22.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
-  editorLanguage: z22.enum(["javaScript", "json", "python", "sql"]).optional(),
-  maxValue: z22.number().optional(),
-  minValue: z22.number().optional(),
-  max: z22.number().optional(),
-  min: z22.number().optional(),
-  multipleValues: z22.boolean().optional(),
-  numberPrecision: z22.number().nonnegative().optional(),
-  password: z22.boolean().optional(),
-  rows: z22.number().int().positive().optional(),
-  assetType: z22.string().optional(),
-  accept: z22.string().optional(),
-  maxSize: z22.number().positive().optional(),
-  fileType: z22.string().optional(),
-  aiMultiShotMainImageField: z22.string().optional(),
-  aiMultiShotWorkflowAppId: z22.string().optional(),
-  aiMultiShotWorkflowId: z22.string().optional(),
-  allowCustomInput: z22.boolean().optional(),
-  allowUploadVideo: z22.boolean().optional(),
-  aspectRatioField: z22.string().optional(),
-  assemblyValueType: z22.string().optional(),
-  autoAnalyzeDesignImage: z22.boolean().optional(),
-  autoDetectAspectRatio: z22.boolean().optional(),
-  autoIncrementId: z22.boolean().optional(),
+  logic: z23.enum(["AND", "OR"]).optional()
+}).strict();
+var ImageSelectMappingAppearanceSchema = z23.object({
+  columns: z23.number().int().min(1).max(4).optional(),
+  cardSize: z23.enum(["sm", "md", "lg"]).optional(),
+  imageAspectRatio: z23.enum(["square", "4:5", "3:4", "16:9"]).optional(),
+  gap: z23.enum(["sm", "md", "lg"]).optional(),
+  radius: z23.enum(["sm", "md", "lg", "xl"]).optional(),
+  borderStyle: z23.enum(["none", "soft", "strong"]).optional(),
+  borderWidth: z23.union([z23.literal(0), z23.literal(1), z23.literal(2)]).optional(),
+  enableScroll: z23.boolean().optional(),
+  maxHeight: z23.number().int().min(160).max(1200).optional(),
+  enableCollapse: z23.boolean().optional(),
+  visibleRows: z23.number().int().min(1).max(6).optional(),
+  hideLabel: z23.boolean().optional(),
+  hideDescription: z23.boolean().optional(),
+  hideValue: z23.boolean().optional()
+}).strict();
+var ComfyWorkflowPortBindingSchema = z23.object({
+  node: z23.union([z23.string(), z23.number()]),
+  key: z23.string().optional()
+}).strict();
+var WorkflowParameterTypeOptionsSchema = z23.object({
+  editor: z23.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
+  editorLanguage: z23.enum(["javaScript", "json", "python", "sql"]).optional(),
+  maxValue: z23.number().optional(),
+  minValue: z23.number().optional(),
+  max: z23.number().optional(),
+  min: z23.number().optional(),
+  multipleValues: z23.boolean().optional(),
+  numberPrecision: z23.number().nonnegative().optional(),
+  password: z23.boolean().optional(),
+  rows: z23.number().int().positive().optional(),
+  assetType: z23.string().optional(),
+  accept: z23.string().optional(),
+  maxSize: z23.number().positive().optional(),
+  fileType: z23.string().optional(),
+  aiMultiShotMainImageField: z23.string().optional(),
+  aiMultiShotWorkflowAppId: z23.string().optional(),
+  aiMultiShotWorkflowId: z23.string().optional(),
+  allowCustomInput: z23.boolean().optional(),
+  allowUploadVideo: z23.boolean().optional(),
+  aspectRatioField: z23.string().optional(),
+  assemblyValueType: z23.string().optional(),
+  autoAnalyzeDesignImage: z23.boolean().optional(),
+  autoDetectAspectRatio: z23.boolean().optional(),
+  autoIncrementId: z23.boolean().optional(),
   comfyOptions: ComfyWorkflowPortBindingSchema.optional(),
-  comfyuiModelServerId: z22.string().optional(),
-  comfyuiModelTypeName: z22.string().optional(),
+  comfyuiModelServerId: z23.string().optional(),
+  comfyuiModelTypeName: z23.string().optional(),
   defaultCustomInput: JsonValueSchema.optional(),
-  descriptionAlert: z22.boolean().optional(),
-  disabled: z22.union([z22.boolean(), WorkflowConditionalStateSchema]).optional(),
-  editable: z22.union([z22.boolean(), WorkflowConditionalStateSchema]).optional(),
-  enableAiMultiShot: z22.boolean().optional(),
-  enableBooleanSwitchMode: z22.boolean().optional(),
-  enableClear: z22.boolean().optional(),
-  enableExpand: z22.boolean().optional(),
-  enableImageCrop: z22.boolean().optional(),
-  enableImageMask: z22.boolean().optional(),
-  enableImageOverlay: z22.boolean().optional(),
-  enablePopupEditor: z22.boolean().optional(),
-  enablePromptFontSize: z22.boolean().optional(),
-  enableReset: z22.boolean().optional(),
-  enableSelectItemIcon: z22.boolean().optional(),
-  enableSelectList: z22.boolean().optional(),
-  enableSelectSearch: z22.boolean().optional(),
-  enableSliderEnterMode: z22.boolean().optional(),
-  enableVoice: z22.boolean().optional(),
-  expandButtonText: z22.string().optional(),
-  foldUp: z22.boolean().optional(),
-  hidden: z22.boolean().optional(),
-  hideRequiredDot: z22.boolean().optional(),
-  inlineTitleWithSelect: z22.boolean().optional(),
-  knowledgeGraphButtonText: z22.string().optional(),
-  identifyAttributeCount: z22.union([z22.number().nonnegative(), z22.string().min(1), z22.object({ min: z22.number().nonnegative().optional(), max: z22.number().nonnegative().optional() }).strict()]).optional(),
-  identifyAttributes: z22.array(JsonValueSchema).optional(),
-  identifyMaxVariants: z22.number().int().nonnegative().optional(),
-  identifySourceField: z22.string().optional(),
-  imageOverlayBaseField: z22.string().optional(),
-  imageOverlayOverlayField: z22.string().optional(),
+  descriptionAlert: z23.boolean().optional(),
+  disabled: z23.union([z23.boolean(), WorkflowConditionalStateSchema]).optional(),
+  editable: z23.union([z23.boolean(), WorkflowConditionalStateSchema]).optional(),
+  enableAiMultiShot: z23.boolean().optional(),
+  enableBooleanSwitchMode: z23.boolean().optional(),
+  enableClear: z23.boolean().optional(),
+  enableExpand: z23.boolean().optional(),
+  enableImageCrop: z23.boolean().optional(),
+  enableImageMask: z23.boolean().optional(),
+  enableImageOverlay: z23.boolean().optional(),
+  enablePopupEditor: z23.boolean().optional(),
+  enablePromptFontSize: z23.boolean().optional(),
+  enableReset: z23.boolean().optional(),
+  enableSelectItemIcon: z23.boolean().optional(),
+  enableSelectList: z23.boolean().optional(),
+  enableSelectSearch: z23.boolean().optional(),
+  enableSliderEnterMode: z23.boolean().optional(),
+  enableVoice: z23.boolean().optional(),
+  expandButtonText: z23.string().optional(),
+  foldUp: z23.boolean().optional(),
+  hidden: z23.boolean().optional(),
+  hideRequiredDot: z23.boolean().optional(),
+  inlineTitleWithSelect: z23.boolean().optional(),
+  knowledgeGraphButtonText: z23.string().optional(),
+  identifyAttributeCount: z23.union([z23.number().nonnegative(), z23.string().min(1), z23.object({ min: z23.number().nonnegative().optional(), max: z23.number().nonnegative().optional() }).strict()]).optional(),
+  identifyAttributes: z23.array(JsonValueSchema).optional(),
+  identifyMaxVariants: z23.number().int().nonnegative().optional(),
+  identifySourceField: z23.string().optional(),
+  imageOverlayBaseField: z23.string().optional(),
+  imageOverlayOverlayField: z23.string().optional(),
   imageSelectMappingAppearance: ImageSelectMappingAppearanceSchema.optional(),
-  imageSelectMappingColumns: z22.number().int().min(1).max(4).optional(),
-  imageSelectMappingEnableCustomUpload: z22.boolean().optional(),
-  imageSelectMappingHideLabel: z22.boolean().optional(),
-  imageSelectMappingHideLink: z22.boolean().optional(),
-  imageSelectMappingHideMeta: z22.boolean().optional(),
-  imageSelectMappingInlineUseLargeUploadBox: z22.boolean().optional(),
-  imageSelectMappingPromptField: z22.string().optional(),
-  imageSelectMappingTabOrder: z22.enum(["template-first", "upload-first"]).optional(),
-  imageSelectMappingTabWidthMode: z22.enum(["content", "fill"]).optional(),
+  imageSelectMappingColumns: z23.number().int().min(1).max(4).optional(),
+  imageSelectMappingEnableCustomUpload: z23.boolean().optional(),
+  imageSelectMappingHideLabel: z23.boolean().optional(),
+  imageSelectMappingHideLink: z23.boolean().optional(),
+  imageSelectMappingHideMeta: z23.boolean().optional(),
+  imageSelectMappingInlineUseLargeUploadBox: z23.boolean().optional(),
+  imageSelectMappingPromptField: z23.string().optional(),
+  imageSelectMappingTabOrder: z23.enum(["template-first", "upload-first"]).optional(),
+  imageSelectMappingTabWidthMode: z23.enum(["content", "fill"]).optional(),
   imageSelectMappingTemplatePrompt: LocalizedTextSchema.optional(),
   imageSelectMappingTemplateTabTitle: LocalizedTextSchema.optional(),
-  imageSelectMappingUploadMode: z22.enum(["tabs", "inline"]).optional(),
+  imageSelectMappingUploadMode: z23.enum(["tabs", "inline"]).optional(),
   imageSelectMappingUploadPrompt: LocalizedTextSchema.optional(),
   imageSelectMappingUploadTabTitle: LocalizedTextSchema.optional(),
-  endpoints: z22.array(JsonValueSchema).optional(),
-  examples: z22.array(JsonValueSchema).optional(),
+  endpoints: z23.array(JsonValueSchema).optional(),
+  examples: z23.array(JsonValueSchema).optional(),
   extraData: JsonValueSchema.optional(),
   layer: JsonValueSchema.optional(),
   map: JsonValueSchema.optional(),
-  multiline: z22.boolean().optional(),
-  options: z22.array(JsonValueSchema).optional(),
-  originalFiles: z22.array(JsonValueSchema).optional(),
+  multiline: z23.boolean().optional(),
+  options: z23.array(JsonValueSchema).optional(),
+  originalFiles: z23.array(JsonValueSchema).optional(),
   placeholder: LocalizedTextSchema.optional(),
-  preserveSelectListOrder: z22.boolean().optional(),
+  preserveSelectListOrder: z23.boolean().optional(),
   promptDictionary: JsonValueSchema.optional(),
-  promptFontSize: z22.number().optional(),
+  promptFontSize: z23.number().optional(),
   promptModeToggle: JsonValueSchema.optional(),
-  requireActiveSelectFilter: z22.boolean().optional(),
-  restoreDefaultOnEmptyEnter: z22.boolean().optional(),
-  search: z22.boolean().optional(),
-  selectButtonEnableCollapse: z22.boolean().optional(),
-  selectButtonVisibleRows: z22.number().int().positive().optional(),
-  selectList: z22.array(JsonValueSchema).optional(),
-  selectListDisplayMode: z22.string().optional(),
-  selectPromptField: z22.string().optional(),
-  showAddLocalFileButton: z22.boolean().optional(),
-  singleColumn: z22.boolean().optional(),
-  singleFrameForMultiple: z22.boolean().optional(),
-  textSingleLine: z22.boolean().optional(),
-  textareaMiniHeight: z22.number().nonnegative().optional(),
+  requireActiveSelectFilter: z23.boolean().optional(),
+  restoreDefaultOnEmptyEnter: z23.boolean().optional(),
+  search: z23.boolean().optional(),
+  selectButtonEnableCollapse: z23.boolean().optional(),
+  selectButtonVisibleRows: z23.number().int().positive().optional(),
+  selectList: z23.array(JsonValueSchema).optional(),
+  selectListDisplayMode: z23.string().optional(),
+  selectPromptField: z23.string().optional(),
+  showAddLocalFileButton: z23.boolean().optional(),
+  singleColumn: z23.boolean().optional(),
+  singleFrameForMultiple: z23.boolean().optional(),
+  textSingleLine: z23.boolean().optional(),
+  textareaMiniHeight: z23.number().nonnegative().optional(),
   tips: LocalizedTextSchema.optional(),
   visibility: JsonValueSchema.optional(),
-  voiceButtonText: z22.string().optional(),
-  designAnalysisFields: z22.array(JsonValueSchema).optional(),
-  designAnalysisFillStrategy: z22.string().optional(),
-  designAnalysisMaxFields: z22.number().int().nonnegative().optional(),
-  designAnalysisType: z22.string().optional(),
-  designAnalysisFieldPrefix: z22.string().optional()
-}).strict();
-var WorkflowParameterSchema = z22.lazy(
-  () => z22.object({
+  voiceButtonText: z23.string().optional(),
+  designAnalysisFields: z23.array(JsonValueSchema).optional(),
+  designAnalysisFillStrategy: z23.string().optional(),
+  designAnalysisMaxFields: z23.number().int().nonnegative().optional(),
+  designAnalysisType: z23.string().optional(),
+  designAnalysisFieldPrefix: z23.string().optional()
+}).strict();
+var WorkflowParameterSchema = z23.lazy(
+  () => z23.object({
     displayName: LocalizedTextSchema,
     name: ContractIdentifierSchema,
     type: WorkflowParameterTypeSchema,
     typeOptions: WorkflowParameterTypeOptionsSchema.optional(),
     default: JsonValueSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    hint: z22.string().optional(),
-    displayOptions: z22.object({
-      hide: z22.record(z22.string(), z22.array(JsonValueSchema)).optional(),
-      show: z22.record(z22.string(), z22.array(JsonValueSchema)).optional()
+    hint: z23.string().optional(),
+    displayOptions: z23.object({
+      hide: z23.record(z23.string(), z23.array(JsonValueSchema)).optional(),
+      show: z23.record(z23.string(), z23.array(JsonValueSchema)).optional()
     }).strict().optional(),
-    options: z22.array(z22.union([
-      z22.object({ name: LocalizedTextSchema, value: z22.union([z22.string(), z22.number(), z22.boolean()]), action: z22.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
+    options: z23.array(z23.union([
+      z23.object({ name: LocalizedTextSchema, value: z23.union([z23.string(), z23.number(), z23.boolean()]), action: z23.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
       WorkflowParameterSchema,
-      z22.object({ displayName: z22.string(), name: ContractIdentifierSchema, values: z22.array(WorkflowParameterSchema) }).strict()
+      z23.object({ displayName: z23.string(), name: ContractIdentifierSchema, values: z23.array(WorkflowParameterSchema) }).strict()
     ])).optional(),
     placeholder: LocalizedTextSchema.optional(),
-    isNodeSetting: z22.boolean().optional(),
-    noDataExpression: z22.boolean().optional(),
-    required: z22.boolean().optional(),
-    example: z22.string().optional(),
-    extractValue: z22.object({ type: z22.literal("regex"), regex: z22.string() }).strict().optional(),
-    properties: z22.array(WorkflowParameterSchema).optional(),
-    assetType: z22.string().optional(),
-    flag: z22.boolean().optional(),
-    enableExpand: z22.boolean().optional(),
-    enableVoice: z22.boolean().optional(),
-    expandButtonText: z22.string().optional(),
-    knowledgeGraphButtonText: z22.string().optional(),
-    selectListDisplayMode: z22.string().optional(),
-    voiceButtonText: z22.string().optional()
+    isNodeSetting: z23.boolean().optional(),
+    noDataExpression: z23.boolean().optional(),
+    required: z23.boolean().optional(),
+    example: z23.string().optional(),
+    extractValue: z23.object({ type: z23.literal("regex"), regex: z23.string() }).strict().optional(),
+    properties: z23.array(WorkflowParameterSchema).optional(),
+    assetType: z23.string().optional(),
+    flag: z23.boolean().optional(),
+    enableExpand: z23.boolean().optional(),
+    enableVoice: z23.boolean().optional(),
+    expandButtonText: z23.string().optional(),
+    knowledgeGraphButtonText: z23.string().optional(),
+    selectListDisplayMode: z23.string().optional(),
+    voiceButtonText: z23.string().optional()
   }).strict()
 );
-var WorkflowOutputBindingSchema = z22.object({ key: ContractIdentifierSchema, value: z22.string() }).strict();
-var WorkflowNodeSchema = z22.object({
+var WorkflowOutputBindingSchema = z23.object({ key: ContractIdentifierSchema, value: z23.string() }).strict();
+var WorkflowNodeSchema = z23.object({
   id: ContractIdentifierSchema,
   referenceName: ContractIdentifierSchema,
   capabilityRef: ContractIdentifierSchema,
   capabilityVersion: ContractIdentifierSchema.optional(),
-  inputBindings: z22.record(z22.string(), JsonValueSchema).default({}),
-  configuration: z22.object({ executor: z22.literal("conductor"), task: ConductorTaskDefinitionSchema }).strict()
+  inputBindings: z23.record(z23.string(), JsonValueSchema).default({}),
+  configuration: z23.object({ executor: z23.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 = z22.object({
+var WorkflowEdgeSchema = z23.object({
   from: ContractIdentifierSchema,
   to: ContractIdentifierSchema,
   outputPort: ContractIdentifierSchema.optional(),
   inputPort: ContractIdentifierSchema.optional(),
-  condition: z22.string().optional()
+  condition: z23.string().optional()
 }).strict();
-var WorkflowTriggerSchema = z22.object({
+var WorkflowTriggerSchema = z23.object({
   id: ContractIdentifierSchema,
-  type: z22.enum(["manual", "schedule", "webhook", "event", "api"]),
-  enabled: z22.boolean(),
-  schedule: z22.object({ cron: z22.string().trim().min(1) }).strict().optional(),
-  webhook: z22.object({
-    path: z22.string().trim().min(1).optional(),
-    method: z22.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
-    auth: z22.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
-    basicAuth: z22.object({ username: z22.string(), password: z22.string() }).strict().optional(),
-    headerAuth: z22.object({ name: z22.string().trim().min(1), value: z22.string() }).strict().optional(),
-    responseUntil: z22.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
+  type: z23.enum(["manual", "schedule", "webhook", "event", "api"]),
+  enabled: z23.boolean(),
+  schedule: z23.object({ cron: z23.string().trim().min(1) }).strict().optional(),
+  webhook: z23.object({
+    path: z23.string().trim().min(1).optional(),
+    method: z23.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
+    auth: z23.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
+    basicAuth: z23.object({ username: z23.string(), password: z23.string() }).strict().optional(),
+    headerAuth: z23.object({ name: z23.string().trim().min(1), value: z23.string() }).strict().optional(),
+    responseUntil: z23.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
   }).strict().optional(),
-  event: z22.object({
+  event: z23.object({
     eventType: ContractIdentifierSchema,
     configuration: JsonValueSchema.optional()
   }).strict().optional()
@@ -20714,63 +20813,63 @@ var WorkflowTriggerSchema = z22.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 = z22.object({
+var WorkflowValidationIssueSchema = z23.object({
   taskReferenceName: ContractIdentifierSchema,
-  issueType: z22.enum(["ERROR", "WARNING"]),
-  detailReason: z22.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
-  humanMessage: z22.object({ en: z22.string(), zh: z22.string() }).strict()
+  issueType: z23.enum(["ERROR", "WARNING"]),
+  detailReason: z23.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
+  humanMessage: z23.object({ en: z23.string(), zh: z23.string() }).strict()
 }).strict();
-var WorkflowDefinitionSchema = z22.object({
-  contract: z22.literal("WorkflowDefinition"),
+var WorkflowDefinitionSchema = z23.object({
+  contract: z23.literal("WorkflowDefinition"),
   metadata: ContractMetadataSchema.omit({ name: true, description: true, labels: true }).extend({
     name: LocalizedTextSchema,
     description: LocalizedTextSchema.optional(),
-    role: z22.enum(["workflow", "template"]),
+    role: z23.enum(["workflow", "template"]),
     teamId: ContractIdentifierSchema,
     creatorRef: EntityRefSchema,
-    tags: z22.array(ContractIdentifierSchema).default([])
+    tags: z23.array(ContractIdentifierSchema).default([])
   }).strict(),
-  revision: z22.object({
-    kind: z22.enum(["release", "backup"]),
-    recordVersion: z22.number().int().positive(),
-    sourceVersion: z22.number().int().positive().optional()
+  revision: z23.object({
+    kind: z23.enum(["release", "backup"]),
+    recordVersion: z23.number().int().positive(),
+    sourceVersion: z23.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: z22.object({ iconUrl: z22.string().optional(), thumbnail: z22.string().optional() }).strict(),
-  ports: z22.object({ inputs: z22.array(ContractPortSchema).default([]), outputs: z22.array(ContractPortSchema).default([]) }).strict(),
-  parameters: z22.object({ variables: z22.array(WorkflowParameterSchema).default([]), outputs: z22.array(WorkflowOutputBindingSchema).default([]) }).strict(),
-  graph: z22.object({ nodes: z22.array(WorkflowNodeSchema), edges: z22.array(WorkflowEdgeSchema).default([]) }).strict(),
-  execution: z22.object({
-    timeoutMs: z22.number().int().positive().optional(),
-    retries: z22.number().int().nonnegative().default(0),
-    concurrencyLimit: z22.number().int().positive().optional(),
-    idempotency: z22.enum(["required", "supported", "none"]),
-    rateLimit: z22.object({ enabled: z22.boolean(), max: z22.number().int().nonnegative(), windowMs: z22.number().int().nonnegative() }).strict().superRefine((rateLimit, context) => {
+  presentation: z23.object({ iconUrl: z23.string().optional(), thumbnail: z23.string().optional() }).strict(),
+  ports: z23.object({ inputs: z23.array(ContractPortSchema).default([]), outputs: z23.array(ContractPortSchema).default([]) }).strict(),
+  parameters: z23.object({ variables: z23.array(WorkflowParameterSchema).default([]), outputs: z23.array(WorkflowOutputBindingSchema).default([]) }).strict(),
+  graph: z23.object({ nodes: z23.array(WorkflowNodeSchema), edges: z23.array(WorkflowEdgeSchema).default([]) }).strict(),
+  execution: z23.object({
+    timeoutMs: z23.number().int().positive().optional(),
+    retries: z23.number().int().nonnegative().default(0),
+    concurrencyLimit: z23.number().int().positive().optional(),
+    idempotency: z23.enum(["required", "supported", "none"]),
+    rateLimit: z23.object({ enabled: z23.boolean(), max: z23.number().int().nonnegative(), windowMs: z23.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: z22.object({
-      ownerApp: z22.string().optional(),
-      createTime: z22.number().int().nonnegative().optional(),
-      updateTime: z22.number().int().nonnegative().optional(),
-      createdBy: z22.string().optional(),
-      updatedBy: z22.string().optional(),
+    conductor: z23.object({
+      ownerApp: z23.string().optional(),
+      createTime: z23.number().int().nonnegative().optional(),
+      updateTime: z23.number().int().nonnegative().optional(),
+      createdBy: z23.string().optional(),
+      updatedBy: z23.string().optional(),
       failureWorkflow: ContractIdentifierSchema.optional(),
-      schemaVersion: z22.number().int().positive().optional(),
-      restartable: z22.boolean().optional(),
-      workflowStatusListenerEnabled: z22.boolean().optional(),
-      ownerEmail: z22.string().email().optional(),
-      timeoutPolicy: z22.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
-      variables: z22.record(z22.string(), JsonValueSchema).optional(),
-      inputTemplate: z22.record(z22.string(), JsonValueSchema).optional()
+      schemaVersion: z23.number().int().positive().optional(),
+      restartable: z23.boolean().optional(),
+      workflowStatusListenerEnabled: z23.boolean().optional(),
+      ownerEmail: z23.string().email().optional(),
+      timeoutPolicy: z23.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+      variables: z23.record(z23.string(), JsonValueSchema).optional(),
+      inputTemplate: z23.record(z23.string(), JsonValueSchema).optional()
     }).strict()
   }).strict(),
-  triggers: z22.array(WorkflowTriggerSchema).default([]),
-  views: z22.array(z22.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
-  dataContracts: z22.object({ reads: z22.array(ContractIdentifierSchema).default([]), writes: z22.array(ContractIdentifierSchema).default([]), emits: z22.array(ContractIdentifierSchema).default([]) }).strict(),
-  governance: z22.object({ activated: z22.boolean(), validated: z22.boolean(), validationIssues: z22.array(WorkflowValidationIssueSchema).default([]), hidden: z22.boolean().optional() }).strict(),
-  interfaces: z22.object({
-    openai: z22.object({ enabled: z22.boolean(), modelName: z22.string().trim().min(1).optional() }).strict(),
+  triggers: z23.array(WorkflowTriggerSchema).default([]),
+  views: z23.array(z23.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
+  dataContracts: z23.object({ reads: z23.array(ContractIdentifierSchema).default([]), writes: z23.array(ContractIdentifierSchema).default([]), emits: z23.array(ContractIdentifierSchema).default([]) }).strict(),
+  governance: z23.object({ activated: z23.boolean(), validated: z23.boolean(), validationIssues: z23.array(WorkflowValidationIssueSchema).default([]), hidden: z23.boolean().optional() }).strict(),
+  interfaces: z23.object({
+    openai: z23.object({ enabled: z23.boolean(), modelName: z23.string().trim().min(1).optional() }).strict(),
     shortcutRef: EntityRefSchema.optional(),
     preferredAppId: ContractIdentifierSchema.optional()
   }).strict().superRefine((interfaces, context) => {
@@ -20789,76 +20888,76 @@ var WorkflowDefinitionSchema = z22.object({
 });
 
 // src/contracts/workflow-column.ts
-import { z as z23 } from "zod";
-var WorkflowColumnFieldRefSchema = z23.object({
+import { z as z24 } from "zod";
+var WorkflowColumnFieldRefSchema = z24.object({
   ontologyId: ContractIdentifierSchema,
   fieldKey: ContractIdentifierSchema
 }).strict();
-var WorkflowColumnInputSchema = z23.discriminatedUnion("kind", [
-  z23.object({ kind: z23.literal("default") }).strict(),
-  z23.object({ kind: z23.literal("constant"), value: JsonValueSchema }).strict(),
-  z23.object({ kind: z23.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
-  z23.object({
-    kind: z23.literal("context"),
-    field: z23.enum(["assetId", "teamId", "ontologyId", "columnId"])
+var WorkflowColumnInputSchema = z24.discriminatedUnion("kind", [
+  z24.object({ kind: z24.literal("default") }).strict(),
+  z24.object({ kind: z24.literal("constant"), value: JsonValueSchema }).strict(),
+  z24.object({ kind: z24.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
+  z24.object({
+    kind: z24.literal("context"),
+    field: z24.enum(["assetId", "teamId", "ontologyId", "columnId"])
   }).strict()
 ]);
-var WorkflowColumnDependencySchema = z23.discriminatedUnion("kind", [
-  z23.object({ kind: z23.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
-  z23.object({
-    kind: z23.literal("relation"),
+var WorkflowColumnDependencySchema = z24.discriminatedUnion("kind", [
+  z24.object({ kind: z24.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
+  z24.object({
+    kind: z24.literal("relation"),
     relation: WorkflowColumnFieldRefSchema,
-    direction: z23.enum(["incoming", "outgoing"]),
-    fields: z23.array(WorkflowColumnFieldRefSchema).max(100)
+    direction: z24.enum(["incoming", "outgoing"]),
+    fields: z24.array(WorkflowColumnFieldRefSchema).max(100)
   }).strict()
 ]);
-var WorkflowColumnOutputPathSchema = z23.array(z23.string().min(1).max(256)).max(20);
-var WorkflowColumnOutputSchema = z23.object({
-  type: z23.enum(["number", "text", "json"]),
+var WorkflowColumnOutputPathSchema = z24.array(z24.string().min(1).max(256)).max(20);
+var WorkflowColumnOutputSchema = z24.object({
+  type: z24.enum(["number", "text", "json"]),
   path: WorkflowColumnOutputPathSchema,
-  nullable: z23.boolean().default(false)
-}).strict();
-var WorkflowColumnBindingSchema = z23.object({
-  contract: z23.literal("WorkflowColumnBinding"),
-  version: z23.literal(1),
-  enabled: z23.boolean(),
-  paused: z23.boolean().default(false),
-  workflow: z23.object({
+  nullable: z24.boolean().default(false)
+}).strict();
+var WorkflowColumnBindingSchema = z24.object({
+  contract: z24.literal("WorkflowColumnBinding"),
+  version: z24.literal(1),
+  enabled: z24.boolean(),
+  paused: z24.boolean().default(false),
+  workflow: z24.object({
     id: ContractIdentifierSchema,
-    version: z23.number().int().positive(),
+    version: z24.number().int().positive(),
     inputSchemaHash: Sha256Schema
   }).strict(),
-  inputs: z23.record(z23.string().min(1).max(128), WorkflowColumnInputSchema),
-  dependencies: z23.array(WorkflowColumnDependencySchema).max(100).default([]),
+  inputs: z24.record(z24.string().min(1).max(128), WorkflowColumnInputSchema),
+  dependencies: z24.array(WorkflowColumnDependencySchema).max(100).default([]),
   output: WorkflowColumnOutputSchema,
-  policy: z23.object({
-    debounceMs: z23.number().int().min(0).max(3e4).default(5e3),
-    maxDelayMs: z23.number().int().min(0).max(3e4).default(3e4),
-    concurrency: z23.number().int().min(1).max(32).default(2),
+  policy: z24.object({
+    debounceMs: z24.number().int().min(0).max(3e4).default(5e3),
+    maxDelayMs: z24.number().int().min(0).max(3e4).default(3e4),
+    concurrency: z24.number().int().min(1).max(32).default(2),
     // Indexed queries need visible projections of their declared sources before execution.
-    requireSearchProjection: z23.boolean().optional()
+    requireSearchProjection: z24.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: z23.object({ path: WorkflowColumnOutputPathSchema }).strict().optional()
+  expiry: z24.object({ path: WorkflowColumnOutputPathSchema }).strict().optional()
 }).strict();
 
 // src/contracts/workflow-runtime.ts
-import { z as z24 } from "zod";
-var WorkflowCatalogEntrySchema = z24.object({
-  contract: z24.literal("WorkflowCatalogEntry"),
+import { z as z25 } from "zod";
+var WorkflowCatalogEntrySchema = z25.object({
+  contract: z25.literal("WorkflowCatalogEntry"),
   workflowId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   creatorRef: EntityRefSchema,
   currentDefinitionRef: EntityRefSchema,
-  lifecycle: z24.enum(["ACTIVE", "DELETED"]),
-  asset: z24.object({
-    preset: z24.boolean(),
-    marketplacePublished: z24.boolean(),
+  lifecycle: z25.enum(["ACTIVE", "DELETED"]),
+  asset: z25.object({
+    preset: z25.boolean(),
+    marketplacePublished: z25.boolean(),
     publishConfig: JsonObjectSchema.optional(),
-    sort: z24.number().int(),
+    sort: z25.number().int(),
     forkFromRef: EntityRefSchema.optional(),
-    notAuthorized: z24.boolean()
+    notAuthorized: z25.boolean()
   }).strict(),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema,
@@ -20893,17 +20992,17 @@ var WorkflowCatalogEntrySchema = z24.object({
     });
   }
 });
-var WorkflowPublicationSchema = z24.object({
-  contract: z24.literal("WorkflowPublication"),
+var WorkflowPublicationSchema = z25.object({
+  contract: z25.literal("WorkflowPublication"),
   publicationId: ContractIdentifierSchema,
   definitionRef: EntityRefSchema,
   runtimeDefinitionRef: EntityRefSchema,
   sourceHash: Sha256Schema,
   compiledHash: Sha256Schema,
-  status: z24.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
+  status: z25.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
   publisherRef: EntityRefSchema,
   publishedAt: IsoDateTimeSchema.optional(),
-  failureReason: z24.string().trim().min(1).optional()
+  failureReason: z25.string().trim().min(1).optional()
 }).strict().superRefine((publication, context) => {
   if (publication.definitionRef.kind !== "workflow-definition") {
     context.addIssue({
@@ -20934,12 +21033,12 @@ var WorkflowPublicationSchema = z24.object({
     });
   }
 });
-var WorkflowCompletionCommitSchema = z24.object({
-  contract: z24.literal("WorkflowCompletionCommit"),
+var WorkflowCompletionCommitSchema = z25.object({
+  contract: z25.literal("WorkflowCompletionCommit"),
   commitId: ContractIdentifierSchema,
   run: ApplicationRunSchema,
-  outputs: z24.array(OutputRecordSchema),
-  artifacts: z24.array(ArtifactManifestSchema),
+  outputs: z25.array(OutputRecordSchema),
+  artifacts: z25.array(ArtifactManifestSchema),
   lineage: LineageRecordSchema,
   completedAt: IsoDateTimeSchema
 }).strict().superRefine((commit, context) => {
@@ -20981,15 +21080,15 @@ var WorkflowCompletionCommitSchema = z24.object({
     }
   });
 });
-var WorkflowCompletionReceiptSchema = z24.object({
-  contract: z24.literal("WorkflowCompletionReceipt"),
+var WorkflowCompletionReceiptSchema = z25.object({
+  contract: z25.literal("WorkflowCompletionReceipt"),
   commitId: ContractIdentifierSchema,
   runRef: EntityRefSchema,
-  outputRefs: z24.array(EntityRefSchema),
-  artifactRefs: z24.array(EntityRefSchema),
+  outputRefs: z25.array(EntityRefSchema),
+  artifactRefs: z25.array(EntityRefSchema),
   contentHash: Sha256Schema,
   committedAt: IsoDateTimeSchema,
-  idempotentReplay: z24.boolean()
+  idempotentReplay: z25.boolean()
 }).strict().superRefine((receipt, context) => {
   if (receipt.runRef.kind !== "application-run") {
     context.addIssue({
@@ -21019,44 +21118,44 @@ var WorkflowCompletionReceiptSchema = z24.object({
 });
 
 // src/contracts/component-assembly.ts
-import { z as z25 } from "zod";
-var member = z25.string().min(1).max(256).refine(
+import { z as z26 } from "zod";
+var member = z26.string().min(1).max(256).refine(
   (value) => !["__proto__", "prototype", "constructor"].includes(value),
   "Unsafe component member."
 );
-var ComponentEventArgumentSchema = z25.object({
-  argument: z25.number().int().min(0).max(31),
-  path: z25.array(member).max(16).default([])
+var ComponentEventArgumentSchema = z26.object({
+  argument: z26.number().int().min(0).max(31),
+  path: z26.array(member).max(16).default([])
 }).strict();
-var ComponentEventBindingSchema = z25.object({
+var ComponentEventBindingSchema = z26.object({
   port: ContractIdentifierSchema,
-  arguments: z25.array(ComponentEventArgumentSchema).max(32).default([]),
-  preventDefault: z25.boolean().default(false),
-  stopPropagation: z25.boolean().default(false)
+  arguments: z26.array(ComponentEventArgumentSchema).max(32).default([]),
+  preventDefault: z26.boolean().default(false),
+  stopPropagation: z26.boolean().default(false)
 }).strict();
-var ComponentMessageSchema = z25.union([
+var ComponentMessageSchema = z26.union([
   ContractIdentifierSchema,
-  z25.object({ textI18n: I18nTextSchema }).strict(),
-  z25.object({ key: ContractIdentifierSchema, values: z25.record(member, z25.union([z25.string(), z25.number().finite(), z25.boolean()])).default({}) }).strict()
+  z26.object({ textI18n: I18nTextSchema }).strict(),
+  z26.object({ key: ContractIdentifierSchema, values: z26.record(member, z26.union([z26.string(), z26.number().finite(), z26.boolean()])).default({}) }).strict()
 ]);
-var ComponentMessageBindingSchema = z25.object({
-  path: z25.array(z25.union([
+var ComponentMessageBindingSchema = z26.object({
+  path: z26.array(z26.union([
     member.refine((value) => !/[\u0000-\u001f\u007f-\u009f]/.test(value), "Invalid component path member."),
-    z25.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
+    z26.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
   ])).min(1).max(16),
   message: ComponentMessageSchema
 }).strict();
-var ComponentAssemblySchema = z25.object({
-  contract: z25.literal("ComponentAssembly"),
-  schemaVersion: z25.literal(1),
+var ComponentAssemblySchema = z26.object({
+  contract: z26.literal("ComponentAssembly"),
+  schemaVersion: z26.literal(1),
   props: JsonObjectSchema.default({}),
-  events: z25.record(member, ComponentEventBindingSchema).default({}),
+  events: z26.record(member, ComponentEventBindingSchema).default({}),
   // Each name remains an explicit RenderTree slot; array order controls composition.
-  slots: z25.record(member, z25.union([ContractIdentifierSchema, z25.array(ContractIdentifierSchema).min(1).max(256).refine((names) => new Set(names).size === names.length, "Component slot names must be unique.")])).default({}),
-  renderers: z25.record(member, ContractIdentifierSchema).default({}),
-  hosts: z25.record(member, ContractIdentifierSchema).default({}),
-  messages: z25.record(member, ComponentMessageSchema).default({}),
-  messageBindings: z25.array(ComponentMessageBindingSchema).max(256).optional()
+  slots: z26.record(member, z26.union([ContractIdentifierSchema, z26.array(ContractIdentifierSchema).min(1).max(256).refine((names) => new Set(names).size === names.length, "Component slot names must be unique.")])).default({}),
+  renderers: z26.record(member, ContractIdentifierSchema).default({}),
+  hosts: z26.record(member, ContractIdentifierSchema).default({}),
+  messages: z26.record(member, ComponentMessageSchema).default({}),
+  messageBindings: z26.array(ComponentMessageBindingSchema).max(256).optional()
 }).strict().superRefine((value, context) => {
   const paths = value.messageBindings?.map((binding) => binding.path) ?? [];
   for (const [index, path] of paths.entries()) {
@@ -21076,75 +21175,75 @@ var ComponentAssemblySchema = z25.object({
 });
 
 // src/contracts/record-editor-draft.ts
-import { z as z26 } from "zod";
-var member2 = z26.string().min(1).max(256).refine((value) => !["__proto__", "prototype", "constructor"].includes(value), "Unsafe editor path.");
-var RecordEditorPathSchema = z26.array(z26.union([member2, z26.object({ itemId: z26.string().min(1).max(256), idKey: member2.default("id") }).strict()])).max(32);
-var RecordEditorFieldErrorSchema = z26.object({ path: RecordEditorPathSchema, code: z26.string().min(1).max(256) }).strict();
-var RecordEditorDraftSchema = z26.object({
-  revision: z26.string().min(1).max(256),
+import { z as z27 } from "zod";
+var member2 = z27.string().min(1).max(256).refine((value) => !["__proto__", "prototype", "constructor"].includes(value), "Unsafe editor path.");
+var RecordEditorPathSchema = z27.array(z27.union([member2, z27.object({ itemId: z27.string().min(1).max(256), idKey: member2.default("id") }).strict()])).max(32);
+var RecordEditorFieldErrorSchema = z27.object({ path: RecordEditorPathSchema, code: z27.string().min(1).max(256) }).strict();
+var RecordEditorDraftSchema = z27.object({
+  revision: z27.string().min(1).max(256),
   original: JsonObjectSchema,
   value: JsonObjectSchema,
-  touched: z26.array(RecordEditorPathSchema).max(4096),
-  errors: z26.array(RecordEditorFieldErrorSchema).max(4096)
-}).strict();
-var RecordEditorDraftOperationSchema = z26.discriminatedUnion("kind", [
-  z26.object({ kind: z26.literal("set"), path: RecordEditorPathSchema, value: JsonValueSchema }).strict(),
-  z26.object({ kind: z26.literal("touch"), path: RecordEditorPathSchema }).strict(),
-  z26.object({ kind: z26.literal("reset"), revision: z26.string().min(1).max(256), value: JsonObjectSchema }).strict(),
-  z26.object({ kind: z26.literal("insert"), path: RecordEditorPathSchema, idKey: member2.default("id"), value: JsonObjectSchema, beforeId: z26.string().min(1).optional() }).strict(),
-  z26.object({ kind: z26.literal("remove"), path: RecordEditorPathSchema, idKey: member2.default("id"), itemId: z26.string().min(1) }).strict(),
-  z26.object({ kind: z26.literal("move"), path: RecordEditorPathSchema, idKey: member2.default("id"), itemId: z26.string().min(1), beforeId: z26.string().min(1).optional() }).strict()
+  touched: z27.array(RecordEditorPathSchema).max(4096),
+  errors: z27.array(RecordEditorFieldErrorSchema).max(4096)
+}).strict();
+var RecordEditorDraftOperationSchema = z27.discriminatedUnion("kind", [
+  z27.object({ kind: z27.literal("set"), path: RecordEditorPathSchema, value: JsonValueSchema }).strict(),
+  z27.object({ kind: z27.literal("touch"), path: RecordEditorPathSchema }).strict(),
+  z27.object({ kind: z27.literal("reset"), revision: z27.string().min(1).max(256), value: JsonObjectSchema }).strict(),
+  z27.object({ kind: z27.literal("insert"), path: RecordEditorPathSchema, idKey: member2.default("id"), value: JsonObjectSchema, beforeId: z27.string().min(1).optional() }).strict(),
+  z27.object({ kind: z27.literal("remove"), path: RecordEditorPathSchema, idKey: member2.default("id"), itemId: z27.string().min(1) }).strict(),
+  z27.object({ kind: z27.literal("move"), path: RecordEditorPathSchema, idKey: member2.default("id"), itemId: z27.string().min(1), beforeId: z27.string().min(1).optional() }).strict()
 ]);
-var RecordEditorValidationDetailsSchema = z26.object({
-  contract: z26.literal("RecordEditorValidation"),
-  schemaVersion: z26.literal(1),
-  errors: z26.array(RecordEditorFieldErrorSchema).min(1).max(256)
+var RecordEditorValidationDetailsSchema = z27.object({
+  contract: z27.literal("RecordEditorValidation"),
+  schemaVersion: z27.literal(1),
+  errors: z27.array(RecordEditorFieldErrorSchema).min(1).max(256)
 }).strict();
-var RecordEditorSubmissionSnapshotSchema = z26.object({
-  revision: z26.string().min(1).max(256),
+var RecordEditorSubmissionSnapshotSchema = z27.object({
+  revision: z27.string().min(1).max(256),
   value: JsonObjectSchema
 }).strict();
 
 // src/contracts/page-stream.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var PAGE_STREAM_MAX_FRAME_BYTES = 256 * 1024;
 var PAGE_STREAM_MAX_BUFFER_BYTES = 2 * 1024 * 1024;
 var PAGE_STREAM_MAX_BUFFER_EVENTS = 2048;
 var PAGE_STREAM_MAX_CURSOR_LENGTH = 2048;
 var PAGE_STREAM_MAX_INPUT_BYTES = 8192;
 var PAGE_STREAM_MAX_EVENT_ITEMS = 256;
-var StreamIdSchema = z27.string().min(1).max(256).regex(/^[^\u0000-\u001f\u007f]+$/);
-var CursorSchema = z27.string().min(1).max(PAGE_STREAM_MAX_CURSOR_LENGTH).regex(/^[^\u0000-\u001f\u007f]+$/);
-var SequenceSchema = z27.number().int().min(1).max(Number.MAX_SAFE_INTEGER);
-var PageStreamDescriptorSchema = z27.object({
-  contract: z27.literal("PageStreamDescriptor"),
-  schemaVersion: z27.literal(1),
+var StreamIdSchema = z28.string().min(1).max(256).regex(/^[^\u0000-\u001f\u007f]+$/);
+var CursorSchema = z28.string().min(1).max(PAGE_STREAM_MAX_CURSOR_LENGTH).regex(/^[^\u0000-\u001f\u007f]+$/);
+var SequenceSchema = z28.number().int().min(1).max(Number.MAX_SAFE_INTEGER);
+var PageStreamDescriptorSchema = z28.object({
+  contract: z28.literal("PageStreamDescriptor"),
+  schemaVersion: z28.literal(1),
   streamId: StreamIdSchema,
   expiresAt: IsoDateTimeSchema,
-  channel: z27.enum(["terminal", "events"]),
+  channel: z28.enum(["terminal", "events"]),
   cursor: CursorSchema.optional()
 }).strict();
-var PageStreamConnectSchema = z27.object({ cursor: CursorSchema.optional() }).strict();
+var PageStreamConnectSchema = z28.object({ cursor: CursorSchema.optional() }).strict();
 var base = {
-  contract: z27.literal("PageStreamEvent"),
-  schemaVersion: z27.literal(1),
+  contract: z28.literal("PageStreamEvent"),
+  schemaVersion: z28.literal(1),
   streamId: StreamIdSchema,
   sequence: SequenceSchema,
   cursor: CursorSchema
 };
-var PageStreamEventSchema = z27.discriminatedUnion("type", [
-  z27.object({ ...base, type: z27.literal("snapshot"), payload: z27.object({ model: JsonObjectSchema }).strict() }).strict(),
-  z27.object({ ...base, type: z27.literal("delta"), payload: z27.object({ events: z27.array(JsonObjectSchema).max(PAGE_STREAM_MAX_EVENT_ITEMS) }).strict() }).strict(),
-  z27.object({ ...base, type: z27.literal("end"), payload: z27.object({}).strict() }).strict(),
-  z27.object({ ...base, type: z27.literal("error"), payload: z27.object({ code: z27.string().min(1).max(128), retryable: z27.boolean() }).strict() }).strict()
+var PageStreamEventSchema = z28.discriminatedUnion("type", [
+  z28.object({ ...base, type: z28.literal("snapshot"), payload: z28.object({ model: JsonObjectSchema }).strict() }).strict(),
+  z28.object({ ...base, type: z28.literal("delta"), payload: z28.object({ events: z28.array(JsonObjectSchema).max(PAGE_STREAM_MAX_EVENT_ITEMS) }).strict() }).strict(),
+  z28.object({ ...base, type: z28.literal("end"), payload: z28.object({}).strict() }).strict(),
+  z28.object({ ...base, type: z28.literal("error"), payload: z28.object({ code: z28.string().min(1).max(128), retryable: z28.boolean() }).strict() }).strict()
 ]).superRefine((value, context) => {
   if (new TextEncoder().encode(JSON.stringify(value)).byteLength > PAGE_STREAM_MAX_FRAME_BYTES)
     context.addIssue({ code: "custom", message: "Page stream frame exceeds the UTF-8 byte limit." });
 });
-var PageStreamControlSchema = z27.discriminatedUnion("port", [
-  z27.object({ requestId: z27.string().uuid(), port: z27.literal("terminal.input"), payload: z27.object({ data: z27.string().min(1).max(PAGE_STREAM_MAX_INPUT_BYTES) }).strict() }).strict(),
-  z27.object({ requestId: z27.string().uuid(), port: z27.literal("terminal.resize"), payload: z27.object({ columns: z27.number().int().min(1).max(1e3), rows: z27.number().int().min(1).max(1e3) }).strict() }).strict(),
-  z27.object({ requestId: z27.string().uuid(), port: z27.literal("stream.disconnect"), payload: z27.object({}).strict() }).strict()
+var PageStreamControlSchema = z28.discriminatedUnion("port", [
+  z28.object({ requestId: z28.string().uuid(), port: z28.literal("terminal.input"), payload: z28.object({ data: z28.string().min(1).max(PAGE_STREAM_MAX_INPUT_BYTES) }).strict() }).strict(),
+  z28.object({ requestId: z28.string().uuid(), port: z28.literal("terminal.resize"), payload: z28.object({ columns: z28.number().int().min(1).max(1e3), rows: z28.number().int().min(1).max(1e3) }).strict() }).strict(),
+  z28.object({ requestId: z28.string().uuid(), port: z28.literal("stream.disconnect"), payload: z28.object({}).strict() }).strict()
 ]).superRefine((value, context) => {
   if (value.port === "terminal.input" && new TextEncoder().encode(value.payload.data).byteLength > PAGE_STREAM_MAX_INPUT_BYTES)
     context.addIssue({ code: "custom", path: ["payload", "data"], message: "Terminal input exceeds the UTF-8 byte limit." });
@@ -21160,7 +21259,7 @@ var pageStreamRoutes = {
   terminal: (releaseSlotId, bindingId, streamId) => `${route(releaseSlotId, bindingId, streamId)}/terminal`,
   control: (releaseSlotId, bindingId, streamId) => `${route(releaseSlotId, bindingId, streamId)}/control`
 };
-var PageStreamControlResultSchema = z27.object({ requestId: z27.string().uuid(), accepted: z27.literal(true) }).strict();
+var PageStreamControlResultSchema = z28.object({ requestId: z28.string().uuid(), accepted: z28.literal(true) }).strict();
 
 // src/schemas/index.ts
 var canonicalContractSchemas = {
@@ -26824,6 +26923,10 @@ export {
   DeclarativeCreateTemplateChoiceSchema,
   DeclarativeCreateTemplateRegistrationSchema,
   DeclarativeDefaultPolicyRegistrationSchema,
+  DeclarativeDocumentImportIntentSchema,
+  DeclarativeDocumentImportPlanSchema,
+  DeclarativeDocumentImportRequestSchema,
+  DeclarativeDocumentImportResultSchema,
   DeclarativeDocumentSchema,
   DeclarativeDocumentSummarySchema,
   DeclarativeDomainCommandDefinitionRegistrationSchema,
@@ -26832,6 +26935,7 @@ export {
   DeclarativeEnvironmentChoiceSchema,
   DeclarativeEnvironmentResourceDocumentSchema,
   DeclarativeErrorEnvelopeSchema,
+  DeclarativeImportDocumentSchema,
   DeclarativeLayoutPolicyResourceDocumentSchema,
   DeclarativeLegacyWorkbenchSummarySchema,
   DeclarativeLifecycleSchema,