@claritylabs/cl-sdk 0.7.1 → 0.7.3

package/dist/index.js

@@ -234,6 +234,7 @@ __export(index_exports, {
   safeGenerateObject: () => safeGenerateObject,
   sanitizeNulls: () => sanitizeNulls,
   stripFences: () => stripFences,
+  toStrictSchema: () => toStrictSchema,
   withRetry: () => withRetry
 });
 module.exports = __toCommonJS(index_exports);
@@ -241,16 +242,22 @@ module.exports = __toCommonJS(index_exports);
 // src/core/retry.ts
 var MAX_RETRIES = 5;
 var BASE_DELAY_MS = 2e3;
-function isRateLimitError(error) {
+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) return true;
+    if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504) return true;
   }
   return false;
 }
@@ -259,12 +266,12 @@ async function withRetry(fn, log) {
     try {
       return await fn();
     } catch (error) {
-      if (!isRateLimitError(error) || attempt >= MAX_RETRIES) {
+      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?.(`Rate limited, retrying in ${(delay / 1e3).toFixed(1)}s (attempt ${attempt + 1}/${MAX_RETRIES})...`);
+      await log?.(`Retryable error, retrying in ${(delay / 1e3).toFixed(1)}s (attempt ${attempt + 1}/${MAX_RETRIES})...`);
       await new Promise((resolve) => setTimeout(resolve, delay));
     }
   }
@@ -311,14 +318,59 @@ function sanitizeNulls(obj) {
   return obj;
 }
 
+// src/core/strict-schema.ts
+var import_zod = require("zod");
+function toStrictSchema(schema) {
+  const def = schema._zod?.def;
+  const typeName = def?.type ?? schema.type;
+  if (typeName === "object") {
+    const shape = schema.shape;
+    if (!shape) return schema;
+    const newShape = {};
+    for (const [key, value] of Object.entries(shape)) {
+      const field = value;
+      const fieldDef = field._zod?.def;
+      const fieldType = fieldDef?.type ?? field.type;
+      if (fieldType === "optional") {
+        const innerType = fieldDef?.innerType;
+        if (innerType) {
+          const transformed = toStrictSchema(innerType);
+          newShape[key] = import_zod.z.nullable(transformed);
+        } else {
+          newShape[key] = import_zod.z.nullable(field);
+        }
+      } else {
+        newShape[key] = toStrictSchema(field);
+      }
+    }
+    return import_zod.z.object(newShape);
+  }
+  if (typeName === "array") {
+    const element = def?.element ?? schema.element;
+    if (element) {
+      return import_zod.z.array(toStrictSchema(element));
+    }
+    return schema;
+  }
+  if (typeName === "nullable") {
+    const innerType = def?.innerType;
+    if (innerType) {
+      return import_zod.z.nullable(toStrictSchema(innerType));
+    }
+    return schema;
+  }
+  return schema;
+}
+
 // src/core/safe-generate.ts
 async function safeGenerateObject(generateObject, params, options) {
   const maxRetries = options?.maxRetries ?? 1;
   let lastError;
+  const strictParams = { ...params, schema: toStrictSchema(params.schema) };
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
       const result = await withRetry(
-        () => generateObject(params),
+        () => generateObject(strictParams),
         options?.log
       );
       return result;
@@ -375,8 +427,8 @@ function createPipelineContext(opts) {
 }
 
 // src/schemas/enums.ts
-var import_zod = require("zod");
-var PolicyTypeSchema = import_zod.z.enum([
+var import_zod2 = require("zod");
+var PolicyTypeSchema = import_zod2.z.enum([
   // Commercial lines
   "general_liability",
   "commercial_property",
@@ -423,7 +475,7 @@ var PolicyTypeSchema = import_zod.z.enum([
   "other"
 ]);
 var POLICY_TYPES = PolicyTypeSchema.options;
-var EndorsementTypeSchema = import_zod.z.enum([
+var EndorsementTypeSchema = import_zod2.z.enum([
   "additional_insured",
   "waiver_of_subrogation",
   "primary_noncontributory",
@@ -444,7 +496,7 @@ var EndorsementTypeSchema = import_zod.z.enum([
   "other"
 ]);
 var ENDORSEMENT_TYPES = EndorsementTypeSchema.options;
-var ConditionTypeSchema = import_zod.z.enum([
+var ConditionTypeSchema = import_zod2.z.enum([
   "duties_after_loss",
   "notice_requirements",
   "other_insurance",
@@ -464,7 +516,7 @@ var ConditionTypeSchema = import_zod.z.enum([
   "other"
 ]);
 var CONDITION_TYPES = ConditionTypeSchema.options;
-var PolicySectionTypeSchema = import_zod.z.enum([
+var PolicySectionTypeSchema = import_zod2.z.enum([
   "declarations",
   "insuring_agreement",
   "policy_form",
@@ -479,7 +531,7 @@ var PolicySectionTypeSchema = import_zod.z.enum([
   "other"
 ]);
 var POLICY_SECTION_TYPES = PolicySectionTypeSchema.options;
-var QuoteSectionTypeSchema = import_zod.z.enum([
+var QuoteSectionTypeSchema = import_zod2.z.enum([
   "terms_summary",
   "premium_indication",
   "underwriting_condition",
@@ -489,13 +541,13 @@ var QuoteSectionTypeSchema = import_zod.z.enum([
   "other"
 ]);
 var QUOTE_SECTION_TYPES = QuoteSectionTypeSchema.options;
-var CoverageFormSchema = import_zod.z.enum(["occurrence", "claims_made", "accident"]);
+var CoverageFormSchema = import_zod2.z.enum(["occurrence", "claims_made", "accident"]);
 var COVERAGE_FORMS = CoverageFormSchema.options;
-var PolicyTermTypeSchema = import_zod.z.enum(["fixed", "continuous"]);
+var PolicyTermTypeSchema = import_zod2.z.enum(["fixed", "continuous"]);
 var POLICY_TERM_TYPES = PolicyTermTypeSchema.options;
-var CoverageTriggerSchema = import_zod.z.enum(["occurrence", "claims_made", "accident"]);
+var CoverageTriggerSchema = import_zod2.z.enum(["occurrence", "claims_made", "accident"]);
 var COVERAGE_TRIGGERS = CoverageTriggerSchema.options;
-var LimitTypeSchema = import_zod.z.enum([
+var LimitTypeSchema = import_zod2.z.enum([
   "per_occurrence",
   "per_claim",
   "aggregate",
@@ -506,7 +558,7 @@ var LimitTypeSchema = import_zod.z.enum([
   "scheduled"
 ]);
 var LIMIT_TYPES = LimitTypeSchema.options;
-var DeductibleTypeSchema = import_zod.z.enum([
+var DeductibleTypeSchema = import_zod2.z.enum([
   "per_occurrence",
   "per_claim",
   "aggregate",
@@ -514,16 +566,16 @@ var DeductibleTypeSchema = import_zod.z.enum([
   "waiting_period"
 ]);
 var DEDUCTIBLE_TYPES = DeductibleTypeSchema.options;
-var ValuationMethodSchema = import_zod.z.enum([
+var ValuationMethodSchema = import_zod2.z.enum([
   "replacement_cost",
   "actual_cash_value",
   "agreed_value",
   "functional_replacement"
 ]);
 var VALUATION_METHODS = ValuationMethodSchema.options;
-var DefenseCostTreatmentSchema = import_zod.z.enum(["inside_limits", "outside_limits", "supplementary"]);
+var DefenseCostTreatmentSchema = import_zod2.z.enum(["inside_limits", "outside_limits", "supplementary"]);
 var DEFENSE_COST_TREATMENTS = DefenseCostTreatmentSchema.options;
-var EntityTypeSchema = import_zod.z.enum([
+var EntityTypeSchema = import_zod2.z.enum([
   "corporation",
   "llc",
   "partnership",
@@ -537,9 +589,9 @@ var EntityTypeSchema = import_zod.z.enum([
   "other"
 ]);
 var ENTITY_TYPES = EntityTypeSchema.options;
-var AdmittedStatusSchema = import_zod.z.enum(["admitted", "non_admitted", "surplus_lines"]);
+var AdmittedStatusSchema = import_zod2.z.enum(["admitted", "non_admitted", "surplus_lines"]);
 var ADMITTED_STATUSES = AdmittedStatusSchema.options;
-var AuditTypeSchema = import_zod.z.enum([
+var AuditTypeSchema = import_zod2.z.enum([
   "annual",
   "semi_annual",
   "quarterly",
@@ -549,7 +601,7 @@ var AuditTypeSchema = import_zod.z.enum([
   "none"
 ]);
 var AUDIT_TYPES = AuditTypeSchema.options;
-var EndorsementPartyRoleSchema = import_zod.z.enum([
+var EndorsementPartyRoleSchema = import_zod2.z.enum([
   "additional_insured",
   "loss_payee",
   "mortgage_holder",
@@ -558,13 +610,13 @@ var EndorsementPartyRoleSchema = import_zod.z.enum([
   "other"
 ]);
 var ENDORSEMENT_PARTY_ROLES = EndorsementPartyRoleSchema.options;
-var ClaimStatusSchema = import_zod.z.enum(["open", "closed", "reopened"]);
+var ClaimStatusSchema = import_zod2.z.enum(["open", "closed", "reopened"]);
 var CLAIM_STATUSES = ClaimStatusSchema.options;
-var SubjectivityCategorySchema = import_zod.z.enum(["pre_binding", "post_binding", "information"]);
+var SubjectivityCategorySchema = import_zod2.z.enum(["pre_binding", "post_binding", "information"]);
 var SUBJECTIVITY_CATEGORIES = SubjectivityCategorySchema.options;
-var DocumentTypeSchema = import_zod.z.enum(["policy", "quote", "binder", "endorsement", "certificate"]);
+var DocumentTypeSchema = import_zod2.z.enum(["policy", "quote", "binder", "endorsement", "certificate"]);
 var DOCUMENT_TYPES = DocumentTypeSchema.options;
-var ChunkTypeSchema = import_zod.z.enum([
+var ChunkTypeSchema = import_zod2.z.enum([
   "declarations",
   "coverage_form",
   "endorsement",
@@ -573,7 +625,7 @@ var ChunkTypeSchema = import_zod.z.enum([
   "mixed"
 ]);
 var CHUNK_TYPES = ChunkTypeSchema.options;
-var RatingBasisTypeSchema = import_zod.z.enum([
+var RatingBasisTypeSchema = import_zod2.z.enum([
   "payroll",
   "revenue",
   "area",
@@ -587,7 +639,7 @@ var RatingBasisTypeSchema = import_zod.z.enum([
   "other"
 ]);
 var RATING_BASIS_TYPES = RatingBasisTypeSchema.options;
-var VehicleCoverageTypeSchema = import_zod.z.enum([
+var VehicleCoverageTypeSchema = import_zod2.z.enum([
   "liability",
   "collision",
   "comprehensive",
@@ -600,32 +652,32 @@ var VehicleCoverageTypeSchema = import_zod.z.enum([
   "physical_damage"
 ]);
 var VEHICLE_COVERAGE_TYPES = VehicleCoverageTypeSchema.options;
-var HomeownersFormTypeSchema = import_zod.z.enum(["HO-3", "HO-5", "HO-4", "HO-6", "HO-7", "HO-8"]);
+var HomeownersFormTypeSchema = import_zod2.z.enum(["HO-3", "HO-5", "HO-4", "HO-6", "HO-7", "HO-8"]);
 var HOMEOWNERS_FORM_TYPES = HomeownersFormTypeSchema.options;
-var DwellingFireFormTypeSchema = import_zod.z.enum(["DP-1", "DP-2", "DP-3"]);
+var DwellingFireFormTypeSchema = import_zod2.z.enum(["DP-1", "DP-2", "DP-3"]);
 var DWELLING_FIRE_FORM_TYPES = DwellingFireFormTypeSchema.options;
-var FloodZoneSchema = import_zod.z.enum(["A", "AE", "AH", "AO", "AR", "V", "VE", "B", "C", "X", "D"]);
+var FloodZoneSchema = import_zod2.z.enum(["A", "AE", "AH", "AO", "AR", "V", "VE", "B", "C", "X", "D"]);
 var FLOOD_ZONES = FloodZoneSchema.options;
-var ConstructionTypeSchema = import_zod.z.enum(["frame", "masonry", "superior", "mixed", "other"]);
+var ConstructionTypeSchema = import_zod2.z.enum(["frame", "masonry", "superior", "mixed", "other"]);
 var CONSTRUCTION_TYPES = ConstructionTypeSchema.options;
-var RoofTypeSchema = import_zod.z.enum(["asphalt_shingle", "tile", "metal", "slate", "flat", "wood_shake", "other"]);
+var RoofTypeSchema = import_zod2.z.enum(["asphalt_shingle", "tile", "metal", "slate", "flat", "wood_shake", "other"]);
 var ROOF_TYPES = RoofTypeSchema.options;
-var FoundationTypeSchema = import_zod.z.enum(["basement", "crawl_space", "slab", "pier", "other"]);
+var FoundationTypeSchema = import_zod2.z.enum(["basement", "crawl_space", "slab", "pier", "other"]);
 var FOUNDATION_TYPES = FoundationTypeSchema.options;
-var PersonalAutoUsageSchema = import_zod.z.enum(["pleasure", "commute", "business", "farm"]);
+var PersonalAutoUsageSchema = import_zod2.z.enum(["pleasure", "commute", "business", "farm"]);
 var PERSONAL_AUTO_USAGES = PersonalAutoUsageSchema.options;
-var LossSettlementSchema = import_zod.z.enum([
+var LossSettlementSchema = import_zod2.z.enum([
   "replacement_cost",
   "actual_cash_value",
   "extended_replacement_cost",
   "guaranteed_replacement_cost"
 ]);
 var LOSS_SETTLEMENTS = LossSettlementSchema.options;
-var BoatTypeSchema = import_zod.z.enum(["sailboat", "powerboat", "pontoon", "jet_ski", "kayak_canoe", "yacht", "other"]);
+var BoatTypeSchema = import_zod2.z.enum(["sailboat", "powerboat", "pontoon", "jet_ski", "kayak_canoe", "yacht", "other"]);
 var BOAT_TYPES = BoatTypeSchema.options;
-var RVTypeSchema = import_zod.z.enum(["rv_motorhome", "travel_trailer", "atv", "snowmobile", "golf_cart", "dirt_bike", "other"]);
+var RVTypeSchema = import_zod2.z.enum(["rv_motorhome", "travel_trailer", "atv", "snowmobile", "golf_cart", "dirt_bike", "other"]);
 var RV_TYPES = RVTypeSchema.options;
-var ScheduledItemCategorySchema = import_zod.z.enum([
+var ScheduledItemCategorySchema = import_zod2.z.enum([
   "jewelry",
   "fine_art",
   "musical_instruments",
@@ -638,691 +690,691 @@ var ScheduledItemCategorySchema = import_zod.z.enum([
   "other"
 ]);
 var SCHEDULED_ITEM_CATEGORIES = ScheduledItemCategorySchema.options;
-var TitlePolicyTypeSchema = import_zod.z.enum(["owners", "lenders"]);
+var TitlePolicyTypeSchema = import_zod2.z.enum(["owners", "lenders"]);
 var TITLE_POLICY_TYPES = TitlePolicyTypeSchema.options;
-var PetSpeciesSchema = import_zod.z.enum(["dog", "cat", "other"]);
+var PetSpeciesSchema = import_zod2.z.enum(["dog", "cat", "other"]);
 var PET_SPECIES = PetSpeciesSchema.options;
 
 // src/schemas/shared.ts
-var import_zod2 = require("zod");
-var AddressSchema = import_zod2.z.object({
-  street1: import_zod2.z.string(),
-  street2: import_zod2.z.string().optional(),
-  city: import_zod2.z.string(),
-  state: import_zod2.z.string(),
-  zip: import_zod2.z.string(),
-  country: import_zod2.z.string().optional()
+var import_zod3 = require("zod");
+var AddressSchema = import_zod3.z.object({
+  street1: import_zod3.z.string(),
+  street2: import_zod3.z.string().optional(),
+  city: import_zod3.z.string(),
+  state: import_zod3.z.string(),
+  zip: import_zod3.z.string(),
+  country: import_zod3.z.string().optional()
 });
-var ContactSchema = import_zod2.z.object({
-  name: import_zod2.z.string().optional(),
-  title: import_zod2.z.string().optional(),
-  type: import_zod2.z.string().optional(),
-  phone: import_zod2.z.string().optional(),
-  fax: import_zod2.z.string().optional(),
-  email: import_zod2.z.string().optional(),
+var ContactSchema = import_zod3.z.object({
+  name: import_zod3.z.string().optional(),
+  title: import_zod3.z.string().optional(),
+  type: import_zod3.z.string().optional(),
+  phone: import_zod3.z.string().optional(),
+  fax: import_zod3.z.string().optional(),
+  email: import_zod3.z.string().optional(),
   address: AddressSchema.optional(),
-  hours: import_zod2.z.string().optional()
+  hours: import_zod3.z.string().optional()
 });
-var FormReferenceSchema = import_zod2.z.object({
-  formNumber: import_zod2.z.string(),
-  editionDate: import_zod2.z.string().optional(),
-  title: import_zod2.z.string().optional(),
-  formType: import_zod2.z.enum(["coverage", "endorsement", "declarations", "application", "notice", "other"])
+var FormReferenceSchema = import_zod3.z.object({
+  formNumber: import_zod3.z.string(),
+  editionDate: import_zod3.z.string().optional(),
+  title: import_zod3.z.string().optional(),
+  formType: import_zod3.z.enum(["coverage", "endorsement", "declarations", "application", "notice", "other"])
 });
-var TaxFeeItemSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  amount: import_zod2.z.string(),
-  type: import_zod2.z.enum(["tax", "fee", "surcharge", "assessment"]).optional(),
-  description: import_zod2.z.string().optional()
+var TaxFeeItemSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  amount: import_zod3.z.string(),
+  type: import_zod3.z.enum(["tax", "fee", "surcharge", "assessment"]).optional(),
+  description: import_zod3.z.string().optional()
 });
-var RatingBasisSchema = import_zod2.z.object({
+var RatingBasisSchema = import_zod3.z.object({
   type: RatingBasisTypeSchema,
-  amount: import_zod2.z.string().optional(),
-  description: import_zod2.z.string().optional()
+  amount: import_zod3.z.string().optional(),
+  description: import_zod3.z.string().optional()
 });
-var SublimitSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  limit: import_zod2.z.string(),
-  appliesTo: import_zod2.z.string().optional(),
-  deductible: import_zod2.z.string().optional()
+var SublimitSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  limit: import_zod3.z.string(),
+  appliesTo: import_zod3.z.string().optional(),
+  deductible: import_zod3.z.string().optional()
 });
-var SharedLimitSchema = import_zod2.z.object({
-  description: import_zod2.z.string(),
-  limit: import_zod2.z.string(),
-  coverageParts: import_zod2.z.array(import_zod2.z.string())
+var SharedLimitSchema = import_zod3.z.object({
+  description: import_zod3.z.string(),
+  limit: import_zod3.z.string(),
+  coverageParts: import_zod3.z.array(import_zod3.z.string())
 });
-var ExtendedReportingPeriodSchema = import_zod2.z.object({
-  basicDays: import_zod2.z.number().optional(),
-  supplementalYears: import_zod2.z.number().optional(),
-  supplementalPremium: import_zod2.z.string().optional()
+var ExtendedReportingPeriodSchema = import_zod3.z.object({
+  basicDays: import_zod3.z.number().optional(),
+  supplementalYears: import_zod3.z.number().optional(),
+  supplementalPremium: import_zod3.z.string().optional()
 });
-var NamedInsuredSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  relationship: import_zod2.z.string().optional(),
+var NamedInsuredSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  relationship: import_zod3.z.string().optional(),
   address: AddressSchema.optional()
 });
 
 // src/schemas/coverage.ts
-var import_zod3 = require("zod");
-var CoverageSchema = import_zod3.z.object({
-  name: import_zod3.z.string(),
-  limit: import_zod3.z.string(),
-  deductible: import_zod3.z.string().optional(),
-  pageNumber: import_zod3.z.number().optional(),
-  sectionRef: import_zod3.z.string().optional()
+var import_zod4 = require("zod");
+var CoverageSchema = import_zod4.z.object({
+  name: import_zod4.z.string(),
+  limit: import_zod4.z.string(),
+  deductible: import_zod4.z.string().optional(),
+  pageNumber: import_zod4.z.number().optional(),
+  sectionRef: import_zod4.z.string().optional()
 });
-var EnrichedCoverageSchema = import_zod3.z.object({
-  name: import_zod3.z.string(),
-  coverageCode: import_zod3.z.string().optional(),
-  formNumber: import_zod3.z.string().optional(),
-  formEditionDate: import_zod3.z.string().optional(),
-  limit: import_zod3.z.string(),
+var EnrichedCoverageSchema = import_zod4.z.object({
+  name: import_zod4.z.string(),
+  coverageCode: import_zod4.z.string().optional(),
+  formNumber: import_zod4.z.string().optional(),
+  formEditionDate: import_zod4.z.string().optional(),
+  limit: import_zod4.z.string(),
   limitType: LimitTypeSchema.optional(),
-  deductible: import_zod3.z.string().optional(),
+  deductible: import_zod4.z.string().optional(),
   deductibleType: DeductibleTypeSchema.optional(),
-  sir: import_zod3.z.string().optional(),
-  sublimit: import_zod3.z.string().optional(),
-  coinsurance: import_zod3.z.string().optional(),
+  sir: import_zod4.z.string().optional(),
+  sublimit: import_zod4.z.string().optional(),
+  coinsurance: import_zod4.z.string().optional(),
   valuation: ValuationMethodSchema.optional(),
-  territory: import_zod3.z.string().optional(),
+  territory: import_zod4.z.string().optional(),
   trigger: CoverageTriggerSchema.optional(),
-  retroactiveDate: import_zod3.z.string().optional(),
-  included: import_zod3.z.boolean(),
-  premium: import_zod3.z.string().optional(),
-  pageNumber: import_zod3.z.number().optional(),
-  sectionRef: import_zod3.z.string().optional()
+  retroactiveDate: import_zod4.z.string().optional(),
+  included: import_zod4.z.boolean(),
+  premium: import_zod4.z.string().optional(),
+  pageNumber: import_zod4.z.number().optional(),
+  sectionRef: import_zod4.z.string().optional()
 });
 
 // src/schemas/endorsement.ts
-var import_zod4 = require("zod");
-var EndorsementPartySchema = import_zod4.z.object({
-  name: import_zod4.z.string(),
+var import_zod5 = require("zod");
+var EndorsementPartySchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
   role: EndorsementPartyRoleSchema,
   address: AddressSchema.optional(),
-  relationship: import_zod4.z.string().optional(),
-  scope: import_zod4.z.string().optional()
+  relationship: import_zod5.z.string().optional(),
+  scope: import_zod5.z.string().optional()
 });
-var EndorsementSchema = import_zod4.z.object({
-  formNumber: import_zod4.z.string(),
-  editionDate: import_zod4.z.string().optional(),
-  title: import_zod4.z.string(),
+var EndorsementSchema = import_zod5.z.object({
+  formNumber: import_zod5.z.string(),
+  editionDate: import_zod5.z.string().optional(),
+  title: import_zod5.z.string(),
   endorsementType: EndorsementTypeSchema,
-  effectiveDate: import_zod4.z.string().optional(),
-  affectedCoverageParts: import_zod4.z.array(import_zod4.z.string()).optional(),
-  namedParties: import_zod4.z.array(EndorsementPartySchema).optional(),
-  keyTerms: import_zod4.z.array(import_zod4.z.string()).optional(),
-  premiumImpact: import_zod4.z.string().optional(),
-  content: import_zod4.z.string(),
-  pageStart: import_zod4.z.number(),
-  pageEnd: import_zod4.z.number().optional()
+  effectiveDate: import_zod5.z.string().optional(),
+  affectedCoverageParts: import_zod5.z.array(import_zod5.z.string()).optional(),
+  namedParties: import_zod5.z.array(EndorsementPartySchema).optional(),
+  keyTerms: import_zod5.z.array(import_zod5.z.string()).optional(),
+  premiumImpact: import_zod5.z.string().optional(),
+  content: import_zod5.z.string(),
+  pageStart: import_zod5.z.number(),
+  pageEnd: import_zod5.z.number().optional()
 });
 
 // src/schemas/exclusion.ts
-var import_zod5 = require("zod");
-var ExclusionSchema = import_zod5.z.object({
-  name: import_zod5.z.string(),
-  formNumber: import_zod5.z.string().optional(),
-  excludedPerils: import_zod5.z.array(import_zod5.z.string()).optional(),
-  isAbsolute: import_zod5.z.boolean().optional(),
-  exceptions: import_zod5.z.array(import_zod5.z.string()).optional(),
-  buybackAvailable: import_zod5.z.boolean().optional(),
-  buybackEndorsement: import_zod5.z.string().optional(),
-  appliesTo: import_zod5.z.array(import_zod5.z.string()).optional(),
-  content: import_zod5.z.string(),
-  pageNumber: import_zod5.z.number().optional()
+var import_zod6 = require("zod");
+var ExclusionSchema = import_zod6.z.object({
+  name: import_zod6.z.string(),
+  formNumber: import_zod6.z.string().optional(),
+  excludedPerils: import_zod6.z.array(import_zod6.z.string()).optional(),
+  isAbsolute: import_zod6.z.boolean().optional(),
+  exceptions: import_zod6.z.array(import_zod6.z.string()).optional(),
+  buybackAvailable: import_zod6.z.boolean().optional(),
+  buybackEndorsement: import_zod6.z.string().optional(),
+  appliesTo: import_zod6.z.array(import_zod6.z.string()).optional(),
+  content: import_zod6.z.string(),
+  pageNumber: import_zod6.z.number().optional()
 });
 
 // src/schemas/condition.ts
-var import_zod6 = require("zod");
-var ConditionKeyValueSchema = import_zod6.z.object({
-  key: import_zod6.z.string(),
-  value: import_zod6.z.string()
+var import_zod7 = require("zod");
+var ConditionKeyValueSchema = import_zod7.z.object({
+  key: import_zod7.z.string(),
+  value: import_zod7.z.string()
 });
-var PolicyConditionSchema = import_zod6.z.object({
-  name: import_zod6.z.string(),
+var PolicyConditionSchema = import_zod7.z.object({
+  name: import_zod7.z.string(),
   conditionType: ConditionTypeSchema,
-  content: import_zod6.z.string(),
-  keyValues: import_zod6.z.array(ConditionKeyValueSchema).optional(),
-  pageNumber: import_zod6.z.number().optional()
+  content: import_zod7.z.string(),
+  keyValues: import_zod7.z.array(ConditionKeyValueSchema).optional(),
+  pageNumber: import_zod7.z.number().optional()
 });
 
 // src/schemas/parties.ts
-var import_zod7 = require("zod");
-var InsurerInfoSchema = import_zod7.z.object({
-  legalName: import_zod7.z.string(),
-  naicNumber: import_zod7.z.string().optional(),
-  amBestRating: import_zod7.z.string().optional(),
-  amBestNumber: import_zod7.z.string().optional(),
+var import_zod8 = require("zod");
+var InsurerInfoSchema = import_zod8.z.object({
+  legalName: import_zod8.z.string(),
+  naicNumber: import_zod8.z.string().optional(),
+  amBestRating: import_zod8.z.string().optional(),
+  amBestNumber: import_zod8.z.string().optional(),
   admittedStatus: AdmittedStatusSchema.optional(),
-  stateOfDomicile: import_zod7.z.string().optional()
+  stateOfDomicile: import_zod8.z.string().optional()
 });
-var ProducerInfoSchema = import_zod7.z.object({
-  agencyName: import_zod7.z.string(),
-  contactName: import_zod7.z.string().optional(),
-  licenseNumber: import_zod7.z.string().optional(),
-  phone: import_zod7.z.string().optional(),
-  email: import_zod7.z.string().optional(),
+var ProducerInfoSchema = import_zod8.z.object({
+  agencyName: import_zod8.z.string(),
+  contactName: import_zod8.z.string().optional(),
+  licenseNumber: import_zod8.z.string().optional(),
+  phone: import_zod8.z.string().optional(),
+  email: import_zod8.z.string().optional(),
   address: AddressSchema.optional()
 });
 
 // src/schemas/financial.ts
-var import_zod8 = require("zod");
-var PaymentInstallmentSchema = import_zod8.z.object({
-  dueDate: import_zod8.z.string(),
-  amount: import_zod8.z.string(),
-  description: import_zod8.z.string().optional()
+var import_zod9 = require("zod");
+var PaymentInstallmentSchema = import_zod9.z.object({
+  dueDate: import_zod9.z.string(),
+  amount: import_zod9.z.string(),
+  description: import_zod9.z.string().optional()
 });
-var PaymentPlanSchema = import_zod8.z.object({
-  installments: import_zod8.z.array(PaymentInstallmentSchema),
-  financeCharge: import_zod8.z.string().optional()
+var PaymentPlanSchema = import_zod9.z.object({
+  installments: import_zod9.z.array(PaymentInstallmentSchema),
+  financeCharge: import_zod9.z.string().optional()
 });
-var LocationPremiumSchema = import_zod8.z.object({
-  locationNumber: import_zod8.z.number(),
-  premium: import_zod8.z.string(),
-  description: import_zod8.z.string().optional()
+var LocationPremiumSchema = import_zod9.z.object({
+  locationNumber: import_zod9.z.number(),
+  premium: import_zod9.z.string(),
+  description: import_zod9.z.string().optional()
 });
 
 // src/schemas/loss-history.ts
-var import_zod9 = require("zod");
-var ClaimRecordSchema = import_zod9.z.object({
-  dateOfLoss: import_zod9.z.string(),
-  claimNumber: import_zod9.z.string().optional(),
-  description: import_zod9.z.string(),
+var import_zod10 = require("zod");
+var ClaimRecordSchema = import_zod10.z.object({
+  dateOfLoss: import_zod10.z.string(),
+  claimNumber: import_zod10.z.string().optional(),
+  description: import_zod10.z.string(),
   status: ClaimStatusSchema,
-  paid: import_zod9.z.string().optional(),
-  reserved: import_zod9.z.string().optional(),
-  incurred: import_zod9.z.string().optional(),
-  claimant: import_zod9.z.string().optional(),
-  coverageLine: import_zod9.z.string().optional()
+  paid: import_zod10.z.string().optional(),
+  reserved: import_zod10.z.string().optional(),
+  incurred: import_zod10.z.string().optional(),
+  claimant: import_zod10.z.string().optional(),
+  coverageLine: import_zod10.z.string().optional()
 });
-var LossSummarySchema = import_zod9.z.object({
-  period: import_zod9.z.string().optional(),
-  totalClaims: import_zod9.z.number().optional(),
-  totalIncurred: import_zod9.z.string().optional(),
-  totalPaid: import_zod9.z.string().optional(),
-  totalReserved: import_zod9.z.string().optional(),
-  lossRatio: import_zod9.z.string().optional()
+var LossSummarySchema = import_zod10.z.object({
+  period: import_zod10.z.string().optional(),
+  totalClaims: import_zod10.z.number().optional(),
+  totalIncurred: import_zod10.z.string().optional(),
+  totalPaid: import_zod10.z.string().optional(),
+  totalReserved: import_zod10.z.string().optional(),
+  lossRatio: import_zod10.z.string().optional()
 });
-var ExperienceModSchema = import_zod9.z.object({
-  factor: import_zod9.z.number(),
-  effectiveDate: import_zod9.z.string().optional(),
-  state: import_zod9.z.string().optional()
+var ExperienceModSchema = import_zod10.z.object({
+  factor: import_zod10.z.number(),
+  effectiveDate: import_zod10.z.string().optional(),
+  state: import_zod10.z.string().optional()
 });
 
 // src/schemas/underwriting.ts
-var import_zod10 = require("zod");
-var EnrichedSubjectivitySchema = import_zod10.z.object({
-  description: import_zod10.z.string(),
+var import_zod11 = require("zod");
+var EnrichedSubjectivitySchema = import_zod11.z.object({
+  description: import_zod11.z.string(),
   category: SubjectivityCategorySchema.optional(),
-  dueDate: import_zod10.z.string().optional(),
-  status: import_zod10.z.enum(["open", "satisfied", "waived"]).optional(),
-  pageNumber: import_zod10.z.number().optional()
+  dueDate: import_zod11.z.string().optional(),
+  status: import_zod11.z.enum(["open", "satisfied", "waived"]).optional(),
+  pageNumber: import_zod11.z.number().optional()
 });
-var EnrichedUnderwritingConditionSchema = import_zod10.z.object({
-  description: import_zod10.z.string(),
-  category: import_zod10.z.string().optional(),
-  pageNumber: import_zod10.z.number().optional()
+var EnrichedUnderwritingConditionSchema = import_zod11.z.object({
+  description: import_zod11.z.string(),
+  category: import_zod11.z.string().optional(),
+  pageNumber: import_zod11.z.number().optional()
 });
-var BindingAuthoritySchema = import_zod10.z.object({
-  authorizedBy: import_zod10.z.string().optional(),
-  method: import_zod10.z.string().optional(),
-  expiration: import_zod10.z.string().optional(),
-  conditions: import_zod10.z.array(import_zod10.z.string()).optional()
+var BindingAuthoritySchema = import_zod11.z.object({
+  authorizedBy: import_zod11.z.string().optional(),
+  method: import_zod11.z.string().optional(),
+  expiration: import_zod11.z.string().optional(),
+  conditions: import_zod11.z.array(import_zod11.z.string()).optional()
 });
 
 // src/schemas/declarations/index.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 
 // src/schemas/declarations/personal.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 
 // src/schemas/declarations/shared.ts
-var import_zod11 = require("zod");
-var EmployersLiabilityLimitsSchema = import_zod11.z.object({
-  eachAccident: import_zod11.z.string(),
-  diseasePolicyLimit: import_zod11.z.string(),
-  diseaseEachEmployee: import_zod11.z.string()
+var import_zod12 = require("zod");
+var EmployersLiabilityLimitsSchema = import_zod12.z.object({
+  eachAccident: import_zod12.z.string(),
+  diseasePolicyLimit: import_zod12.z.string(),
+  diseaseEachEmployee: import_zod12.z.string()
 });
-var LimitScheduleSchema = import_zod11.z.object({
-  perOccurrence: import_zod11.z.string().optional(),
-  generalAggregate: import_zod11.z.string().optional(),
-  productsCompletedOpsAggregate: import_zod11.z.string().optional(),
-  personalAdvertisingInjury: import_zod11.z.string().optional(),
-  eachEmployee: import_zod11.z.string().optional(),
-  fireDamage: import_zod11.z.string().optional(),
-  medicalExpense: import_zod11.z.string().optional(),
-  combinedSingleLimit: import_zod11.z.string().optional(),
-  bodilyInjuryPerPerson: import_zod11.z.string().optional(),
-  bodilyInjuryPerAccident: import_zod11.z.string().optional(),
-  propertyDamage: import_zod11.z.string().optional(),
-  eachOccurrenceUmbrella: import_zod11.z.string().optional(),
-  umbrellaAggregate: import_zod11.z.string().optional(),
-  umbrellaRetention: import_zod11.z.string().optional(),
-  statutory: import_zod11.z.boolean().optional(),
+var LimitScheduleSchema = import_zod12.z.object({
+  perOccurrence: import_zod12.z.string().optional(),
+  generalAggregate: import_zod12.z.string().optional(),
+  productsCompletedOpsAggregate: import_zod12.z.string().optional(),
+  personalAdvertisingInjury: import_zod12.z.string().optional(),
+  eachEmployee: import_zod12.z.string().optional(),
+  fireDamage: import_zod12.z.string().optional(),
+  medicalExpense: import_zod12.z.string().optional(),
+  combinedSingleLimit: import_zod12.z.string().optional(),
+  bodilyInjuryPerPerson: import_zod12.z.string().optional(),
+  bodilyInjuryPerAccident: import_zod12.z.string().optional(),
+  propertyDamage: import_zod12.z.string().optional(),
+  eachOccurrenceUmbrella: import_zod12.z.string().optional(),
+  umbrellaAggregate: import_zod12.z.string().optional(),
+  umbrellaRetention: import_zod12.z.string().optional(),
+  statutory: import_zod12.z.boolean().optional(),
   employersLiability: EmployersLiabilityLimitsSchema.optional(),
-  sublimits: import_zod11.z.array(SublimitSchema).optional(),
-  sharedLimits: import_zod11.z.array(SharedLimitSchema).optional(),
+  sublimits: import_zod12.z.array(SublimitSchema).optional(),
+  sharedLimits: import_zod12.z.array(SharedLimitSchema).optional(),
   defenseCostTreatment: DefenseCostTreatmentSchema.optional()
 });
-var DeductibleScheduleSchema = import_zod11.z.object({
-  perClaim: import_zod11.z.string().optional(),
-  perOccurrence: import_zod11.z.string().optional(),
-  aggregateDeductible: import_zod11.z.string().optional(),
-  selfInsuredRetention: import_zod11.z.string().optional(),
-  corridorDeductible: import_zod11.z.string().optional(),
-  waitingPeriod: import_zod11.z.string().optional(),
-  appliesTo: import_zod11.z.enum(["damages_only", "damages_and_defense", "defense_only"]).optional()
+var DeductibleScheduleSchema = import_zod12.z.object({
+  perClaim: import_zod12.z.string().optional(),
+  perOccurrence: import_zod12.z.string().optional(),
+  aggregateDeductible: import_zod12.z.string().optional(),
+  selfInsuredRetention: import_zod12.z.string().optional(),
+  corridorDeductible: import_zod12.z.string().optional(),
+  waitingPeriod: import_zod12.z.string().optional(),
+  appliesTo: import_zod12.z.enum(["damages_only", "damages_and_defense", "defense_only"]).optional()
 });
-var InsuredLocationSchema = import_zod11.z.object({
-  number: import_zod11.z.number(),
+var InsuredLocationSchema = import_zod12.z.object({
+  number: import_zod12.z.number(),
   address: AddressSchema,
-  description: import_zod11.z.string().optional(),
-  buildingValue: import_zod11.z.string().optional(),
-  contentsValue: import_zod11.z.string().optional(),
-  businessIncomeValue: import_zod11.z.string().optional(),
-  constructionType: import_zod11.z.string().optional(),
-  yearBuilt: import_zod11.z.number().optional(),
-  squareFootage: import_zod11.z.number().optional(),
-  protectionClass: import_zod11.z.string().optional(),
-  sprinklered: import_zod11.z.boolean().optional(),
-  alarmType: import_zod11.z.string().optional(),
-  occupancy: import_zod11.z.string().optional()
+  description: import_zod12.z.string().optional(),
+  buildingValue: import_zod12.z.string().optional(),
+  contentsValue: import_zod12.z.string().optional(),
+  businessIncomeValue: import_zod12.z.string().optional(),
+  constructionType: import_zod12.z.string().optional(),
+  yearBuilt: import_zod12.z.number().optional(),
+  squareFootage: import_zod12.z.number().optional(),
+  protectionClass: import_zod12.z.string().optional(),
+  sprinklered: import_zod12.z.boolean().optional(),
+  alarmType: import_zod12.z.string().optional(),
+  occupancy: import_zod12.z.string().optional()
 });
-var VehicleCoverageSchema = import_zod11.z.object({
+var VehicleCoverageSchema = import_zod12.z.object({
   type: VehicleCoverageTypeSchema,
-  limit: import_zod11.z.string().optional(),
-  deductible: import_zod11.z.string().optional(),
-  included: import_zod11.z.boolean()
+  limit: import_zod12.z.string().optional(),
+  deductible: import_zod12.z.string().optional(),
+  included: import_zod12.z.boolean()
 });
-var InsuredVehicleSchema = import_zod11.z.object({
-  number: import_zod11.z.number(),
-  year: import_zod11.z.number(),
-  make: import_zod11.z.string(),
-  model: import_zod11.z.string(),
-  vin: import_zod11.z.string(),
-  costNew: import_zod11.z.string().optional(),
-  statedValue: import_zod11.z.string().optional(),
-  garageLocation: import_zod11.z.number().optional(),
-  coverages: import_zod11.z.array(VehicleCoverageSchema).optional(),
-  radius: import_zod11.z.string().optional(),
-  vehicleType: import_zod11.z.string().optional()
+var InsuredVehicleSchema = import_zod12.z.object({
+  number: import_zod12.z.number(),
+  year: import_zod12.z.number(),
+  make: import_zod12.z.string(),
+  model: import_zod12.z.string(),
+  vin: import_zod12.z.string(),
+  costNew: import_zod12.z.string().optional(),
+  statedValue: import_zod12.z.string().optional(),
+  garageLocation: import_zod12.z.number().optional(),
+  coverages: import_zod12.z.array(VehicleCoverageSchema).optional(),
+  radius: import_zod12.z.string().optional(),
+  vehicleType: import_zod12.z.string().optional()
 });
-var ClassificationCodeSchema = import_zod11.z.object({
-  code: import_zod11.z.string(),
-  description: import_zod11.z.string(),
-  premiumBasis: import_zod11.z.string(),
-  basisAmount: import_zod11.z.string().optional(),
-  rate: import_zod11.z.string().optional(),
-  premium: import_zod11.z.string().optional(),
-  locationNumber: import_zod11.z.number().optional()
+var ClassificationCodeSchema = import_zod12.z.object({
+  code: import_zod12.z.string(),
+  description: import_zod12.z.string(),
+  premiumBasis: import_zod12.z.string(),
+  basisAmount: import_zod12.z.string().optional(),
+  rate: import_zod12.z.string().optional(),
+  premium: import_zod12.z.string().optional(),
+  locationNumber: import_zod12.z.number().optional()
 });
-var DwellingDetailsSchema = import_zod11.z.object({
+var DwellingDetailsSchema = import_zod12.z.object({
   constructionType: ConstructionTypeSchema.optional(),
-  yearBuilt: import_zod11.z.number().optional(),
-  squareFootage: import_zod11.z.number().optional(),
-  stories: import_zod11.z.number().optional(),
+  yearBuilt: import_zod12.z.number().optional(),
+  squareFootage: import_zod12.z.number().optional(),
+  stories: import_zod12.z.number().optional(),
   roofType: RoofTypeSchema.optional(),
-  roofAge: import_zod11.z.number().optional(),
-  heatingType: import_zod11.z.enum(["central", "baseboard", "radiant", "space_heater", "heat_pump", "other"]).optional(),
+  roofAge: import_zod12.z.number().optional(),
+  heatingType: import_zod12.z.enum(["central", "baseboard", "radiant", "space_heater", "heat_pump", "other"]).optional(),
   foundationType: FoundationTypeSchema.optional(),
-  plumbingType: import_zod11.z.enum(["copper", "pex", "galvanized", "polybutylene", "cpvc", "other"]).optional(),
-  electricalType: import_zod11.z.enum(["circuit_breaker", "fuse_box", "knob_and_tube", "other"]).optional(),
-  electricalAmps: import_zod11.z.number().optional(),
-  hasSwimmingPool: import_zod11.z.boolean().optional(),
-  poolType: import_zod11.z.enum(["in_ground", "above_ground"]).optional(),
-  hasTrampoline: import_zod11.z.boolean().optional(),
-  hasDog: import_zod11.z.boolean().optional(),
-  dogBreed: import_zod11.z.string().optional(),
-  protectiveDevices: import_zod11.z.array(import_zod11.z.string()).optional(),
-  distanceToFireStation: import_zod11.z.string().optional(),
-  distanceToHydrant: import_zod11.z.string().optional(),
-  fireProtectionClass: import_zod11.z.string().optional()
+  plumbingType: import_zod12.z.enum(["copper", "pex", "galvanized", "polybutylene", "cpvc", "other"]).optional(),
+  electricalType: import_zod12.z.enum(["circuit_breaker", "fuse_box", "knob_and_tube", "other"]).optional(),
+  electricalAmps: import_zod12.z.number().optional(),
+  hasSwimmingPool: import_zod12.z.boolean().optional(),
+  poolType: import_zod12.z.enum(["in_ground", "above_ground"]).optional(),
+  hasTrampoline: import_zod12.z.boolean().optional(),
+  hasDog: import_zod12.z.boolean().optional(),
+  dogBreed: import_zod12.z.string().optional(),
+  protectiveDevices: import_zod12.z.array(import_zod12.z.string()).optional(),
+  distanceToFireStation: import_zod12.z.string().optional(),
+  distanceToHydrant: import_zod12.z.string().optional(),
+  fireProtectionClass: import_zod12.z.string().optional()
 });
-var DriverRecordSchema = import_zod11.z.object({
-  name: import_zod11.z.string(),
-  dateOfBirth: import_zod11.z.string().optional(),
-  licenseNumber: import_zod11.z.string().optional(),
-  licenseState: import_zod11.z.string().optional(),
-  relationship: import_zod11.z.enum(["named_insured", "spouse", "child", "other_household", "other"]).optional(),
-  yearsLicensed: import_zod11.z.number().optional(),
-  gender: import_zod11.z.string().optional(),
-  maritalStatus: import_zod11.z.string().optional(),
-  goodStudentDiscount: import_zod11.z.boolean().optional(),
-  defensiveDriverDiscount: import_zod11.z.boolean().optional(),
-  violations: import_zod11.z.array(import_zod11.z.object({
-    date: import_zod11.z.string().optional(),
-    type: import_zod11.z.string().optional(),
-    description: import_zod11.z.string().optional()
+var DriverRecordSchema = import_zod12.z.object({
+  name: import_zod12.z.string(),
+  dateOfBirth: import_zod12.z.string().optional(),
+  licenseNumber: import_zod12.z.string().optional(),
+  licenseState: import_zod12.z.string().optional(),
+  relationship: import_zod12.z.enum(["named_insured", "spouse", "child", "other_household", "other"]).optional(),
+  yearsLicensed: import_zod12.z.number().optional(),
+  gender: import_zod12.z.string().optional(),
+  maritalStatus: import_zod12.z.string().optional(),
+  goodStudentDiscount: import_zod12.z.boolean().optional(),
+  defensiveDriverDiscount: import_zod12.z.boolean().optional(),
+  violations: import_zod12.z.array(import_zod12.z.object({
+    date: import_zod12.z.string().optional(),
+    type: import_zod12.z.string().optional(),
+    description: import_zod12.z.string().optional()
   })).optional(),
-  accidents: import_zod11.z.array(import_zod11.z.object({
-    date: import_zod11.z.string().optional(),
-    atFault: import_zod11.z.boolean().optional(),
-    description: import_zod11.z.string().optional(),
-    amountPaid: import_zod11.z.string().optional()
+  accidents: import_zod12.z.array(import_zod12.z.object({
+    date: import_zod12.z.string().optional(),
+    atFault: import_zod12.z.boolean().optional(),
+    description: import_zod12.z.string().optional(),
+    amountPaid: import_zod12.z.string().optional()
   })).optional(),
-  sr22Required: import_zod11.z.boolean().optional()
+  sr22Required: import_zod12.z.boolean().optional()
 });
-var PersonalVehicleDetailsSchema = import_zod11.z.object({
-  number: import_zod11.z.number().optional(),
-  year: import_zod11.z.number().optional(),
-  make: import_zod11.z.string().optional(),
-  model: import_zod11.z.string().optional(),
-  vin: import_zod11.z.string().optional(),
-  bodyType: import_zod11.z.string().optional(),
+var PersonalVehicleDetailsSchema = import_zod12.z.object({
+  number: import_zod12.z.number().optional(),
+  year: import_zod12.z.number().optional(),
+  make: import_zod12.z.string().optional(),
+  model: import_zod12.z.string().optional(),
+  vin: import_zod12.z.string().optional(),
+  bodyType: import_zod12.z.string().optional(),
   garagingAddress: AddressSchema.optional(),
   usage: PersonalAutoUsageSchema.optional(),
-  annualMileage: import_zod11.z.number().optional(),
-  odometerReading: import_zod11.z.number().optional(),
-  driverAssignment: import_zod11.z.string().optional(),
+  annualMileage: import_zod12.z.number().optional(),
+  odometerReading: import_zod12.z.number().optional(),
+  driverAssignment: import_zod12.z.string().optional(),
   lienHolder: EndorsementPartySchema.optional(),
-  collisionDeductible: import_zod11.z.string().optional(),
-  comprehensiveDeductible: import_zod11.z.string().optional(),
-  rentalReimbursement: import_zod11.z.boolean().optional(),
-  towing: import_zod11.z.boolean().optional()
+  collisionDeductible: import_zod12.z.string().optional(),
+  comprehensiveDeductible: import_zod12.z.string().optional(),
+  rentalReimbursement: import_zod12.z.boolean().optional(),
+  towing: import_zod12.z.boolean().optional()
 });
 
 // src/schemas/declarations/personal.ts
-var HomeownersDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("homeowners"),
+var HomeownersDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("homeowners"),
   formType: HomeownersFormTypeSchema,
-  coverageA: import_zod12.z.string().optional(),
-  coverageB: import_zod12.z.string().optional(),
-  coverageC: import_zod12.z.string().optional(),
-  coverageD: import_zod12.z.string().optional(),
-  coverageE: import_zod12.z.string().optional(),
-  coverageF: import_zod12.z.string().optional(),
-  allPerilDeductible: import_zod12.z.string().optional(),
-  windHailDeductible: import_zod12.z.string().optional(),
-  hurricaneDeductible: import_zod12.z.string().optional(),
+  coverageA: import_zod13.z.string().optional(),
+  coverageB: import_zod13.z.string().optional(),
+  coverageC: import_zod13.z.string().optional(),
+  coverageD: import_zod13.z.string().optional(),
+  coverageE: import_zod13.z.string().optional(),
+  coverageF: import_zod13.z.string().optional(),
+  allPerilDeductible: import_zod13.z.string().optional(),
+  windHailDeductible: import_zod13.z.string().optional(),
+  hurricaneDeductible: import_zod13.z.string().optional(),
   lossSettlement: LossSettlementSchema.optional(),
   dwelling: DwellingDetailsSchema,
   mortgagee: EndorsementPartySchema.optional(),
-  additionalMortgagees: import_zod12.z.array(EndorsementPartySchema).optional()
+  additionalMortgagees: import_zod13.z.array(EndorsementPartySchema).optional()
 });
-var PersonalAutoDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("personal_auto"),
-  vehicles: import_zod12.z.array(PersonalVehicleDetailsSchema),
-  drivers: import_zod12.z.array(DriverRecordSchema),
-  liabilityLimits: import_zod12.z.object({
-    bodilyInjuryPerPerson: import_zod12.z.string().optional(),
-    bodilyInjuryPerAccident: import_zod12.z.string().optional(),
-    propertyDamage: import_zod12.z.string().optional(),
-    combinedSingleLimit: import_zod12.z.string().optional()
+var PersonalAutoDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("personal_auto"),
+  vehicles: import_zod13.z.array(PersonalVehicleDetailsSchema),
+  drivers: import_zod13.z.array(DriverRecordSchema),
+  liabilityLimits: import_zod13.z.object({
+    bodilyInjuryPerPerson: import_zod13.z.string().optional(),
+    bodilyInjuryPerAccident: import_zod13.z.string().optional(),
+    propertyDamage: import_zod13.z.string().optional(),
+    combinedSingleLimit: import_zod13.z.string().optional()
   }).optional(),
-  umLimits: import_zod12.z.object({
-    bodilyInjuryPerPerson: import_zod12.z.string().optional(),
-    bodilyInjuryPerAccident: import_zod12.z.string().optional()
+  umLimits: import_zod13.z.object({
+    bodilyInjuryPerPerson: import_zod13.z.string().optional(),
+    bodilyInjuryPerAccident: import_zod13.z.string().optional()
   }).optional(),
-  uimLimits: import_zod12.z.object({
-    bodilyInjuryPerPerson: import_zod12.z.string().optional(),
-    bodilyInjuryPerAccident: import_zod12.z.string().optional()
+  uimLimits: import_zod13.z.object({
+    bodilyInjuryPerPerson: import_zod13.z.string().optional(),
+    bodilyInjuryPerAccident: import_zod13.z.string().optional()
   }).optional(),
-  pipLimit: import_zod12.z.string().optional(),
-  medPayLimit: import_zod12.z.string().optional()
+  pipLimit: import_zod13.z.string().optional(),
+  medPayLimit: import_zod13.z.string().optional()
 });
-var DwellingFireDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("dwelling_fire"),
+var DwellingFireDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("dwelling_fire"),
   formType: DwellingFireFormTypeSchema,
-  dwellingLimit: import_zod12.z.string().optional(),
-  otherStructuresLimit: import_zod12.z.string().optional(),
-  personalPropertyLimit: import_zod12.z.string().optional(),
-  fairRentalValueLimit: import_zod12.z.string().optional(),
-  liabilityLimit: import_zod12.z.string().optional(),
-  medicalPaymentsLimit: import_zod12.z.string().optional(),
-  deductible: import_zod12.z.string().optional(),
+  dwellingLimit: import_zod13.z.string().optional(),
+  otherStructuresLimit: import_zod13.z.string().optional(),
+  personalPropertyLimit: import_zod13.z.string().optional(),
+  fairRentalValueLimit: import_zod13.z.string().optional(),
+  liabilityLimit: import_zod13.z.string().optional(),
+  medicalPaymentsLimit: import_zod13.z.string().optional(),
+  deductible: import_zod13.z.string().optional(),
   dwelling: DwellingDetailsSchema
 });
-var FloodDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("flood"),
-  programType: import_zod12.z.enum(["nfip", "private"]),
+var FloodDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("flood"),
+  programType: import_zod13.z.enum(["nfip", "private"]),
   floodZone: FloodZoneSchema.optional(),
-  communityNumber: import_zod12.z.string().optional(),
-  communityRating: import_zod12.z.number().optional(),
-  buildingCoverage: import_zod12.z.string().optional(),
-  contentsCoverage: import_zod12.z.string().optional(),
-  iccCoverage: import_zod12.z.string().optional(),
-  deductible: import_zod12.z.string().optional(),
-  waitingPeriodDays: import_zod12.z.number().optional(),
-  elevationCertificate: import_zod12.z.boolean().optional(),
-  elevationDifference: import_zod12.z.string().optional(),
-  buildingDiagramNumber: import_zod12.z.number().optional(),
-  basementOrEnclosure: import_zod12.z.boolean().optional(),
-  postFirmConstruction: import_zod12.z.boolean().optional()
+  communityNumber: import_zod13.z.string().optional(),
+  communityRating: import_zod13.z.number().optional(),
+  buildingCoverage: import_zod13.z.string().optional(),
+  contentsCoverage: import_zod13.z.string().optional(),
+  iccCoverage: import_zod13.z.string().optional(),
+  deductible: import_zod13.z.string().optional(),
+  waitingPeriodDays: import_zod13.z.number().optional(),
+  elevationCertificate: import_zod13.z.boolean().optional(),
+  elevationDifference: import_zod13.z.string().optional(),
+  buildingDiagramNumber: import_zod13.z.number().optional(),
+  basementOrEnclosure: import_zod13.z.boolean().optional(),
+  postFirmConstruction: import_zod13.z.boolean().optional()
 });
-var EarthquakeDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("earthquake"),
-  dwellingCoverage: import_zod12.z.string().optional(),
-  contentsCoverage: import_zod12.z.string().optional(),
-  lossOfUseCoverage: import_zod12.z.string().optional(),
-  deductiblePercent: import_zod12.z.number().optional(),
-  retrofitDiscount: import_zod12.z.boolean().optional(),
-  masonryVeneerCoverage: import_zod12.z.boolean().optional()
+var EarthquakeDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("earthquake"),
+  dwellingCoverage: import_zod13.z.string().optional(),
+  contentsCoverage: import_zod13.z.string().optional(),
+  lossOfUseCoverage: import_zod13.z.string().optional(),
+  deductiblePercent: import_zod13.z.number().optional(),
+  retrofitDiscount: import_zod13.z.boolean().optional(),
+  masonryVeneerCoverage: import_zod13.z.boolean().optional()
 });
-var PersonalUmbrellaDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("personal_umbrella"),
-  perOccurrenceLimit: import_zod12.z.string().optional(),
-  aggregateLimit: import_zod12.z.string().optional(),
-  retainedLimit: import_zod12.z.string().optional(),
-  underlyingPolicies: import_zod12.z.array(import_zod12.z.object({
-    carrier: import_zod12.z.string().optional(),
-    policyNumber: import_zod12.z.string().optional(),
-    policyType: import_zod12.z.string().optional(),
-    limits: import_zod12.z.string().optional()
+var PersonalUmbrellaDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("personal_umbrella"),
+  perOccurrenceLimit: import_zod13.z.string().optional(),
+  aggregateLimit: import_zod13.z.string().optional(),
+  retainedLimit: import_zod13.z.string().optional(),
+  underlyingPolicies: import_zod13.z.array(import_zod13.z.object({
+    carrier: import_zod13.z.string().optional(),
+    policyNumber: import_zod13.z.string().optional(),
+    policyType: import_zod13.z.string().optional(),
+    limits: import_zod13.z.string().optional()
   }))
 });
-var PersonalArticlesDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("personal_articles"),
-  scheduledItems: import_zod12.z.array(import_zod12.z.object({
-    itemNumber: import_zod12.z.number().optional(),
+var PersonalArticlesDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("personal_articles"),
+  scheduledItems: import_zod13.z.array(import_zod13.z.object({
+    itemNumber: import_zod13.z.number().optional(),
     category: ScheduledItemCategorySchema.optional(),
-    description: import_zod12.z.string(),
-    appraisedValue: import_zod12.z.string(),
-    appraisalDate: import_zod12.z.string().optional()
+    description: import_zod13.z.string(),
+    appraisedValue: import_zod13.z.string(),
+    appraisalDate: import_zod13.z.string().optional()
   })),
-  blanketCoverage: import_zod12.z.string().optional(),
-  deductible: import_zod12.z.string().optional(),
-  worldwideCoverage: import_zod12.z.boolean().optional(),
-  breakageCoverage: import_zod12.z.boolean().optional()
+  blanketCoverage: import_zod13.z.string().optional(),
+  deductible: import_zod13.z.string().optional(),
+  worldwideCoverage: import_zod13.z.boolean().optional(),
+  breakageCoverage: import_zod13.z.boolean().optional()
 });
-var WatercraftDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("watercraft"),
+var WatercraftDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("watercraft"),
   boatType: BoatTypeSchema.optional(),
-  year: import_zod12.z.number().optional(),
-  make: import_zod12.z.string().optional(),
-  model: import_zod12.z.string().optional(),
-  length: import_zod12.z.string().optional(),
-  hullMaterial: import_zod12.z.enum(["fiberglass", "aluminum", "wood", "steel", "inflatable", "other"]).optional(),
-  hullValue: import_zod12.z.string().optional(),
-  motorHorsepower: import_zod12.z.number().optional(),
-  motorType: import_zod12.z.enum(["outboard", "inboard", "inboard_outboard", "jet"]).optional(),
-  navigationLimits: import_zod12.z.string().optional(),
-  layupPeriod: import_zod12.z.string().optional(),
-  liabilityLimit: import_zod12.z.string().optional(),
-  medicalPaymentsLimit: import_zod12.z.string().optional(),
-  physicalDamageDeductible: import_zod12.z.string().optional(),
-  uninsuredBoaterLimit: import_zod12.z.string().optional(),
-  trailerCovered: import_zod12.z.boolean().optional(),
-  trailerValue: import_zod12.z.string().optional()
+  year: import_zod13.z.number().optional(),
+  make: import_zod13.z.string().optional(),
+  model: import_zod13.z.string().optional(),
+  length: import_zod13.z.string().optional(),
+  hullMaterial: import_zod13.z.enum(["fiberglass", "aluminum", "wood", "steel", "inflatable", "other"]).optional(),
+  hullValue: import_zod13.z.string().optional(),
+  motorHorsepower: import_zod13.z.number().optional(),
+  motorType: import_zod13.z.enum(["outboard", "inboard", "inboard_outboard", "jet"]).optional(),
+  navigationLimits: import_zod13.z.string().optional(),
+  layupPeriod: import_zod13.z.string().optional(),
+  liabilityLimit: import_zod13.z.string().optional(),
+  medicalPaymentsLimit: import_zod13.z.string().optional(),
+  physicalDamageDeductible: import_zod13.z.string().optional(),
+  uninsuredBoaterLimit: import_zod13.z.string().optional(),
+  trailerCovered: import_zod13.z.boolean().optional(),
+  trailerValue: import_zod13.z.string().optional()
 });
-var RecreationalVehicleDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("recreational_vehicle"),
+var RecreationalVehicleDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("recreational_vehicle"),
   vehicleType: RVTypeSchema,
-  year: import_zod12.z.number().optional(),
-  make: import_zod12.z.string().optional(),
-  model: import_zod12.z.string().optional(),
-  vin: import_zod12.z.string().optional(),
-  value: import_zod12.z.string().optional(),
-  liabilityLimit: import_zod12.z.string().optional(),
-  collisionDeductible: import_zod12.z.string().optional(),
-  comprehensiveDeductible: import_zod12.z.string().optional(),
-  personalEffectsCoverage: import_zod12.z.string().optional(),
-  fullTimerCoverage: import_zod12.z.boolean().optional()
+  year: import_zod13.z.number().optional(),
+  make: import_zod13.z.string().optional(),
+  model: import_zod13.z.string().optional(),
+  vin: import_zod13.z.string().optional(),
+  value: import_zod13.z.string().optional(),
+  liabilityLimit: import_zod13.z.string().optional(),
+  collisionDeductible: import_zod13.z.string().optional(),
+  comprehensiveDeductible: import_zod13.z.string().optional(),
+  personalEffectsCoverage: import_zod13.z.string().optional(),
+  fullTimerCoverage: import_zod13.z.boolean().optional()
 });
-var FarmRanchDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("farm_ranch"),
-  dwellingCoverage: import_zod12.z.string().optional(),
-  farmPersonalPropertyCoverage: import_zod12.z.string().optional(),
-  farmLiabilityLimit: import_zod12.z.string().optional(),
-  farmAutoIncluded: import_zod12.z.boolean().optional(),
-  livestock: import_zod12.z.array(import_zod12.z.object({
-    type: import_zod12.z.string(),
-    headCount: import_zod12.z.number(),
-    value: import_zod12.z.string().optional()
+var FarmRanchDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("farm_ranch"),
+  dwellingCoverage: import_zod13.z.string().optional(),
+  farmPersonalPropertyCoverage: import_zod13.z.string().optional(),
+  farmLiabilityLimit: import_zod13.z.string().optional(),
+  farmAutoIncluded: import_zod13.z.boolean().optional(),
+  livestock: import_zod13.z.array(import_zod13.z.object({
+    type: import_zod13.z.string(),
+    headCount: import_zod13.z.number(),
+    value: import_zod13.z.string().optional()
   })).optional(),
-  equipmentSchedule: import_zod12.z.array(import_zod12.z.object({
-    description: import_zod12.z.string(),
-    value: import_zod12.z.string()
+  equipmentSchedule: import_zod13.z.array(import_zod13.z.object({
+    description: import_zod13.z.string(),
+    value: import_zod13.z.string()
   })).optional(),
-  acreage: import_zod12.z.number().optional(),
+  acreage: import_zod13.z.number().optional(),
   dwelling: DwellingDetailsSchema.optional()
 });
-var TitleDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("title"),
+var TitleDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("title"),
   policyType: TitlePolicyTypeSchema,
-  policyAmount: import_zod12.z.string(),
-  legalDescription: import_zod12.z.string().optional(),
+  policyAmount: import_zod13.z.string(),
+  legalDescription: import_zod13.z.string().optional(),
   propertyAddress: AddressSchema.optional(),
-  effectiveDate: import_zod12.z.string().optional(),
-  exceptions: import_zod12.z.array(import_zod12.z.object({
-    number: import_zod12.z.number(),
-    description: import_zod12.z.string()
+  effectiveDate: import_zod13.z.string().optional(),
+  exceptions: import_zod13.z.array(import_zod13.z.object({
+    number: import_zod13.z.number(),
+    description: import_zod13.z.string()
   })).optional(),
-  underwriter: import_zod12.z.string().optional()
+  underwriter: import_zod13.z.string().optional()
 });
-var PetDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("pet"),
+var PetDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("pet"),
   species: PetSpeciesSchema,
-  breed: import_zod12.z.string().optional(),
-  petName: import_zod12.z.string().optional(),
-  age: import_zod12.z.number().optional(),
-  annualLimit: import_zod12.z.string().optional(),
-  perIncidentLimit: import_zod12.z.string().optional(),
-  deductible: import_zod12.z.string().optional(),
-  reimbursementPercent: import_zod12.z.number().optional(),
-  waitingPeriodDays: import_zod12.z.number().optional(),
-  preExistingConditionsExcluded: import_zod12.z.boolean().optional(),
-  wellnessCoverage: import_zod12.z.boolean().optional()
+  breed: import_zod13.z.string().optional(),
+  petName: import_zod13.z.string().optional(),
+  age: import_zod13.z.number().optional(),
+  annualLimit: import_zod13.z.string().optional(),
+  perIncidentLimit: import_zod13.z.string().optional(),
+  deductible: import_zod13.z.string().optional(),
+  reimbursementPercent: import_zod13.z.number().optional(),
+  waitingPeriodDays: import_zod13.z.number().optional(),
+  preExistingConditionsExcluded: import_zod13.z.boolean().optional(),
+  wellnessCoverage: import_zod13.z.boolean().optional()
 });
-var TravelDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("travel"),
-  tripDepartureDate: import_zod12.z.string().optional(),
-  tripReturnDate: import_zod12.z.string().optional(),
-  destinations: import_zod12.z.array(import_zod12.z.string()).optional(),
-  travelers: import_zod12.z.array(import_zod12.z.object({
-    name: import_zod12.z.string(),
-    age: import_zod12.z.number().optional()
+var TravelDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("travel"),
+  tripDepartureDate: import_zod13.z.string().optional(),
+  tripReturnDate: import_zod13.z.string().optional(),
+  destinations: import_zod13.z.array(import_zod13.z.string()).optional(),
+  travelers: import_zod13.z.array(import_zod13.z.object({
+    name: import_zod13.z.string(),
+    age: import_zod13.z.number().optional()
   })).optional(),
-  tripCost: import_zod12.z.string().optional(),
-  tripCancellationLimit: import_zod12.z.string().optional(),
-  medicalLimit: import_zod12.z.string().optional(),
-  evacuationLimit: import_zod12.z.string().optional(),
-  baggageLimit: import_zod12.z.string().optional()
+  tripCost: import_zod13.z.string().optional(),
+  tripCancellationLimit: import_zod13.z.string().optional(),
+  medicalLimit: import_zod13.z.string().optional(),
+  evacuationLimit: import_zod13.z.string().optional(),
+  baggageLimit: import_zod13.z.string().optional()
 });
-var IdentityTheftDeclarationsSchema = import_zod12.z.object({
-  line: import_zod12.z.literal("identity_theft"),
-  coverageLimit: import_zod12.z.string().optional(),
-  expenseReimbursement: import_zod12.z.string().optional(),
-  creditMonitoring: import_zod12.z.boolean().optional(),
-  restorationServices: import_zod12.z.boolean().optional(),
-  lostWagesLimit: import_zod12.z.string().optional()
+var IdentityTheftDeclarationsSchema = import_zod13.z.object({
+  line: import_zod13.z.literal("identity_theft"),
+  coverageLimit: import_zod13.z.string().optional(),
+  expenseReimbursement: import_zod13.z.string().optional(),
+  creditMonitoring: import_zod13.z.boolean().optional(),
+  restorationServices: import_zod13.z.boolean().optional(),
+  lostWagesLimit: import_zod13.z.string().optional()
 });
 
 // src/schemas/declarations/commercial.ts
-var import_zod13 = require("zod");
-var GLDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("gl"),
+var import_zod14 = require("zod");
+var GLDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("gl"),
   coverageForm: CoverageFormSchema.optional(),
-  perOccurrenceLimit: import_zod13.z.string().optional(),
-  generalAggregate: import_zod13.z.string().optional(),
-  productsCompletedOpsAggregate: import_zod13.z.string().optional(),
-  personalAdvertisingInjury: import_zod13.z.string().optional(),
-  fireDamage: import_zod13.z.string().optional(),
-  medicalExpense: import_zod13.z.string().optional(),
+  perOccurrenceLimit: import_zod14.z.string().optional(),
+  generalAggregate: import_zod14.z.string().optional(),
+  productsCompletedOpsAggregate: import_zod14.z.string().optional(),
+  personalAdvertisingInjury: import_zod14.z.string().optional(),
+  fireDamage: import_zod14.z.string().optional(),
+  medicalExpense: import_zod14.z.string().optional(),
   defenseCostTreatment: DefenseCostTreatmentSchema.optional(),
-  deductible: import_zod13.z.string().optional(),
-  classifications: import_zod13.z.array(ClassificationCodeSchema).optional(),
-  retroactiveDate: import_zod13.z.string().optional()
+  deductible: import_zod14.z.string().optional(),
+  classifications: import_zod14.z.array(ClassificationCodeSchema).optional(),
+  retroactiveDate: import_zod14.z.string().optional()
 });
-var CommercialPropertyDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("commercial_property"),
-  causesOfLossForm: import_zod13.z.enum(["basic", "broad", "special"]).optional(),
-  coinsurancePercent: import_zod13.z.number().optional(),
+var CommercialPropertyDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("commercial_property"),
+  causesOfLossForm: import_zod14.z.enum(["basic", "broad", "special"]).optional(),
+  coinsurancePercent: import_zod14.z.number().optional(),
   valuationMethod: ValuationMethodSchema.optional(),
-  locations: import_zod13.z.array(InsuredLocationSchema),
-  blanketLimit: import_zod13.z.string().optional(),
-  businessIncomeLimit: import_zod13.z.string().optional(),
-  extraExpenseLimit: import_zod13.z.string().optional()
+  locations: import_zod14.z.array(InsuredLocationSchema),
+  blanketLimit: import_zod14.z.string().optional(),
+  businessIncomeLimit: import_zod14.z.string().optional(),
+  extraExpenseLimit: import_zod14.z.string().optional()
 });
-var CommercialAutoDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("commercial_auto"),
-  vehicles: import_zod13.z.array(InsuredVehicleSchema),
-  coveredAutoSymbols: import_zod13.z.array(import_zod13.z.number()).optional(),
-  liabilityLimit: import_zod13.z.string().optional(),
-  umLimit: import_zod13.z.string().optional(),
-  uimLimit: import_zod13.z.string().optional(),
-  hiredAutoLiability: import_zod13.z.boolean().optional(),
-  nonOwnedAutoLiability: import_zod13.z.boolean().optional()
+var CommercialAutoDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("commercial_auto"),
+  vehicles: import_zod14.z.array(InsuredVehicleSchema),
+  coveredAutoSymbols: import_zod14.z.array(import_zod14.z.number()).optional(),
+  liabilityLimit: import_zod14.z.string().optional(),
+  umLimit: import_zod14.z.string().optional(),
+  uimLimit: import_zod14.z.string().optional(),
+  hiredAutoLiability: import_zod14.z.boolean().optional(),
+  nonOwnedAutoLiability: import_zod14.z.boolean().optional()
 });
-var WorkersCompDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("workers_comp"),
-  coveredStates: import_zod13.z.array(import_zod13.z.string()).optional(),
-  classifications: import_zod13.z.array(ClassificationCodeSchema),
+var WorkersCompDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("workers_comp"),
+  coveredStates: import_zod14.z.array(import_zod14.z.string()).optional(),
+  classifications: import_zod14.z.array(ClassificationCodeSchema),
   experienceMod: ExperienceModSchema.optional(),
   employersLiability: EmployersLiabilityLimitsSchema.optional()
 });
-var UmbrellaExcessDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("umbrella_excess"),
-  perOccurrenceLimit: import_zod13.z.string().optional(),
-  aggregateLimit: import_zod13.z.string().optional(),
-  retention: import_zod13.z.string().optional(),
-  underlyingPolicies: import_zod13.z.array(import_zod13.z.object({
-    carrier: import_zod13.z.string().optional(),
-    policyNumber: import_zod13.z.string().optional(),
-    policyType: import_zod13.z.string().optional(),
-    limits: import_zod13.z.string().optional()
+var UmbrellaExcessDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("umbrella_excess"),
+  perOccurrenceLimit: import_zod14.z.string().optional(),
+  aggregateLimit: import_zod14.z.string().optional(),
+  retention: import_zod14.z.string().optional(),
+  underlyingPolicies: import_zod14.z.array(import_zod14.z.object({
+    carrier: import_zod14.z.string().optional(),
+    policyNumber: import_zod14.z.string().optional(),
+    policyType: import_zod14.z.string().optional(),
+    limits: import_zod14.z.string().optional()
   }))
 });
-var ProfessionalLiabilityDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("professional_liability"),
-  perClaimLimit: import_zod13.z.string().optional(),
-  aggregateLimit: import_zod13.z.string().optional(),
-  retroactiveDate: import_zod13.z.string().optional(),
+var ProfessionalLiabilityDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("professional_liability"),
+  perClaimLimit: import_zod14.z.string().optional(),
+  aggregateLimit: import_zod14.z.string().optional(),
+  retroactiveDate: import_zod14.z.string().optional(),
   defenseCostTreatment: DefenseCostTreatmentSchema.optional(),
   extendedReportingPeriod: ExtendedReportingPeriodSchema.optional()
 });
-var CyberDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("cyber"),
-  aggregateLimit: import_zod13.z.string().optional(),
-  retroactiveDate: import_zod13.z.string().optional(),
-  waitingPeriodHours: import_zod13.z.number().optional(),
-  sublimits: import_zod13.z.array(import_zod13.z.object({
-    coverageName: import_zod13.z.string(),
-    limit: import_zod13.z.string()
+var CyberDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("cyber"),
+  aggregateLimit: import_zod14.z.string().optional(),
+  retroactiveDate: import_zod14.z.string().optional(),
+  waitingPeriodHours: import_zod14.z.number().optional(),
+  sublimits: import_zod14.z.array(import_zod14.z.object({
+    coverageName: import_zod14.z.string(),
+    limit: import_zod14.z.string()
   })).optional()
 });
-var DODeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("directors_officers"),
-  sideALimit: import_zod13.z.string().optional(),
-  sideBLimit: import_zod13.z.string().optional(),
-  sideCLimit: import_zod13.z.string().optional(),
-  sideARetention: import_zod13.z.string().optional(),
-  sideBRetention: import_zod13.z.string().optional(),
-  sideCRetention: import_zod13.z.string().optional(),
-  continuityDate: import_zod13.z.string().optional()
+var DODeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("directors_officers"),
+  sideALimit: import_zod14.z.string().optional(),
+  sideBLimit: import_zod14.z.string().optional(),
+  sideCLimit: import_zod14.z.string().optional(),
+  sideARetention: import_zod14.z.string().optional(),
+  sideBRetention: import_zod14.z.string().optional(),
+  sideCRetention: import_zod14.z.string().optional(),
+  continuityDate: import_zod14.z.string().optional()
 });
-var CrimeDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("crime"),
-  formType: import_zod13.z.enum(["discovery", "loss_sustained"]).optional(),
-  agreements: import_zod13.z.array(import_zod13.z.object({
-    agreement: import_zod13.z.string(),
-    coverageName: import_zod13.z.string(),
-    limit: import_zod13.z.string(),
-    deductible: import_zod13.z.string()
+var CrimeDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("crime"),
+  formType: import_zod14.z.enum(["discovery", "loss_sustained"]).optional(),
+  agreements: import_zod14.z.array(import_zod14.z.object({
+    agreement: import_zod14.z.string(),
+    coverageName: import_zod14.z.string(),
+    limit: import_zod14.z.string(),
+    deductible: import_zod14.z.string()
   }))
 });
 
 // src/schemas/declarations/index.ts
-var DeclarationsSchema = import_zod14.z.discriminatedUnion("line", [
+var DeclarationsSchema = import_zod15.z.discriminatedUnion("line", [
   // Personal lines
   HomeownersDeclarationsSchema,
   PersonalAutoDeclarationsSchema,
@@ -1351,137 +1403,137 @@ var DeclarationsSchema = import_zod14.z.discriminatedUnion("line", [
 ]);
 
 // src/schemas/document.ts
-var import_zod15 = require("zod");
-var SubsectionSchema = import_zod15.z.object({
-  title: import_zod15.z.string(),
-  sectionNumber: import_zod15.z.string().optional(),
-  pageNumber: import_zod15.z.number().optional(),
-  content: import_zod15.z.string()
+var import_zod16 = require("zod");
+var SubsectionSchema = import_zod16.z.object({
+  title: import_zod16.z.string(),
+  sectionNumber: import_zod16.z.string().optional(),
+  pageNumber: import_zod16.z.number().optional(),
+  content: import_zod16.z.string()
 });
-var SectionSchema = import_zod15.z.object({
-  title: import_zod15.z.string(),
-  sectionNumber: import_zod15.z.string().optional(),
-  pageStart: import_zod15.z.number(),
-  pageEnd: import_zod15.z.number().optional(),
-  type: import_zod15.z.string(),
-  coverageType: import_zod15.z.string().optional(),
-  content: import_zod15.z.string(),
-  subsections: import_zod15.z.array(SubsectionSchema).optional()
+var SectionSchema = import_zod16.z.object({
+  title: import_zod16.z.string(),
+  sectionNumber: import_zod16.z.string().optional(),
+  pageStart: import_zod16.z.number(),
+  pageEnd: import_zod16.z.number().optional(),
+  type: import_zod16.z.string(),
+  coverageType: import_zod16.z.string().optional(),
+  content: import_zod16.z.string(),
+  subsections: import_zod16.z.array(SubsectionSchema).optional()
 });
-var SubjectivitySchema = import_zod15.z.object({
-  description: import_zod15.z.string(),
-  category: import_zod15.z.string().optional()
+var SubjectivitySchema = import_zod16.z.object({
+  description: import_zod16.z.string(),
+  category: import_zod16.z.string().optional()
 });
-var UnderwritingConditionSchema = import_zod15.z.object({
-  description: import_zod15.z.string()
+var UnderwritingConditionSchema = import_zod16.z.object({
+  description: import_zod16.z.string()
 });
-var PremiumLineSchema = import_zod15.z.object({
-  line: import_zod15.z.string(),
-  amount: import_zod15.z.string()
+var PremiumLineSchema = import_zod16.z.object({
+  line: import_zod16.z.string(),
+  amount: import_zod16.z.string()
 });
 var BaseDocumentFields = {
-  id: import_zod15.z.string(),
-  carrier: import_zod15.z.string(),
-  security: import_zod15.z.string().optional(),
-  insuredName: import_zod15.z.string(),
-  premium: import_zod15.z.string().optional(),
-  summary: import_zod15.z.string().optional(),
-  policyTypes: import_zod15.z.array(import_zod15.z.string()).optional(),
-  coverages: import_zod15.z.array(CoverageSchema),
-  sections: import_zod15.z.array(SectionSchema).optional(),
+  id: import_zod16.z.string(),
+  carrier: import_zod16.z.string(),
+  security: import_zod16.z.string().optional(),
+  insuredName: import_zod16.z.string(),
+  premium: import_zod16.z.string().optional(),
+  summary: import_zod16.z.string().optional(),
+  policyTypes: import_zod16.z.array(import_zod16.z.string()).optional(),
+  coverages: import_zod16.z.array(CoverageSchema),
+  sections: import_zod16.z.array(SectionSchema).optional(),
   // Enriched fields (v1.2+)
-  carrierLegalName: import_zod15.z.string().optional(),
-  carrierNaicNumber: import_zod15.z.string().optional(),
-  carrierAmBestRating: import_zod15.z.string().optional(),
-  carrierAdmittedStatus: import_zod15.z.string().optional(),
-  mga: import_zod15.z.string().optional(),
-  underwriter: import_zod15.z.string().optional(),
-  brokerAgency: import_zod15.z.string().optional(),
-  brokerContactName: import_zod15.z.string().optional(),
-  brokerLicenseNumber: import_zod15.z.string().optional(),
-  priorPolicyNumber: import_zod15.z.string().optional(),
-  programName: import_zod15.z.string().optional(),
-  isRenewal: import_zod15.z.boolean().optional(),
-  isPackage: import_zod15.z.boolean().optional(),
-  insuredDba: import_zod15.z.string().optional(),
+  carrierLegalName: import_zod16.z.string().optional(),
+  carrierNaicNumber: import_zod16.z.string().optional(),
+  carrierAmBestRating: import_zod16.z.string().optional(),
+  carrierAdmittedStatus: import_zod16.z.string().optional(),
+  mga: import_zod16.z.string().optional(),
+  underwriter: import_zod16.z.string().optional(),
+  brokerAgency: import_zod16.z.string().optional(),
+  brokerContactName: import_zod16.z.string().optional(),
+  brokerLicenseNumber: import_zod16.z.string().optional(),
+  priorPolicyNumber: import_zod16.z.string().optional(),
+  programName: import_zod16.z.string().optional(),
+  isRenewal: import_zod16.z.boolean().optional(),
+  isPackage: import_zod16.z.boolean().optional(),
+  insuredDba: import_zod16.z.string().optional(),
   insuredAddress: AddressSchema.optional(),
   insuredEntityType: EntityTypeSchema.optional(),
-  additionalNamedInsureds: import_zod15.z.array(NamedInsuredSchema).optional(),
-  insuredSicCode: import_zod15.z.string().optional(),
-  insuredNaicsCode: import_zod15.z.string().optional(),
-  insuredFein: import_zod15.z.string().optional(),
-  enrichedCoverages: import_zod15.z.array(EnrichedCoverageSchema).optional(),
-  endorsements: import_zod15.z.array(EndorsementSchema).optional(),
-  exclusions: import_zod15.z.array(ExclusionSchema).optional(),
-  conditions: import_zod15.z.array(PolicyConditionSchema).optional(),
+  additionalNamedInsureds: import_zod16.z.array(NamedInsuredSchema).optional(),
+  insuredSicCode: import_zod16.z.string().optional(),
+  insuredNaicsCode: import_zod16.z.string().optional(),
+  insuredFein: import_zod16.z.string().optional(),
+  enrichedCoverages: import_zod16.z.array(EnrichedCoverageSchema).optional(),
+  endorsements: import_zod16.z.array(EndorsementSchema).optional(),
+  exclusions: import_zod16.z.array(ExclusionSchema).optional(),
+  conditions: import_zod16.z.array(PolicyConditionSchema).optional(),
   limits: LimitScheduleSchema.optional(),
   deductibles: DeductibleScheduleSchema.optional(),
-  locations: import_zod15.z.array(InsuredLocationSchema).optional(),
-  vehicles: import_zod15.z.array(InsuredVehicleSchema).optional(),
-  classifications: import_zod15.z.array(ClassificationCodeSchema).optional(),
-  formInventory: import_zod15.z.array(FormReferenceSchema).optional(),
+  locations: import_zod16.z.array(InsuredLocationSchema).optional(),
+  vehicles: import_zod16.z.array(InsuredVehicleSchema).optional(),
+  classifications: import_zod16.z.array(ClassificationCodeSchema).optional(),
+  formInventory: import_zod16.z.array(FormReferenceSchema).optional(),
   declarations: DeclarationsSchema.optional(),
   coverageForm: CoverageFormSchema.optional(),
-  retroactiveDate: import_zod15.z.string().optional(),
+  retroactiveDate: import_zod16.z.string().optional(),
   extendedReportingPeriod: ExtendedReportingPeriodSchema.optional(),
   insurer: InsurerInfoSchema.optional(),
   producer: ProducerInfoSchema.optional(),
-  claimsContacts: import_zod15.z.array(ContactSchema).optional(),
-  regulatoryContacts: import_zod15.z.array(ContactSchema).optional(),
-  thirdPartyAdministrators: import_zod15.z.array(ContactSchema).optional(),
-  additionalInsureds: import_zod15.z.array(EndorsementPartySchema).optional(),
-  lossPayees: import_zod15.z.array(EndorsementPartySchema).optional(),
-  mortgageHolders: import_zod15.z.array(EndorsementPartySchema).optional(),
-  taxesAndFees: import_zod15.z.array(TaxFeeItemSchema).optional(),
-  totalCost: import_zod15.z.string().optional(),
-  minimumPremium: import_zod15.z.string().optional(),
-  depositPremium: import_zod15.z.string().optional(),
+  claimsContacts: import_zod16.z.array(ContactSchema).optional(),
+  regulatoryContacts: import_zod16.z.array(ContactSchema).optional(),
+  thirdPartyAdministrators: import_zod16.z.array(ContactSchema).optional(),
+  additionalInsureds: import_zod16.z.array(EndorsementPartySchema).optional(),
+  lossPayees: import_zod16.z.array(EndorsementPartySchema).optional(),
+  mortgageHolders: import_zod16.z.array(EndorsementPartySchema).optional(),
+  taxesAndFees: import_zod16.z.array(TaxFeeItemSchema).optional(),
+  totalCost: import_zod16.z.string().optional(),
+  minimumPremium: import_zod16.z.string().optional(),
+  depositPremium: import_zod16.z.string().optional(),
   paymentPlan: PaymentPlanSchema.optional(),
   auditType: AuditTypeSchema.optional(),
-  ratingBasis: import_zod15.z.array(RatingBasisSchema).optional(),
-  premiumByLocation: import_zod15.z.array(LocationPremiumSchema).optional(),
+  ratingBasis: import_zod16.z.array(RatingBasisSchema).optional(),
+  premiumByLocation: import_zod16.z.array(LocationPremiumSchema).optional(),
   lossSummary: LossSummarySchema.optional(),
-  individualClaims: import_zod15.z.array(ClaimRecordSchema).optional(),
+  individualClaims: import_zod16.z.array(ClaimRecordSchema).optional(),
   experienceMod: ExperienceModSchema.optional(),
-  cancellationNoticeDays: import_zod15.z.number().optional(),
-  nonrenewalNoticeDays: import_zod15.z.number().optional()
+  cancellationNoticeDays: import_zod16.z.number().optional(),
+  nonrenewalNoticeDays: import_zod16.z.number().optional()
 };
-var PolicyDocumentSchema = import_zod15.z.object({
+var PolicyDocumentSchema = import_zod16.z.object({
   ...BaseDocumentFields,
-  type: import_zod15.z.literal("policy"),
-  policyNumber: import_zod15.z.string(),
-  effectiveDate: import_zod15.z.string(),
-  expirationDate: import_zod15.z.string().optional(),
+  type: import_zod16.z.literal("policy"),
+  policyNumber: import_zod16.z.string(),
+  effectiveDate: import_zod16.z.string(),
+  expirationDate: import_zod16.z.string().optional(),
   policyTermType: PolicyTermTypeSchema.optional(),
-  nextReviewDate: import_zod15.z.string().optional(),
-  effectiveTime: import_zod15.z.string().optional()
+  nextReviewDate: import_zod16.z.string().optional(),
+  effectiveTime: import_zod16.z.string().optional()
 });
-var QuoteDocumentSchema = import_zod15.z.object({
+var QuoteDocumentSchema = import_zod16.z.object({
   ...BaseDocumentFields,
-  type: import_zod15.z.literal("quote"),
-  quoteNumber: import_zod15.z.string(),
-  proposedEffectiveDate: import_zod15.z.string().optional(),
-  proposedExpirationDate: import_zod15.z.string().optional(),
-  quoteExpirationDate: import_zod15.z.string().optional(),
-  subjectivities: import_zod15.z.array(SubjectivitySchema).optional(),
-  underwritingConditions: import_zod15.z.array(UnderwritingConditionSchema).optional(),
-  premiumBreakdown: import_zod15.z.array(PremiumLineSchema).optional(),
+  type: import_zod16.z.literal("quote"),
+  quoteNumber: import_zod16.z.string(),
+  proposedEffectiveDate: import_zod16.z.string().optional(),
+  proposedExpirationDate: import_zod16.z.string().optional(),
+  quoteExpirationDate: import_zod16.z.string().optional(),
+  subjectivities: import_zod16.z.array(SubjectivitySchema).optional(),
+  underwritingConditions: import_zod16.z.array(UnderwritingConditionSchema).optional(),
+  premiumBreakdown: import_zod16.z.array(PremiumLineSchema).optional(),
   // Enriched quote fields (v1.2+)
-  enrichedSubjectivities: import_zod15.z.array(EnrichedSubjectivitySchema).optional(),
-  enrichedUnderwritingConditions: import_zod15.z.array(EnrichedUnderwritingConditionSchema).optional(),
-  warrantyRequirements: import_zod15.z.array(import_zod15.z.string()).optional(),
-  lossControlRecommendations: import_zod15.z.array(import_zod15.z.string()).optional(),
+  enrichedSubjectivities: import_zod16.z.array(EnrichedSubjectivitySchema).optional(),
+  enrichedUnderwritingConditions: import_zod16.z.array(EnrichedUnderwritingConditionSchema).optional(),
+  warrantyRequirements: import_zod16.z.array(import_zod16.z.string()).optional(),
+  lossControlRecommendations: import_zod16.z.array(import_zod16.z.string()).optional(),
   bindingAuthority: BindingAuthoritySchema.optional()
 });
-var InsuranceDocumentSchema = import_zod15.z.discriminatedUnion("type", [
+var InsuranceDocumentSchema = import_zod16.z.discriminatedUnion("type", [
   PolicyDocumentSchema,
   QuoteDocumentSchema
 ]);
 
 // src/schemas/platform.ts
-var import_zod16 = require("zod");
-var PlatformSchema = import_zod16.z.enum(["email", "chat", "sms", "slack", "discord"]);
-var CommunicationIntentSchema = import_zod16.z.enum(["direct", "mediated", "observed"]);
+var import_zod17 = require("zod");
+var PlatformSchema = import_zod17.z.enum(["email", "chat", "sms", "slack", "discord"]);
+var CommunicationIntentSchema = import_zod17.z.enum(["direct", "mediated", "observed"]);
 var PLATFORM_CONFIGS = {
   email: {
     supportsMarkdown: false,
@@ -1701,10 +1753,11 @@ async function runExtractor(params) {
 [Document pages ${startPage}-${endPage} are provided as images above.]` : `${prompt}
 
 [Document pages ${startPage}-${endPage} are provided as a PDF file above.]`;
+  const strictSchema = toStrictSchema(schema);
   const result = await withRetry(
     () => generateObject({
       prompt: fullPrompt,
-      schema,
+      schema: strictSchema,
       maxTokens,
       providerOptions
     })
@@ -2783,11 +2836,11 @@ function getTemplate(policyType) {
 }
 
 // src/prompts/coordinator/classify.ts
-var import_zod17 = require("zod");
-var ClassifyResultSchema = import_zod17.z.object({
-  documentType: import_zod17.z.enum(["policy", "quote"]),
-  policyTypes: import_zod17.z.array(PolicyTypeSchema),
-  confidence: import_zod17.z.number()
+var import_zod18 = require("zod");
+var ClassifyResultSchema = import_zod18.z.object({
+  documentType: import_zod18.z.enum(["policy", "quote"]),
+  policyTypes: import_zod18.z.array(PolicyTypeSchema),
+  confidence: import_zod18.z.number()
 });
 function buildClassifyPrompt() {
   return `You are classifying an insurance document. Examine the first few pages and determine:
@@ -2811,20 +2864,20 @@ Respond with JSON only.`;
 }
 
 // src/prompts/coordinator/plan.ts
-var import_zod18 = require("zod");
-var ExtractionTaskSchema = import_zod18.z.object({
-  extractorName: import_zod18.z.string(),
-  startPage: import_zod18.z.number(),
-  endPage: import_zod18.z.number(),
-  description: import_zod18.z.string()
+var import_zod19 = require("zod");
+var ExtractionTaskSchema = import_zod19.z.object({
+  extractorName: import_zod19.z.string(),
+  startPage: import_zod19.z.number(),
+  endPage: import_zod19.z.number(),
+  description: import_zod19.z.string()
 });
-var PageMapEntrySchema = import_zod18.z.object({
-  section: import_zod18.z.string(),
-  pages: import_zod18.z.string()
+var PageMapEntrySchema = import_zod19.z.object({
+  section: import_zod19.z.string(),
+  pages: import_zod19.z.string()
 });
-var ExtractionPlanSchema = import_zod18.z.object({
-  tasks: import_zod18.z.array(ExtractionTaskSchema),
-  pageMap: import_zod18.z.array(PageMapEntrySchema).optional()
+var ExtractionPlanSchema = import_zod19.z.object({
+  tasks: import_zod19.z.array(ExtractionTaskSchema),
+  pageMap: import_zod19.z.array(PageMapEntrySchema).optional()
 });
 function buildPlanPrompt(templateHints) {
   return `You are planning the extraction of an insurance document. You have already classified this document. Now scan the full document and create a page map + extraction plan.
@@ -2865,15 +2918,15 @@ Respond with JSON only.`;
 }
 
 // src/prompts/coordinator/review.ts
-var import_zod19 = require("zod");
-var ReviewResultSchema = import_zod19.z.object({
-  complete: import_zod19.z.boolean(),
-  missingFields: import_zod19.z.array(import_zod19.z.string()),
-  additionalTasks: import_zod19.z.array(import_zod19.z.object({
-    extractorName: import_zod19.z.string(),
-    startPage: import_zod19.z.number(),
-    endPage: import_zod19.z.number(),
-    description: import_zod19.z.string()
+var import_zod20 = require("zod");
+var ReviewResultSchema = import_zod20.z.object({
+  complete: import_zod20.z.boolean(),
+  missingFields: import_zod20.z.array(import_zod20.z.string()),
+  additionalTasks: import_zod20.z.array(import_zod20.z.object({
+    extractorName: import_zod20.z.string(),
+    startPage: import_zod20.z.number(),
+    endPage: import_zod20.z.number(),
+    description: import_zod20.z.string()
   }))
 });
 function buildReviewPrompt(templateExpected, extractedKeys) {
@@ -2905,20 +2958,20 @@ Respond with JSON only.`;
 }
 
 // src/prompts/extractors/carrier-info.ts
-var import_zod20 = require("zod");
-var CarrierInfoSchema = import_zod20.z.object({
-  carrierName: import_zod20.z.string().describe("Primary insurance company name for display"),
-  carrierLegalName: import_zod20.z.string().optional().describe("Legal entity name of insurer"),
-  naicNumber: import_zod20.z.string().optional().describe("NAIC company code"),
-  amBestRating: import_zod20.z.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
-  admittedStatus: import_zod20.z.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
-  mga: import_zod20.z.string().optional().describe("Managing General Agent or Program Administrator name"),
-  underwriter: import_zod20.z.string().optional().describe("Named individual underwriter"),
-  policyNumber: import_zod20.z.string().optional().describe("Policy or quote reference number"),
-  effectiveDate: import_zod20.z.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
-  expirationDate: import_zod20.z.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
-  quoteNumber: import_zod20.z.string().optional().describe("Quote or proposal reference number"),
-  proposedEffectiveDate: import_zod20.z.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
+var import_zod21 = require("zod");
+var CarrierInfoSchema = import_zod21.z.object({
+  carrierName: import_zod21.z.string().describe("Primary insurance company name for display"),
+  carrierLegalName: import_zod21.z.string().optional().describe("Legal entity name of insurer"),
+  naicNumber: import_zod21.z.string().optional().describe("NAIC company code"),
+  amBestRating: import_zod21.z.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
+  admittedStatus: import_zod21.z.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
+  mga: import_zod21.z.string().optional().describe("Managing General Agent or Program Administrator name"),
+  underwriter: import_zod21.z.string().optional().describe("Named individual underwriter"),
+  policyNumber: import_zod21.z.string().optional().describe("Policy or quote reference number"),
+  effectiveDate: import_zod21.z.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
+  expirationDate: import_zod21.z.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
+  quoteNumber: import_zod21.z.string().optional().describe("Quote or proposal reference number"),
+  proposedEffectiveDate: import_zod21.z.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
 });
 function buildCarrierInfoPrompt() {
   return `You are an expert insurance document analyst. Extract carrier and policy identification information from this document.
@@ -2938,18 +2991,18 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/named-insured.ts
-var import_zod21 = require("zod");
-var AddressSchema2 = import_zod21.z.object({
-  street1: import_zod21.z.string(),
-  city: import_zod21.z.string(),
-  state: import_zod21.z.string(),
-  zip: import_zod21.z.string()
+var import_zod22 = require("zod");
+var AddressSchema2 = import_zod22.z.object({
+  street1: import_zod22.z.string(),
+  city: import_zod22.z.string(),
+  state: import_zod22.z.string(),
+  zip: import_zod22.z.string()
 });
-var NamedInsuredSchema2 = import_zod21.z.object({
-  insuredName: import_zod21.z.string().describe("Name of primary named insured"),
-  insuredDba: import_zod21.z.string().optional().describe("Doing-business-as name"),
+var NamedInsuredSchema2 = import_zod22.z.object({
+  insuredName: import_zod22.z.string().describe("Name of primary named insured"),
+  insuredDba: import_zod22.z.string().optional().describe("Doing-business-as name"),
   insuredAddress: AddressSchema2.optional().describe("Primary insured mailing address"),
-  insuredEntityType: import_zod21.z.enum([
+  insuredEntityType: import_zod22.z.enum([
     "corporation",
     "llc",
     "partnership",
@@ -2962,13 +3015,13 @@ var NamedInsuredSchema2 = import_zod21.z.object({
     "married_couple",
     "other"
   ]).optional().describe("Legal entity type of the insured"),
-  insuredFein: import_zod21.z.string().optional().describe("Federal Employer Identification Number"),
-  insuredSicCode: import_zod21.z.string().optional().describe("SIC code"),
-  insuredNaicsCode: import_zod21.z.string().optional().describe("NAICS code"),
-  additionalNamedInsureds: import_zod21.z.array(
-    import_zod21.z.object({
-      name: import_zod21.z.string(),
-      relationship: import_zod21.z.string().optional().describe("e.g. subsidiary, affiliate"),
+  insuredFein: import_zod22.z.string().optional().describe("Federal Employer Identification Number"),
+  insuredSicCode: import_zod22.z.string().optional().describe("SIC code"),
+  insuredNaicsCode: import_zod22.z.string().optional().describe("NAICS code"),
+  additionalNamedInsureds: import_zod22.z.array(
+    import_zod22.z.object({
+      name: import_zod22.z.string(),
+      relationship: import_zod22.z.string().optional().describe("e.g. subsidiary, affiliate"),
       address: AddressSchema2.optional()
     })
   ).optional().describe("Additional named insureds listed on the policy")
@@ -2989,19 +3042,19 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/coverage-limits.ts
-var import_zod22 = require("zod");
-var CoverageLimitsSchema = import_zod22.z.object({
-  coverages: import_zod22.z.array(
-    import_zod22.z.object({
-      name: import_zod22.z.string().describe("Coverage name"),
-      limit: import_zod22.z.string().describe("Coverage limit, e.g. '$1,000,000'"),
-      deductible: import_zod22.z.string().optional().describe("Deductible amount"),
-      coverageCode: import_zod22.z.string().optional().describe("Coverage code or class code"),
-      formNumber: import_zod22.z.string().optional().describe("Associated form number, e.g. 'CG 00 01'")
+var import_zod23 = require("zod");
+var CoverageLimitsSchema = import_zod23.z.object({
+  coverages: import_zod23.z.array(
+    import_zod23.z.object({
+      name: import_zod23.z.string().describe("Coverage name"),
+      limit: import_zod23.z.string().describe("Coverage limit, e.g. '$1,000,000'"),
+      deductible: import_zod23.z.string().optional().describe("Deductible amount"),
+      coverageCode: import_zod23.z.string().optional().describe("Coverage code or class code"),
+      formNumber: import_zod23.z.string().optional().describe("Associated form number, e.g. 'CG 00 01'")
     })
   ).describe("All coverages with their limits"),
-  coverageForm: import_zod22.z.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
-  retroactiveDate: import_zod22.z.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
+  coverageForm: import_zod23.z.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
+  retroactiveDate: import_zod23.z.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
 });
 function buildCoverageLimitsPrompt() {
   return `You are an expert insurance document analyst. Extract all coverage limits and deductibles from this document.
@@ -3022,17 +3075,17 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/endorsements.ts
-var import_zod23 = require("zod");
-var EndorsementsSchema = import_zod23.z.object({
-  endorsements: import_zod23.z.array(
-    import_zod23.z.object({
-      formNumber: import_zod23.z.string().optional().describe("Form number, e.g. 'CG 21 47'"),
-      title: import_zod23.z.string().optional().describe("Endorsement title"),
-      type: import_zod23.z.enum(["broadening", "restrictive", "informational"]).optional().describe("Effect type: broadening adds coverage, restrictive limits it"),
-      content: import_zod23.z.string().optional().describe("Full verbatim text of the endorsement"),
-      effectiveDate: import_zod23.z.string().optional().describe("Endorsement effective date"),
-      premium: import_zod23.z.string().optional().describe("Additional premium or credit"),
-      parties: import_zod23.z.array(import_zod23.z.string()).optional().describe("Named parties (additional insureds, loss payees, etc.)")
+var import_zod24 = require("zod");
+var EndorsementsSchema = import_zod24.z.object({
+  endorsements: import_zod24.z.array(
+    import_zod24.z.object({
+      formNumber: import_zod24.z.string().optional().describe("Form number, e.g. 'CG 21 47'"),
+      title: import_zod24.z.string().optional().describe("Endorsement title"),
+      type: import_zod24.z.enum(["broadening", "restrictive", "informational"]).optional().describe("Effect type: broadening adds coverage, restrictive limits it"),
+      content: import_zod24.z.string().optional().describe("Full verbatim text of the endorsement"),
+      effectiveDate: import_zod24.z.string().optional().describe("Endorsement effective date"),
+      premium: import_zod24.z.string().optional().describe("Additional premium or credit"),
+      parties: import_zod24.z.array(import_zod24.z.string()).optional().describe("Named parties (additional insureds, loss payees, etc.)")
     })
   ).describe("All endorsements found in the document")
 });
@@ -3058,14 +3111,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/exclusions.ts
-var import_zod24 = require("zod");
-var ExclusionsSchema = import_zod24.z.object({
-  exclusions: import_zod24.z.array(
-    import_zod24.z.object({
-      title: import_zod24.z.string().describe("Exclusion title or short description"),
-      content: import_zod24.z.string().optional().describe("Full verbatim exclusion text"),
-      formNumber: import_zod24.z.string().optional().describe("Form number if part of a named endorsement"),
-      appliesTo: import_zod24.z.string().optional().describe("Coverage type this exclusion applies to")
+var import_zod25 = require("zod");
+var ExclusionsSchema = import_zod25.z.object({
+  exclusions: import_zod25.z.array(
+    import_zod25.z.object({
+      title: import_zod25.z.string().describe("Exclusion title or short description"),
+      content: import_zod25.z.string().optional().describe("Full verbatim exclusion text"),
+      formNumber: import_zod25.z.string().optional().describe("Form number if part of a named endorsement"),
+      appliesTo: import_zod25.z.string().optional().describe("Coverage type this exclusion applies to")
     })
   ).describe("All exclusions found in the document")
 });
@@ -3086,11 +3139,11 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/conditions.ts
-var import_zod25 = require("zod");
-var ConditionsSchema = import_zod25.z.object({
-  conditions: import_zod25.z.array(
-    import_zod25.z.object({
-      type: import_zod25.z.enum([
+var import_zod26 = require("zod");
+var ConditionsSchema = import_zod26.z.object({
+  conditions: import_zod26.z.array(
+    import_zod26.z.object({
+      type: import_zod26.z.enum([
         "duties_after_loss",
         "cooperation",
         "cancellation",
@@ -3104,9 +3157,9 @@ var ConditionsSchema = import_zod25.z.object({
         "liberalization",
         "other"
       ]).optional().describe("Condition category"),
-      title: import_zod25.z.string().describe("Condition title"),
-      content: import_zod25.z.string().optional().describe("Full verbatim condition text"),
-      noticeDays: import_zod25.z.number().optional().describe("Notice period in days if specified (e.g. cancellation notice)")
+      title: import_zod26.z.string().describe("Condition title"),
+      content: import_zod26.z.string().optional().describe("Full verbatim condition text"),
+      noticeDays: import_zod26.z.number().optional().describe("Notice period in days if specified (e.g. cancellation notice)")
     })
   ).describe("All policy conditions found in the document")
 });
@@ -3131,28 +3184,28 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/premium-breakdown.ts
-var import_zod26 = require("zod");
-var PremiumBreakdownSchema = import_zod26.z.object({
-  premium: import_zod26.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
-  totalCost: import_zod26.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
-  premiumBreakdown: import_zod26.z.array(
-    import_zod26.z.object({
-      line: import_zod26.z.string().describe("Coverage line name"),
-      amount: import_zod26.z.string().describe("Premium amount for this line")
+var import_zod27 = require("zod");
+var PremiumBreakdownSchema = import_zod27.z.object({
+  premium: import_zod27.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
+  totalCost: import_zod27.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
+  premiumBreakdown: import_zod27.z.array(
+    import_zod27.z.object({
+      line: import_zod27.z.string().describe("Coverage line name"),
+      amount: import_zod27.z.string().describe("Premium amount for this line")
     })
   ).optional().describe("Per-coverage-line premium breakdown"),
-  taxesAndFees: import_zod26.z.array(
-    import_zod26.z.object({
-      name: import_zod26.z.string().describe("Fee or tax name"),
-      amount: import_zod26.z.string().describe("Dollar amount"),
-      type: import_zod26.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
+  taxesAndFees: import_zod27.z.array(
+    import_zod27.z.object({
+      name: import_zod27.z.string().describe("Fee or tax name"),
+      amount: import_zod27.z.string().describe("Dollar amount"),
+      type: import_zod27.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
     })
   ).optional().describe("Taxes, fees, surcharges, and assessments"),
-  minimumPremium: import_zod26.z.string().optional().describe("Minimum premium if stated"),
-  depositPremium: import_zod26.z.string().optional().describe("Deposit premium if stated"),
-  paymentPlan: import_zod26.z.string().optional().describe("Payment plan description"),
-  auditType: import_zod26.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
-  ratingBasis: import_zod26.z.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
+  minimumPremium: import_zod27.z.string().optional().describe("Minimum premium if stated"),
+  depositPremium: import_zod27.z.string().optional().describe("Deposit premium if stated"),
+  paymentPlan: import_zod27.z.string().optional().describe("Payment plan description"),
+  auditType: import_zod27.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
+  ratingBasis: import_zod27.z.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
 });
 function buildPremiumBreakdownPrompt() {
   return `You are an expert insurance document analyst. Extract all premium and cost information from this document.
@@ -3172,14 +3225,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/declarations.ts
-var import_zod27 = require("zod");
-var DeclarationsFieldSchema = import_zod27.z.object({
-  field: import_zod27.z.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
-  value: import_zod27.z.string().describe("Extracted value exactly as it appears in the document"),
-  section: import_zod27.z.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
+var import_zod28 = require("zod");
+var DeclarationsFieldSchema = import_zod28.z.object({
+  field: import_zod28.z.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
+  value: import_zod28.z.string().describe("Extracted value exactly as it appears in the document"),
+  section: import_zod28.z.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
 });
-var DeclarationsExtractSchema = import_zod27.z.object({
-  fields: import_zod27.z.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
+var DeclarationsExtractSchema = import_zod28.z.object({
+  fields: import_zod28.z.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
 });
 function buildDeclarationsPrompt() {
   return `You are an expert insurance document analyst. Extract all declarations page data from this document into a flexible key-value structure.
@@ -3219,21 +3272,21 @@ Preserve original values exactly as they appear. Return JSON only.`;
 }
 
 // src/prompts/extractors/loss-history.ts
-var import_zod28 = require("zod");
-var LossHistorySchema = import_zod28.z.object({
-  lossSummary: import_zod28.z.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
-  individualClaims: import_zod28.z.array(
-    import_zod28.z.object({
-      date: import_zod28.z.string().optional().describe("Date of loss or claim"),
-      type: import_zod28.z.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
-      description: import_zod28.z.string().optional().describe("Brief description of the claim"),
-      amountPaid: import_zod28.z.string().optional().describe("Amount paid"),
-      amountReserved: import_zod28.z.string().optional().describe("Amount reserved"),
-      status: import_zod28.z.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
-      claimNumber: import_zod28.z.string().optional().describe("Claim reference number")
+var import_zod29 = require("zod");
+var LossHistorySchema = import_zod29.z.object({
+  lossSummary: import_zod29.z.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
+  individualClaims: import_zod29.z.array(
+    import_zod29.z.object({
+      date: import_zod29.z.string().optional().describe("Date of loss or claim"),
+      type: import_zod29.z.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
+      description: import_zod29.z.string().optional().describe("Brief description of the claim"),
+      amountPaid: import_zod29.z.string().optional().describe("Amount paid"),
+      amountReserved: import_zod29.z.string().optional().describe("Amount reserved"),
+      status: import_zod29.z.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
+      claimNumber: import_zod29.z.string().optional().describe("Claim reference number")
     })
   ).optional().describe("Individual claim records"),
-  experienceMod: import_zod28.z.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
+  experienceMod: import_zod29.z.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
 });
 function buildLossHistoryPrompt() {
   return `You are an expert insurance document analyst. Extract all loss history and claims information from this document.
@@ -3250,18 +3303,18 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/sections.ts
-var import_zod29 = require("zod");
-var SubsectionSchema2 = import_zod29.z.object({
-  title: import_zod29.z.string().describe("Subsection title"),
-  sectionNumber: import_zod29.z.string().optional().describe("Subsection number"),
-  pageNumber: import_zod29.z.number().optional().describe("Page number"),
-  content: import_zod29.z.string().describe("Full verbatim text")
+var import_zod30 = require("zod");
+var SubsectionSchema2 = import_zod30.z.object({
+  title: import_zod30.z.string().describe("Subsection title"),
+  sectionNumber: import_zod30.z.string().optional().describe("Subsection number"),
+  pageNumber: import_zod30.z.number().optional().describe("Page number"),
+  content: import_zod30.z.string().describe("Full verbatim text")
 });
-var SectionsSchema = import_zod29.z.object({
-  sections: import_zod29.z.array(
-    import_zod29.z.object({
-      title: import_zod29.z.string().describe("Section title"),
-      type: import_zod29.z.enum([
+var SectionsSchema = import_zod30.z.object({
+  sections: import_zod30.z.array(
+    import_zod30.z.object({
+      title: import_zod30.z.string().describe("Section title"),
+      type: import_zod30.z.enum([
         "declarations",
         "insuring_agreement",
         "policy_form",
@@ -3275,10 +3328,10 @@ var SectionsSchema = import_zod29.z.object({
         "regulatory",
         "other"
       ]).describe("Section type classification"),
-      content: import_zod29.z.string().describe("Full verbatim text of the section"),
-      pageStart: import_zod29.z.number().describe("Starting page number"),
-      pageEnd: import_zod29.z.number().optional().describe("Ending page number"),
-      subsections: import_zod29.z.array(SubsectionSchema2).optional().describe("Subsections within this section")
+      content: import_zod30.z.string().describe("Full verbatim text of the section"),
+      pageStart: import_zod30.z.number().describe("Starting page number"),
+      pageEnd: import_zod30.z.number().optional().describe("Ending page number"),
+      subsections: import_zod30.z.array(SubsectionSchema2).optional().describe("Subsections within this section")
     })
   ).describe("All document sections")
 });
@@ -3302,20 +3355,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/supplementary.ts
-var import_zod30 = require("zod");
-var ContactSchema2 = import_zod30.z.object({
-  name: import_zod30.z.string().optional().describe("Organization or person name"),
-  phone: import_zod30.z.string().optional().describe("Phone number"),
-  email: import_zod30.z.string().optional().describe("Email address"),
-  address: import_zod30.z.string().optional().describe("Mailing address"),
-  type: import_zod30.z.string().optional().describe("Contact type, e.g. 'State Department of Insurance'")
+var import_zod31 = require("zod");
+var ContactSchema2 = import_zod31.z.object({
+  name: import_zod31.z.string().optional().describe("Organization or person name"),
+  phone: import_zod31.z.string().optional().describe("Phone number"),
+  email: import_zod31.z.string().optional().describe("Email address"),
+  address: import_zod31.z.string().optional().describe("Mailing address"),
+  type: import_zod31.z.string().optional().describe("Contact type, e.g. 'State Department of Insurance'")
 });
-var SupplementarySchema = import_zod30.z.object({
-  regulatoryContacts: import_zod30.z.array(ContactSchema2).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
-  claimsContacts: import_zod30.z.array(ContactSchema2).optional().describe("Claims reporting contacts and instructions"),
-  thirdPartyAdministrators: import_zod30.z.array(ContactSchema2).optional().describe("Third-party administrators for claims handling"),
-  cancellationNoticeDays: import_zod30.z.number().optional().describe("Required notice period for cancellation in days"),
-  nonrenewalNoticeDays: import_zod30.z.number().optional().describe("Required notice period for nonrenewal in days")
+var SupplementarySchema = import_zod31.z.object({
+  regulatoryContacts: import_zod31.z.array(ContactSchema2).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
+  claimsContacts: import_zod31.z.array(ContactSchema2).optional().describe("Claims reporting contacts and instructions"),
+  thirdPartyAdministrators: import_zod31.z.array(ContactSchema2).optional().describe("Third-party administrators for claims handling"),
+  cancellationNoticeDays: import_zod31.z.number().optional().describe("Required notice period for cancellation in days"),
+  nonrenewalNoticeDays: import_zod31.z.number().optional().describe("Required notice period for nonrenewal in days")
 });
 function buildSupplementaryPrompt() {
   return `You are an expert insurance document analyst. Extract supplementary and regulatory information from this document.
@@ -3817,8 +3870,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-var import_zod31 = require("zod");
-var FieldTypeSchema = import_zod31.z.enum([
+var import_zod32 = require("zod");
+var FieldTypeSchema = import_zod32.z.enum([
   "text",
   "numeric",
   "currency",
@@ -3827,100 +3880,100 @@ var FieldTypeSchema = import_zod31.z.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = import_zod31.z.object({
-  id: import_zod31.z.string(),
-  label: import_zod31.z.string(),
-  section: import_zod31.z.string(),
+var ApplicationFieldSchema = import_zod32.z.object({
+  id: import_zod32.z.string(),
+  label: import_zod32.z.string(),
+  section: import_zod32.z.string(),
   fieldType: FieldTypeSchema,
-  required: import_zod31.z.boolean(),
-  options: import_zod31.z.array(import_zod31.z.string()).optional(),
-  columns: import_zod31.z.array(import_zod31.z.string()).optional(),
-  requiresExplanationIfYes: import_zod31.z.boolean().optional(),
-  condition: import_zod31.z.object({
-    dependsOn: import_zod31.z.string(),
-    whenValue: import_zod31.z.string()
+  required: import_zod32.z.boolean(),
+  options: import_zod32.z.array(import_zod32.z.string()).optional(),
+  columns: import_zod32.z.array(import_zod32.z.string()).optional(),
+  requiresExplanationIfYes: import_zod32.z.boolean().optional(),
+  condition: import_zod32.z.object({
+    dependsOn: import_zod32.z.string(),
+    whenValue: import_zod32.z.string()
   }).optional(),
-  value: import_zod31.z.string().optional(),
-  source: import_zod31.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: import_zod31.z.enum(["confirmed", "high", "medium", "low"]).optional()
+  value: import_zod32.z.string().optional(),
+  source: import_zod32.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: import_zod32.z.enum(["confirmed", "high", "medium", "low"]).optional()
 });
-var ApplicationClassifyResultSchema = import_zod31.z.object({
-  isApplication: import_zod31.z.boolean(),
-  confidence: import_zod31.z.number().min(0).max(1),
-  applicationType: import_zod31.z.string().nullable()
+var ApplicationClassifyResultSchema = import_zod32.z.object({
+  isApplication: import_zod32.z.boolean(),
+  confidence: import_zod32.z.number().min(0).max(1),
+  applicationType: import_zod32.z.string().nullable()
 });
-var FieldExtractionResultSchema = import_zod31.z.object({
-  fields: import_zod31.z.array(ApplicationFieldSchema)
+var FieldExtractionResultSchema = import_zod32.z.object({
+  fields: import_zod32.z.array(ApplicationFieldSchema)
 });
-var AutoFillMatchSchema = import_zod31.z.object({
-  fieldId: import_zod31.z.string(),
-  value: import_zod31.z.string(),
-  confidence: import_zod31.z.enum(["confirmed"]),
-  contextKey: import_zod31.z.string()
+var AutoFillMatchSchema = import_zod32.z.object({
+  fieldId: import_zod32.z.string(),
+  value: import_zod32.z.string(),
+  confidence: import_zod32.z.enum(["confirmed"]),
+  contextKey: import_zod32.z.string()
 });
-var AutoFillResultSchema = import_zod31.z.object({
-  matches: import_zod31.z.array(AutoFillMatchSchema)
+var AutoFillResultSchema = import_zod32.z.object({
+  matches: import_zod32.z.array(AutoFillMatchSchema)
 });
-var QuestionBatchResultSchema = import_zod31.z.object({
-  batches: import_zod31.z.array(import_zod31.z.array(import_zod31.z.string()).describe("Array of field IDs in this batch"))
+var QuestionBatchResultSchema = import_zod32.z.object({
+  batches: import_zod32.z.array(import_zod32.z.array(import_zod32.z.string()).describe("Array of field IDs in this batch"))
 });
-var LookupRequestSchema = import_zod31.z.object({
-  type: import_zod31.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: import_zod31.z.string(),
-  url: import_zod31.z.string().optional(),
-  targetFieldIds: import_zod31.z.array(import_zod31.z.string())
+var LookupRequestSchema = import_zod32.z.object({
+  type: import_zod32.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: import_zod32.z.string(),
+  url: import_zod32.z.string().optional(),
+  targetFieldIds: import_zod32.z.array(import_zod32.z.string())
 });
-var ReplyIntentSchema = import_zod31.z.object({
-  primaryIntent: import_zod31.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: import_zod31.z.boolean(),
-  questionText: import_zod31.z.string().optional(),
-  questionFieldIds: import_zod31.z.array(import_zod31.z.string()).optional(),
-  lookupRequests: import_zod31.z.array(LookupRequestSchema).optional()
+var ReplyIntentSchema = import_zod32.z.object({
+  primaryIntent: import_zod32.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: import_zod32.z.boolean(),
+  questionText: import_zod32.z.string().optional(),
+  questionFieldIds: import_zod32.z.array(import_zod32.z.string()).optional(),
+  lookupRequests: import_zod32.z.array(LookupRequestSchema).optional()
 });
-var ParsedAnswerSchema = import_zod31.z.object({
-  fieldId: import_zod31.z.string(),
-  value: import_zod31.z.string(),
-  explanation: import_zod31.z.string().optional()
+var ParsedAnswerSchema = import_zod32.z.object({
+  fieldId: import_zod32.z.string(),
+  value: import_zod32.z.string(),
+  explanation: import_zod32.z.string().optional()
 });
-var AnswerParsingResultSchema = import_zod31.z.object({
-  answers: import_zod31.z.array(ParsedAnswerSchema),
-  unanswered: import_zod31.z.array(import_zod31.z.string()).describe("Field IDs that were not answered")
+var AnswerParsingResultSchema = import_zod32.z.object({
+  answers: import_zod32.z.array(ParsedAnswerSchema),
+  unanswered: import_zod32.z.array(import_zod32.z.string()).describe("Field IDs that were not answered")
 });
-var LookupFillSchema = import_zod31.z.object({
-  fieldId: import_zod31.z.string(),
-  value: import_zod31.z.string(),
-  source: import_zod31.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
+var LookupFillSchema = import_zod32.z.object({
+  fieldId: import_zod32.z.string(),
+  value: import_zod32.z.string(),
+  source: import_zod32.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
 });
-var LookupFillResultSchema = import_zod31.z.object({
-  fills: import_zod31.z.array(LookupFillSchema),
-  unfillable: import_zod31.z.array(import_zod31.z.string()),
-  explanation: import_zod31.z.string().optional()
+var LookupFillResultSchema = import_zod32.z.object({
+  fills: import_zod32.z.array(LookupFillSchema),
+  unfillable: import_zod32.z.array(import_zod32.z.string()),
+  explanation: import_zod32.z.string().optional()
 });
-var FlatPdfPlacementSchema = import_zod31.z.object({
-  fieldId: import_zod31.z.string(),
-  page: import_zod31.z.number(),
-  x: import_zod31.z.number().describe("Percentage from left edge (0-100)"),
-  y: import_zod31.z.number().describe("Percentage from top edge (0-100)"),
-  text: import_zod31.z.string(),
-  fontSize: import_zod31.z.number().optional(),
-  isCheckmark: import_zod31.z.boolean().optional()
+var FlatPdfPlacementSchema = import_zod32.z.object({
+  fieldId: import_zod32.z.string(),
+  page: import_zod32.z.number(),
+  x: import_zod32.z.number().describe("Percentage from left edge (0-100)"),
+  y: import_zod32.z.number().describe("Percentage from top edge (0-100)"),
+  text: import_zod32.z.string(),
+  fontSize: import_zod32.z.number().optional(),
+  isCheckmark: import_zod32.z.boolean().optional()
 });
-var AcroFormMappingSchema = import_zod31.z.object({
-  fieldId: import_zod31.z.string(),
-  acroFormName: import_zod31.z.string(),
-  value: import_zod31.z.string()
+var AcroFormMappingSchema = import_zod32.z.object({
+  fieldId: import_zod32.z.string(),
+  acroFormName: import_zod32.z.string(),
+  value: import_zod32.z.string()
 });
-var ApplicationStateSchema = import_zod31.z.object({
-  id: import_zod31.z.string(),
-  pdfBase64: import_zod31.z.string().optional().describe("Original PDF, omitted after extraction"),
-  title: import_zod31.z.string().optional(),
-  applicationType: import_zod31.z.string().nullable().optional(),
-  fields: import_zod31.z.array(ApplicationFieldSchema),
-  batches: import_zod31.z.array(import_zod31.z.array(import_zod31.z.string())).optional(),
-  currentBatchIndex: import_zod31.z.number().default(0),
-  status: import_zod31.z.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
-  createdAt: import_zod31.z.number(),
-  updatedAt: import_zod31.z.number()
+var ApplicationStateSchema = import_zod32.z.object({
+  id: import_zod32.z.string(),
+  pdfBase64: import_zod32.z.string().optional().describe("Original PDF, omitted after extraction"),
+  title: import_zod32.z.string().optional(),
+  applicationType: import_zod32.z.string().nullable().optional(),
+  fields: import_zod32.z.array(ApplicationFieldSchema),
+  batches: import_zod32.z.array(import_zod32.z.array(import_zod32.z.string())).optional(),
+  currentBatchIndex: import_zod32.z.number().default(0),
+  status: import_zod32.z.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
+  createdAt: import_zod32.z.number(),
+  updatedAt: import_zod32.z.number()
 });
 
 // src/application/agents/classifier.ts
@@ -4948,73 +5001,73 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-var import_zod32 = require("zod");
-var QueryIntentSchema = import_zod32.z.enum([
+var import_zod33 = require("zod");
+var QueryIntentSchema = import_zod33.z.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var SubQuestionSchema = import_zod32.z.object({
-  question: import_zod32.z.string().describe("Atomic sub-question to retrieve and answer independently"),
+var SubQuestionSchema = import_zod33.z.object({
+  question: import_zod33.z.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: import_zod32.z.array(import_zod32.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: import_zod32.z.object({
-    type: import_zod32.z.enum(["policy", "quote"]).optional(),
-    carrier: import_zod32.z.string().optional(),
-    insuredName: import_zod32.z.string().optional(),
-    policyNumber: import_zod32.z.string().optional(),
-    quoteNumber: import_zod32.z.string().optional()
+  chunkTypes: import_zod33.z.array(import_zod33.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: import_zod33.z.object({
+    type: import_zod33.z.enum(["policy", "quote"]).optional(),
+    carrier: import_zod33.z.string().optional(),
+    insuredName: import_zod33.z.string().optional(),
+    policyNumber: import_zod33.z.string().optional(),
+    quoteNumber: import_zod33.z.string().optional()
   }).optional().describe("Structured filters to narrow document lookup")
 });
-var QueryClassifyResultSchema = import_zod32.z.object({
+var QueryClassifyResultSchema = import_zod33.z.object({
   intent: QueryIntentSchema,
-  subQuestions: import_zod32.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: import_zod32.z.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: import_zod32.z.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: import_zod32.z.boolean().describe("Whether conversation history is relevant")
+  subQuestions: import_zod33.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: import_zod33.z.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: import_zod33.z.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: import_zod33.z.boolean().describe("Whether conversation history is relevant")
 });
-var EvidenceItemSchema = import_zod32.z.object({
-  source: import_zod32.z.enum(["chunk", "document", "conversation"]),
-  chunkId: import_zod32.z.string().optional(),
-  documentId: import_zod32.z.string().optional(),
-  turnId: import_zod32.z.string().optional(),
-  text: import_zod32.z.string().describe("Text excerpt from the source"),
-  relevance: import_zod32.z.number().min(0).max(1),
-  metadata: import_zod32.z.array(import_zod32.z.object({ key: import_zod32.z.string(), value: import_zod32.z.string() })).optional()
+var EvidenceItemSchema = import_zod33.z.object({
+  source: import_zod33.z.enum(["chunk", "document", "conversation"]),
+  chunkId: import_zod33.z.string().optional(),
+  documentId: import_zod33.z.string().optional(),
+  turnId: import_zod33.z.string().optional(),
+  text: import_zod33.z.string().describe("Text excerpt from the source"),
+  relevance: import_zod33.z.number().min(0).max(1),
+  metadata: import_zod33.z.array(import_zod33.z.object({ key: import_zod33.z.string(), value: import_zod33.z.string() })).optional()
 });
-var RetrievalResultSchema = import_zod32.z.object({
-  subQuestion: import_zod32.z.string(),
-  evidence: import_zod32.z.array(EvidenceItemSchema)
+var RetrievalResultSchema = import_zod33.z.object({
+  subQuestion: import_zod33.z.string(),
+  evidence: import_zod33.z.array(EvidenceItemSchema)
 });
-var CitationSchema = import_zod32.z.object({
-  index: import_zod32.z.number().describe("Citation number [1], [2], etc."),
-  chunkId: import_zod32.z.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  documentId: import_zod32.z.string(),
-  documentType: import_zod32.z.enum(["policy", "quote"]).optional(),
-  field: import_zod32.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: import_zod32.z.string().describe("Exact text from source that supports the claim"),
-  relevance: import_zod32.z.number().min(0).max(1)
+var CitationSchema = import_zod33.z.object({
+  index: import_zod33.z.number().describe("Citation number [1], [2], etc."),
+  chunkId: import_zod33.z.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  documentId: import_zod33.z.string(),
+  documentType: import_zod33.z.enum(["policy", "quote"]).optional(),
+  field: import_zod33.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: import_zod33.z.string().describe("Exact text from source that supports the claim"),
+  relevance: import_zod33.z.number().min(0).max(1)
 });
-var SubAnswerSchema = import_zod32.z.object({
-  subQuestion: import_zod32.z.string(),
-  answer: import_zod32.z.string(),
-  citations: import_zod32.z.array(CitationSchema),
-  confidence: import_zod32.z.number().min(0).max(1),
-  needsMoreContext: import_zod32.z.boolean().describe("True if evidence was insufficient to answer fully")
+var SubAnswerSchema = import_zod33.z.object({
+  subQuestion: import_zod33.z.string(),
+  answer: import_zod33.z.string(),
+  citations: import_zod33.z.array(CitationSchema),
+  confidence: import_zod33.z.number().min(0).max(1),
+  needsMoreContext: import_zod33.z.boolean().describe("True if evidence was insufficient to answer fully")
 });
-var VerifyResultSchema = import_zod32.z.object({
-  approved: import_zod32.z.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: import_zod32.z.array(import_zod32.z.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: import_zod32.z.array(import_zod32.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+var VerifyResultSchema = import_zod33.z.object({
+  approved: import_zod33.z.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: import_zod33.z.array(import_zod33.z.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: import_zod33.z.array(import_zod33.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
 });
-var QueryResultSchema = import_zod32.z.object({
-  answer: import_zod32.z.string(),
-  citations: import_zod32.z.array(CitationSchema),
+var QueryResultSchema = import_zod33.z.object({
+  answer: import_zod33.z.string(),
+  citations: import_zod33.z.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: import_zod32.z.number().min(0).max(1),
-  followUp: import_zod32.z.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: import_zod33.z.number().min(0).max(1),
+  followUp: import_zod33.z.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -5896,6 +5949,7 @@ var AGENT_TOOLS = [
   safeGenerateObject,
   sanitizeNulls,
   stripFences,
+  toStrictSchema,
   withRetry
 });
 //# sourceMappingURL=index.js.map