lua-cli 3.53.0 → 3.55.0

package/dist/workflow-builder.js

@@ -1026,6 +1026,10 @@ import { z as z3 } from "zod";
 import { z as z4 } from "zod";
 import { z as z5 } from "zod";
 import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z8 } from "zod";
+import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var __defProp4 = Object.defineProperty;
 var __name4 = /* @__PURE__ */ __name((target, value3) => __defProp4(target, "name", { value: value3, configurable: true }), "__name");
 var PLUMBING_THREAD_CHANNELS = [
@@ -1344,6 +1348,7 @@ var INTEGRATION_PASSTHROUGH_READ_METHODS = [
   "GET",
   "HEAD"
 ];
+var INTEGRATION_PASSTHROUGH_MAX_BASE64_RESPONSE_BYTES = 25 * 1024 * 1024;
 function isIntegrationPassthroughReadMethod(method) {
   return typeof method === "string" && INTEGRATION_PASSTHROUGH_READ_METHODS.includes(method.toUpperCase());
 }
@@ -5105,6 +5110,24 @@ function sanitizeProgressUpdateInput(input) {
 }
 __name(sanitizeProgressUpdateInput, "sanitizeProgressUpdateInput");
 __name4(sanitizeProgressUpdateInput, "sanitizeProgressUpdateInput");
+function agentIdentityError(code, message, statusCode) {
+  return Object.assign(new Error(message), {
+    name: "AgentIdentityError",
+    code,
+    ...typeof statusCode === "number" ? {
+      statusCode
+    } : {}
+  });
+}
+__name(agentIdentityError, "agentIdentityError");
+__name4(agentIdentityError, "agentIdentityError");
+function readAgentIdentityAudience(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return null;
+  const audience = input.audience;
+  return typeof audience === "string" && audience.length > 0 && audience.length <= 200 ? audience : null;
+}
+__name(readAgentIdentityAudience, "readAgentIdentityAudience");
+__name4(readAgentIdentityAudience, "readAgentIdentityAudience");
 function toEpochMs(value3) {
   if (value3 === null || value3 === void 0) return void 0;
   const ms = value3 instanceof Date ? value3.getTime() : typeof value3 === "number" ? value3 : Date.parse(value3);
@@ -6479,6 +6502,12 @@ function removeHiddenBlocks(input) {
 }
 __name(removeHiddenBlocks, "removeHiddenBlocks");
 __name4(removeHiddenBlocks, "removeHiddenBlocks");
+function stripBlocksKeepingEdges(input, names) {
+  const stripped = stripBlocks(input, names);
+  return stripped === input ? input : stripped.trim();
+}
+__name(stripBlocksKeepingEdges, "stripBlocksKeepingEdges");
+__name4(stripBlocksKeepingEdges, "stripBlocksKeepingEdges");
 function startsWithHiddenBlock(input) {
   const [first] = splitBlocks(input);
   return first?.type === "block" && first.name === "hide";
@@ -6570,8 +6599,10 @@ function transformChatHistoryContentParts(parts) {
     }
     if (part?.type !== "text" && part?.type !== "file") continue;
     if (part.type === "text" && typeof part.text === "string") {
-      const rawText = removeHiddenBlocks(part.text || "");
-      if (!rawText) continue;
+      const rawText = stripBlocksKeepingEdges(part.text || "", [
+        "hide"
+      ]);
+      if (!rawText.trim()) continue;
       const audioMatch = rawText.match(/::: audio\s*!\[(.*?)\]\((.*?)\)\s*:::/);
       const videoMatch = rawText.match(/::: video\s*!\[(.*?)\]\((.*?)\)\s*:::/);
       if (audioMatch) {
@@ -6588,7 +6619,9 @@ function transformChatHistoryContentParts(parts) {
         });
       } else {
         let text2 = rawText.replace(/\\\\\\n/g, "\n");
-        text2 = removeNavigateBlock(text2);
+        text2 = stripBlocksKeepingEdges(text2, [
+          "navigate"
+        ]);
         content.push({
           type: "text",
           text: text2
@@ -6669,6 +6702,15 @@ function mergeRichPartMirrorMessages(messages, sameTurnGroup) {
         break;
       }
       if (folded) continue;
+      const content = message.content.filter((part) => part.type !== "data-lua-tool-step" && part.type !== "data-lua-reasoning-time" && part.type !== "data-lua-reply-timing");
+      if (content.length === 0) continue;
+      if (content.length !== message.content.length) {
+        merged.push({
+          ...message,
+          content
+        });
+        continue;
+      }
     }
     merged.push(message);
   }
@@ -6722,6 +6764,61 @@ function foldRichPartsIntoMessages(messages, records, makeMessage, sameTurnGroup
 }
 __name(foldRichPartsIntoMessages, "foldRichPartsIntoMessages");
 __name4(foldRichPartsIntoMessages, "foldRichPartsIntoMessages");
+function readStoredReplyVersion(metadata) {
+  const md = metadata && typeof metadata === "object" ? metadata : void 0;
+  const value3 = md?.replyVersion;
+  const stamp = value3 && typeof value3.group === "string" && value3.group && typeof value3.index === "number" && Number.isInteger(value3.index) && value3.index >= 1 ? {
+    group: value3.group,
+    index: value3.index
+  } : null;
+  return {
+    stamp,
+    inactive: md?.inactiveVersion === true
+  };
+}
+__name(readStoredReplyVersion, "readStoredReplyVersion");
+__name4(readStoredReplyVersion, "readStoredReplyVersion");
+function applyReplyVersions(messages, markOf, includeVersions) {
+  const blocks = [];
+  const indicesByGroup = /* @__PURE__ */ new Map();
+  let current = null;
+  for (const message of messages) {
+    const mark = markOf(message);
+    if (message.role === "user") {
+      current = mark?.stamp ? {
+        ...mark.stamp,
+        inactive: mark.inactive
+      } : null;
+      if (current) {
+        const seen = indicesByGroup.get(current.group) ?? /* @__PURE__ */ new Set();
+        seen.add(current.index);
+        indicesByGroup.set(current.group, seen);
+      }
+    }
+    blocks.push(current);
+  }
+  const out = [];
+  messages.forEach((message, i) => {
+    const block = blocks[i];
+    if (!block) {
+      out.push(message);
+      return;
+    }
+    if (block.inactive && !includeVersions) return;
+    out.push({
+      ...message,
+      replyVersion: {
+        group: block.group,
+        index: block.index,
+        total: indicesByGroup.get(block.group)?.size ?? 1,
+        active: !block.inactive
+      }
+    });
+  });
+  return out;
+}
+__name(applyReplyVersions, "applyReplyVersions");
+__name4(applyReplyVersions, "applyReplyVersions");
 var WORK_ITEMS_KEY = "_luaWorkItems";
 var MAX_WORK_ITEMS = 100;
 var LIMITS = {
@@ -11843,7 +11940,44 @@ function composeAgentPaneRuntimeContext(input) {
 __name(composeAgentPaneRuntimeContext, "composeAgentPaneRuntimeContext");
 __name4(composeAgentPaneRuntimeContext, "composeAgentPaneRuntimeContext");
 var WEB_APP_ENTRY_HTML_MAX_CHARS = 256 * 1024;
+var WEB_APP_MAX_ASSETS = 1e3;
 var WEB_APP_MAX_ASSET_BYTES = 8 * 1024 * 1024;
+var WEB_APP_HEALTH_KEY_TTL_SECONDS = 15 * 60;
+var WEB_APP_HEALTH_MIN_FAILURES = 3;
+var WEB_APP_HEALTH_MIN_FAILURE_RATIO = 0.5;
+function webAppHealthMinute(atMs) {
+  return Math.floor(atMs / 6e4);
+}
+__name(webAppHealthMinute, "webAppHealthMinute");
+__name4(webAppHealthMinute, "webAppHealthMinute");
+function webAppHealthKey(webAppId, minute) {
+  return `webapp:health:${webAppId}:${minute}`;
+}
+__name(webAppHealthKey, "webAppHealthKey");
+__name4(webAppHealthKey, "webAppHealthKey");
+function webAppHealthVerdict(minutes) {
+  let requests = 0;
+  let failures = 0;
+  let firstFailingMinute;
+  for (const m of minutes) {
+    const r = Math.max(0, m.requests || 0);
+    const f = Math.max(0, Math.min(m.failures || 0, r));
+    requests += r;
+    failures += f;
+    if (f > 0 && (firstFailingMinute === void 0 || m.minute < firstFailingMinute)) firstFailingMinute = m.minute;
+  }
+  if (failures >= WEB_APP_HEALTH_MIN_FAILURES && failures >= requests * WEB_APP_HEALTH_MIN_FAILURE_RATIO) {
+    return {
+      state: "needs_attention",
+      since: new Date(firstFailingMinute * 6e4)
+    };
+  }
+  return {
+    state: "ok"
+  };
+}
+__name(webAppHealthVerdict, "webAppHealthVerdict");
+__name4(webAppHealthVerdict, "webAppHealthVerdict");
 var EVIDENCE_SESSION_IDLE_MS = 30 * 6e4;
 var EVIDENCE_MIN_CONVERSATIONS = 20;
 var EVIDENCE_LOW_CONFIDENCE_N = 5;
@@ -13005,13 +13139,15 @@ function parseConnectionSendPolicy(value3) {
 __name(parseConnectionSendPolicy, "parseConnectionSendPolicy");
 __name4(parseConnectionSendPolicy, "parseConnectionSendPolicy");
 var BILLING_REJECTION_TEXT_CREDITS = "This agent has run out of credits. Please top up to continue chatting.";
+var BILLING_REJECTION_TEXT_OUT_OF_ACTIONS = "This workspace is out of actions. A workspace owner or billing admin can top up or upgrade the plan to continue.";
 var BILLING_REJECTION_TEXT_SEAT = "You don't have access to this agent in this workspace. Ask a workspace admin to add you.";
 var BILLING_REJECTION_TEXT_USER_QUOTA = "You've reached your monthly usage limit in this workspace. Ask a workspace admin to raise it.";
 function isPaymentRequiredChatErrorEnvelope(data) {
   if (!data || typeof data !== "object") return false;
   const d = data;
   if (d.type !== "error") return false;
-  return d.textDelta === BILLING_REJECTION_TEXT_CREDITS || d.textDelta === BILLING_REJECTION_TEXT_SEAT || d.textDelta === BILLING_REJECTION_TEXT_USER_QUOTA;
+  if (d.code === "OUT_OF_ACTIONS") return true;
+  return d.textDelta === BILLING_REJECTION_TEXT_CREDITS || d.textDelta === BILLING_REJECTION_TEXT_OUT_OF_ACTIONS || d.textDelta === BILLING_REJECTION_TEXT_SEAT || d.textDelta === BILLING_REJECTION_TEXT_USER_QUOTA;
 }
 __name(isPaymentRequiredChatErrorEnvelope, "isPaymentRequiredChatErrorEnvelope");
 __name4(isPaymentRequiredChatErrorEnvelope, "isPaymentRequiredChatErrorEnvelope");
@@ -13599,6 +13735,74 @@ var customMcpMountUpsertBodySchema = z6.object({
   }).strict().optional(),
   timeout: customMcpTimeoutSchema.optional()
 }).strict();
+var opaque = z7.record(z7.unknown());
+var summaryHash = z7.string().regex(/^[0-9a-f]{64}$/);
+var defaultWebAppBriefRequestSchema = z7.object({
+  agentId: z7.string().min(1).max(200),
+  orgId: z7.string().min(1).max(200).optional(),
+  /** A rebuild: the brief the app was built from. The new brief keeps its entity, fields and statuses. */
+  previous: z7.object({
+    brief: opaque
+  }).optional(),
+  /**
+  * Another agent's brief (same template id + version) and the `summaryHash` it was made from. Used without a model
+  * call only when the hash equals this agent's, its schema version is current and it is valid here; else ignored.
+  */
+  reuse: z7.object({
+    brief: opaque,
+    summaryHash
+  }).optional()
+});
+var DEFAULT_WEB_APP_BRIEF_SOURCES = [
+  "model",
+  "fallback",
+  "reused",
+  "previous"
+];
+var defaultWebAppBriefUsageSchema = z7.object({
+  inputTokens: z7.number().nonnegative(),
+  outputTokens: z7.number().nonnegative(),
+  cacheReadTokens: z7.number().nonnegative(),
+  cacheWriteTokens: z7.number().nonnegative()
+});
+var briefResponseBase = z7.object({
+  source: z7.enum(DEFAULT_WEB_APP_BRIEF_SOURCES),
+  brief: opaque,
+  names: opaque,
+  capabilitySignature: z7.string().min(1),
+  model: z7.string().optional(),
+  usage: defaultWebAppBriefUsageSchema,
+  costUsd: z7.number().nonnegative()
+});
+var defaultWebAppBriefResponseSchema = z7.discriminatedUnion("reusable", [
+  briefResponseBase.extend({
+    reusable: z7.literal(true),
+    summaryHash
+  }),
+  briefResponseBase.extend({
+    reusable: z7.literal(false)
+  })
+]);
+var defaultWebAppBriefKeyRequestSchema = z7.object({
+  agentId: z7.string().min(1).max(200)
+});
+var defaultWebAppBriefKeyResponseSchema = z7.object({
+  summaryHash,
+  schemaVersion: z7.number().int().positive()
+});
+var DEFAULT_WEB_APP_BRIEF_ERROR_CODES = [
+  "AGENT_NOT_FOUND",
+  "BRIEF_INVALID",
+  "BRIEF_UNAVAILABLE"
+];
+var defaultWebAppBriefErrorSchema = z7.object({
+  code: z7.enum(DEFAULT_WEB_APP_BRIEF_ERROR_CODES),
+  message: z7.string().optional(),
+  problems: z7.array(z7.string()).optional(),
+  model: z7.string().optional(),
+  usage: defaultWebAppBriefUsageSchema.optional(),
+  costUsd: z7.number().nonnegative().optional()
+});
 function maskMcpServerHeaders(server) {
   const { headers, ...rest } = server;
   const headerNames = Object.keys(headers ?? {});
@@ -13621,10 +13825,383 @@ function isSharedDataOwnerKey(agentId2) {
 }
 __name(isSharedDataOwnerKey, "isSharedDataOwnerKey");
 __name4(isSharedDataOwnerKey, "isSharedDataOwnerKey");
+var PLAN_KEYS = {
+  agents: {
+    kind: "limit",
+    default: null,
+    label: "Agents"
+  },
+  members: {
+    kind: "limit",
+    default: null,
+    label: "Members"
+  },
+  rooms: {
+    kind: "limit",
+    default: null,
+    label: "Rooms"
+  },
+  externalShares: {
+    kind: "limit",
+    default: null,
+    label: "Shares outside the workspace"
+  },
+  viewsPerAgent: {
+    kind: "limit",
+    default: null,
+    label: "Views per agent"
+  },
+  freeWorkspacesPerPerson: {
+    kind: "limit",
+    default: null,
+    label: "Free workspaces per person"
+  },
+  shareOutsideWorkspace: {
+    kind: "feature",
+    default: true,
+    label: "Share outside the workspace"
+  },
+  roomsEnabled: {
+    kind: "feature",
+    default: true,
+    label: "Rooms with agents"
+  },
+  comments: {
+    kind: "feature",
+    default: true,
+    label: "Comments"
+  },
+  snapshots: {
+    kind: "feature",
+    default: true,
+    label: "Snapshots"
+  },
+  topUps: {
+    kind: "feature",
+    default: true,
+    label: "Top-ups"
+  },
+  deployAgents: {
+    kind: "feature",
+    default: true,
+    label: "Deploy agents to production"
+  }
+};
+var PLAN_LIMIT_KEYS = Object.keys(PLAN_KEYS).filter((k) => PLAN_KEYS[k].kind === "limit");
+var PLAN_FEATURE_KEYS = Object.keys(PLAN_KEYS).filter((k) => PLAN_KEYS[k].kind === "feature");
+var BILLING_ENGINES = [
+  "actions",
+  "credits"
+];
+var BILLING_VERSION_KINDS = [
+  "catalog",
+  "custom"
+];
+var planKeyString = z8.string().regex(/^[a-z0-9][a-z0-9-]{0,47}$/, "lowercase letters, digits and dashes");
+var planPriceSchema = z8.object({
+  amountUsd: z8.number().nonnegative(),
+  interval: z8.enum([
+    "month",
+    "year"
+  ]),
+  per: z8.enum([
+    "workspace",
+    "seat"
+  ])
+}).strict();
+var limitsShape = Object.fromEntries(PLAN_LIMIT_KEYS.map((k) => [
+  k,
+  z8.number().int().nonnegative().nullable().optional()
+]));
+var featuresShape = Object.fromEntries(PLAN_FEATURE_KEYS.map((k) => [
+  k,
+  z8.boolean().optional()
+]));
+var billingPlanSchema = z8.object({
+  key: planKeyString,
+  name: z8.string().min(1).max(80),
+  /** Absent = a workspace plan. An agent-team plan prices a hired team; it sets no limits or features. */
+  kind: z8.enum([
+    "workspace",
+    "agent-team"
+  ]).optional(),
+  tagline: z8.string().max(200).optional(),
+  visible: z8.boolean(),
+  order: z8.number().int(),
+  price: planPriceSchema.nullable(),
+  stripeProductId: z8.string().optional(),
+  stripePriceId: z8.string().optional(),
+  actionsPerPeriod: z8.number().int().nonnegative(),
+  trialDays: z8.number().int().nonnegative().optional(),
+  limits: z8.object(limitsShape).strict(),
+  features: z8.object(featuresShape).strict(),
+  invoice: z8.object({
+    collectionMode: z8.enum([
+      "card",
+      "invoice"
+    ]),
+    dueDays: z8.number().int().nonnegative(),
+    lines: z8.array(z8.object({
+      description: z8.string().min(1),
+      amountUsd: z8.number().nonnegative()
+    }).strict())
+  }).strict().optional()
+}).strict();
+var topUpPackSchema = z8.object({
+  key: planKeyString,
+  name: z8.string().min(1).max(80),
+  priceUsd: z8.number().positive(),
+  actions: z8.number().int().positive(),
+  stripeProductId: z8.string().optional(),
+  stripePriceId: z8.string().optional()
+}).strict();
+function resolvePlanEntitlements(plan) {
+  const limits = {};
+  for (const k of PLAN_LIMIT_KEYS) {
+    const v = plan.limits[k];
+    limits[k] = v === void 0 ? PLAN_KEYS[k].default : v;
+  }
+  const features = {};
+  for (const k of PLAN_FEATURE_KEYS) {
+    const v = plan.features[k];
+    features[k] = v === void 0 ? PLAN_KEYS[k].default : v;
+  }
+  return {
+    limits,
+    features
+  };
+}
+__name(resolvePlanEntitlements, "resolvePlanEntitlements");
+__name4(resolvePlanEntitlements, "resolvePlanEntitlements");
+var PLAN_REFUSAL_CODES = [
+  "PLAN_LIMIT_REACHED",
+  "PLAN_FEATURE_LOCKED",
+  "OUT_OF_ACTIONS"
+];
+function isPlanRefusal(body) {
+  if (!body || typeof body !== "object") return false;
+  const code = body.code;
+  return typeof code === "string" && PLAN_REFUSAL_CODES.includes(code);
+}
+__name(isPlanRefusal, "isPlanRefusal");
+__name4(isPlanRefusal, "isPlanRefusal");
+var billingSignupConfigSchema = z8.object({
+  enabled: z8.boolean(),
+  defaultVersionKey: z8.string().min(1).nullable(),
+  allowlistEmails: z8.array(z8.string().email().toLowerCase()).max(500),
+  friendsPlan: z8.object({
+    versionKey: z8.string().min(1),
+    planKey: planKeyString
+  }).strict().nullable()
+}).strict();
+var billingVersionDraftPatchSchema = z8.object({
+  revision: z8.number().int().nonnegative().optional(),
+  name: z8.string().min(1).max(80).optional(),
+  kind: z8.enum(BILLING_VERSION_KINDS).optional(),
+  engine: z8.enum(BILLING_ENGINES).optional(),
+  defaultPlanKey: z8.string().optional(),
+  plans: z8.array(billingPlanSchema).optional(),
+  topUpPacks: z8.array(topUpPackSchema).optional(),
+  forOrgIds: z8.array(z8.string().min(1)).optional(),
+  legacyCheckout: z8.boolean().optional(),
+  voiceAndDelegationAsActions: z8.boolean().optional(),
+  notes: z8.string().max(2e3).optional()
+}).strict();
+var billingVersionDraftCreateSchema = billingVersionDraftPatchSchema.extend({
+  key: z8.string().min(2),
+  copyFrom: z8.string().optional()
+}).strict();
+var EXISTING_SUBSCRIPTION_POLICIES = [
+  "keep",
+  "next-renewal"
+];
+var billingVersionEditSchema = billingVersionDraftPatchSchema.extend({
+  existingSubscriptions: z8.enum(EXISTING_SUBSCRIPTION_POLICIES).optional()
+}).strict();
+var assignBillingPlanSchema = z8.object({
+  versionKey: z8.string().min(1),
+  planKey: z8.string().optional()
+}).strict();
+function planKeyList() {
+  return Object.keys(PLAN_KEYS).map((key) => ({
+    key,
+    kind: PLAN_KEYS[key].kind,
+    label: PLAN_KEYS[key].label,
+    default: PLAN_KEYS[key].default
+  }));
+}
+__name(planKeyList, "planKeyList");
+__name4(planKeyList, "planKeyList");
+function parseWith(schema, body) {
+  const r = schema.safeParse(body);
+  return r.success ? {
+    ok: true,
+    data: r.data
+  } : {
+    ok: false,
+    problems: r.error.issues.map((i) => `${i.path.join(".")} ${i.message}`)
+  };
+}
+__name(parseWith, "parseWith");
+__name4(parseWith, "parseWith");
+var billingActionRatesSchema = z8.object({
+  voiceActionsPerMinute: z8.number().nonnegative()
+}).strict();
+var BILLING_MOVE_DEFAULT_NOTICE_DAYS = 90;
+var BILLING_MOVE_NOTICE_KINDS = [
+  "scheduled",
+  "reminder",
+  "done"
+];
+var BILLING_MOVE_WHEN = [
+  "notice",
+  "now"
+];
+var keyString = z9.string().regex(/^[a-z0-9][a-z0-9-]{1,63}$/, "lowercase letters, digits and dashes");
+var emailTextSchema = z9.object({
+  subject: z9.string().trim().min(1).max(200).optional(),
+  title: z9.string().trim().min(1).max(200).optional(),
+  body: z9.string().trim().min(1).max(2e3).optional()
+}).strict();
+var billingMoveDraftSchema = z9.object({
+  key: keyString,
+  name: z9.string().min(1).max(120),
+  fromVersionKey: keyString,
+  toVersionKey: keyString,
+  /** Every plan of the source version → a plan of the target version. */
+  planMap: z9.record(z9.string().min(1), z9.string().min(1)),
+  noticeDays: z9.number().int().min(0).max(730).default(BILLING_MOVE_DEFAULT_NOTICE_DAYS),
+  /** Absent ⇒ every org on the source version. */
+  orgIds: z9.array(z9.string().min(1)).max(1e4).optional(),
+  excludeOrgIds: z9.array(z9.string().min(1)).max(1e4).default([]),
+  notes: z9.string().max(2e3).optional(),
+  /** Actions per leftover credit when a credits version moves to an actions version; required then. */
+  creditsToActionsRate: z9.number().positive().max(1e4).optional(),
+  when: z9.enum(BILLING_MOVE_WHEN).default("notice"),
+  /** Which owner emails this move sends; all off sends nothing. */
+  emails: z9.object({
+    scheduled: z9.boolean(),
+    reminder: z9.boolean(),
+    done: z9.boolean()
+  }).strict().default({
+    scheduled: true,
+    reminder: true,
+    done: true
+  }),
+  /** Staff wording per email, replacing ours; the list of what changes is always added. */
+  emailText: z9.object({
+    scheduled: emailTextSchema.optional(),
+    reminder: emailTextSchema.optional(),
+    done: emailTextSchema.optional()
+  }).strict().optional()
+}).strict().refine((m) => m.fromVersionKey !== m.toVersionKey, {
+  message: "source and target version must differ"
+});
+var billingMovePatchSchema = z9.object({
+  name: z9.string().min(1).max(120).optional(),
+  noticeDays: z9.number().int().min(0).max(730).optional(),
+  when: z9.enum(BILLING_MOVE_WHEN).optional(),
+  emails: z9.object({
+    scheduled: z9.boolean(),
+    reminder: z9.boolean(),
+    done: z9.boolean()
+  }).strict().optional(),
+  emailText: z9.object({
+    scheduled: emailTextSchema.optional(),
+    reminder: emailTextSchema.optional(),
+    done: emailTextSchema.optional()
+  }).strict().optional(),
+  notes: z9.string().max(2e3).optional()
+}).strict();
+var billingMoveOrgDateSchema = z9.object({
+  effectiveAt: z9.coerce.date()
+}).strict();
+var billingMoveEmailPreviewSchema = z9.object({
+  orgId: z9.string().min(1).optional(),
+  kind: z9.enum(BILLING_MOVE_NOTICE_KINDS),
+  /** Unsaved wording to try, so the dialog shows the email before the move is created. */
+  subject: z9.string().max(200).optional(),
+  title: z9.string().max(200).optional(),
+  body: z9.string().max(2e3).optional()
+}).strict();
+function parseWith2(schema, body) {
+  const r = schema.safeParse(body);
+  return r.success ? {
+    ok: true,
+    data: r.data
+  } : {
+    ok: false,
+    problems: r.error.issues.map((i) => `${i.path.join(".")} ${i.message}`)
+  };
+}
+__name(parseWith2, "parseWith2");
+__name4(parseWith2, "parseWith");
+var DWA_BUILD_MAX_BUNDLE_BYTES = 12 * 1024 * 1024;
+var sha256Hex = z10.string().regex(/^[a-f0-9]{64}$/);
+var defaultWebAppBundleAssetSchema = z10.object({
+  path: z10.string().min(1).max(512),
+  hash: sha256Hex,
+  size: z10.number().int().nonnegative().max(WEB_APP_MAX_ASSET_BYTES),
+  contentType: z10.string().min(1).max(200),
+  base64: z10.string()
+});
+var defaultWebAppBundleToolSchema = z10.object({
+  name: z10.string().min(1).max(64),
+  description: z10.string().max(2e3),
+  inputSchema: z10.unknown().optional(),
+  outputSchema: z10.unknown().optional(),
+  /** gzip + base64, as `lua push skill` sends a tool. */
+  code: z10.string().min(1)
+});
+var defaultWebAppBundleSchema = z10.object({
+  format: z10.literal(1),
+  templateVersion: z10.string().regex(/^\d+\.\d+\.\d+$/),
+  webApp: z10.object({
+    name: z10.string().regex(/^[a-z][a-z0-9-]{1,39}$/),
+    title: z10.string().max(200).optional(),
+    description: z10.string().max(1e3).optional(),
+    routes: z10.array(z10.object({
+      key: z10.string(),
+      method: z10.string(),
+      path: z10.string(),
+      description: z10.string().optional()
+    }).passthrough()).min(1),
+    hasFetch: z10.boolean(),
+    nav: z10.array(z10.object({
+      path: z10.string(),
+      label: z10.string(),
+      icon: z10.string().optional()
+    }).passthrough()),
+    csp: z10.record(z10.array(z10.string())).optional(),
+    branding: z10.record(z10.unknown()).optional(),
+    bundlesAgentPane: z10.boolean(),
+    uiVersion: z10.string().max(64).optional(),
+    entryHtml: z10.string().min(1).max(WEB_APP_ENTRY_HTML_MAX_CHARS),
+    /** The route bundle, uncompressed. */
+    code: z10.string().min(1),
+    codeSha256: sha256Hex,
+    assets: z10.array(defaultWebAppBundleAssetSchema).max(WEB_APP_MAX_ASSETS),
+    compiler: z10.object({
+      vite: z10.string().optional()
+    })
+  }),
+  skill: z10.object({
+    name: z10.string().regex(/^dwa-[a-z0-9-]+$/),
+    title: z10.string().max(200).optional(),
+    description: z10.string().min(1).max(2e3),
+    context: z10.unknown(),
+    tools: z10.array(defaultWebAppBundleToolSchema).min(1).max(10)
+  }),
+  /** What the pod's smoke run answered, route by route: every one 2xx or the build failed. */
+  smoke: z10.array(z10.object({
+    route: z10.string(),
+    status: z10.number().int()
+  })).min(1)
+});
 
 // ../workflow-graph/dist/index.mjs
 import { createHash } from "crypto";
-import { z as z7 } from "zod";
+import { z as z11 } from "zod";
 import { z as z22 } from "zod";
 import { createHash as createHash2 } from "crypto";
 var __defProp5 = Object.defineProperty;
@@ -13919,8 +14496,8 @@ var rows = /* @__PURE__ */ __name5((s, path, page) => ({
 var fromKnowledge = /* @__PURE__ */ __name5((k) => ({
   knowledge: k
 }), "fromKnowledge");
-var SideEffectsSchema = z7.enum(WORKFLOW_SIDE_EFFECTS);
-var JobResourcesSchema = z7.enum(WORKFLOW_JOB_RESOURCES);
+var SideEffectsSchema = z11.enum(WORKFLOW_SIDE_EFFECTS);
+var JobResourcesSchema = z11.enum(WORKFLOW_JOB_RESOURCES);
 var WORKFLOW_MODEL_TEMPLATE_ROOT = "initData";
 var WORKFLOW_MODEL_TEMPLATE_RE = /^\$\{\s*initData\.([A-Za-z0-9_.\-[\]]+)\s*(?:\|([^}]*))?\}$/;
 var PATH_SEGMENT_RE = /^[A-Za-z0-9_-]+(?:\[(?:0|[1-9]\d*)\])*$/;