@claritylabs/cl-sdk 3.0.33 → 3.1.2

package/dist/application.js

@@ -0,0 +1,2351 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/application/index.ts
+var application_exports = {};
+__export(application_exports, {
+  AcroFormMappingSchema: () => AcroFormMappingSchema,
+  AnswerParsingResultSchema: () => AnswerParsingResultSchema,
+  ApplicationClassifyResultSchema: () => ApplicationClassifyResultSchema,
+  ApplicationContextProposalSchema: () => ApplicationContextProposalSchema,
+  ApplicationEmailReviewSchema: () => ApplicationEmailReviewSchema,
+  ApplicationFieldSchema: () => ApplicationFieldSchema,
+  ApplicationPacketAnswerSchema: () => ApplicationPacketAnswerSchema,
+  ApplicationPacketSchema: () => ApplicationPacketSchema,
+  ApplicationQualityArtifactSchema: () => ApplicationQualityArtifactSchema,
+  ApplicationQualityIssueSchema: () => ApplicationQualityIssueSchema,
+  ApplicationQualityReportSchema: () => ApplicationQualityReportSchema,
+  ApplicationQualityRoundSchema: () => ApplicationQualityRoundSchema,
+  ApplicationQuestionConditionSchema: () => ApplicationQuestionConditionSchema,
+  ApplicationQuestionGraphSchema: () => ApplicationQuestionGraphSchema,
+  ApplicationQuestionNodeSchema: () => ApplicationQuestionNodeSchema,
+  ApplicationRepeatSchema: () => ApplicationRepeatSchema,
+  ApplicationStateSchema: () => ApplicationStateSchema,
+  ApplicationTemplateSchema: () => ApplicationTemplateSchema,
+  AutoFillMatchSchema: () => AutoFillMatchSchema,
+  AutoFillResultSchema: () => AutoFillResultSchema,
+  FieldExtractionResultSchema: () => FieldExtractionResultSchema,
+  FieldTypeSchema: () => FieldTypeSchema,
+  FlatPdfPlacementSchema: () => FlatPdfPlacementSchema,
+  LookupFillResultSchema: () => LookupFillResultSchema,
+  LookupFillSchema: () => LookupFillSchema,
+  LookupRequestSchema: () => LookupRequestSchema,
+  ParsedAnswerSchema: () => ParsedAnswerSchema,
+  QuestionBatchResultSchema: () => QuestionBatchResultSchema,
+  ReplyIntentSchema: () => ReplyIntentSchema,
+  applyApplicationAnswers: () => applyApplicationAnswers,
+  buildApplicationPacket: () => buildApplicationPacket,
+  buildQuestionGraphFromFields: () => buildQuestionGraphFromFields,
+  createApplicationPipeline: () => createApplicationPipeline,
+  createApplicationRun: () => createApplicationRun,
+  extractQuestionGraphFromFields: () => extractQuestionGraphFromFields,
+  flattenQuestionGraph: () => flattenQuestionGraph,
+  getActiveApplicationFields: () => getActiveApplicationFields,
+  getNextApplicationQuestions: () => getNextApplicationQuestions,
+  normalizeApplicationQuestionGraph: () => normalizeApplicationQuestionGraph,
+  planNextApplicationQuestions: () => planNextApplicationQuestions,
+  proposeContextWrites: () => proposeContextWrites,
+  validateApplicationPacket: () => validateApplicationPacket
+});
+module.exports = __toCommonJS(application_exports);
+
+// src/core/model-budget.ts
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+function resolveModelBudget(params) {
+  const { taskKind, modelCapabilities, constraint } = params;
+  const hintTokens = positiveInteger(params.hintTokens) ?? 4096;
+  const taskCapability = positiveInteger(modelCapabilities?.taskOutputTokens?.[taskKind]);
+  const longListCapability = taskKind === "extraction_long_list" ? positiveInteger(modelCapabilities?.longListOutputTokens) : void 0;
+  const defaultCapability = positiveInteger(modelCapabilities?.defaultOutputTokens);
+  const constrainedPreference = positiveInteger(constraint?.outputTokens);
+  const minOutputTokens = positiveInteger(constraint?.minOutputTokens);
+  const modelMaxOutputTokens = positiveInteger(modelCapabilities?.maxOutputTokens);
+  const providerMaxOutputTokens = positiveInteger(params.providerMaxOutputTokens);
+  const hardMaxOutputTokens = positiveInteger(constraint?.maxOutputTokens) ?? providerMaxOutputTokens;
+  const estimatedInputTokens = estimateTokens(params.inputContextBytes);
+  const schemaTokens = estimateTokens(params.schemaSizeBytes) ?? 0;
+  const expectedListLength = positiveInteger(params.expectedListLength) ?? 0;
+  const warnings = [];
+  const preferredOutputTokens = constrainedPreference ?? taskCapability ?? longListCapability ?? defaultCapability ?? hintTokens;
+  let maxTokens = hardMaxOutputTokens ?? modelMaxOutputTokens ?? preferredOutputTokens;
+  if (minOutputTokens) {
+    maxTokens = Math.max(maxTokens, minOutputTokens);
+  }
+  if (modelMaxOutputTokens) {
+    if (maxTokens > modelMaxOutputTokens) {
+      warnings.push(`Resolved ${taskKind} budget was capped by model max output tokens.`);
+    }
+    maxTokens = Math.min(maxTokens, modelMaxOutputTokens);
+  }
+  if (hardMaxOutputTokens) {
+    if (maxTokens > hardMaxOutputTokens) {
+      warnings.push(`Resolved ${taskKind} budget was capped by an explicit hard max output token constraint.`);
+    }
+    maxTokens = Math.min(maxTokens, hardMaxOutputTokens);
+  }
+  const expectedOutputFloor = expectedOutputTokensFloor(taskKind, schemaTokens, expectedListLength, hintTokens);
+  const outputTruncationRisk = maxTokens < expectedOutputFloor * 0.65 ? "high" : maxTokens < expectedOutputFloor ? "medium" : "low";
+  if (outputTruncationRisk !== "low") {
+    warnings.push(`Resolved ${taskKind} budget may be under-sized for the expected output shape.`);
+  }
+  const maxInputTokens = positiveInteger(modelCapabilities?.maxInputTokens);
+  if (estimatedInputTokens && maxInputTokens && estimatedInputTokens > maxInputTokens * 0.9) {
+    warnings.push(`Estimated ${taskKind} input context is close to or above the configured model input limit.`);
+  }
+  return {
+    taskKind,
+    maxTokens,
+    hintTokens,
+    preferredOutputTokens,
+    modelMaxOutputTokens,
+    hardMaxOutputTokens,
+    estimatedInputTokens,
+    outputTruncationRisk,
+    warnings
+  };
+}
+function estimateTokens(bytes) {
+  const positive = positiveInteger(bytes);
+  if (!positive) return void 0;
+  return Math.ceil(positive / 4);
+}
+function expectedOutputTokensFloor(taskKind, schemaTokens, expectedListLength, hintTokens) {
+  const listMultiplier = taskKind === "extraction_long_list" ? 90 : 45;
+  const listFloor = expectedListLength > 0 ? expectedListLength * listMultiplier : 0;
+  return Math.max(Math.ceil(schemaTokens * 1.5), listFloor, Math.floor(hintTokens * 0.75));
+}
+
+// src/core/concurrency.ts
+function pLimit(concurrency) {
+  const maxConcurrency = Number.isFinite(concurrency) ? Math.max(1, Math.floor(concurrency)) : 1;
+  let active = 0;
+  const queue = [];
+  function next() {
+    if (queue.length > 0 && active < maxConcurrency) {
+      active++;
+      queue.shift()();
+    }
+  }
+  return (fn) => new Promise((resolve, reject) => {
+    const run = () => {
+      fn().then(resolve, reject).finally(() => {
+        active--;
+        next();
+      });
+    };
+    queue.push(run);
+    next();
+  });
+}
+
+// src/core/retry.ts
+var MAX_RETRIES = 5;
+var BASE_DELAY_MS = 2e3;
+function isRetryableError(error) {
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    if (msg.includes("rate limit") || msg.includes("rate_limit") || msg.includes("too many requests")) {
+      return true;
+    }
+    if (msg.includes("grammar compilation timed out")) return true;
+    if (msg.includes("no output generated")) return true;
+    if (msg.includes("overloaded")) return true;
+    if (msg.includes("internal server error")) return true;
+    if (msg.includes("service unavailable")) return true;
+    if (msg.includes("gateway timeout")) return true;
+  }
+  if (typeof error === "object" && error !== null) {
+    const status = error.status ?? error.statusCode;
+    if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504) return true;
+  }
+  return false;
+}
+async function withRetry(fn, log) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (!isRetryableError(error) || attempt >= MAX_RETRIES) {
+        throw error;
+      }
+      const jitter = Math.random() * 1e3;
+      const delay = BASE_DELAY_MS * Math.pow(2, attempt) + jitter;
+      await log?.(`Retryable error, retrying in ${(delay / 1e3).toFixed(1)}s (attempt ${attempt + 1}/${MAX_RETRIES})...`);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+}
+
+// src/prompts/application/classify.ts
+var APPLICATION_CLASSIFY_PROMPT = `You are classifying a PDF document. Determine if this is an insurance APPLICATION FORM (a form to be filled out to apply for insurance) versus a policy document, quote, certificate, or other document.
+
+Insurance applications typically:
+- Have blank fields, checkboxes, or spaces to fill in
+- Ask for company information, coverage limits, loss history
+- Include ACORD form numbers or "Application for" in the title
+- Request signatures and dates
+
+Respond with JSON only:
+{
+  "isApplication": boolean,
+  "confidence": number (0-1),
+  "applicationType": string | null  // e.g. "General Liability", "Professional Liability", "Commercial Property", "Workers Compensation", "ACORD 125", etc.
+}`;
+
+// src/schemas/application.ts
+var import_zod = require("zod");
+var FieldTypeSchema = import_zod.z.enum([
+  "text",
+  "numeric",
+  "currency",
+  "date",
+  "yes_no",
+  "table",
+  "declaration"
+]);
+var ApplicationFieldSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  label: import_zod.z.string(),
+  section: import_zod.z.string(),
+  fieldType: FieldTypeSchema,
+  required: import_zod.z.boolean(),
+  options: import_zod.z.array(import_zod.z.string()).optional(),
+  columns: import_zod.z.array(import_zod.z.string()).optional(),
+  requiresExplanationIfYes: import_zod.z.boolean().optional(),
+  condition: import_zod.z.object({
+    dependsOn: import_zod.z.string(),
+    whenValue: import_zod.z.string()
+  }).optional(),
+  value: import_zod.z.string().optional(),
+  source: import_zod.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: import_zod.z.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: import_zod.z.array(import_zod.z.string()).optional().describe("Stable source spans that support the field value or field anchor"),
+  userSourceSpanIds: import_zod.z.array(import_zod.z.string()).optional().describe("Message or attachment spans that support user-provided values"),
+  pageNumber: import_zod.z.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
+  fieldAnchorId: import_zod.z.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
+  acroFormName: import_zod.z.string().optional().describe("Native PDF AcroForm field name when available"),
+  validationStatus: import_zod.z.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
+});
+var ApplicationQuestionConditionSchema = import_zod.z.object({
+  dependsOn: import_zod.z.string(),
+  operator: import_zod.z.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
+  value: import_zod.z.string().optional(),
+  whenValue: import_zod.z.string().optional(),
+  values: import_zod.z.array(import_zod.z.string()).optional()
+});
+var ApplicationRepeatSchema = import_zod.z.object({
+  min: import_zod.z.number().int().nonnegative().optional(),
+  max: import_zod.z.number().int().positive().optional(),
+  label: import_zod.z.string().optional()
+});
+var ApplicationQuestionNodeSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    id: import_zod.z.string(),
+    nodeType: import_zod.z.enum(["group", "question", "repeat_group", "table"]),
+    fieldId: import_zod.z.string().optional(),
+    fieldPath: import_zod.z.string().optional(),
+    parentId: import_zod.z.string().optional(),
+    order: import_zod.z.number().int().nonnegative().optional(),
+    label: import_zod.z.string(),
+    section: import_zod.z.string().optional(),
+    fieldType: FieldTypeSchema.optional(),
+    required: import_zod.z.boolean().optional(),
+    prompt: import_zod.z.string().optional(),
+    options: import_zod.z.array(import_zod.z.string()).optional(),
+    columns: import_zod.z.array(import_zod.z.string()).optional(),
+    condition: ApplicationQuestionConditionSchema.optional(),
+    repeat: ApplicationRepeatSchema.optional(),
+    children: import_zod.z.array(ApplicationQuestionNodeSchema).optional()
+  })
+);
+var ApplicationQuestionGraphSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  version: import_zod.z.string(),
+  title: import_zod.z.string().optional(),
+  applicationType: import_zod.z.string().nullable().optional(),
+  source: import_zod.z.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
+  rootNodeIds: import_zod.z.array(import_zod.z.string()).optional(),
+  nodes: import_zod.z.array(ApplicationQuestionNodeSchema)
+});
+var ApplicationTemplateSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  version: import_zod.z.string(),
+  title: import_zod.z.string(),
+  applicationType: import_zod.z.string().nullable().optional(),
+  questionGraph: ApplicationQuestionGraphSchema,
+  fields: import_zod.z.array(ApplicationFieldSchema).optional()
+});
+var ApplicationClassifyResultSchema = import_zod.z.object({
+  isApplication: import_zod.z.boolean(),
+  confidence: import_zod.z.number().min(0).max(1),
+  applicationType: import_zod.z.string().nullable()
+});
+var FieldExtractionResultSchema = import_zod.z.object({
+  fields: import_zod.z.array(ApplicationFieldSchema)
+});
+var AutoFillMatchSchema = import_zod.z.object({
+  fieldId: import_zod.z.string(),
+  value: import_zod.z.string(),
+  confidence: import_zod.z.enum(["confirmed"]),
+  contextKey: import_zod.z.string()
+});
+var AutoFillResultSchema = import_zod.z.object({
+  matches: import_zod.z.array(AutoFillMatchSchema)
+});
+var QuestionBatchResultSchema = import_zod.z.object({
+  batches: import_zod.z.array(import_zod.z.array(import_zod.z.string()).describe("Array of field IDs in this batch"))
+});
+var LookupRequestSchema = import_zod.z.object({
+  type: import_zod.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: import_zod.z.string(),
+  url: import_zod.z.string().optional(),
+  targetFieldIds: import_zod.z.array(import_zod.z.string())
+});
+var ReplyIntentSchema = import_zod.z.object({
+  primaryIntent: import_zod.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: import_zod.z.boolean(),
+  questionText: import_zod.z.string().optional(),
+  questionFieldIds: import_zod.z.array(import_zod.z.string()).optional(),
+  lookupRequests: import_zod.z.array(LookupRequestSchema).optional()
+});
+var ParsedAnswerSchema = import_zod.z.object({
+  fieldId: import_zod.z.string(),
+  value: import_zod.z.string(),
+  explanation: import_zod.z.string().optional()
+});
+var AnswerParsingResultSchema = import_zod.z.object({
+  answers: import_zod.z.array(ParsedAnswerSchema),
+  unanswered: import_zod.z.array(import_zod.z.string()).describe("Field IDs that were not answered")
+});
+var LookupFillSchema = import_zod.z.object({
+  fieldId: import_zod.z.string(),
+  value: import_zod.z.string(),
+  source: import_zod.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
+  sourceSpanIds: import_zod.z.array(import_zod.z.string()).optional()
+});
+var LookupFillResultSchema = import_zod.z.object({
+  fills: import_zod.z.array(LookupFillSchema),
+  unfillable: import_zod.z.array(import_zod.z.string()),
+  explanation: import_zod.z.string().optional()
+});
+var FlatPdfPlacementSchema = import_zod.z.object({
+  fieldId: import_zod.z.string(),
+  page: import_zod.z.number(),
+  x: import_zod.z.number().describe("Percentage from left edge (0-100)"),
+  y: import_zod.z.number().describe("Percentage from top edge (0-100)"),
+  text: import_zod.z.string(),
+  fontSize: import_zod.z.number().optional(),
+  isCheckmark: import_zod.z.boolean().optional()
+});
+var AcroFormMappingSchema = import_zod.z.object({
+  fieldId: import_zod.z.string(),
+  acroFormName: import_zod.z.string(),
+  value: import_zod.z.string()
+});
+var QualityGateStatusSchema = import_zod.z.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = import_zod.z.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = import_zod.z.object({
+  code: import_zod.z.string(),
+  severity: QualitySeveritySchema,
+  message: import_zod.z.string(),
+  fieldId: import_zod.z.string().optional()
+});
+var ApplicationQualityRoundSchema = import_zod.z.object({
+  round: import_zod.z.number(),
+  kind: import_zod.z.string(),
+  status: QualityGateStatusSchema,
+  summary: import_zod.z.string().optional()
+});
+var ApplicationQualityArtifactSchema = import_zod.z.object({
+  kind: import_zod.z.string(),
+  label: import_zod.z.string().optional(),
+  itemCount: import_zod.z.number().optional()
+});
+var ApplicationEmailReviewSchema = import_zod.z.object({
+  issues: import_zod.z.array(ApplicationQualityIssueSchema),
+  qualityGateStatus: QualityGateStatusSchema
+});
+var ApplicationQualityReportSchema = import_zod.z.object({
+  issues: import_zod.z.array(ApplicationQualityIssueSchema),
+  rounds: import_zod.z.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: import_zod.z.array(ApplicationQualityArtifactSchema).optional(),
+  emailReview: ApplicationEmailReviewSchema.optional(),
+  qualityGateStatus: QualityGateStatusSchema
+});
+var ApplicationContextProposalSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  fieldId: import_zod.z.string().optional(),
+  key: import_zod.z.string(),
+  value: import_zod.z.string(),
+  category: import_zod.z.string(),
+  source: import_zod.z.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
+  confidence: import_zod.z.enum(["confirmed", "high", "medium", "low"]),
+  sourceSpanIds: import_zod.z.array(import_zod.z.string()).optional(),
+  userSourceSpanIds: import_zod.z.array(import_zod.z.string()).optional()
+});
+var ApplicationPacketAnswerSchema = import_zod.z.object({
+  fieldId: import_zod.z.string(),
+  label: import_zod.z.string(),
+  section: import_zod.z.string(),
+  value: import_zod.z.string(),
+  source: import_zod.z.string(),
+  confidence: import_zod.z.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: import_zod.z.array(import_zod.z.string()).optional(),
+  userSourceSpanIds: import_zod.z.array(import_zod.z.string()).optional()
+});
+var ApplicationPacketSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  applicationId: import_zod.z.string(),
+  title: import_zod.z.string(),
+  status: import_zod.z.enum(["draft", "broker_ready", "submitted"]),
+  answers: import_zod.z.array(ApplicationPacketAnswerSchema),
+  missingFieldIds: import_zod.z.array(import_zod.z.string()),
+  qualityReport: ApplicationQualityReportSchema,
+  submissionNotes: import_zod.z.string().optional(),
+  createdAt: import_zod.z.number()
+});
+var ApplicationStateSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  pdfBase64: import_zod.z.string().optional().describe("Original PDF, omitted after extraction"),
+  templateId: import_zod.z.string().optional(),
+  templateVersion: import_zod.z.string().optional(),
+  templateSnapshot: ApplicationTemplateSchema.optional(),
+  title: import_zod.z.string().optional(),
+  applicationType: import_zod.z.string().nullable().optional(),
+  questionGraph: ApplicationQuestionGraphSchema.optional(),
+  fields: import_zod.z.array(ApplicationFieldSchema),
+  batches: import_zod.z.array(import_zod.z.array(import_zod.z.string())).optional(),
+  currentBatchIndex: import_zod.z.number().default(0),
+  contextProposals: import_zod.z.array(ApplicationContextProposalSchema).optional(),
+  packet: ApplicationPacketSchema.optional(),
+  qualityReport: ApplicationQualityReportSchema.optional(),
+  status: import_zod.z.enum([
+    "classifying",
+    "extracting",
+    "auto_filling",
+    "batching",
+    "collecting",
+    "confirming",
+    "mapping",
+    "broker_review",
+    "packet_ready",
+    "submitted",
+    "cancelled",
+    "complete"
+  ]),
+  createdAt: import_zod.z.number(),
+  updatedAt: import_zod.z.number()
+});
+
+// src/application/agents/classifier.ts
+async function classifyApplication(pdfContent, generateObject, providerOptions, maxTokens = 512) {
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt: `${APPLICATION_CLASSIFY_PROMPT}
+
+Analyze the attached insurance document. If text source units are provided in provider options, use them as supporting context. Do not infer from base64 text.`,
+      schema: ApplicationClassifyResultSchema,
+      maxTokens,
+      taskKind: "application_classify",
+      providerOptions: {
+        ...providerOptions,
+        pdfBase64: providerOptions?.pdfBase64 ?? pdfContent
+      }
+    })
+  );
+  return { result: object, usage };
+}
+
+// src/prompts/application/field-extraction.ts
+function buildFieldExtractionPrompt() {
+  return `Extract all fillable fields from this insurance application PDF as a JSON array. Be concise \u2014 use short IDs and minimal keys.
+
+Field types: "text", "numeric", "currency", "date", "yes_no", "table", "declaration"
+
+Required keys per field:
+- "id": short provisional snake_case ID. The SDK will replace this with a stable deterministic ID.
+- "label": field label \u2014 a clear, natural question that a human would understand
+- "section": section heading
+- "fieldType": one of the types above
+- "required": boolean
+
+Optional keys (only include when applicable):
+- "sourceSpanIds": stable source span IDs if the caller provided source units for this application
+- "pageNumber": PDF page number where the field label/anchor appears
+- "fieldAnchorId": stable caller-provided field anchor ID, when available
+- "acroFormName": native PDF form field name, when visible or provided
+- "validationStatus": "missing" for extracted blank fields, "needs_review" for prefilled fields that need source validation
+- "options": array of strings \u2014 for fields with checkboxes/radio buttons/multiple choices (e.g. business type, state selections). Use "text" fieldType with options.
+- "columns": array of {"name","type"} \u2014 tables only
+- "requiresExplanationIfYes": boolean \u2014 declarations only
+- "condition": {"dependsOn":"field_id","whenValue":"value"} \u2014 conditional fields only
+
+IMPORTANT \u2014 Grouped fields: When you see a group of checkboxes or radio buttons for a single question (e.g. "Type of Business: Corporation / Partnership / LLC / Individual / Joint Venture / Other"), extract as ONE field with the group label and an "options" array \u2014 NOT as separate fields for each option. The label should describe what's being asked (e.g. "Type of Business Entity"), and options lists the choices.
+
+Example:
+[
+  {"id":"company_name","label":"Applicant Name","section":"General Info","fieldType":"text","required":true},
+  {"id":"business_type","label":"Type of Business Entity","section":"General Info","fieldType":"text","required":true,"options":["Corporation","Partnership","LLC","Individual","Joint Venture","Other"]},
+  {"id":"loss_history","label":"Loss History","section":"Losses","fieldType":"table","required":true,"columns":[{"name":"Year","type":"numeric"},{"name":"Amount","type":"currency"}]},
+  {"id":"prior_claims","text":"Any claims in past 5 years?","section":"Declarations","fieldType":"declaration","required":true,"requiresExplanationIfYes":true}
+]
+
+Extract ALL fields. Prefer page numbers and source span IDs over model-generated guesses whenever source units are supplied. Respond with ONLY the JSON array, no other text.`;
+}
+
+// src/application/field-ids.ts
+function normalizePart(value) {
+  const normalized = (value ?? "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized || "unknown";
+}
+function hashText(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0").slice(0, 8);
+}
+function buildApplicationFieldAnchorId(field) {
+  const page = field.pageNumber ? `p${field.pageNumber}` : "pna";
+  const section = normalizePart(field.section);
+  const label = normalizePart(field.label);
+  const acroFormName = normalizePart(field.acroFormName);
+  const hash = hashText(`${page}|${section}|${label}|${acroFormName}`);
+  return `app_field_anchor:${page}:${section}:${label}:${hash}`;
+}
+function buildStableApplicationFieldId(field) {
+  const page = field.pageNumber ? `p${field.pageNumber}` : "pna";
+  const section = normalizePart(field.section);
+  const label = normalizePart(field.label);
+  const fieldType = normalizePart(field.fieldType);
+  const anchor = field.fieldAnchorId ?? buildApplicationFieldAnchorId(field);
+  const hash = hashText(`${page}|${section}|${label}|${fieldType}|${field.acroFormName ?? ""}|${anchor}`);
+  return `app_field:${page}:${section}:${label}:${hash}`;
+}
+function normalizeApplicationFields(fields) {
+  const seen = /* @__PURE__ */ new Map();
+  return fields.map((field) => {
+    const fieldAnchorId = field.fieldAnchorId ?? buildApplicationFieldAnchorId(field);
+    const baseId = buildStableApplicationFieldId({ ...field, fieldAnchorId });
+    const count = seen.get(baseId) ?? 0;
+    seen.set(baseId, count + 1);
+    return {
+      ...field,
+      id: count === 0 ? baseId : `${baseId}:${count + 1}`,
+      fieldAnchorId,
+      validationStatus: field.validationStatus ?? (field.value ? "needs_review" : "missing")
+    };
+  });
+}
+
+// src/application/agents/field-extractor.ts
+async function extractFields(pdfContent, generateObject, providerOptions, maxTokens = 8192) {
+  const prompt = `${buildFieldExtractionPrompt()}
+
+Extract fields from the attached application PDF. Use provider-supplied source units/spans for page numbers and anchors when present. Do not treat raw base64 as readable document text.`;
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: FieldExtractionResultSchema,
+      maxTokens,
+      taskKind: "application_extract_fields",
+      providerOptions: {
+        ...providerOptions,
+        pdfBase64: providerOptions?.pdfBase64 ?? pdfContent
+      }
+    })
+  );
+  const result = object;
+  return { fields: normalizeApplicationFields(result.fields), usage };
+}
+
+// src/prompts/application/auto-fill.ts
+function buildAutoFillPrompt(fields, orgContext) {
+  const fieldList = fields.map((f) => `- ${f.id}: "${f.label}" (${f.fieldType}, section: ${f.section})`).join("\n");
+  const contextList = orgContext.map((c) => `- ${c.key}: "${c.value}" (category: ${c.category})`).join("\n");
+  return `You are matching insurance application fields to existing business context data.
+
+APPLICATION FIELDS:
+${fieldList}
+
+AVAILABLE BUSINESS CONTEXT:
+${contextList}
+
+For each field that can be filled from the context, provide a match. Only match when you are confident the context value correctly answers the field. For date fields, ensure format compatibility.
+
+Respond with JSON only:
+{
+  "matches": [
+    {
+      "fieldId": "company_name",
+      "value": "Acme Corp",
+      "confidence": "confirmed",
+      "contextKey": "company_name"
+    }
+  ]
+}
+
+Only include fields you can confidently fill. Do not guess or fabricate values.`;
+}
+
+// src/application/agents/auto-filler.ts
+async function autoFillFromContext(fields, orgContext, generateObject, providerOptions, maxTokens = 4096) {
+  const fieldSummaries = fields.map((f) => ({
+    id: f.id,
+    label: f.label,
+    fieldType: f.fieldType,
+    section: f.section
+  }));
+  const prompt = buildAutoFillPrompt(fieldSummaries, orgContext);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: AutoFillResultSchema,
+      maxTokens,
+      taskKind: "application_auto_fill",
+      providerOptions
+    })
+  );
+  return { result: object, usage };
+}
+async function backfillFromPriorAnswers(fields, backfillProvider) {
+  const unfilled = fields.filter((f) => !f.value);
+  if (unfilled.length === 0) return [];
+  return backfillProvider.searchPriorAnswers(
+    unfilled.map((f) => ({
+      id: f.id,
+      label: f.label,
+      section: f.section,
+      fieldType: f.fieldType
+    })),
+    { limit: unfilled.length * 2 }
+  );
+}
+
+// src/prompts/application/question-batch.ts
+function buildQuestionBatchPrompt(unfilledFields) {
+  const fieldList = unfilledFields.map(
+    (f) => {
+      let line = `- ${f.id}: "${f.label ?? f.text}" (${f.fieldType}, section: ${f.section}, required: ${f.required})`;
+      if (f.condition) line += ` [depends on: ${f.condition.dependsOn} when "${f.condition.whenValue}"]`;
+      return line;
+    }
+  ).join("\n");
+  return `You are organizing insurance application questions into topic-based email batches. Each batch = one email, grouped by topic so the recipient can answer related questions together.
+
+UNFILLED FIELDS:
+${fieldList}
+
+Rules:
+- Group by TOPIC, not by fixed size. All questions about the same topic belong in the same batch.
+- Typical topics: Company/Applicant Info, Business Operations, Financial/Revenue, Coverage/Limits, Loss History, Declarations, Premises/Location, etc.
+- A batch can have as many questions as the topic requires \u2014 don't split a natural topic group across multiple emails.
+- If a topic has 20+ fields, you may split into sub-topics (e.g. "Premises - Location" vs "Premises - Details").
+- Put required fields before optional ones within each batch.
+- Keep conditional fields in the same batch as the field they depend on, with the parent field listed BEFORE dependents.
+- Keep related address-like fields (street, city, state, zip, address) in the same batch so the email generator can merge them into a single compound question.
+- Order batches by importance: company info first, then operations, financial, coverage, declarations last.
+- Aim for roughly 3-8 batches total. Fewer large topical batches are better than many tiny ones.
+
+Respond with JSON only:
+{
+  "batches": [
+    ["field_id_1", "field_id_2", "field_id_3", ...],
+    ["field_id_4", "field_id_5", ...]
+  ]
+}`;
+}
+
+// src/application/agents/batcher.ts
+async function batchQuestions(unfilledFields, generateObject, providerOptions, maxTokens = 2048) {
+  const fieldSummaries = unfilledFields.map((f) => ({
+    id: f.id,
+    label: f.label,
+    text: f.label,
+    fieldType: f.fieldType,
+    section: f.section,
+    required: f.required,
+    condition: f.condition
+  }));
+  const prompt = buildQuestionBatchPrompt(fieldSummaries);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: QuestionBatchResultSchema,
+      maxTokens,
+      taskKind: "application_batch",
+      providerOptions
+    })
+  );
+  return { result: object, usage };
+}
+
+// src/prompts/application/reply-intent.ts
+function buildReplyIntentClassificationPrompt(questions, emailBody) {
+  const questionList = questions.map((q, i) => `${i + 1}. ${q.id}: "${q.label}"`).join("\n");
+  return `Classify the intent of this email reply to insurance application questions.
+
+QUESTIONS THAT WERE ASKED:
+${questionList}
+
+USER'S EMAIL REPLY:
+${emailBody}
+
+Classify the primary intent:
+- "answers_only": User is providing answers to the questions
+- "question": User is asking a question about one or more fields (e.g. "What does aggregate limit mean?")
+- "lookup_request": User is requesting data be pulled from existing records OR from a third-party website (e.g. "Use our GL policy for coverage info", "Check Stripe's site for PCI compliance info", "Pull from our last application")
+- "mixed": User is providing some answers AND asking questions or requesting lookups
+
+IMPORTANT: When a user provides answers AND asks you to look something up (e.g. "Yes we use Stripe, check their site for PCI info"), classify as "mixed" with hasAnswers=true and a lookupRequest \u2014 NOT as "question". A "question" is when the user asks what a field means, not when they direct you to a data source.
+
+Respond with JSON only:
+{
+  "primaryIntent": "answers_only" | "question" | "lookup_request" | "mixed",
+  "hasAnswers": boolean,
+  "questionText": "the user's question if any, or null",
+  "questionFieldIds": ["field_ids the question is about, if identifiable"],
+  "lookupRequests": [
+    {
+      "type": "policy" | "quote" | "profile" | "business_context" | "web",
+      "description": "what they want looked up",
+      "url": "URL or domain mentioned (e.g. 'stripe.com'), or null if not a web lookup",
+      "targetFieldIds": ["field_ids to fill from the lookup"]
+    }
+  ]
+}`;
+}
+
+// src/application/agents/reply-router.ts
+async function classifyReplyIntent(fields, replyText, generateObject, providerOptions, maxTokens = 1024) {
+  const fieldSummaries = fields.map((f) => ({ id: f.id, label: f.label }));
+  const prompt = buildReplyIntentClassificationPrompt(fieldSummaries, replyText);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: ReplyIntentSchema,
+      maxTokens,
+      taskKind: "application_classify",
+      providerOptions
+    })
+  );
+  return { intent: object, usage };
+}
+
+// src/prompts/application/answer-parsing.ts
+function buildAnswerParsingPrompt(questions, emailBody) {
+  const questionList = questions.map(
+    (q, i) => `${i + 1}. ${q.id}: "${q.label ?? q.text}" (type: ${q.fieldType})`
+  ).join("\n");
+  return `You are parsing a user's email reply to extract answers for specific insurance application questions.
+
+QUESTIONS ASKED:
+${questionList}
+
+USER'S EMAIL REPLY:
+${emailBody}
+
+Extract answers for each question. Handle:
+- Direct numbered answers (1. answer, 2. answer)
+- Inline answers referencing the question
+- Table data provided as lists or comma-separated values
+- Yes/no answers with optional explanations
+- Partial responses (some questions answered, others skipped)
+
+Respond with JSON only:
+{
+  "answers": [
+    {
+      "fieldId": "company_name",
+      "value": "Acme Corp"
+    },
+    {
+      "fieldId": "prior_claims_decl",
+      "value": "yes",
+      "explanation": "One claim in 2024 for water damage, $15,000 paid"
+    }
+  ],
+  "unanswered": ["field_id_that_was_not_answered"]
+}
+
+Only include answers you are confident about. If a response is ambiguous, include the field in "unanswered".`;
+}
+
+// src/application/agents/answer-parser.ts
+async function parseAnswers(fields, replyText, generateObject, providerOptions, maxTokens = 4096) {
+  const questions = fields.map((f) => ({
+    id: f.id,
+    label: f.label,
+    text: f.label,
+    fieldType: f.fieldType
+  }));
+  const prompt = buildAnswerParsingPrompt(questions, replyText);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: AnswerParsingResultSchema,
+      maxTokens,
+      taskKind: "application_parse_answers",
+      providerOptions
+    })
+  );
+  return { result: object, usage };
+}
+
+// src/prompts/application/pdf-mapping.ts
+function buildLookupFillPrompt(requests, targetFields, availableData) {
+  const requestList = requests.map((r) => `- ${r.type}: ${r.description} (target fields: ${r.targetFieldIds.join(", ")})`).join("\n");
+  const fieldList = targetFields.map((f) => `- ${f.id}: "${f.label}" (${f.fieldType})`).join("\n");
+  return `You are an internal risk management assistant filling out an insurance application for your company. A colleague asked you to look up data from existing company records to fill certain fields.
+
+LOOKUP REQUESTS:
+${requestList}
+
+TARGET FIELDS:
+${fieldList}
+
+AVAILABLE DATA:
+${availableData}
+
+Match the available data to the target fields. Only fill fields where you have a confident match.
+
+IMPORTANT: The "source" field must be a specific, citable reference that will be shown to the user. Examples:
+- "GL Policy #POL-12345 (Hartford)"
+- "vercel.com (Security page)"
+- "Business Context (company_info)"
+- "User Profile"
+Never use vague sources like "existing records" or "available data".
+If AVAILABLE DATA contains sourceSpanId values, include them in "sourceSpanIds" for every value filled from that source. Existing policy values such as policy numbers, dates, limits, deductibles, premiums, coverages, exclusions, conditions, endorsements, locations, vehicles, or named insureds must not be filled without sourceSpanIds unless the value is explicitly marked for review.
+
+Respond with JSON only:
+{
+  "fills": [
+    { "fieldId": "field_id", "value": "the value from data", "source": "Specific source with identifier (e.g. GL Policy #ABC123, stripe.com)", "sourceSpanIds": ["doc-1:span:1:0:abcd1234"] }
+  ],
+  "unfillable": ["field_ids that couldn't be matched"],
+  "explanation": "Brief note about what was filled and what couldn't be found, citing sources"
+}`;
+}
+
+// src/application/agents/lookup-filler.ts
+async function fillFromLookup(requests, targetFields, availableData, generateObject, providerOptions, maxTokens = 4096) {
+  const requestSummaries = requests.map((r) => ({
+    type: r.type,
+    description: r.description,
+    targetFieldIds: r.targetFieldIds
+  }));
+  const fieldSummaries = targetFields.map((f) => ({
+    id: f.id,
+    label: f.label,
+    fieldType: f.fieldType
+  }));
+  const prompt = buildLookupFillPrompt(requestSummaries, fieldSummaries, availableData);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: LookupFillResultSchema,
+      maxTokens,
+      taskKind: "application_lookup",
+      providerOptions
+    })
+  );
+  return { result: object, usage };
+}
+
+// src/prompts/application/batch-email.ts
+function buildBatchEmailGenerationPrompt(batchFields, batchIndex, totalBatches, appTitle, totalFieldCount, filledFieldCount, previousBatchSummary, companyName) {
+  const nonConditionalFields = batchFields.filter((f) => !f.condition);
+  const conditionalFields = batchFields.filter((f) => f.condition);
+  const fieldList = nonConditionalFields.map((f, i) => {
+    let line = `${i + 1}. id="${f.id}" label="${f.label}" type=${f.fieldType}`;
+    if (f.options) line += ` options=[${f.options.join(", ")}]`;
+    return line;
+  }).join("\n");
+  const conditionalNote = conditionalFields.length > 0 ? `
+
+CONDITIONAL FIELDS (DO NOT include in this email \u2014 they will be asked as follow-ups in a separate email after the parent is answered):
+${conditionalFields.map((f) => `- id="${f.id}" label="${f.label}" depends on ${f.condition.dependsOn} = "${f.condition.whenValue}"`).join("\n")}` : "";
+  const company = companyName ?? "the company";
+  const remainingFields = totalFieldCount - filledFieldCount;
+  const estMinutes = Math.max(1, Math.round(remainingFields * 0.5));
+  return `You are an internal risk management assistant helping your colleague fill out an insurance application for ${company}. You work FOR ${company} \u2014 you are NOT the insurer, broker, or any external party.
+
+APPLICATION: ${appTitle ?? "Insurance Application"}
+COMPANY: ${company}
+PROGRESS: ${filledFieldCount} of ${totalFieldCount} fields done, ~${remainingFields} remaining (~${estMinutes} min of questions left)
+${previousBatchSummary ? `
+PREVIOUS ANSWERS RECEIVED:
+${previousBatchSummary}
+` : ""}
+FIELDS TO ASK ABOUT:
+${fieldList}${conditionalNote}
+
+Rules:
+- ${previousBatchSummary ? 'Start by acknowledging previous answers or auto-filled data. If fields were auto-filled, list each field with its value AND cite the specific source (e.g. "from your GL Policy #ABC123", "from vercel.com", "from your business context"). If a web lookup was done, name the URL that was checked. Ask them to reply with corrections if anything is wrong.' : "Start with a one-line intro."}
+- Mention progress once using estimated time remaining. Don't mention section/batch numbers or field counts.
+- Use "${company}" by name when referring to the company. Also fine: "we" or "our". Never "our company" or "the company".
+- Ask questions plainly. No em-dashes for dramatic effect, no filler phrases like "need to nail down" or "let's dive into". Just ask.
+- For yes/no questions, ask naturally in one sentence. Don't list "Yes / No" as options. Mention what you'll need if the answer triggers a follow-up (e.g. "If not, I'll need a brief explanation.").
+- For fields with 2-3 options, mention them inline. 4+ options can be a short list.
+- Group related fields (address, coverage limits) into single compound questions.
+- Do NOT include conditional/follow-up fields. They will be sent separately.
+- Number each question.
+- Note expected format where relevant: dollar amounts for currency, MM/DD/YYYY for dates, column descriptions for tables.
+- End with a short closing.
+- Tone: professional, brief, matter-of-fact. Write like a busy coworker, not a chatbot. No flourishes, no em-dashes between clauses, no editorializing about the questions.
+
+NEVER:
+- Sound like a salesperson or customer service agent
+- Use em-dashes for emphasis or dramatic pacing
+- Editorialize ("these two should wrap up this section", "just a couple more")
+- List "Yes / No / N/A" as bullet options
+- Include conditional follow-up questions
+- Mention section numbers, batch numbers, or field counts
+
+Output the email body text ONLY. No subject line, no JSON. Use markdown for numbered lists.`;
+}
+
+// src/application/agents/email-generator.ts
+async function generateBatchEmail(batchFields, batchIndex, totalBatches, opts, generateText, providerOptions, maxTokens = 2048) {
+  const fieldSummaries = batchFields.map((f) => ({
+    id: f.id,
+    label: f.label,
+    fieldType: f.fieldType,
+    options: f.options,
+    condition: f.condition
+  }));
+  const prompt = buildBatchEmailGenerationPrompt(
+    fieldSummaries,
+    batchIndex,
+    totalBatches,
+    opts.appTitle,
+    opts.totalFieldCount,
+    opts.filledFieldCount,
+    opts.previousBatchSummary,
+    opts.companyName
+  );
+  const { text, usage } = await withRetry(
+    () => generateText({
+      prompt,
+      maxTokens,
+      taskKind: "application_email",
+      providerOptions
+    })
+  );
+  return { text, usage };
+}
+
+// src/core/quality.ts
+function evaluateQualityGate(params) {
+  const { issues, hasRoundWarnings = false } = params;
+  const hasBlocking = issues.some((issue) => issue.severity === "blocking");
+  const hasWarnings = issues.some((issue) => issue.severity === "warning") || hasRoundWarnings;
+  return hasBlocking ? "failed" : hasWarnings ? "warning" : "passed";
+}
+function shouldFailQualityGate(mode, status) {
+  return mode === "strict" && status === "failed";
+}
+
+// src/application/quality.ts
+function isVagueSource(source) {
+  if (!source) return true;
+  const normalized = source.trim().toLowerCase();
+  return normalized === "unknown" || normalized.includes("existing records") || normalized.includes("available data") || normalized === "context" || normalized === "user provided";
+}
+function isSourceGroundedPolicyValue(field) {
+  if (!field.value) return false;
+  const source = field.source?.toLowerCase() ?? "";
+  if (field.sourceSpanIds?.length) return false;
+  if (field.userSourceSpanIds?.length) return false;
+  const label = `${field.section} ${field.label}`.toLowerCase();
+  const highValueLabel = /\b(policy|effective|expiration|date|limit|deductible|premium|coverage|exclusion|condition|endorsement|location|vehicle|named insured|revenue|payroll|loss|claim|prior)\b/.test(label);
+  const highValueType = field.fieldType === "currency" || field.fieldType === "date" || field.fieldType === "numeric" || field.fieldType === "declaration";
+  const fromPolicyLikeSource = /\b(policy|quote|document|lookup|carrier|endorsement)\b/.test(source);
+  return fromPolicyLikeSource && (highValueLabel || highValueType);
+}
+function buildApplicationQualityReport(state) {
+  const issues = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const field of state.fields) {
+    if (seenIds.has(field.id)) {
+      issues.push({
+        code: "duplicate_field_id",
+        severity: "blocking",
+        message: `Field "${field.label}" has a duplicate id "${field.id}".`,
+        fieldId: field.id
+      });
+    }
+    seenIds.add(field.id);
+    if (field.required && !field.value) {
+      issues.push({
+        code: "required_field_unfilled",
+        severity: "warning",
+        message: `Required field "${field.label}" is still unfilled.`,
+        fieldId: field.id
+      });
+    }
+    if (field.value && !field.source) {
+      issues.push({
+        code: "filled_field_missing_source",
+        severity: "blocking",
+        message: `Filled field "${field.label}" is missing source provenance.`,
+        fieldId: field.id
+      });
+    }
+    if (field.value && isVagueSource(field.source)) {
+      issues.push({
+        code: "filled_field_vague_source",
+        severity: "warning",
+        message: `Filled field "${field.label}" has a vague or non-citable source.`,
+        fieldId: field.id
+      });
+    }
+    if (field.value && (!field.confidence || field.confidence === "low")) {
+      issues.push({
+        code: "filled_field_low_confidence",
+        severity: "warning",
+        message: `Filled field "${field.label}" has low or missing confidence.`,
+        fieldId: field.id
+      });
+    }
+    if (isSourceGroundedPolicyValue(field)) {
+      issues.push({
+        code: "policy_value_missing_source_span",
+        severity: "blocking",
+        message: `Filled policy-derived field "${field.label}" is missing source span evidence.`,
+        fieldId: field.id
+      });
+    }
+  }
+  return {
+    issues,
+    rounds: [],
+    artifacts: [
+      { kind: "application_fields", label: "Application Fields", itemCount: state.fields.length }
+    ],
+    qualityGateStatus: evaluateQualityGate({ issues })
+  };
+}
+function reviewBatchEmail(text, batchFields) {
+  const issues = [];
+  const normalized = text.toLowerCase();
+  for (const field of batchFields) {
+    const label = field.label.trim().toLowerCase();
+    if (label.length >= 6 && !normalized.includes(label)) {
+      issues.push({
+        code: "email_missing_field_prompt",
+        severity: "warning",
+        message: `Generated email does not clearly mention field "${field.label}".`,
+        fieldId: field.id
+      });
+    }
+  }
+  return {
+    issues,
+    qualityGateStatus: evaluateQualityGate({ issues })
+  };
+}
+
+// src/application/workflow.ts
+var MAX_DOCUMENT_SEARCH_FIELDS = 5;
+var LOW_VALUE_FIELD_RATIO_LIMIT = 0.6;
+function planApplicationWorkflow(input) {
+  const unfilledFields = input.fields.filter(isUnfilled);
+  const documentSearchFields = planDocumentSearchFields(
+    unfilledFields,
+    input.hasDocumentStore && input.hasMemoryStore
+  );
+  return {
+    runBackfill: input.hasBackfillProvider && unfilledFields.length > 0,
+    runContextAutoFill: input.orgContextCount > 0 && unfilledFields.length > 0,
+    documentSearchFields,
+    runBatching: unfilledFields.length > 0,
+    unfilledFields
+  };
+}
+function planReplyActions(input) {
+  const hasCurrentFields = input.currentBatchFields.length > 0;
+  const nextBatchNeedsAnswers = (input.nextBatchFields ?? []).some(isUnfilled);
+  const hasLookupRequests = (input.intent.lookupRequests?.length ?? 0) > 0;
+  return {
+    parseAnswers: input.intent.hasAnswers && hasCurrentFields,
+    runLookup: hasLookupRequests && input.hasDocumentStore,
+    answerQuestion: Boolean(input.intent.questionText) && (input.intent.primaryIntent === "question" || input.intent.primaryIntent === "mixed"),
+    advanceBatch: hasCurrentFields && input.currentBatchFields.every((field) => !isUnfilled(field)) || !hasCurrentFields && nextBatchNeedsAnswers,
+    generateNextEmail: nextBatchNeedsAnswers
+  };
+}
+function planDocumentSearchFields(unfilledFields, hasStores) {
+  if (!hasStores || unfilledFields.length === 0) return [];
+  const searchableFields = unfilledFields.filter(isHighValueLookupField);
+  if (searchableFields.length === 0) return [];
+  const lowValueRatio = 1 - searchableFields.length / unfilledFields.length;
+  if (unfilledFields.length > MAX_DOCUMENT_SEARCH_FIELDS && lowValueRatio > LOW_VALUE_FIELD_RATIO_LIMIT) {
+    return [];
+  }
+  return searchableFields.slice(0, MAX_DOCUMENT_SEARCH_FIELDS);
+}
+function isUnfilled(field) {
+  return field.value === void 0 || field.value.trim() === "";
+}
+function isHighValueLookupField(field) {
+  const text = `${field.section} ${field.label}`.toLowerCase();
+  if (field.required) return true;
+  return [
+    "carrier",
+    "policy",
+    "premium",
+    "limit",
+    "deductible",
+    "insured",
+    "address",
+    "revenue",
+    "payroll",
+    "effective",
+    "expiration",
+    "coverage",
+    "class code",
+    "fein",
+    "entity"
+  ].some((term) => text.includes(term));
+}
+
+// src/source/schemas.ts
+var import_zod2 = require("zod");
+var SourceSpanKindSchema = import_zod2.z.enum([
+  "pdf_text",
+  "pdf_image",
+  "html",
+  "markdown",
+  "plain_text",
+  "structured_field"
+]);
+var SourceSpanUnitSchema = import_zod2.z.enum([
+  "page",
+  "section",
+  "table",
+  "table_row",
+  "table_cell",
+  "key_value",
+  "text"
+]);
+var SourceKindSchema = import_zod2.z.enum([
+  "policy_pdf",
+  "application_pdf",
+  "email",
+  "attachment",
+  "manual_note"
+]);
+var SourceSpanBBoxSchema = import_zod2.z.object({
+  page: import_zod2.z.number().int().positive(),
+  x: import_zod2.z.number(),
+  y: import_zod2.z.number(),
+  width: import_zod2.z.number(),
+  height: import_zod2.z.number()
+});
+var SourceSpanLocationSchema = import_zod2.z.object({
+  page: import_zod2.z.number().int().positive().optional(),
+  startPage: import_zod2.z.number().int().positive().optional(),
+  endPage: import_zod2.z.number().int().positive().optional(),
+  charStart: import_zod2.z.number().int().nonnegative().optional(),
+  charEnd: import_zod2.z.number().int().nonnegative().optional(),
+  lineStart: import_zod2.z.number().int().positive().optional(),
+  lineEnd: import_zod2.z.number().int().positive().optional(),
+  fieldPath: import_zod2.z.string().optional()
+});
+var SourceSpanTableLocationSchema = import_zod2.z.object({
+  tableId: import_zod2.z.string().optional(),
+  rowIndex: import_zod2.z.number().int().nonnegative().optional(),
+  columnIndex: import_zod2.z.number().int().nonnegative().optional(),
+  columnName: import_zod2.z.string().optional(),
+  rowSpanId: import_zod2.z.string().optional(),
+  tableSpanId: import_zod2.z.string().optional(),
+  isHeader: import_zod2.z.boolean().optional()
+});
+var SourceSpanSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1),
+  documentId: import_zod2.z.string().min(1),
+  sourceKind: SourceKindSchema.optional(),
+  chunkId: import_zod2.z.string().optional(),
+  kind: SourceSpanKindSchema,
+  text: import_zod2.z.string(),
+  hash: import_zod2.z.string().min(1),
+  textHash: import_zod2.z.string().optional(),
+  pageStart: import_zod2.z.number().int().positive().optional(),
+  pageEnd: import_zod2.z.number().int().positive().optional(),
+  sectionId: import_zod2.z.string().optional(),
+  formNumber: import_zod2.z.string().optional(),
+  sourceUnit: SourceSpanUnitSchema.optional(),
+  parentSpanId: import_zod2.z.string().optional(),
+  table: SourceSpanTableLocationSchema.optional(),
+  bbox: import_zod2.z.array(SourceSpanBBoxSchema).optional(),
+  location: SourceSpanLocationSchema.optional(),
+  metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional()
+});
+var SourceSpanRefSchema = import_zod2.z.object({
+  sourceSpanId: import_zod2.z.string().min(1),
+  documentId: import_zod2.z.string().min(1).optional(),
+  chunkId: import_zod2.z.string().optional(),
+  quote: import_zod2.z.string().optional(),
+  hash: import_zod2.z.string().optional(),
+  location: SourceSpanLocationSchema.optional()
+});
+var SourceChunkSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1),
+  documentId: import_zod2.z.string().min(1),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)),
+  text: import_zod2.z.string(),
+  textHash: import_zod2.z.string().min(1),
+  pageStart: import_zod2.z.number().int().positive().optional(),
+  pageEnd: import_zod2.z.number().int().positive().optional(),
+  metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).default({})
+});
+var DocumentSourceNodeKindSchema = import_zod2.z.enum([
+  "document",
+  "page_group",
+  "page",
+  "form",
+  "endorsement",
+  "section",
+  "schedule",
+  "clause",
+  "table",
+  "table_row",
+  "table_cell",
+  "text"
+]);
+var DocumentSourceNodeSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1),
+  documentId: import_zod2.z.string().min(1),
+  parentId: import_zod2.z.string().optional(),
+  kind: DocumentSourceNodeKindSchema,
+  title: import_zod2.z.string(),
+  description: import_zod2.z.string(),
+  textExcerpt: import_zod2.z.string().optional(),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)),
+  pageStart: import_zod2.z.number().int().positive().optional(),
+  pageEnd: import_zod2.z.number().int().positive().optional(),
+  bbox: import_zod2.z.array(SourceSpanBBoxSchema).optional(),
+  order: import_zod2.z.number().int().nonnegative(),
+  path: import_zod2.z.string(),
+  metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
+});
+var SourceBackedValueSchema = import_zod2.z.object({
+  value: import_zod2.z.string(),
+  normalizedValue: import_zod2.z.string().optional(),
+  confidence: import_zod2.z.enum(["low", "medium", "high"]).default("medium"),
+  sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([])
+});
+var OperationalCoverageTermSchema = import_zod2.z.object({
+  kind: import_zod2.z.enum([
+    "each_claim_limit",
+    "each_occurrence_limit",
+    "each_loss_limit",
+    "aggregate_limit",
+    "sublimit",
+    "retention",
+    "deductible",
+    "retroactive_date",
+    "premium",
+    "other"
+  ]).default("other"),
+  label: import_zod2.z.string(),
+  value: import_zod2.z.string(),
+  amount: import_zod2.z.number().optional(),
+  appliesTo: import_zod2.z.string().optional(),
+  sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([])
+});
+var OperationalCoverageLineSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  coverageCode: import_zod2.z.string().optional(),
+  limit: import_zod2.z.string().optional(),
+  deductible: import_zod2.z.string().optional(),
+  premium: import_zod2.z.string().optional(),
+  retroactiveDate: import_zod2.z.string().optional(),
+  formNumber: import_zod2.z.string().optional(),
+  sectionRef: import_zod2.z.string().optional(),
+  coverageOrigin: import_zod2.z.enum(["core", "endorsement"]).optional(),
+  endorsementNumber: import_zod2.z.string().optional(),
+  limits: import_zod2.z.array(OperationalCoverageTermSchema).default([]),
+  sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([])
+});
+var OperationalPartySchema = import_zod2.z.object({
+  role: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([])
+});
+var OperationalEndorsementSupportSchema = import_zod2.z.object({
+  kind: import_zod2.z.string(),
+  status: import_zod2.z.enum(["supported", "excluded", "requires_review"]),
+  summary: import_zod2.z.string(),
+  sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([])
+});
+var PolicyOperationalProfileSchema = import_zod2.z.object({
+  documentType: import_zod2.z.enum(["policy", "quote"]).default("policy"),
+  policyTypes: import_zod2.z.array(import_zod2.z.string()).default(["other"]),
+  policyNumber: SourceBackedValueSchema.optional(),
+  namedInsured: SourceBackedValueSchema.optional(),
+  insurer: SourceBackedValueSchema.optional(),
+  broker: SourceBackedValueSchema.optional(),
+  effectiveDate: SourceBackedValueSchema.optional(),
+  expirationDate: SourceBackedValueSchema.optional(),
+  retroactiveDate: SourceBackedValueSchema.optional(),
+  premium: SourceBackedValueSchema.optional(),
+  coverageTypes: import_zod2.z.array(import_zod2.z.string()).default([]),
+  coverages: import_zod2.z.array(OperationalCoverageLineSchema).default([]),
+  parties: import_zod2.z.array(OperationalPartySchema).default([]),
+  endorsementSupport: import_zod2.z.array(OperationalEndorsementSupportSchema).default([]),
+  sourceNodeIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
+  warnings: import_zod2.z.array(import_zod2.z.string()).default([])
+});
+
+// src/source/ids.ts
+function normalizeText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function stableStringify(value) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? "undefined";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const record = value;
+  return `{${Object.keys(record).sort().filter((key) => record[key] !== void 0).map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function stableHash(value) {
+  const input = stableStringify(value);
+  let hashA = 2166136261;
+  let hashB = 73244475;
+  for (let index = 0; index < input.length; index++) {
+    const char = input.charCodeAt(index);
+    hashA ^= char;
+    hashA = Math.imul(hashA, 16777619);
+    hashB ^= char + index;
+    hashB = Math.imul(hashB, 668265261);
+  }
+  return `${(hashA >>> 0).toString(16).padStart(8, "0")}${(hashB >>> 0).toString(16).padStart(8, "0")}`;
+}
+function sourceSpanTextHash(text) {
+  return stableHash(normalizeText(text));
+}
+
+// src/source/extraction.ts
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function sanitizeIdPart(value) {
+  return value.replace(/[^a-zA-Z0-9_.:-]/g, "_");
+}
+function buildSourceSpan(input, localIndex = 0) {
+  const text = normalizeWhitespace(input.text);
+  const textHash = sourceSpanTextHash(text);
+  const pagePart = input.pageStart ?? "na";
+  const id = [
+    sanitizeIdPart(input.documentId),
+    "span",
+    pagePart,
+    localIndex,
+    textHash.slice(0, 12)
+  ].join(":");
+  return SourceSpanSchema.parse({
+    id,
+    documentId: input.documentId,
+    sourceKind: input.sourceKind,
+    kind: input.sourceKind.endsWith("_pdf") ? "pdf_text" : "plain_text",
+    text,
+    hash: textHash,
+    textHash,
+    pageStart: input.pageStart,
+    pageEnd: input.pageEnd,
+    sectionId: input.sectionId,
+    formNumber: input.formNumber,
+    sourceUnit: input.sourceUnit,
+    parentSpanId: input.parentSpanId,
+    table: input.table,
+    location: {
+      page: input.pageStart === input.pageEnd ? input.pageStart : void 0,
+      startPage: input.pageStart,
+      endPage: input.pageEnd,
+      fieldPath: input.sectionId
+    },
+    metadata: input.metadata
+  });
+}
+function buildTextSourceSpans(input, options = {}) {
+  const maxChars = options.maxChars ?? 4e3;
+  const overlapChars = Math.min(options.overlapChars ?? 0, Math.max(0, maxChars - 1));
+  const text = normalizeWhitespace(input.text);
+  if (!text) return [];
+  const spans = [];
+  let cursor = 0;
+  while (cursor < text.length) {
+    const end = Math.min(text.length, cursor + maxChars);
+    const unitText = text.slice(cursor, end);
+    spans.push(buildSourceSpan({ ...input, text: unitText }, spans.length));
+    if (end === text.length) break;
+    cursor = end - overlapChars;
+  }
+  return spans;
+}
+
+// src/application/question-graph.ts
+function buildQuestionGraphFromFields(fields, options) {
+  const sectionNodes = /* @__PURE__ */ new Map();
+  const nodes = [];
+  for (const [index, field] of fields.entries()) {
+    const sectionId = stableNodeId(["section", field.section]);
+    let sectionNode = sectionNodes.get(sectionId);
+    if (!sectionNode) {
+      sectionNode = {
+        id: sectionId,
+        nodeType: "group",
+        label: field.section,
+        order: sectionNodes.size,
+        children: []
+      };
+      sectionNodes.set(sectionId, sectionNode);
+      nodes.push(sectionNode);
+    }
+    const child = {
+      id: field.fieldAnchorId ?? stableNodeId(["field", field.section, field.id || field.label]),
+      nodeType: field.fieldType === "table" ? "table" : "question",
+      fieldId: field.id,
+      fieldPath: `${field.section}.${field.id}`,
+      parentId: sectionId,
+      order: index,
+      label: field.label,
+      section: field.section,
+      fieldType: field.fieldType,
+      required: field.required,
+      options: field.options,
+      columns: field.columns,
+      condition: field.condition ? {
+        dependsOn: field.condition.dependsOn,
+        operator: "equals",
+        value: field.condition.whenValue,
+        whenValue: field.condition.whenValue
+      } : void 0
+    };
+    sectionNode.children = [...sectionNode.children ?? [], child];
+  }
+  return normalizeApplicationQuestionGraph({
+    id: options.id,
+    version: options.version ?? "v1",
+    title: options.title,
+    applicationType: options.applicationType,
+    source: options.source ?? "generated",
+    rootNodeIds: nodes.map((node) => node.id),
+    nodes
+  });
+}
+function normalizeApplicationQuestionGraph(graph) {
+  const normalizedNodes = graph.nodes.map((node, index) => normalizeNode(node, void 0, index)).sort(compareNodes);
+  return {
+    ...graph,
+    rootNodeIds: graph.rootNodeIds?.length ? graph.rootNodeIds : normalizedNodes.map((node) => node.id),
+    nodes: normalizedNodes
+  };
+}
+function flattenQuestionGraph(graph) {
+  const fields = [];
+  for (const node of graph.nodes.sort(compareNodes)) {
+    collectFields(node, fields);
+  }
+  return fields;
+}
+function getActiveApplicationFields(state) {
+  const valueByFieldId = new Map(
+    state.fields.filter((field) => field.value !== void 0 && field.value.trim() !== "").map((field) => [field.id, field.value ?? ""])
+  );
+  const graphConditions = /* @__PURE__ */ new Map();
+  for (const node of state.questionGraph?.nodes ?? []) {
+    collectNodeConditions(node, graphConditions);
+  }
+  return state.fields.filter((field) => {
+    const graphCondition = graphConditions.get(field.id);
+    return isConditionSatisfied(field.condition, valueByFieldId) && isQuestionConditionSatisfied(graphCondition, valueByFieldId);
+  });
+}
+function getNextApplicationQuestions(state, limit = 8) {
+  const activeUnfilled = getActiveApplicationFields(state).filter((field) => !field.value);
+  if (activeUnfilled.length === 0) return [];
+  const currentBatchIds = state.batches?.[state.currentBatchIndex] ?? [];
+  const currentBatchFields = activeUnfilled.filter((field) => currentBatchIds.includes(field.id));
+  return (currentBatchFields.length > 0 ? currentBatchFields : activeUnfilled).slice(0, limit);
+}
+function normalizeNode(node, parentId, index) {
+  const children = node.children?.map((child, childIndex) => normalizeNode(child, node.id, childIndex));
+  return {
+    ...node,
+    parentId: node.parentId ?? parentId,
+    order: node.order ?? index,
+    fieldPath: node.fieldPath ?? (node.fieldId ? [node.section, node.fieldId].filter(Boolean).join(".") : void 0),
+    children
+  };
+}
+function collectFields(node, fields) {
+  if ((node.nodeType === "question" || node.nodeType === "table") && node.fieldId) {
+    fields.push({
+      id: node.fieldId,
+      label: node.label,
+      section: node.section ?? "General",
+      fieldType: node.fieldType ?? (node.nodeType === "table" ? "table" : "text"),
+      required: node.required ?? false,
+      options: node.options,
+      columns: node.columns,
+      condition: node.condition ? {
+        dependsOn: node.condition.dependsOn,
+        whenValue: node.condition.value ?? node.condition.whenValue ?? ""
+      } : void 0,
+      fieldAnchorId: node.id
+    });
+  }
+  for (const child of node.children ?? []) {
+    collectFields(child, fields);
+  }
+}
+function collectNodeConditions(node, conditions) {
+  if (node.fieldId && node.condition) {
+    conditions.set(node.fieldId, node.condition);
+  }
+  for (const child of node.children ?? []) {
+    collectNodeConditions(child, conditions);
+  }
+}
+function isConditionSatisfied(condition, valueByFieldId) {
+  if (!condition) return true;
+  const current = valueByFieldId.get(condition.dependsOn);
+  return normalizeValue(current) === normalizeValue(condition.whenValue);
+}
+function isQuestionConditionSatisfied(condition, valueByFieldId) {
+  if (!condition) return true;
+  const current = valueByFieldId.get(condition.dependsOn);
+  const expected = condition.value ?? condition.whenValue;
+  const values = condition.values ?? (expected !== void 0 ? [expected] : []);
+  switch (condition.operator) {
+    case "exists":
+      return current !== void 0 && current.trim() !== "";
+    case "not_equals":
+      return normalizeValue(current) !== normalizeValue(expected);
+    case "in":
+      return values.map(normalizeValue).includes(normalizeValue(current));
+    case "not_in":
+      return !values.map(normalizeValue).includes(normalizeValue(current));
+    case "equals":
+    default:
+      return normalizeValue(current) === normalizeValue(expected);
+  }
+}
+function compareNodes(a, b) {
+  return (a.order ?? 0) - (b.order ?? 0) || a.id.localeCompare(b.id);
+}
+function normalizeValue(value) {
+  return (value ?? "").trim().toLowerCase();
+}
+function stableNodeId(parts) {
+  return parts.join(":").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "node";
+}
+
+// src/application/intake.ts
+function extractQuestionGraphFromFields(fields, options) {
+  return buildQuestionGraphFromFields(fields, options);
+}
+function createApplicationRun(params) {
+  const now = params.now ?? Date.now();
+  const graph = normalizeApplicationQuestionGraph(params.template.questionGraph);
+  const fields = params.template.fields?.length ? params.template.fields : flattenQuestionGraph(graph);
+  return {
+    id: params.applicationId,
+    templateId: params.template.id,
+    templateVersion: params.template.version,
+    templateSnapshot: params.template,
+    title: params.template.title,
+    applicationType: params.template.applicationType,
+    questionGraph: graph,
+    fields,
+    currentBatchIndex: 0,
+    status: "collecting",
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function planNextApplicationQuestions(state, limit) {
+  const fields = getNextApplicationQuestions(state, limit);
+  return {
+    status: fields.length === 0 ? "complete" : "needs_answers",
+    fieldIds: fields.map((field) => field.id),
+    fields
+  };
+}
+function applyApplicationAnswers(state, answers, now = Date.now()) {
+  const answerByFieldId = new Map(answers.map((answer) => [answer.fieldId, answer]));
+  const fields = state.fields.map((field) => {
+    const answer = answerByFieldId.get(field.id);
+    if (!answer) return field;
+    return {
+      ...field,
+      value: answer.value,
+      source: answer.source ?? "user",
+      confidence: answer.confidence ?? "confirmed",
+      sourceSpanIds: answer.sourceSpanIds ?? field.sourceSpanIds,
+      userSourceSpanIds: answer.userSourceSpanIds ?? field.userSourceSpanIds,
+      validationStatus: "valid"
+    };
+  });
+  const nextState = {
+    ...state,
+    fields,
+    updatedAt: now
+  };
+  const nextQuestions = planNextApplicationQuestions(nextState);
+  return {
+    ...nextState,
+    status: nextQuestions.status === "complete" ? "confirming" : nextState.status,
+    qualityReport: buildApplicationQualityReport(nextState)
+  };
+}
+function proposeContextWrites(state) {
+  return getActiveApplicationFields(state).filter((field) => field.value && field.confidence && field.confidence !== "low").map((field) => ({
+    id: `${state.id}:${field.id}:context`,
+    fieldId: field.id,
+    key: stableContextKey(field),
+    value: field.value ?? "",
+    category: field.section,
+    source: field.source?.startsWith("lookup:") ? "lookup" : "application",
+    confidence: field.confidence ?? "medium",
+    sourceSpanIds: field.sourceSpanIds,
+    userSourceSpanIds: field.userSourceSpanIds
+  }));
+}
+function buildApplicationPacket(state, options = {}) {
+  const qualityReport = buildApplicationQualityReport(state);
+  const activeFields = getActiveApplicationFields(state);
+  const answers = activeFields.filter((field) => field.value).map((field) => ({
+    fieldId: field.id,
+    label: field.label,
+    section: field.section,
+    value: field.value ?? "",
+    source: field.source ?? "unknown",
+    confidence: field.confidence,
+    sourceSpanIds: field.sourceSpanIds,
+    userSourceSpanIds: field.userSourceSpanIds
+  }));
+  const missingFieldIds = activeFields.filter((field) => field.required && !field.value).map((field) => field.id);
+  return {
+    id: `${state.id}:packet`,
+    applicationId: state.id,
+    title: state.title ?? state.applicationType ?? "Insurance Application",
+    status: qualityReport.qualityGateStatus === "failed" || missingFieldIds.length > 0 ? "draft" : "broker_ready",
+    answers,
+    missingFieldIds,
+    qualityReport,
+    submissionNotes: options.submissionNotes,
+    createdAt: options.now ?? Date.now()
+  };
+}
+function validateApplicationPacket(packet) {
+  const issues = [...packet.qualityReport.issues];
+  if (packet.missingFieldIds.length > 0) {
+    issues.push({
+      code: "packet_missing_required_answers",
+      severity: "blocking",
+      message: "Packet still has required unanswered application fields."
+    });
+  }
+  return {
+    ...packet.qualityReport,
+    issues,
+    qualityGateStatus: issues.some((issue) => issue.severity === "blocking") ? "failed" : packet.qualityReport.qualityGateStatus
+  };
+}
+function stableContextKey(field) {
+  return `${field.section}.${field.label}`.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+
+// src/application/coordinator.ts
+function createApplicationPipeline(config) {
+  const {
+    generateText,
+    generateObject,
+    applicationStore,
+    templateStore,
+    documentStore,
+    memoryStore,
+    backfillProvider,
+    orgContext = [],
+    concurrency = 4,
+    onTokenUsage,
+    onProgress,
+    log,
+    providerOptions,
+    qualityGate = "warn",
+    modelCapabilities,
+    modelBudgetConstraints
+  } = config;
+  const limit = pLimit(concurrency);
+  let totalUsage = { inputTokens: 0, outputTokens: 0 };
+  function trackUsage(usage) {
+    if (usage) {
+      totalUsage.inputTokens += usage.inputTokens;
+      totalUsage.outputTokens += usage.outputTokens;
+      onTokenUsage?.(usage);
+    }
+  }
+  function resolveBudget(taskKind, hintTokens) {
+    return resolveModelBudget({
+      taskKind,
+      hintTokens,
+      modelCapabilities,
+      constraint: modelBudgetConstraints?.[taskKind]
+    });
+  }
+  async function processApplication(input) {
+    totalUsage = { inputTokens: 0, outputTokens: 0 };
+    const { pdfBase64, context } = input;
+    const applicationProviderOptions = input.sourceSpans?.length ? { ...providerOptions, sourceSpans: input.sourceSpans } : providerOptions;
+    const id = input.applicationId ?? `app-${Date.now()}`;
+    const now = Date.now();
+    if (input.template) {
+      await templateStore?.saveTemplate(input.template);
+    }
+    let state = {
+      id,
+      templateId: input.template?.id,
+      templateVersion: input.template?.version,
+      templateSnapshot: input.template,
+      pdfBase64: void 0,
+      title: void 0,
+      applicationType: null,
+      questionGraph: input.questionGraph ?? input.template?.questionGraph,
+      fields: [],
+      qualityReport: void 0,
+      batches: void 0,
+      currentBatchIndex: 0,
+      status: "classifying",
+      createdAt: now,
+      updatedAt: now
+    };
+    onProgress?.("Classifying document...");
+    await applicationStore?.save(state);
+    let classifyResult;
+    try {
+      const { result, usage: classifyUsage } = await classifyApplication(
+        pdfBase64,
+        generateObject,
+        applicationProviderOptions,
+        resolveBudget("application_classify", 512).maxTokens
+      );
+      trackUsage(classifyUsage);
+      classifyResult = result;
+    } catch (error) {
+      await log?.(`Classification failed, treating as non-application: ${error instanceof Error ? error.message : String(error)}`);
+      classifyResult = { isApplication: false, confidence: 0, applicationType: null };
+    }
+    if (!classifyResult.isApplication) {
+      state.status = "complete";
+      state.updatedAt = Date.now();
+      state.qualityReport = buildApplicationQualityReport(state);
+      await applicationStore?.save(state);
+      return { state, tokenUsage: totalUsage, reviewReport: state.qualityReport };
+    }
+    state.applicationType = classifyResult.applicationType;
+    state.status = "extracting";
+    state.updatedAt = Date.now();
+    await applicationStore?.save(state);
+    onProgress?.("Extracting form fields...");
+    let fields;
+    try {
+      const { fields: extractedFields, usage: extractUsage } = await extractFields(
+        pdfBase64,
+        generateObject,
+        applicationProviderOptions,
+        resolveBudget("application_extract_fields", 8192).maxTokens
+      );
+      trackUsage(extractUsage);
+      fields = extractedFields;
+    } catch (error) {
+      await log?.(`Field extraction failed: ${error instanceof Error ? error.message : String(error)}`);
+      fields = [];
+    }
+    if (fields.length === 0) {
+      await log?.("No fields extracted, completing pipeline with empty result");
+      state.status = "complete";
+      state.updatedAt = Date.now();
+      state.qualityReport = buildApplicationQualityReport(state);
+      await applicationStore?.save(state);
+      return { state, tokenUsage: totalUsage, reviewReport: state.qualityReport };
+    }
+    state.fields = fields;
+    state.questionGraph = input.questionGraph ?? input.template?.questionGraph ?? buildQuestionGraphFromFields(fields, {
+      id: `${id}:graph`,
+      title: classifyResult.applicationType ?? void 0,
+      applicationType: classifyResult.applicationType,
+      source: "pdf"
+    });
+    state.title = classifyResult.applicationType ?? void 0;
+    state.status = "auto_filling";
+    state.updatedAt = Date.now();
+    await applicationStore?.save(state);
+    onProgress?.(`Auto-filling ${fields.length} fields...`);
+    let workflowPlan = planApplicationWorkflow({
+      fields: state.fields,
+      hasBackfillProvider: Boolean(backfillProvider),
+      orgContextCount: orgContext.length,
+      hasDocumentStore: Boolean(documentStore),
+      hasMemoryStore: Boolean(memoryStore)
+    });
+    if (workflowPlan.runBackfill && backfillProvider) {
+      try {
+        const priorAnswers = await backfillFromPriorAnswers(state.fields, backfillProvider);
+        for (const pa of priorAnswers) {
+          const field = state.fields.find((f) => f.id === pa.fieldId);
+          if (field && !field.value && pa.relevance > 0.8) {
+            field.value = pa.value;
+            field.source = `backfill: ${pa.source}`;
+            field.confidence = pa.confidence ?? "high";
+            field.validationStatus = pa.sourceSpanIds?.length ? "valid" : "needs_review";
+            field.sourceSpanIds = pa.sourceSpanIds;
+            field.userSourceSpanIds = pa.userSourceSpanIds;
+          }
+        }
+      } catch (e) {
+        await log?.(`Backfill failed: ${e}`);
+      }
+    }
+    workflowPlan = planApplicationWorkflow({
+      fields: state.fields,
+      hasBackfillProvider: false,
+      orgContextCount: orgContext.length,
+      hasDocumentStore: Boolean(documentStore),
+      hasMemoryStore: Boolean(memoryStore)
+    });
+    const fillTasks = [];
+    if (workflowPlan.runContextAutoFill) {
+      fillTasks.push(
+        limit(async () => {
+          const unfilledFields2 = state.fields.filter((f) => !f.value);
+          if (unfilledFields2.length === 0) return;
+          try {
+            const { result: autoFillResult, usage: afUsage } = await autoFillFromContext(
+              unfilledFields2,
+              orgContext,
+              generateObject,
+              providerOptions,
+              resolveBudget("application_auto_fill", 4096).maxTokens
+            );
+            trackUsage(afUsage);
+            for (const match of autoFillResult.matches) {
+              const field = state.fields.find((f) => f.id === match.fieldId);
+              if (field && !field.value) {
+                field.value = match.value;
+                field.source = `auto-fill: ${match.contextKey}`;
+                field.confidence = match.confidence;
+                field.validationStatus = "valid";
+              }
+            }
+          } catch (e) {
+            await log?.(`Auto-fill from context failed: ${e instanceof Error ? e.message : String(e)}`);
+          }
+        })
+      );
+    }
+    if (workflowPlan.documentSearchFields.length > 0 && memoryStore) {
+      fillTasks.push(
+        (async () => {
+          try {
+            const searchPromises = workflowPlan.documentSearchFields.map(
+              (f) => limit(async () => {
+                const chunks = await memoryStore.search(`${f.section} ${f.label}`, { limit: 3 });
+                const match = selectMemoryBackfillMatch(f, chunks);
+                if (match) {
+                  const field = state.fields.find((candidate) => candidate.id === f.id);
+                  if (field && !field.value) {
+                    field.value = match.value;
+                    field.source = match.source;
+                    field.confidence = match.confidence;
+                    field.validationStatus = match.sourceSpanIds.length > 0 ? "valid" : "needs_review";
+                    field.sourceSpanIds = match.sourceSpanIds.length > 0 ? match.sourceSpanIds : void 0;
+                  }
+                }
+              })
+            );
+            await Promise.all(searchPromises);
+          } catch (e) {
+            await log?.(`Document backfill search failed: ${e}`);
+          }
+        })()
+      );
+    }
+    await Promise.all(fillTasks);
+    state.updatedAt = Date.now();
+    await applicationStore?.save(state);
+    workflowPlan = planApplicationWorkflow({
+      fields: state.fields,
+      hasBackfillProvider: false,
+      orgContextCount: 0,
+      hasDocumentStore: false,
+      hasMemoryStore: false
+    });
+    const unfilledFields = getActiveApplicationFields(state).filter((field) => !field.value);
+    if (workflowPlan.runBatching) {
+      onProgress?.(`Batching ${unfilledFields.length} remaining questions...`);
+      state.status = "batching";
+      try {
+        const { result: batchResult, usage: batchUsage } = await batchQuestions(
+          unfilledFields,
+          generateObject,
+          providerOptions,
+          resolveBudget("application_batch", 2048).maxTokens
+        );
+        trackUsage(batchUsage);
+        state.batches = batchResult.batches;
+      } catch (error) {
+        await log?.(`Batching failed, using single-batch fallback: ${error instanceof Error ? error.message : String(error)}`);
+        state.batches = [unfilledFields.map((f) => f.id)];
+      }
+      state.currentBatchIndex = 0;
+      state.status = "collecting";
+    } else {
+      state.status = "confirming";
+    }
+    state.contextProposals = proposeContextWrites(state);
+    state.qualityReport = buildApplicationQualityReport(state);
+    state.updatedAt = Date.now();
+    await applicationStore?.save(state);
+    if (shouldFailQualityGate(qualityGate, state.qualityReport.qualityGateStatus)) {
+      throw new Error("Application quality gate failed. See state.qualityReport for blocking issues.");
+    }
+    const filledCount = state.fields.filter((f) => f.value).length;
+    onProgress?.(`Application processed: ${filledCount}/${state.fields.length} fields filled, ${state.batches?.length ?? 0} batches to collect.`);
+    return { state, tokenUsage: totalUsage, reviewReport: state.qualityReport };
+  }
+  async function processReply(input) {
+    totalUsage = { inputTokens: 0, outputTokens: 0 };
+    const { applicationId, replyText, context } = input;
+    const replySourceSpanIds = input.replySourceSpanIds?.length ? input.replySourceSpanIds : buildTextSourceSpans({
+      documentId: `${applicationId}:reply:${sourceSpanTextHash(replyText).slice(0, 12)}`,
+      sourceKind: "email",
+      text: replyText,
+      metadata: { applicationId }
+    }).map((span) => span.id);
+    let state = null;
+    if (applicationStore) {
+      state = await applicationStore.get(applicationId);
+    }
+    if (!state) {
+      throw new Error(`Application ${applicationId} not found`);
+    }
+    const currentBatchFieldIds = state.batches?.[state.currentBatchIndex] ?? [];
+    const activeFields = getActiveApplicationFields(state);
+    const currentBatchFields = activeFields.filter(
+      (f) => currentBatchFieldIds.includes(f.id)
+    );
+    onProgress?.("Classifying reply...");
+    let intent;
+    try {
+      const { intent: classifiedIntent, usage: intentUsage } = await classifyReplyIntent(
+        currentBatchFields,
+        replyText,
+        generateObject,
+        providerOptions,
+        resolveBudget("application_classify", 1024).maxTokens
+      );
+      trackUsage(intentUsage);
+      intent = classifiedIntent;
+    } catch (error) {
+      await log?.(`Reply intent classification failed, defaulting to answers_only: ${error instanceof Error ? error.message : String(error)}`);
+      intent = {
+        primaryIntent: "answers_only",
+        hasAnswers: true,
+        questionText: void 0,
+        questionFieldIds: void 0,
+        lookupRequests: void 0
+      };
+    }
+    let fieldsFilled = 0;
+    let responseText;
+    let replyPlan = planReplyActions({
+      intent,
+      currentBatchFields,
+      hasDocumentStore: Boolean(documentStore)
+    });
+    if (replyPlan.parseAnswers) {
+      onProgress?.("Parsing answers...");
+      try {
+        const { result: parseResult, usage: parseUsage } = await parseAnswers(
+          currentBatchFields,
+          replyText,
+          generateObject,
+          providerOptions,
+          resolveBudget("application_parse_answers", 4096).maxTokens
+        );
+        trackUsage(parseUsage);
+        for (const answer of parseResult.answers) {
+          const field = state.fields.find((f) => f.id === answer.fieldId);
+          if (field) {
+            field.value = answer.value;
+            field.source = "user";
+            field.confidence = "confirmed";
+            field.userSourceSpanIds = replySourceSpanIds;
+            field.validationStatus = "valid";
+            fieldsFilled++;
+          }
+        }
+      } catch (error) {
+        await log?.(`Answer parsing failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (replyPlan.runLookup && intent.lookupRequests?.length) {
+      onProgress?.("Processing lookup requests...");
+      let availableData = "";
+      if (documentStore) {
+        try {
+          const docs = await documentStore.query({});
+          availableData = docs.map((d) => {
+            const doc = d;
+            return `Document ${doc.id}: ${doc.type} - ${doc.carrier ?? "unknown carrier"} - ${doc.insuredName ?? ""}`;
+          }).join("\n");
+        } catch (e) {
+          await log?.(`Document query for lookup failed: ${e}`);
+        }
+      }
+      if (availableData) {
+        const targetFields = state.fields.filter(
+          (f) => intent.lookupRequests.some((lr) => lr.targetFieldIds.includes(f.id))
+        );
+        try {
+          const { result: lookupResult, usage: lookupUsage } = await fillFromLookup(
+            intent.lookupRequests,
+            targetFields,
+            availableData,
+            generateObject,
+            providerOptions,
+            resolveBudget("application_lookup", 4096).maxTokens
+          );
+          trackUsage(lookupUsage);
+          for (const fill of lookupResult.fills) {
+            const field = state.fields.find((f) => f.id === fill.fieldId);
+            if (field) {
+              field.value = fill.value;
+              field.source = `lookup: ${fill.source}`;
+              field.confidence = "high";
+              field.validationStatus = fill.sourceSpanIds?.length ? "valid" : "needs_review";
+              if (fill.sourceSpanIds?.length) {
+                field.sourceSpanIds = fill.sourceSpanIds;
+              }
+              fieldsFilled++;
+            }
+          }
+        } catch (error) {
+          await log?.(`Lookup fill failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    }
+    if (replyPlan.answerQuestion && intent.questionText) {
+      try {
+        const budget = resolveBudget("application_email", 512);
+        const { text, usage } = await generateText({
+          prompt: `The user is filling out an insurance application and asked: "${intent.questionText}"
+
+Provide a brief, helpful explanation (2-3 sentences). End with "Just reply with the answer when you're ready and I'll fill it in."`,
+          maxTokens: budget.maxTokens,
+          taskKind: "application_email",
+          budgetDiagnostics: budget,
+          providerOptions
+        });
+        trackUsage(usage);
+        responseText = text;
+      } catch (error) {
+        await log?.(`Question response generation failed: ${error instanceof Error ? error.message : String(error)}`);
+        responseText = `I wasn't able to generate an explanation for your question. Could you rephrase it, or just provide the answer directly?`;
+      }
+    }
+    const activeCurrentBatchFieldIds = currentBatchFields.map((field) => field.id);
+    const currentBatchComplete = activeCurrentBatchFieldIds.every(
+      (fid) => state.fields.find((f) => f.id === fid)?.value
+    );
+    let nextBatchIndex;
+    let nextBatchFields;
+    if (state.batches) {
+      for (let index = state.currentBatchIndex + 1; index < state.batches.length; index++) {
+        const activeCandidateFields = getActiveApplicationFields(state);
+        const candidateFields = activeCandidateFields.filter((f) => state.batches[index].includes(f.id));
+        if (candidateFields.some((f) => !f.value)) {
+          nextBatchIndex = index;
+          nextBatchFields = candidateFields;
+          break;
+        }
+      }
+    }
+    replyPlan = planReplyActions({
+      intent,
+      currentBatchFields,
+      nextBatchFields,
+      hasDocumentStore: Boolean(documentStore)
+    });
+    if (currentBatchComplete && replyPlan.advanceBatch && state.batches) {
+      if (nextBatchIndex !== void 0 && nextBatchFields) {
+        state.currentBatchIndex = nextBatchIndex;
+        const filledCount = state.fields.filter((f) => f.value).length;
+        if (replyPlan.generateNextEmail) {
+          try {
+            const { text: emailText, usage: emailUsage } = await generateBatchEmail(
+              nextBatchFields,
+              state.currentBatchIndex,
+              state.batches.length,
+              {
+                appTitle: state.title,
+                totalFieldCount: state.fields.length,
+                filledFieldCount: filledCount,
+                companyName: context?.companyName
+              },
+              generateText,
+              providerOptions,
+              resolveBudget("application_email", 2048).maxTokens
+            );
+            trackUsage(emailUsage);
+            const emailReview = reviewBatchEmail(emailText, nextBatchFields);
+            state.qualityReport = {
+              ...buildApplicationQualityReport(state),
+              emailReview
+            };
+            if (!responseText) {
+              responseText = emailText;
+            } else {
+              responseText += `
+
+${emailText}`;
+            }
+          } catch (error) {
+            await log?.(`Batch email generation failed: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+      } else {
+        state.status = "confirming";
+      }
+    }
+    state.updatedAt = Date.now();
+    state.contextProposals = proposeContextWrites(state);
+    state.qualityReport = buildApplicationQualityReport(state);
+    await applicationStore?.save(state);
+    if (shouldFailQualityGate(qualityGate, state.qualityReport.qualityGateStatus)) {
+      throw new Error("Application quality gate failed. See state.qualityReport for blocking issues.");
+    }
+    return {
+      state,
+      intent: intent.primaryIntent,
+      fieldsFilled,
+      responseText,
+      tokenUsage: totalUsage,
+      reviewReport: state.qualityReport
+    };
+  }
+  async function generateCurrentBatchEmail(applicationId, opts) {
+    totalUsage = { inputTokens: 0, outputTokens: 0 };
+    const state = await applicationStore?.get(applicationId);
+    if (!state) throw new Error(`Application ${applicationId} not found`);
+    if (!state.batches?.length) throw new Error("No batches available");
+    const batchFieldIds = state.batches[state.currentBatchIndex];
+    const batchFields = getActiveApplicationFields(state).filter((f) => batchFieldIds.includes(f.id));
+    const filledCount = state.fields.filter((f) => f.value).length;
+    const { text, usage } = await generateBatchEmail(
+      batchFields,
+      state.currentBatchIndex,
+      state.batches.length,
+      {
+        appTitle: state.title,
+        totalFieldCount: state.fields.length,
+        filledFieldCount: filledCount,
+        companyName: opts?.companyName,
+        previousBatchSummary: opts?.previousBatchSummary
+      },
+      generateText,
+      providerOptions,
+      resolveBudget("application_email", 2048).maxTokens
+    );
+    trackUsage(usage);
+    const emailReview = reviewBatchEmail(text, batchFields);
+    state.qualityReport = {
+      ...buildApplicationQualityReport(state),
+      emailReview
+    };
+    await applicationStore?.save(state);
+    return { text, tokenUsage: totalUsage };
+  }
+  async function getConfirmationSummary(applicationId) {
+    totalUsage = { inputTokens: 0, outputTokens: 0 };
+    const state = await applicationStore?.get(applicationId);
+    if (!state) throw new Error(`Application ${applicationId} not found`);
+    const filledFields = state.fields.filter((f) => f.value);
+    const fieldSummary = filledFields.map((f) => `${f.section} > ${f.label}: ${f.value} (source: ${f.source ?? "unknown"})`).join("\n");
+    const budget = resolveBudget("application_email", 4096);
+    const { text, usage } = await generateText({
+      prompt: `Format these filled insurance application fields as a clean confirmation summary for the user to review. Group by section, show each field as "Label: Value". End with a note asking them to confirm or request changes.
+
+Application: ${state.title ?? "Insurance Application"}
+
+Fields:
+${fieldSummary}`,
+      maxTokens: budget.maxTokens,
+      taskKind: "application_email",
+      budgetDiagnostics: budget,
+      providerOptions
+    });
+    trackUsage(usage);
+    return { text, tokenUsage: totalUsage };
+  }
+  async function createApplicationRun2(input) {
+    const state = createApplicationRun(input);
+    await applicationStore?.save(state);
+    return state;
+  }
+  async function planNextQuestions(applicationId, limit2) {
+    const state = await applicationStore?.get(applicationId);
+    if (!state) throw new Error(`Application ${applicationId} not found`);
+    return planNextApplicationQuestions(state, limit2);
+  }
+  async function proposeContextWrites2(applicationId) {
+    const state = await applicationStore?.get(applicationId);
+    if (!state) throw new Error(`Application ${applicationId} not found`);
+    const proposals = proposeContextWrites(state);
+    await applicationStore?.save({
+      ...state,
+      contextProposals: proposals,
+      updatedAt: Date.now()
+    });
+    return { proposals };
+  }
+  async function buildApplicationPacket2(input) {
+    const state = await applicationStore?.get(input.applicationId);
+    if (!state) throw new Error(`Application ${input.applicationId} not found`);
+    const packet = buildApplicationPacket(state, {
+      submissionNotes: input.submissionNotes,
+      now: input.now
+    });
+    const reviewReport = validateApplicationPacket(packet);
+    await applicationStore?.save({
+      ...state,
+      packet: { ...packet, qualityReport: reviewReport },
+      status: reviewReport.qualityGateStatus === "failed" ? "broker_review" : "packet_ready",
+      qualityReport: reviewReport,
+      updatedAt: Date.now()
+    });
+    return { packet: { ...packet, qualityReport: reviewReport }, reviewReport };
+  }
+  return {
+    processApplication,
+    processReply,
+    generateCurrentBatchEmail,
+    getConfirmationSummary,
+    createApplicationRun: createApplicationRun2,
+    planNextQuestions,
+    proposeContextWrites: proposeContextWrites2,
+    buildApplicationPacket: buildApplicationPacket2
+  };
+}
+function selectMemoryBackfillMatch(field, chunks) {
+  for (const chunk of chunks) {
+    const value = chunk.metadata.value ?? chunk.metadata.answer ?? chunk.metadata.fieldValue;
+    if (!value) continue;
+    const metadataFieldId = chunk.metadata.fieldId ?? chunk.metadata.applicationFieldId;
+    const metadataLabel = chunk.metadata.fieldLabel?.toLowerCase();
+    const labelMatches = metadataLabel === field.label.toLowerCase();
+    if (metadataFieldId && metadataFieldId !== field.id && !labelMatches) continue;
+    return {
+      value,
+      source: chunk.metadata.source ?? `memory: ${chunk.documentId}`,
+      confidence: metadataFieldId === field.id || labelMatches ? "high" : "medium",
+      sourceSpanIds: parseSourceSpanIds(chunk.metadata.sourceSpanIds)
+    };
+  }
+  return null;
+}
+function parseSourceSpanIds(value) {
+  if (!value) return [];
+  const trimmed = value.trim();
+  if (!trimmed) return [];
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+    } catch {
+      return [];
+    }
+  }
+  return trimmed.split(",").map((item) => item.trim()).filter(Boolean);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AcroFormMappingSchema,
+  AnswerParsingResultSchema,
+  ApplicationClassifyResultSchema,
+  ApplicationContextProposalSchema,
+  ApplicationEmailReviewSchema,
+  ApplicationFieldSchema,
+  ApplicationPacketAnswerSchema,
+  ApplicationPacketSchema,
+  ApplicationQualityArtifactSchema,
+  ApplicationQualityIssueSchema,
+  ApplicationQualityReportSchema,
+  ApplicationQualityRoundSchema,
+  ApplicationQuestionConditionSchema,
+  ApplicationQuestionGraphSchema,
+  ApplicationQuestionNodeSchema,
+  ApplicationRepeatSchema,
+  ApplicationStateSchema,
+  ApplicationTemplateSchema,
+  AutoFillMatchSchema,
+  AutoFillResultSchema,
+  FieldExtractionResultSchema,
+  FieldTypeSchema,
+  FlatPdfPlacementSchema,
+  LookupFillResultSchema,
+  LookupFillSchema,
+  LookupRequestSchema,
+  ParsedAnswerSchema,
+  QuestionBatchResultSchema,
+  ReplyIntentSchema,
+  applyApplicationAnswers,
+  buildApplicationPacket,
+  buildQuestionGraphFromFields,
+  createApplicationPipeline,
+  createApplicationRun,
+  extractQuestionGraphFromFields,
+  flattenQuestionGraph,
+  getActiveApplicationFields,
+  getNextApplicationQuestions,
+  normalizeApplicationQuestionGraph,
+  planNextApplicationQuestions,
+  proposeContextWrites,
+  validateApplicationPacket
+});
+//# sourceMappingURL=application.js.map