@eigenpal/cli 0.20.27 → 0.20.29

package/dist/cli.js

@@ -6684,6 +6684,14 @@ function object(shape, params) {
   };
   return new ZodObject(def);
 }
+function strictObject(shape, params) {
+  return new ZodObject({
+    type: "object",
+    shape,
+    catchall: never(),
+    ...normalizeParams(params)
+  });
+}
 function union(options, params) {
   return new ZodUnion({
     type: "union",
@@ -7671,6 +7679,637 @@ var require_picocolors = __commonJS(function(exports, module) {
   module.exports.createColors = createColors;
 });
 
+// ../types/src/client/ai-client.ts
+var REASONING_EFFORTS, ReasoningEffortSchema, ModelReasoningConfigSchema;
+var init_ai_client = __esm(() => {
+  init_zod();
+  REASONING_EFFORTS = [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max"
+  ];
+  ReasoningEffortSchema = _enum(REASONING_EFFORTS);
+  ModelReasoningConfigSchema = object({
+    supportedEfforts: array(ReasoningEffortSchema).min(1),
+    defaultEffort: ReasoningEffortSchema.optional()
+  }).refine((config) => config.defaultEffort === undefined || config.supportedEfforts.includes(config.defaultEffort), {
+    message: "defaultEffort must be included in supportedEfforts",
+    path: ["defaultEffort"]
+  }).strict();
+});
+
+// ../types/src/parser/native-text-quality.ts
+var NativeTextQualityStatusSchema, NativeTextQualityReasonSchema, NativeTextQualityCountsSchema, NativeTextQualityProfileSchema, NativeTextQualitySchema;
+var init_native_text_quality = __esm(() => {
+  init_zod();
+  NativeTextQualityStatusSchema = _enum(["clean", "empty", "suspect"]);
+  NativeTextQualityReasonSchema = _enum([
+    "empty",
+    "replacement-character",
+    "lone-surrogate",
+    "forbidden-control",
+    "unassigned",
+    "noncharacter",
+    "private-use"
+  ]);
+  NativeTextQualityCountsSchema = object({
+    codePoints: number2().int().nonnegative(),
+    nonWhitespace: number2().int().nonnegative(),
+    replacement: number2().int().nonnegative(),
+    loneSurrogate: number2().int().nonnegative(),
+    forbiddenControl: number2().int().nonnegative(),
+    unassigned: number2().int().nonnegative(),
+    noncharacter: number2().int().nonnegative(),
+    privateUse: number2().int().nonnegative()
+  });
+  NativeTextQualityProfileSchema = object({
+    replacementRatio: number2().nonnegative(),
+    loneSurrogateRatio: number2().nonnegative(),
+    forbiddenControlRatio: number2().nonnegative(),
+    unassignedRatio: number2().nonnegative(),
+    noncharacterRatio: number2().nonnegative(),
+    privateUseRatio: number2().nonnegative()
+  });
+  NativeTextQualitySchema = object({
+    status: NativeTextQualityStatusSchema,
+    reasons: array(NativeTextQualityReasonSchema),
+    counts: NativeTextQualityCountsSchema,
+    profile: NativeTextQualityProfileSchema
+  });
+});
+
+// ../types/src/parser/spreadsheet-evidence.ts
+var SpreadsheetCellEvidenceSchema, SpreadsheetPageEvidenceSchema;
+var init_spreadsheet_evidence = __esm(() => {
+  init_zod();
+  SpreadsheetCellEvidenceSchema = object({
+    address: string2().describe("Original A1 cell address"),
+    type: string2().describe("Excel storage type: n=number, s=string, b=boolean, e=error, d=date, z=blank. A numeric date remains type n."),
+    rawValue: union([string2(), number2(), boolean2(), _null3()]).optional().describe("Stored cached value; formulas are never evaluated"),
+    displayedValue: string2().describe("Value formatted using the workbook number format and date system"),
+    numberFormat: string2().optional(),
+    formula: string2().optional(),
+    dateValue: string2().optional().describe("Calendar rendering for a valid date-formatted serial, without a timezone. Evidence of Excel formatting, not a business classification."),
+    excelLeapDay: boolean2().optional().describe("True for the fictitious 1900-02-29 in the Excel 1900 date system")
+  });
+  SpreadsheetPageEvidenceSchema = object({
+    dateSystem: _enum(["1900", "1904"]),
+    declaredRange: string2().optional(),
+    cells: array(SpreadsheetCellEvidenceSchema)
+  });
+});
+
+// ../types/src/parser/parser.ts
+function refineNativeParseModeConflicts(config, ctx) {
+  if (config.parseMode === "native" && config.describeFigures === true) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      path: ["describeFigures"],
+      message: 'parseMode "native" cannot be combined with describeFigures because figure captions require vision egress'
+    });
+  }
+}
+function isNativeLayoutCompatible(config) {
+  return config.parseMode === "native" || config.parseMode === "native-or-ocr";
+}
+function refineLayoutOutputFormat(config, ctx) {
+  if (config.outputFormat !== "layout")
+    return;
+  if (isNativeLayoutCompatible(config))
+    return;
+  ctx.addIssue({
+    code: ZodIssueCode.custom,
+    path: ["outputFormat"],
+    message: LAYOUT_OUTPUT_PARSE_MODE_ERROR
+  });
+}
+function mimeTypeForExtension(extension) {
+  return EXTENSION_TO_MIME[extension.replace(/^\./, "").toLowerCase()];
+}
+var OFFICE_MIME_TYPES, ParserCategory, ParserTypeSchema, ParseModeSchema, PARSE_OUTPUT_FORMATS, ParseOutputFormatSchema, PageProvenanceSourceSchema, PageProvenanceSchema, ProcessingStrategySchema, LAYOUT_OUTPUT_PARSE_MODE_ERROR = 'outputFormat "layout" is native PDF-only. Set parseMode to "native" or "native-or-ocr". Omitted parseMode, OCR, vision, and nativeText: true cannot request layout.', PARSE_OUTPUT_FORMAT_DESCRIPTION = "Format for extracted text. `markdown` (default) keeps structure; `plain` is unstyled text; `djot`/`html` preserve more markup. `layout` is native-PDF spatial text with column gaps preserved as spaces. It requires `parseMode: native` or `parseMode: native-or-ocr` and a PDF — omitted parseMode and `nativeText: true` are not enough. Native mode is layout-only and fail-closed. `native-or-ocr` keeps layout text on accepted native pages and uses OCR markdown on suspect or empty pages, so the document can mix fixed-width layout and markdown. Extractor failure never falls back to another parser. Office, plaintext, and images fail. OCR/vision cannot request `layout`.", DocumentMetadataSchema, ParseUsageSchema, StructuredDocumentSchema, CoordinateUnitSchema, PointSchema, BoundingRegionSchema, PositionedTextSchema, TableCellSchema, ExtractedTableSchema, LayoutElementTypeSchema, LayoutElementSchema, PageResultSchema, ParseResultSchema, ParseOptionsSchema, ParserInputSchema, EXTENSION_TO_MIME, MIME_TO_EXTENSION;
+var init_parser = __esm(() => {
+  init_zod();
+  init_ai_client();
+  init_native_text_quality();
+  init_spreadsheet_evidence();
+  OFFICE_MIME_TYPES = [
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/msword",
+    "application/vnd.oasis.opendocument.text",
+    "application/rtf",
+    "text/rtf",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.ms-excel",
+    "application/vnd.ms-excel.sheet.macroenabled.12",
+    "application/vnd.ms-excel.sheet.binary.macroenabled.12",
+    "application/vnd.oasis.opendocument.spreadsheet",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
+    "application/vnd.ms-powerpoint.presentation.macroenabled.12",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.oasis.opendocument.presentation",
+    "message/rfc822",
+    "application/vnd.ms-outlook",
+    "application/epub+zip"
+  ];
+  ParserCategory = {
+    PLAINTEXT: [
+      "text/plain",
+      "text/markdown",
+      "text/csv",
+      "text/tab-separated-values",
+      "text/html",
+      "text/xml",
+      "application/json",
+      "application/x-yaml",
+      "application/toml",
+      "image/svg+xml",
+      "text/x-rst",
+      "text/x-org",
+      "application/x-latex",
+      "application/x-ipynb+json",
+      "application/x-bibtex",
+      "application/docbook+xml",
+      "application/x-fictionbook+xml"
+    ],
+    OFFICE: [...OFFICE_MIME_TYPES],
+    DOCUMENT: [
+      "application/pdf",
+      "image/png",
+      "image/jpeg",
+      "image/webp",
+      "image/tiff",
+      "image/gif",
+      "image/bmp"
+    ]
+  };
+  ParserTypeSchema = _enum([
+    "plaintext",
+    "office",
+    "llm-vision",
+    "ocr"
+  ]);
+  ParseModeSchema = _enum(["ocr", "vision", "native", "native-or-ocr"]);
+  PARSE_OUTPUT_FORMATS = ["plain", "markdown", "djot", "html", "layout"];
+  ParseOutputFormatSchema = _enum(PARSE_OUTPUT_FORMATS);
+  PageProvenanceSourceSchema = _enum(["native", "ocr", "vision"]);
+  PageProvenanceSchema = object({
+    source: PageProvenanceSourceSchema
+  });
+  ProcessingStrategySchema = _enum(["native", "ocr", "vision", "hybrid"]);
+  DocumentMetadataSchema = object({
+    filename: string2(),
+    mimeType: string2(),
+    size: number2().describe("File size in bytes"),
+    storageRef: string2().optional().describe("Storage reference for the original file")
+  });
+  ParseUsageSchema = object({
+    pageCount: number2(),
+    processingTimeMs: number2().optional(),
+    ocrPagesProcessed: number2().int().nonnegative().optional(),
+    visionPagesProcessed: number2().int().nonnegative().optional(),
+    visionPromptTokens: number2().int().nonnegative().optional(),
+    visionCompletionTokens: number2().int().nonnegative().optional(),
+    cached: boolean2().optional()
+  });
+  StructuredDocumentSchema = record(string2(), unknown());
+  CoordinateUnitSchema = _enum(["pixel", "inch", "point", "normalized"]);
+  PointSchema = object({
+    x: number2(),
+    y: number2()
+  });
+  BoundingRegionSchema = object({
+    polygon: array(PointSchema).min(3),
+    unit: CoordinateUnitSchema,
+    pageIndex: number2()
+  });
+  PositionedTextSchema = object({
+    text: string2(),
+    confidence: number2().min(0).max(1).optional(),
+    boundingRegion: BoundingRegionSchema.optional()
+  });
+  TableCellSchema = object({
+    content: string2(),
+    rowIndex: number2(),
+    columnIndex: number2(),
+    rowSpan: number2().default(1),
+    columnSpan: number2().default(1),
+    boundingRegion: BoundingRegionSchema.optional()
+  });
+  ExtractedTableSchema = object({
+    cells: array(TableCellSchema),
+    rowCount: number2(),
+    columnCount: number2(),
+    boundingRegion: BoundingRegionSchema.optional()
+  });
+  LayoutElementTypeSchema = _enum([
+    "paragraph",
+    "title",
+    "sectionHeading",
+    "pageHeader",
+    "pageFooter",
+    "pageNumber",
+    "footnote",
+    "table",
+    "figure",
+    "formulaBlock"
+  ]);
+  LayoutElementSchema = object({
+    type: LayoutElementTypeSchema,
+    content: string2(),
+    table: ExtractedTableSchema.optional(),
+    caption: string2().optional(),
+    figureId: string2().optional(),
+    boundingRegion: BoundingRegionSchema.optional()
+  });
+  PageResultSchema = object({
+    spreadsheet: SpreadsheetPageEvidenceSchema.optional().describe("Opt-in original spreadsheet cell evidence"),
+    pageIndex: number2().describe("0-based page index"),
+    text: string2().describe("Extracted page text (markdown/HTML/plain, or spatial layout text)"),
+    pageName: string2().optional().describe("Page/sheet name (e.g., Excel sheet name)"),
+    layoutElements: array(LayoutElementSchema).optional().describe("Semantic layout elements in reading order"),
+    words: array(PositionedTextSchema).optional().describe("Word-level positions"),
+    lines: array(PositionedTextSchema).optional().describe("Line-level positions"),
+    tables: array(ExtractedTableSchema).optional().describe("Extracted tables"),
+    width: number2().optional().describe("Page width"),
+    height: number2().optional().describe("Page height"),
+    unit: CoordinateUnitSchema.optional().describe("Unit for width/height and bounding regions"),
+    confidence: number2().min(0).max(1).optional().describe("Overall page confidence"),
+    nativeTextQuality: NativeTextQualitySchema.optional().describe('Per-page diagnosis of native-extracted text. Reports objectively detectable anomalies (empty, U+FFFD, forbidden controls, unassigned/noncharacter code points, heavy private-use). Does not certify semantic correctness — valid-looking wrong mappings and literal "?" cannot be distinguished from legitimate text.'),
+    provenance: PageProvenanceSchema.optional().describe("Which extractor produced the final text/layout on this page")
+  });
+  ParseResultSchema = object({
+    document: DocumentMetadataSchema,
+    usage: ParseUsageSchema,
+    pages: array(PageResultSchema),
+    text: string2().describe("Combined text from all pages"),
+    parserType: ParserTypeSchema,
+    parserVersion: string2().optional(),
+    model: string2().optional().describe("Model used (for LLM/OCR parsers)"),
+    processingStrategy: ProcessingStrategySchema.optional().describe("How this result was produced: `native` (local PDF text only), `ocr`, `vision`, or `hybrid` (native pages merged with OCR on fallback pages)."),
+    structured: StructuredDocumentSchema.optional().describe("Canonical structured document with ordered blocks, regions, bounding boxes, tables, figures, and chunks when supported by the parser"),
+    rawResponse: unknown().optional()
+  });
+  ParseOptionsSchema = object({
+    includeCellMetadata: boolean2().optional(),
+    outputFormat: ParseOutputFormatSchema.default("markdown"),
+    ocrProvider: string2().optional().describe("OCR provider ID to use"),
+    includeWordPositions: boolean2().default(false),
+    includeLinePositions: boolean2().default(false),
+    extractTables: boolean2().default(true),
+    provider: string2().optional().describe("LLM provider ID to use"),
+    model: string2().optional(),
+    reasoningEffort: ReasoningEffortSchema.optional(),
+    maxConcurrency: number2().min(1).max(30).default(3),
+    pagesPerBatch: number2().min(1).max(20).default(5),
+    pdfRenderScale: number2().min(1).max(4).default(1).describe("Scale factor used when rendering PDF pages for VLM parsing"),
+    imageQuality: number2().int().min(1).max(100).default(85).describe("JPEG quality used for PDF page images sent to VLM parsing"),
+    prompt: string2().optional().describe("Custom prompt for LLM-based parsing"),
+    languages: array(string2()).optional().describe("OCR language hints"),
+    pages: array(number2().int().min(1)).optional().describe("1-indexed pages to OCR; omit or empty to analyze the whole document"),
+    tenantId: string2().optional(),
+    requireCompletePages: boolean2().optional()
+  });
+  ParserInputSchema = object({
+    data: _instanceof(Buffer).or(_instanceof(Uint8Array)),
+    filename: string2(),
+    mimeType: string2(),
+    options: ParseOptionsSchema.optional()
+  });
+  EXTENSION_TO_MIME = {
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    doc: "application/msword",
+    odt: "application/vnd.oasis.opendocument.text",
+    rtf: "application/rtf",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    xls: "application/vnd.ms-excel",
+    xlsm: "application/vnd.ms-excel.sheet.macroenabled.12",
+    xlsb: "application/vnd.ms-excel.sheet.binary.macroenabled.12",
+    ods: "application/vnd.oasis.opendocument.spreadsheet",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ppsx: "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
+    pptm: "application/vnd.ms-powerpoint.presentation.macroenabled.12",
+    ppt: "application/vnd.ms-powerpoint",
+    odp: "application/vnd.oasis.opendocument.presentation",
+    eml: "message/rfc822",
+    msg: "application/vnd.ms-outlook",
+    epub: "application/epub+zip",
+    pdf: "application/pdf",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    tiff: "image/tiff",
+    tif: "image/tiff",
+    gif: "image/gif",
+    bmp: "image/bmp",
+    svg: "image/svg+xml",
+    txt: "text/plain",
+    md: "text/markdown",
+    markdown: "text/markdown",
+    csv: "text/csv",
+    tsv: "text/tab-separated-values",
+    html: "text/html",
+    htm: "text/html",
+    xml: "text/xml",
+    json: "application/json",
+    yaml: "application/x-yaml",
+    yml: "application/x-yaml",
+    toml: "application/toml",
+    rst: "text/x-rst",
+    org: "text/x-org",
+    tex: "application/x-latex",
+    latex: "application/x-latex",
+    ipynb: "application/x-ipynb+json",
+    bib: "application/x-bibtex",
+    dbk: "application/docbook+xml",
+    docbook: "application/docbook+xml",
+    fb2: "application/x-fictionbook+xml",
+    zip: "application/zip"
+  };
+  MIME_TO_EXTENSION = Object.entries(EXTENSION_TO_MIME).reduce((acc, [ext, mime]) => {
+    if (!(mime in acc))
+      acc[mime] = ext;
+    return acc;
+  }, {});
+});
+
+// ../types/src/files/runtime-file-ref.ts
+var DbFileRefSchema, LegacyFileIdInputSchema, LocalFileRefSchema, S3FileRefSchema, InlineFileRefSchema, RuntimeFileRefSchema, FilePathDescriptorSchema, ResolvedProcessorFileSchema;
+var init_runtime_file_ref = __esm(() => {
+  init_zod();
+  DbFileRefSchema = object({
+    kind: literal("file"),
+    fileId: string2().describe("File ID from files table"),
+    filename: string2().optional().describe("Original filename"),
+    mimeType: string2().optional().describe("MIME type")
+  });
+  LegacyFileIdInputSchema = object({
+    kind: never().optional(),
+    fileId: string2().describe("File ID from files table"),
+    filename: string2().optional().describe("Original filename"),
+    mimeType: string2().optional().describe("MIME type")
+  });
+  LocalFileRefSchema = object({
+    kind: literal("local"),
+    path: string2().describe("Absolute path to a file on disk"),
+    filename: string2().describe("Original filename"),
+    mimeType: string2().describe("MIME type of the file")
+  });
+  S3FileRefSchema = object({
+    kind: literal("s3"),
+    ref: string2().describe("Storage key (suffix-only, prefix added by adapter)"),
+    filename: string2().describe("Original filename"),
+    mimeType: string2().describe("MIME type of the file")
+  });
+  InlineFileRefSchema = object({
+    kind: literal("inline"),
+    base64: string2().describe("Base64-encoded file bytes"),
+    filename: string2().describe("Original filename"),
+    mimeType: string2().describe("MIME type of the file")
+  });
+  RuntimeFileRefSchema = discriminatedUnion("kind", [
+    DbFileRefSchema,
+    LocalFileRefSchema,
+    S3FileRefSchema,
+    InlineFileRefSchema
+  ]);
+  FilePathDescriptorSchema = discriminatedUnion("kind", [
+    LocalFileRefSchema,
+    S3FileRefSchema,
+    InlineFileRefSchema
+  ]);
+  ResolvedProcessorFileSchema = object({
+    __eigenpalFile: literal(true),
+    source: _enum(["db", "tenant-s3", "local", "inline"]),
+    filename: string2().describe("Display filename for processor logs and parser routing"),
+    mimeType: string2().describe("MIME type for processor routing"),
+    fileId: string2().optional().describe("Legacy files-table id for db-backed handles"),
+    ref: string2().optional().describe("Tenant-scoped storage key suffix for S3-backed handles"),
+    path: string2().optional().describe("Local filesystem path for headless/CLI handles"),
+    base64: string2().optional().describe("Base64 bytes for inline handles"),
+    size: number2().int().nonnegative().optional().describe("Byte size when a file-producing step recorded it")
+  }).strict();
+});
+
+// ../types/src/processor/configs/document-parser.ts
+var DocumentParserInputSchema, DocumentParserOutputSchema, DocumentParserConfigSchema;
+var init_document_parser = __esm(() => {
+  init_zod();
+  init_ai_client();
+  init_runtime_file_ref();
+  init_parser();
+  DocumentParserInputSchema = ResolvedProcessorFileSchema;
+  DocumentParserOutputSchema = ParseResultSchema;
+  DocumentParserConfigSchema = object({
+    parseMode: ParseModeSchema.optional().describe('Base parser for PDF/image inputs. OCR is the default. `native` extracts PDF text only (never OCR/vision). `native-or-ocr` requests OCR when pages have detectable native-text anomalies (empty, U+FFFD, lone surrogates, forbidden controls, unassigned/noncharacter, heavy PUA). Page selection, subset egress, and billing are provider-dependent. Valid-looking wrong text and literal "?" are not flagged.'),
+    ocrModel: string2().optional().describe("OCR provider ID for PDF/image parsing"),
+    llmModel: string2().optional().describe("LLM provider ID for vision-based parsing"),
+    llmReasoningEffort: ReasoningEffortSchema.optional().describe("Reasoning effort for vision-based parsing. Omit to use the model default."),
+    figureModel: string2().optional().describe("Vision model used only for the optional figure-description pass"),
+    figureReasoningEffort: ReasoningEffortSchema.optional().describe("Reasoning effort for figure descriptions. Omit to use the model default."),
+    maxConcurrency: number2().min(1).max(10).default(3).describe("Max concurrent VLM batch requests"),
+    pagesPerBatch: number2().min(1).max(20).default(5).describe("Number of page images per VLM request"),
+    pdfRenderScale: number2().min(1).max(4).default(1).optional().describe("Scale factor used when rendering PDF pages for VLM parsing"),
+    imageQuality: number2().int().min(1).max(100).default(85).optional().describe("JPEG quality used for PDF page images sent to VLM parsing"),
+    prompt: string2().optional().describe("Custom extraction prompt"),
+    nativeText: boolean2().default(false).optional().describe("Use native text extraction for PDFs with embedded text (no OCR/VLM)"),
+    describeFigures: boolean2().optional().describe("Opt-in (default off). After text extraction, detect figure pages with a layout model and caption them with a vision model, appending `<figure>description</figure>` to their text. Skipped for plaintext. The caption vision calls are billed."),
+    figureInstructions: string2().optional().describe("Custom instruction for the figure-description pass."),
+    languages: array(string2()).optional().describe('OCR language hints (e.g., ["en", "de"])'),
+    outputFormat: ParseOutputFormatSchema.default("markdown").optional().describe(PARSE_OUTPUT_FORMAT_DESCRIPTION),
+    cache: boolean2().default(false).optional().describe("When true, reuse a prior parse for identical file bytes and parse settings. Skips OCR/vision on cache hit. Stored in tenant blob storage with no automatic expiry (TTL/lifecycle is a follow-up). Default off.")
+  }).superRefine(refineNativeParseModeConflicts).superRefine(refineLayoutOutputFormat).prefault({});
+});
+
+// ../types/src/processor/configs/document-parser-v2.ts
+var ImageReadingBackendSchema, ParseV2TextFormatSchema, ParseV2SettingsSchema, DocumentParserV2ConfigSchema, AiParseV2ConfigSchema, ParseV2PageSchema, ParseV2ResultSchema, DocumentParserV2InputSchema;
+var init_document_parser_v2 = __esm(() => {
+  init_zod();
+  init_ai_client();
+  init_parser();
+  init_document_parser();
+  ImageReadingBackendSchema = _enum(["ocr", "vision"]);
+  ParseV2TextFormatSchema = _enum(["plain", "markdown", "html", "djot"]);
+  ParseV2SettingsSchema = strictObject({
+    policy: strictObject({
+      native: _enum(["prefer", "require", "skip"]).default("prefer").describe("Prefer local text extraction, require local text extraction with no image transcription, or skip native PDF extraction. Figure enrichment is independent."),
+      imageReading: strictObject({
+        order: array(ImageReadingBackendSchema).min(1).max(2).refine((v) => new Set(v).size === v.length, "Backends must be unique").default(["ocr", "vision"]).describe("Ordered allowed backends. A single entry prohibits the other backend.")
+      }).prefault({})
+    }).prefault({}),
+    providers: strictObject({
+      ocr: string2().min(1).optional().describe("Exact configured OCR provider ID. Missing pins fail; they never resolve to another provider."),
+      vision: string2().min(1).optional().describe("Exact configured vision provider ID. Otherwise uses the deployment parsing default or vision role.")
+    }).prefault({}),
+    output: strictObject({
+      textFormat: ParseV2TextFormatSchema.default("markdown"),
+      includeCellMetadata: boolean2().default(false).describe("Include spreadsheet cell evidence in pages[].spreadsheet and annotate text for downstream extraction. Preserves raw/displayed values and workbook date system."),
+      nativeWhitespace: _enum(["reading-order", "spatial"]).default("reading-order").describe("Spatial preserves native PDF column spacing. It does not promise OCR/vision coordinates."),
+      require: array(_enum(["wordCoordinates", "tables"])).default([]).describe("Required evidence capabilities on nonblank pages. Backends unable to satisfy them are rejected.")
+    }).prefault({}),
+    enrichment: strictObject({
+      figures: strictObject({
+        enabled: boolean2().default(false),
+        provider: string2().min(1).optional(),
+        instructions: string2().optional(),
+        reasoningEffort: ReasoningEffortSchema.optional()
+      }).prefault({})
+    }).prefault({}),
+    advanced: strictObject({
+      vision: strictObject({
+        maxConcurrency: number2().int().min(1).max(10).default(3),
+        pagesPerBatch: number2().int().min(1).max(20).default(5),
+        renderScale: number2().min(1).max(4).default(2),
+        imageQuality: number2().int().min(1).max(100).default(85),
+        instructions: string2().optional().describe("Transcription instructions, never document-specific extraction/schema instructions."),
+        reasoningEffort: ReasoningEffortSchema.optional()
+      }).prefault({}),
+      languages: array(string2().min(1)).optional(),
+      allowPartial: boolean2().default(false).describe("Return unresolved pages explicitly instead of failing. Default false."),
+      cache: boolean2().default(false)
+    }).prefault({})
+  }).superRefine((config, ctx) => {
+    if (config.output.nativeWhitespace === "spatial" && config.output.textFormat !== "plain") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["output"],
+        message: "Spatial native whitespace requires textFormat: plain."
+      });
+    }
+  });
+  DocumentParserV2ConfigSchema = ParseV2SettingsSchema.prefault({});
+  AiParseV2ConfigSchema = ParseV2SettingsSchema.safeExtend({
+    input: string2().min(1).describe("File reference or template expression for the document")
+  });
+  ParseV2PageSchema = PageResultSchema.extend({
+    provenance: object({
+      source: _enum(["native", "ocr", "vision"]),
+      provider: string2().optional(),
+      model: string2().optional(),
+      reason: string2(),
+      textFormat: ParseV2TextFormatSchema,
+      capabilities: array(_enum(["wordCoordinates", "tables"]))
+    }),
+    status: _enum(["complete", "blank", "no-text", "unresolved"]),
+    warnings: array(string2()).default([])
+  });
+  ParseV2ResultSchema = ParseResultSchema.omit({ rawResponse: true }).extend({
+    parserVersion: literal("2"),
+    pages: array(ParseV2PageSchema),
+    completeness: object({
+      status: _enum(["complete", "partial"]),
+      unresolvedPageIndexes: array(number2().int().nonnegative())
+    }),
+    usage: ParseResultSchema.shape.usage.extend({
+      visionPagesProcessed: number2().int().nonnegative()
+    })
+  });
+  DocumentParserV2InputSchema = DocumentParserInputSchema;
+});
+
+// ../types/src/processor/configs/parse-v2-migration.ts
+function migrateWorkflowParsers(definition, policy) {
+  const warnings = [];
+  const migratedSteps = [];
+  function walk(value) {
+    if (Array.isArray(value))
+      return value.map(walk);
+    if (!value || typeof value !== "object")
+      return value;
+    const record = value;
+    const result = { ...record };
+    for (const key of ["steps", "then", "else", "branches", "cases", "default"])
+      if (Array.isArray(record[key]))
+        result[key] = walk(record[key]);
+    if (record.type !== "ai.parse")
+      return result;
+    const name = String(record.name ?? "parse");
+    const config = record.with ?? {};
+    const unknown = Object.keys(config).filter((k) => !LEGACY_FIELDS.has(k));
+    if (unknown.length)
+      throw new Error(`Cannot migrate '${name}': unsupported settings ${unknown.join(", ")}. Review them before migrating.`);
+    const mode = config.parseMode;
+    let native = mode === "native" ? "require" : mode === "native-or-ocr" || config.nativeText === true ? "prefer" : "skip";
+    if (mode !== undefined && !["native", "ocr", "vision", "native-or-ocr"].includes(String(mode)))
+      throw new Error(`Cannot migrate '${name}': unknown legacy parseMode '${String(mode)}'.`);
+    let order = mode === "vision" || !mode && !config.ocrModel && config.llmModel ? ["vision"] : ["ocr"];
+    if (policy === "auto") {
+      if (native === "require" || order.length === 1)
+        warnings.push(`${name}: automatic policy broadens allowed image-reading backends; review egress and cost restrictions.`);
+      native = "prefer";
+      order = ["ocr", "vision"];
+    }
+    if (config.nativeText)
+      warnings.push(`${name}: v2 checks every page; legacy document-wide nativeText success is intentionally not preserved.`);
+    if (config.outputFormat === "layout")
+      warnings.push(`${name}: layout becomes plain text with spatial native whitespace. Image-reading pages use plain transcription without invented geometry.`);
+    warnings.push(`${name}: completeness validation may expose unread content; compare downstream outputs before publishing.`);
+    const next = {
+      input: config.input,
+      policy: { native, imageReading: { order } },
+      providers: { ocr: config.ocrModel, vision: config.llmModel },
+      output: {
+        textFormat: config.outputFormat === "layout" ? "plain" : config.outputFormat ?? "markdown",
+        nativeWhitespace: config.outputFormat === "layout" ? "spatial" : "reading-order"
+      },
+      enrichment: {
+        figures: {
+          enabled: config.describeFigures ?? false,
+          provider: config.figureModel ?? (mode === "vision" ? config.llmModel : undefined),
+          instructions: config.figureInstructions,
+          reasoningEffort: config.figureReasoningEffort
+        }
+      },
+      advanced: {
+        cache: config.cache ?? false,
+        languages: config.languages,
+        vision: {
+          maxConcurrency: config.maxConcurrency,
+          pagesPerBatch: config.pagesPerBatch,
+          renderScale: config.pdfRenderScale,
+          imageQuality: config.imageQuality,
+          instructions: config.prompt,
+          reasoningEffort: config.llmReasoningEffort
+        }
+      }
+    };
+    result.type = "ai.parse-v2";
+    result.with = AiParseV2ConfigSchema.parse(next);
+    migratedSteps.push(name);
+    return result;
+  }
+  return { definition: walk(definition), migratedSteps, warnings };
+}
+var LEGACY_FIELDS;
+var init_parse_v2_migration = __esm(() => {
+  init_document_parser_v2();
+  LEGACY_FIELDS = new Set([
+    "input",
+    "parseMode",
+    "nativeText",
+    "ocrModel",
+    "llmModel",
+    "llmReasoningEffort",
+    "figureModel",
+    "figureReasoningEffort",
+    "describeFigures",
+    "figureInstructions",
+    "maxConcurrency",
+    "pagesPerBatch",
+    "pdfRenderScale",
+    "imageQuality",
+    "prompt",
+    "languages",
+    "outputFormat",
+    "cache"
+  ]);
+});
+
 // ../../node_modules/nanoid/index.js
 import { webcrypto as crypto } from "node:crypto";
 function fillPool(bytes) {
@@ -7825,6 +8464,7 @@ var init_ids = __esm(() => {
   PROCESSOR_IDS = {
     MERGE: "builtin/merge",
     DOCUMENT_PARSER: "builtin/parser",
+    DOCUMENT_PARSER_V2: "builtin/parser-v2",
     EXTRACT: "builtin/extract",
     SPLIT: "builtin/split",
     SEGMENT: "builtin/segment",
@@ -15179,29 +15819,6 @@ var init_scoped_file_ref = __esm(() => {
   ]);
 });
 
-// ../types/src/client/ai-client.ts
-var REASONING_EFFORTS, ReasoningEffortSchema, ModelReasoningConfigSchema;
-var init_ai_client = __esm(() => {
-  init_zod();
-  REASONING_EFFORTS = [
-    "none",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max"
-  ];
-  ReasoningEffortSchema = _enum(REASONING_EFFORTS);
-  ModelReasoningConfigSchema = object({
-    supportedEfforts: array(ReasoningEffortSchema).min(1),
-    defaultEffort: ReasoningEffortSchema.optional()
-  }).refine((config) => config.defaultEffort === undefined || config.supportedEfforts.includes(config.defaultEffort), {
-    message: "defaultEffort must be included in supportedEfforts",
-    path: ["defaultEffort"]
-  }).strict();
-});
-
 // ../types/src/processor/configs/classify.ts
 var ClassifyInputSchema, ClassifyLabelSchema, ClassifyConfigSchema, ClassifyOutputSchema;
 var init_classify = __esm(() => {
@@ -15268,402 +15885,6 @@ var init_classify_pages = __esm(() => {
   });
 });
 
-// ../types/src/files/runtime-file-ref.ts
-var DbFileRefSchema, LegacyFileIdInputSchema, LocalFileRefSchema, S3FileRefSchema, InlineFileRefSchema, RuntimeFileRefSchema, FilePathDescriptorSchema, ResolvedProcessorFileSchema;
-var init_runtime_file_ref = __esm(() => {
-  init_zod();
-  DbFileRefSchema = object({
-    kind: literal("file"),
-    fileId: string2().describe("File ID from files table"),
-    filename: string2().optional().describe("Original filename"),
-    mimeType: string2().optional().describe("MIME type")
-  });
-  LegacyFileIdInputSchema = object({
-    kind: never().optional(),
-    fileId: string2().describe("File ID from files table"),
-    filename: string2().optional().describe("Original filename"),
-    mimeType: string2().optional().describe("MIME type")
-  });
-  LocalFileRefSchema = object({
-    kind: literal("local"),
-    path: string2().describe("Absolute path to a file on disk"),
-    filename: string2().describe("Original filename"),
-    mimeType: string2().describe("MIME type of the file")
-  });
-  S3FileRefSchema = object({
-    kind: literal("s3"),
-    ref: string2().describe("Storage key (suffix-only, prefix added by adapter)"),
-    filename: string2().describe("Original filename"),
-    mimeType: string2().describe("MIME type of the file")
-  });
-  InlineFileRefSchema = object({
-    kind: literal("inline"),
-    base64: string2().describe("Base64-encoded file bytes"),
-    filename: string2().describe("Original filename"),
-    mimeType: string2().describe("MIME type of the file")
-  });
-  RuntimeFileRefSchema = discriminatedUnion("kind", [
-    DbFileRefSchema,
-    LocalFileRefSchema,
-    S3FileRefSchema,
-    InlineFileRefSchema
-  ]);
-  FilePathDescriptorSchema = discriminatedUnion("kind", [
-    LocalFileRefSchema,
-    S3FileRefSchema,
-    InlineFileRefSchema
-  ]);
-  ResolvedProcessorFileSchema = object({
-    __eigenpalFile: literal(true),
-    source: _enum(["db", "tenant-s3", "local", "inline"]),
-    filename: string2().describe("Display filename for processor logs and parser routing"),
-    mimeType: string2().describe("MIME type for processor routing"),
-    fileId: string2().optional().describe("Legacy files-table id for db-backed handles"),
-    ref: string2().optional().describe("Tenant-scoped storage key suffix for S3-backed handles"),
-    path: string2().optional().describe("Local filesystem path for headless/CLI handles"),
-    base64: string2().optional().describe("Base64 bytes for inline handles"),
-    size: number2().int().nonnegative().optional().describe("Byte size when a file-producing step recorded it")
-  }).strict();
-});
-
-// ../types/src/parser/native-text-quality.ts
-var NativeTextQualityStatusSchema, NativeTextQualityReasonSchema, NativeTextQualityCountsSchema, NativeTextQualityProfileSchema, NativeTextQualitySchema;
-var init_native_text_quality = __esm(() => {
-  init_zod();
-  NativeTextQualityStatusSchema = _enum(["clean", "empty", "suspect"]);
-  NativeTextQualityReasonSchema = _enum([
-    "empty",
-    "replacement-character",
-    "lone-surrogate",
-    "forbidden-control",
-    "unassigned",
-    "noncharacter",
-    "private-use"
-  ]);
-  NativeTextQualityCountsSchema = object({
-    codePoints: number2().int().nonnegative(),
-    nonWhitespace: number2().int().nonnegative(),
-    replacement: number2().int().nonnegative(),
-    loneSurrogate: number2().int().nonnegative(),
-    forbiddenControl: number2().int().nonnegative(),
-    unassigned: number2().int().nonnegative(),
-    noncharacter: number2().int().nonnegative(),
-    privateUse: number2().int().nonnegative()
-  });
-  NativeTextQualityProfileSchema = object({
-    replacementRatio: number2().nonnegative(),
-    loneSurrogateRatio: number2().nonnegative(),
-    forbiddenControlRatio: number2().nonnegative(),
-    unassignedRatio: number2().nonnegative(),
-    noncharacterRatio: number2().nonnegative(),
-    privateUseRatio: number2().nonnegative()
-  });
-  NativeTextQualitySchema = object({
-    status: NativeTextQualityStatusSchema,
-    reasons: array(NativeTextQualityReasonSchema),
-    counts: NativeTextQualityCountsSchema,
-    profile: NativeTextQualityProfileSchema
-  });
-});
-
-// ../types/src/parser/parser.ts
-function refineNativeParseModeConflicts(config, ctx) {
-  if (config.parseMode === "native" && config.describeFigures === true) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      path: ["describeFigures"],
-      message: 'parseMode "native" cannot be combined with describeFigures because figure captions require vision egress'
-    });
-  }
-}
-function isNativeLayoutCompatible(config) {
-  return config.parseMode === "native" || config.parseMode === "native-or-ocr";
-}
-function refineLayoutOutputFormat(config, ctx) {
-  if (config.outputFormat !== "layout")
-    return;
-  if (isNativeLayoutCompatible(config))
-    return;
-  ctx.addIssue({
-    code: ZodIssueCode.custom,
-    path: ["outputFormat"],
-    message: LAYOUT_OUTPUT_PARSE_MODE_ERROR
-  });
-}
-function mimeTypeForExtension(extension) {
-  return EXTENSION_TO_MIME[extension.replace(/^\./, "").toLowerCase()];
-}
-var OFFICE_MIME_TYPES, ParserCategory, ParserTypeSchema, ParseModeSchema, PARSE_OUTPUT_FORMATS, ParseOutputFormatSchema, PageProvenanceSourceSchema, PageProvenanceSchema, ProcessingStrategySchema, LAYOUT_OUTPUT_PARSE_MODE_ERROR = 'outputFormat "layout" is native PDF-only. Set parseMode to "native" or "native-or-ocr". Omitted parseMode, OCR, vision, and nativeText: true cannot request layout.', PARSE_OUTPUT_FORMAT_DESCRIPTION = "Format for extracted text. `markdown` (default) keeps structure; `plain` is unstyled text; `djot`/`html` preserve more markup. `layout` is native-PDF spatial text with column gaps preserved as spaces. It requires `parseMode: native` or `parseMode: native-or-ocr` and a PDF — omitted parseMode and `nativeText: true` are not enough. Native mode is layout-only and fail-closed. `native-or-ocr` keeps layout text on accepted native pages and uses OCR markdown on suspect or empty pages, so the document can mix fixed-width layout and markdown. Extractor failure never falls back to another parser. Office, plaintext, and images fail. OCR/vision cannot request `layout`.", DocumentMetadataSchema, ParseUsageSchema, StructuredDocumentSchema, CoordinateUnitSchema, PointSchema, BoundingRegionSchema, PositionedTextSchema, TableCellSchema, ExtractedTableSchema, LayoutElementTypeSchema, LayoutElementSchema, PageResultSchema, ParseResultSchema, ParseOptionsSchema, ParserInputSchema, EXTENSION_TO_MIME, MIME_TO_EXTENSION;
-var init_parser = __esm(() => {
-  init_zod();
-  init_ai_client();
-  init_native_text_quality();
-  OFFICE_MIME_TYPES = [
-    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    "application/msword",
-    "application/vnd.oasis.opendocument.text",
-    "application/rtf",
-    "text/rtf",
-    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    "application/vnd.ms-excel",
-    "application/vnd.ms-excel.sheet.macroenabled.12",
-    "application/vnd.ms-excel.sheet.binary.macroenabled.12",
-    "application/vnd.oasis.opendocument.spreadsheet",
-    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
-    "application/vnd.ms-powerpoint.presentation.macroenabled.12",
-    "application/vnd.ms-powerpoint",
-    "application/vnd.oasis.opendocument.presentation",
-    "message/rfc822",
-    "application/vnd.ms-outlook",
-    "application/epub+zip"
-  ];
-  ParserCategory = {
-    PLAINTEXT: [
-      "text/plain",
-      "text/markdown",
-      "text/csv",
-      "text/tab-separated-values",
-      "text/html",
-      "text/xml",
-      "application/json",
-      "application/x-yaml",
-      "application/toml",
-      "image/svg+xml",
-      "text/x-rst",
-      "text/x-org",
-      "application/x-latex",
-      "application/x-ipynb+json",
-      "application/x-bibtex",
-      "application/docbook+xml",
-      "application/x-fictionbook+xml"
-    ],
-    OFFICE: [...OFFICE_MIME_TYPES],
-    DOCUMENT: [
-      "application/pdf",
-      "image/png",
-      "image/jpeg",
-      "image/webp",
-      "image/tiff",
-      "image/gif",
-      "image/bmp"
-    ]
-  };
-  ParserTypeSchema = _enum([
-    "plaintext",
-    "office",
-    "llm-vision",
-    "ocr"
-  ]);
-  ParseModeSchema = _enum(["ocr", "vision", "native", "native-or-ocr"]);
-  PARSE_OUTPUT_FORMATS = ["plain", "markdown", "djot", "html", "layout"];
-  ParseOutputFormatSchema = _enum(PARSE_OUTPUT_FORMATS);
-  PageProvenanceSourceSchema = _enum(["native", "ocr", "vision"]);
-  PageProvenanceSchema = object({
-    source: PageProvenanceSourceSchema
-  });
-  ProcessingStrategySchema = _enum(["native", "ocr", "vision", "hybrid"]);
-  DocumentMetadataSchema = object({
-    filename: string2(),
-    mimeType: string2(),
-    size: number2().describe("File size in bytes"),
-    storageRef: string2().optional().describe("Storage reference for the original file")
-  });
-  ParseUsageSchema = object({
-    pageCount: number2(),
-    processingTimeMs: number2().optional(),
-    ocrPagesProcessed: number2().int().nonnegative().optional(),
-    cached: boolean2().optional()
-  });
-  StructuredDocumentSchema = record(string2(), unknown());
-  CoordinateUnitSchema = _enum(["pixel", "inch", "point", "normalized"]);
-  PointSchema = object({
-    x: number2(),
-    y: number2()
-  });
-  BoundingRegionSchema = object({
-    polygon: array(PointSchema).min(3),
-    unit: CoordinateUnitSchema,
-    pageIndex: number2()
-  });
-  PositionedTextSchema = object({
-    text: string2(),
-    confidence: number2().min(0).max(1).optional(),
-    boundingRegion: BoundingRegionSchema.optional()
-  });
-  TableCellSchema = object({
-    content: string2(),
-    rowIndex: number2(),
-    columnIndex: number2(),
-    rowSpan: number2().default(1),
-    columnSpan: number2().default(1),
-    boundingRegion: BoundingRegionSchema.optional()
-  });
-  ExtractedTableSchema = object({
-    cells: array(TableCellSchema),
-    rowCount: number2(),
-    columnCount: number2(),
-    boundingRegion: BoundingRegionSchema.optional()
-  });
-  LayoutElementTypeSchema = _enum([
-    "paragraph",
-    "title",
-    "sectionHeading",
-    "pageHeader",
-    "pageFooter",
-    "pageNumber",
-    "footnote",
-    "table",
-    "figure",
-    "formulaBlock"
-  ]);
-  LayoutElementSchema = object({
-    type: LayoutElementTypeSchema,
-    content: string2(),
-    table: ExtractedTableSchema.optional(),
-    caption: string2().optional(),
-    figureId: string2().optional(),
-    boundingRegion: BoundingRegionSchema.optional()
-  });
-  PageResultSchema = object({
-    pageIndex: number2().describe("0-based page index"),
-    text: string2().describe("Extracted page text (markdown/HTML/plain, or spatial layout text)"),
-    pageName: string2().optional().describe("Page/sheet name (e.g., Excel sheet name)"),
-    layoutElements: array(LayoutElementSchema).optional().describe("Semantic layout elements in reading order"),
-    words: array(PositionedTextSchema).optional().describe("Word-level positions"),
-    lines: array(PositionedTextSchema).optional().describe("Line-level positions"),
-    tables: array(ExtractedTableSchema).optional().describe("Extracted tables"),
-    width: number2().optional().describe("Page width"),
-    height: number2().optional().describe("Page height"),
-    unit: CoordinateUnitSchema.optional().describe("Unit for width/height and bounding regions"),
-    confidence: number2().min(0).max(1).optional().describe("Overall page confidence"),
-    nativeTextQuality: NativeTextQualitySchema.optional().describe('Per-page diagnosis of native-extracted text. Reports objectively detectable anomalies (empty, U+FFFD, forbidden controls, unassigned/noncharacter code points, heavy private-use). Does not certify semantic correctness — valid-looking wrong mappings and literal "?" cannot be distinguished from legitimate text.'),
-    provenance: PageProvenanceSchema.optional().describe("Which extractor produced the final text/layout on this page")
-  });
-  ParseResultSchema = object({
-    document: DocumentMetadataSchema,
-    usage: ParseUsageSchema,
-    pages: array(PageResultSchema),
-    text: string2().describe("Combined text from all pages"),
-    parserType: ParserTypeSchema,
-    parserVersion: string2().optional(),
-    model: string2().optional().describe("Model used (for LLM/OCR parsers)"),
-    processingStrategy: ProcessingStrategySchema.optional().describe("How this result was produced: `native` (local PDF text only), `ocr`, `vision`, or `hybrid` (native pages merged with OCR on fallback pages)."),
-    structured: StructuredDocumentSchema.optional().describe("Canonical structured document with ordered blocks, regions, bounding boxes, tables, figures, and chunks when supported by the parser"),
-    rawResponse: unknown().optional()
-  });
-  ParseOptionsSchema = object({
-    outputFormat: ParseOutputFormatSchema.default("markdown"),
-    ocrProvider: string2().optional().describe("OCR provider ID to use"),
-    includeWordPositions: boolean2().default(false),
-    includeLinePositions: boolean2().default(false),
-    extractTables: boolean2().default(true),
-    provider: string2().optional().describe("LLM provider ID to use"),
-    model: string2().optional(),
-    reasoningEffort: ReasoningEffortSchema.optional(),
-    maxConcurrency: number2().min(1).max(30).default(3),
-    pagesPerBatch: number2().min(1).max(20).default(5),
-    pdfRenderScale: number2().min(1).max(4).default(1).describe("Scale factor used when rendering PDF pages for VLM parsing"),
-    imageQuality: number2().int().min(1).max(100).default(85).describe("JPEG quality used for PDF page images sent to VLM parsing"),
-    prompt: string2().optional().describe("Custom prompt for LLM-based parsing"),
-    languages: array(string2()).optional().describe("OCR language hints"),
-    pages: array(number2().int().min(1)).optional().describe("1-indexed pages to OCR; omit or empty to analyze the whole document"),
-    tenantId: string2().optional()
-  });
-  ParserInputSchema = object({
-    data: _instanceof(Buffer).or(_instanceof(Uint8Array)),
-    filename: string2(),
-    mimeType: string2(),
-    options: ParseOptionsSchema.optional()
-  });
-  EXTENSION_TO_MIME = {
-    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    doc: "application/msword",
-    odt: "application/vnd.oasis.opendocument.text",
-    rtf: "application/rtf",
-    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    xls: "application/vnd.ms-excel",
-    xlsm: "application/vnd.ms-excel.sheet.macroenabled.12",
-    xlsb: "application/vnd.ms-excel.sheet.binary.macroenabled.12",
-    ods: "application/vnd.oasis.opendocument.spreadsheet",
-    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    ppsx: "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
-    pptm: "application/vnd.ms-powerpoint.presentation.macroenabled.12",
-    ppt: "application/vnd.ms-powerpoint",
-    odp: "application/vnd.oasis.opendocument.presentation",
-    eml: "message/rfc822",
-    msg: "application/vnd.ms-outlook",
-    epub: "application/epub+zip",
-    pdf: "application/pdf",
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    webp: "image/webp",
-    tiff: "image/tiff",
-    tif: "image/tiff",
-    gif: "image/gif",
-    bmp: "image/bmp",
-    svg: "image/svg+xml",
-    txt: "text/plain",
-    md: "text/markdown",
-    markdown: "text/markdown",
-    csv: "text/csv",
-    tsv: "text/tab-separated-values",
-    html: "text/html",
-    htm: "text/html",
-    xml: "text/xml",
-    json: "application/json",
-    yaml: "application/x-yaml",
-    yml: "application/x-yaml",
-    toml: "application/toml",
-    rst: "text/x-rst",
-    org: "text/x-org",
-    tex: "application/x-latex",
-    latex: "application/x-latex",
-    ipynb: "application/x-ipynb+json",
-    bib: "application/x-bibtex",
-    dbk: "application/docbook+xml",
-    docbook: "application/docbook+xml",
-    fb2: "application/x-fictionbook+xml",
-    zip: "application/zip"
-  };
-  MIME_TO_EXTENSION = Object.entries(EXTENSION_TO_MIME).reduce((acc, [ext, mime]) => {
-    if (!(mime in acc))
-      acc[mime] = ext;
-    return acc;
-  }, {});
-});
-
-// ../types/src/processor/configs/document-parser.ts
-var DocumentParserInputSchema, DocumentParserOutputSchema, DocumentParserConfigSchema;
-var init_document_parser = __esm(() => {
-  init_zod();
-  init_ai_client();
-  init_runtime_file_ref();
-  init_parser();
-  DocumentParserInputSchema = ResolvedProcessorFileSchema;
-  DocumentParserOutputSchema = ParseResultSchema;
-  DocumentParserConfigSchema = object({
-    parseMode: ParseModeSchema.optional().describe('Base parser for PDF/image inputs. OCR is the default. `native` extracts PDF text only (never OCR/vision). `native-or-ocr` requests OCR when pages have detectable native-text anomalies (empty, U+FFFD, lone surrogates, forbidden controls, unassigned/noncharacter, heavy PUA). Page selection, subset egress, and billing are provider-dependent. Valid-looking wrong text and literal "?" are not flagged.'),
-    ocrModel: string2().optional().describe("OCR provider ID for PDF/image parsing"),
-    llmModel: string2().optional().describe("LLM provider ID for vision-based parsing"),
-    llmReasoningEffort: ReasoningEffortSchema.optional().describe("Reasoning effort for vision-based parsing. Omit to use the model default."),
-    figureModel: string2().optional().describe("Vision model used only for the optional figure-description pass"),
-    figureReasoningEffort: ReasoningEffortSchema.optional().describe("Reasoning effort for figure descriptions. Omit to use the model default."),
-    maxConcurrency: number2().min(1).max(10).default(3).describe("Max concurrent VLM batch requests"),
-    pagesPerBatch: number2().min(1).max(20).default(5).describe("Number of page images per VLM request"),
-    pdfRenderScale: number2().min(1).max(4).default(1).optional().describe("Scale factor used when rendering PDF pages for VLM parsing"),
-    imageQuality: number2().int().min(1).max(100).default(85).optional().describe("JPEG quality used for PDF page images sent to VLM parsing"),
-    prompt: string2().optional().describe("Custom extraction prompt"),
-    nativeText: boolean2().default(false).optional().describe("Use native text extraction for PDFs with embedded text (no OCR/VLM)"),
-    describeFigures: boolean2().optional().describe("Opt-in (default off). After text extraction, detect figure pages with a layout model and caption them with a vision model, appending `<figure>description</figure>` to their text. Skipped for plaintext. The caption vision calls are billed."),
-    figureInstructions: string2().optional().describe("Custom instruction for the figure-description pass."),
-    languages: array(string2()).optional().describe('OCR language hints (e.g., ["en", "de"])'),
-    outputFormat: ParseOutputFormatSchema.default("markdown").optional().describe(PARSE_OUTPUT_FORMAT_DESCRIPTION),
-    cache: boolean2().default(false).optional().describe("When true, reuse a prior parse for identical file bytes and parse settings. Skips OCR/vision on cache hit. Stored in tenant blob storage with no automatic expiry (TTL/lifecycle is a follow-up). Default off.")
-  }).superRefine(refineNativeParseModeConflicts).superRefine(refineLayoutOutputFormat).prefault({});
-});
-
 // ../types/src/processor/configs/extract.ts
 var ExtractInputSchema, ExtractOutputSchema, ExtractConfigSchema;
 var init_extract = __esm(() => {
@@ -16044,6 +16265,7 @@ var XLSX_TO_JSON_DEFAULT_LIMITS, A1_RANGE_RE, XlsxToJsonColumnSchema, XlsxToJson
 var init_xlsx_to_json = __esm(() => {
   init_zod();
   init_runtime_file_ref();
+  init_spreadsheet_evidence();
   XLSX_TO_JSON_DEFAULT_LIMITS = {
     maxInputBytes: 50 * 1024 * 1024,
     maxRows: 1e5,
@@ -16082,6 +16304,8 @@ var init_xlsx_to_json = __esm(() => {
   XlsxToJsonInputSchema = ResolvedProcessorFileSchema;
   XlsxToJsonSheetMetaSchema = object({
     name: string2().describe("Selected sheet name"),
+    declaredRange: string2().optional().describe("Worksheet declared extent before empty trailing rows/columns were removed"),
+    dateSystem: _enum(["1900", "1904"]).optional().describe("Workbook Excel date system"),
     index: number2().int().min(0).describe("0-based sheet index in the workbook"),
     range: string2().describe("Effective rectangular A1 range that was read"),
     rowCount: number2().int().min(0).describe("Number of data rows returned in rows"),
@@ -16096,15 +16320,20 @@ var init_xlsx_to_json = __esm(() => {
     column: number2().int().optional().describe("0-based worksheet column when applicable")
   });
   XlsxToJsonOutputSchema = object({
+    cellMetadata: array(SpreadsheetCellEvidenceSchema.extend({
+      key: string2(),
+      outputRowIndex: number2().int().nonnegative()
+    })).optional().describe("Evidence for nonblank projected data cells, linked to rows by outputRowIndex and key. Present when includeCellMetadata is true."),
     rows: array(record(string2(), unknown())).describe("Array of row objects (first row = headers as keys unless headerRow is false)"),
     fileId: string2().optional().describe("File ID of stored CSV when outputCsv is true"),
-    sheet: XlsxToJsonSheetMetaSchema.optional().describe("Selected sheet metadata after projection. Present only when includeMetadata is true."),
-    diagnostics: array(XlsxToJsonDiagnosticSchema).optional().describe("Non-fatal warnings collected while reading the sheet. Present only when includeMetadata is true. Warnings are still logged when metadata is omitted.")
+    sheet: XlsxToJsonSheetMetaSchema.optional().describe("Selected sheet metadata after projection. Present when includeMetadata or includeCellMetadata is true."),
+    diagnostics: array(XlsxToJsonDiagnosticSchema).optional().describe("Non-fatal warnings collected while reading the sheet. Present when includeMetadata or includeCellMetadata is true. Warnings are still logged when metadata is omitted.")
   });
   XlsxToJsonConfigSchema = object({
     sheet: union([number2().int().min(0), string2()]).optional().describe("Sheet to read: 0-based index or exact sheet name. Omit for the first sheet."),
-    outputCsv: boolean2().default(false).optional().describe("If true, also write CSV to storage and include fileId. Zero-config uses the historical full-sheet SheetJS CSV. When columns, range, headerRow, valueMode, blankCells, or blankRows are set, CSV matches that projection."),
-    includeMetadata: boolean2().default(false).optional().describe("If true, include sheet metadata and diagnostics in the step output. Omit to keep output as rows (and fileId when outputCsv is true). Warnings are still logged when this is false."),
+    outputCsv: boolean2().default(false).optional().describe("If true, also write CSV to storage and include fileId. Zero-config uses SheetJS CSV of the effective sheet extent, excluding empty trailing rows and columns. When columns, range, headerRow, valueMode, blankCells, or blankRows are set, CSV matches that projection."),
+    includeCellMetadata: boolean2().default(false).optional().describe("Include original cell address, type, raw/displayed value, number format and date rendering. Also includes sheet metadata with the workbook date system. Does not classify identifiers or clean names."),
+    includeMetadata: boolean2().default(false).optional().describe("If true, include sheet metadata and diagnostics in the step output. includeCellMetadata also enables these. Omit to keep output as rows (and fileId when outputCsv is true). Warnings are still logged when this is false."),
     outputFilename: string2().optional().describe("Output CSV filename when outputCsv is true"),
     headerRow: union([literal(false), number2().int().min(1)]).optional().describe("Header row: a positive 1-based Excel row, or false to keep the first effective row as data. Omit to use the first effective row as the header. When range is set and this is omitted, the first range row is the header."),
     columns: array(XlsxToJsonColumnSchema).min(1).optional().superRefine(refineUniqueOutputKeys).describe("Ordered output columns. Each item needs a key and exactly one source: index (0-based absolute column) or header (exact displayed header text). Named header sources require a header row. Omit to keep every column in the effective range."),
@@ -16127,6 +16356,7 @@ var init_xlsx_to_json = __esm(() => {
 var PROCESSOR_SCHEMAS;
 var init_configs = __esm(() => {
   init_ids();
+  init_document_parser_v2();
   init_classify();
   init_classify_pages();
   init_document_parser();
@@ -16141,6 +16371,7 @@ var init_configs = __esm(() => {
   init_classify();
   init_classify_pages();
   init_document_parser();
+  init_document_parser_v2();
   init_extract();
   init_json_to_xlsx();
   init_merge();
@@ -16150,6 +16381,12 @@ var init_configs = __esm(() => {
   init_template();
   init_xlsx_to_json();
   PROCESSOR_SCHEMAS = {
+    [PROCESSOR_IDS.DOCUMENT_PARSER_V2]: {
+      id: PROCESSOR_IDS.DOCUMENT_PARSER_V2,
+      inputSchema: DocumentParserV2InputSchema,
+      outputSchema: ParseV2ResultSchema,
+      configSchema: DocumentParserV2ConfigSchema
+    },
     [PROCESSOR_IDS.EXTRACT]: {
       id: PROCESSOR_IDS.EXTRACT,
       inputSchema: ExtractInputSchema,
@@ -16294,6 +16531,259 @@ var init_run_expand = __esm(() => {
   };
 });
 
+// ../types/src/file-source/resolver.ts
+var init_resolver = () => {};
+
+// ../types/src/file-source/reference.ts
+var init_reference = () => {};
+
+// ../types/src/file-source/descriptor.ts
+function isHttpsOrLocal(value) {
+  if (typeof value !== "string")
+    return true;
+  try {
+    const url = new URL(value.trim());
+    return url.protocol !== "http:" || LOCAL_HOSTS.has(url.hostname);
+  } catch {
+    return true;
+  }
+}
+function isSet(config, key) {
+  const value = config[key];
+  return value !== undefined && value !== "";
+}
+function allowedContainersField(plural) {
+  return {
+    key: "allowedContainers",
+    label: `Allowed ${plural}`,
+    type: "string",
+    required: false,
+    description: `Comma-separated. Runs can only fetch from these ${plural}. Leave blank to allow any the credentials can read.`
+  };
+}
+function transferLimitFields(remote) {
+  return [
+    {
+      key: "timeoutMs",
+      label: "Timeout (ms)",
+      type: "number",
+      required: false,
+      description: `How long to wait for the ${remote} before giving up.`,
+      default: 30000,
+      advanced: true
+    },
+    {
+      key: "maxFileBytes",
+      label: "Max file size (bytes)",
+      type: "number",
+      required: false,
+      description: "Reject files larger than this. At most 1 GiB.",
+      default: 50 * 1024 * 1024,
+      advanced: true
+    }
+  ];
+}
+var LOCAL_HOSTS, GPFS_FILE_SOURCE_NAME = "gpfs", GPFS_FILE_SOURCE_DESCRIPTOR, S3_FILE_SOURCE_NAME = "s3", S3_FILE_SOURCE_DESCRIPTOR, AZURE_BLOB_FILE_SOURCE_NAME = "azure-blob", AZURE_BLOB_FILE_SOURCE_DESCRIPTOR;
+var init_descriptor = __esm(() => {
+  LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
+  GPFS_FILE_SOURCE_DESCRIPTOR = {
+    name: GPFS_FILE_SOURCE_NAME,
+    label: "GPFS file registry",
+    description: "Fetch documents from a GPFS/GFR HTTP file registry by stack and file id.",
+    referenceFormat: "stackId/fileId",
+    referenceParts: { container: "stackId", id: "fileId" },
+    configFields: [
+      {
+        key: "baseUrl",
+        label: "Base URL",
+        type: "string",
+        required: true,
+        description: "Registry URL without a stack. Files are fetched from <base URL>/<stackId>/<fileId>/content.",
+        placeholder: "https://files.example.com/ims/gfr"
+      },
+      {
+        key: "defaultStack",
+        label: "Default stack",
+        type: "string",
+        required: false,
+        description: "Stack used when a run passes only a file id. Leave blank if the base URL already ends in a stack."
+      },
+      allowedContainersField("stacks"),
+      {
+        key: "authToken",
+        label: "Bearer token",
+        type: "secret",
+        required: false,
+        description: "Bearer token for the registry, if it requires one."
+      },
+      {
+        key: "insecureSkipTlsVerify",
+        label: "Skip TLS verification",
+        type: "boolean",
+        required: false,
+        description: "Only for registries with self-signed or legacy certificates. Prefer installing your CA instead.",
+        default: false,
+        advanced: true
+      },
+      ...transferLimitFields("registry")
+    ]
+  };
+  S3_FILE_SOURCE_DESCRIPTOR = {
+    name: S3_FILE_SOURCE_NAME,
+    label: "Amazon S3",
+    description: "Fetch documents from Amazon S3 or S3-compatible storage by bucket and key.",
+    referenceFormat: "bucket/key",
+    referenceParts: { container: "bucket", id: "key" },
+    check: (config) => {
+      const keyId = isSet(config, "accessKeyId");
+      const secret = isSet(config, "secretAccessKey");
+      if (keyId !== secret)
+        return ["Set both the access key ID and the secret access key"];
+      if (!keyId && !isSet(config, "roleArn"))
+        return ["Set an access key or a role ARN"];
+      return [];
+    },
+    configFields: [
+      {
+        key: "region",
+        label: "Region",
+        type: "string",
+        required: true,
+        default: "us-east-1",
+        description: "AWS region of the bucket. Most S3-compatible stores accept us-east-1."
+      },
+      allowedContainersField("buckets"),
+      {
+        key: "accessKeyId",
+        label: "Access key ID",
+        type: "string",
+        required: false,
+        description: "Required unless a role ARN is set."
+      },
+      {
+        key: "secretAccessKey",
+        label: "Secret access key",
+        type: "secret",
+        required: false,
+        description: "Use a key that can only read the buckets EigenPal should fetch from."
+      },
+      {
+        key: "roleArn",
+        label: "Role ARN",
+        type: "string",
+        required: false,
+        description: "AWS role to assume for reading objects. Without an access key, the worker identity is used only to assume it.",
+        placeholder: "arn:aws:iam::123456789012:role/eigenpal-documents-read",
+        advanced: true
+      },
+      {
+        key: "externalId",
+        label: "External ID",
+        type: "string",
+        required: false,
+        description: "External ID the role trust policy requires, if any.",
+        advanced: true
+      },
+      {
+        key: "stsEndpointUrl",
+        label: "STS endpoint URL",
+        type: "string",
+        required: false,
+        description: "Where to assume the role. Leave blank for AWS; set it for S3-compatible storage with STS, such as MinIO.",
+        advanced: true
+      },
+      {
+        key: "sessionToken",
+        label: "Session token",
+        type: "secret",
+        required: false,
+        description: "Only for temporary access keys.",
+        advanced: true
+      },
+      {
+        key: "endpointUrl",
+        label: "Endpoint URL",
+        type: "string",
+        required: false,
+        description: "Only for S3-compatible storage such as MinIO or Ceph. Leave blank for AWS.",
+        placeholder: "https://minio.example.com",
+        advanced: true
+      },
+      ...transferLimitFields("storage")
+    ]
+  };
+  AZURE_BLOB_FILE_SOURCE_DESCRIPTOR = {
+    name: AZURE_BLOB_FILE_SOURCE_NAME,
+    label: "Azure Blob Storage",
+    description: "Fetch documents from Azure Blob Storage by container and blob name.",
+    referenceFormat: "container/blobName",
+    referenceParts: { container: "container", id: "blobName" },
+    check: (config) => {
+      const principal = ["tenantId", "clientId", "clientSecret"].filter((k) => isSet(config, k));
+      const sas = isSet(config, "sasToken");
+      if (principal.length > 0 && sas)
+        return ["Use either the service principal or the SAS token, not both"];
+      if (principal.length > 0 && principal.length < 3) {
+        return ["A service principal needs the tenant ID, client ID and client secret"];
+      }
+      if (principal.length === 0 && !sas)
+        return ["Set a service principal or a SAS token"];
+      if (!isHttpsOrLocal(config.accountUrl)) {
+        return ["The account URL must use HTTPS (HTTP only for a local emulator)"];
+      }
+      return [];
+    },
+    configFields: [
+      {
+        key: "accountUrl",
+        label: "Account URL",
+        type: "string",
+        required: true,
+        description: "Blob service URL of the storage account.",
+        placeholder: "https://myaccount.blob.core.windows.net"
+      },
+      allowedContainersField("containers"),
+      {
+        key: "tenantId",
+        label: "Entra tenant ID",
+        type: "string",
+        required: false,
+        description: "Service principal sign-in. Set tenant, client ID and client secret, or a SAS token instead."
+      },
+      {
+        key: "clientId",
+        label: "Client ID",
+        type: "string",
+        required: false
+      },
+      {
+        key: "clientSecret",
+        label: "Client secret",
+        type: "secret",
+        required: false,
+        description: "The service principal needs the Storage Blob Data Reader role."
+      },
+      {
+        key: "sasToken",
+        label: "SAS token",
+        type: "secret",
+        required: false,
+        description: "Alternative to a service principal: a SAS token with read permission."
+      },
+      {
+        key: "authorityHost",
+        label: "Authority host",
+        type: "string",
+        required: false,
+        description: "Only for sovereign clouds, for example Azure Government.",
+        default: "https://login.microsoftonline.com",
+        advanced: true
+      },
+      ...transferLimitFields("storage account")
+    ]
+  };
+});
+
 // ../types/src/validation/workspace-schema.ts
 function validateWorkspaceSchema(content, _filename) {
   let json;
@@ -53805,7 +54295,7 @@ function describeUnsupportedType(nodeType) {
 function compileTypedScript(opts) {
   let ast;
   try {
-    ast = import_parser4.parse(opts.source, {
+    ast = import_parser5.parse(opts.source, {
       sourceType: "script",
       plugins: ["typescript"],
       ranges: true
@@ -54058,9 +54548,9 @@ function stripCommentsAndStrings(s) {
   out = out.replace(/`(\\.|[^`\\])*`/g, "``");
   return out;
 }
-var import_parser4, import_sucrase, EVALUATOR_FN_NAME = "scoreScript", EVALUATOR_PARAM_NAMES, TRANSFORM_FN_NAME = "script";
+var import_parser5, import_sucrase, EVALUATOR_FN_NAME = "scoreScript", EVALUATOR_PARAM_NAMES, TRANSFORM_FN_NAME = "script";
 var init_compile = __esm(() => {
-  import_parser4 = __toESM(require_lib(), 1);
+  import_parser5 = __toESM(require_lib(), 1);
   import_sucrase = __toESM(require_dist3(), 1);
   EVALUATOR_PARAM_NAMES = ["expected", "actual"];
 });
@@ -54207,6 +54697,7 @@ var init_steps = __esm(() => {
   init_retry();
   AI_STEP_TYPES = [
     "ai.parse",
+    "ai.parse-v2",
     "ai.extract",
     "ai.split",
     "ai.segment",
@@ -54381,6 +54872,7 @@ var init_step_configs = __esm(() => {
   init_email_servers();
   init_human_review();
   init_parser();
+  init_document_parser_v2();
   init_json_to_xlsx();
   init_xlsx_to_json();
   init_typed_script();
@@ -55145,10 +55637,19 @@ var init_step_configs = __esm(() => {
   });
   ControlFailOutputSchema = never().describe("control.fail never produces output — it terminates the workflow when triggered.");
   STEP_SCHEMAS = {
+    "ai.parse-v2": {
+      type: "ai.parse-v2",
+      category: "ai",
+      name: "Parse Document",
+      description: "Automatically read native, scanned, and mixed documents with capability-aware OCR/vision fallback and explicit completeness.",
+      configSchema: AiParseV2ConfigSchema,
+      outputSchema: ParseV2ResultSchema,
+      configInWith: true
+    },
     "ai.parse": {
       type: "ai.parse",
       category: "ai",
-      name: "Parse Document",
+      name: "Parse Document — legacy",
       description: "Extract text from documents (PDF, DOCX, images) using native extraction, OCR, or vision models",
       configSchema: AiParseConfigSchema,
       outputSchema: AiParseOutputSchema,
@@ -55684,63 +56185,11 @@ var init_workflow2 = __esm(() => {
   init_workflow();
 });
 
-// ../types/src/file-source/descriptor.ts
-var GPFS_FILE_SOURCE_NAME = "gpfs", GPFS_FILE_SOURCE_DESCRIPTOR;
-var init_descriptor = __esm(() => {
-  GPFS_FILE_SOURCE_DESCRIPTOR = {
-    name: GPFS_FILE_SOURCE_NAME,
-    label: "GPFS file registry",
-    description: "Fetch documents by id from a GPFS/GFR HTTP file registry.",
-    configFields: [
-      {
-        key: "baseUrl",
-        label: "Base URL",
-        type: "string",
-        required: true,
-        description: "Base URL of the registry. The file id is appended to fetch each file.",
-        placeholder: "https://files.example.com/registry"
-      },
-      {
-        key: "authToken",
-        label: "Bearer token",
-        type: "secret",
-        required: false,
-        description: "Bearer token for the registry, if it requires one."
-      },
-      {
-        key: "insecureSkipTlsVerify",
-        label: "Skip TLS verification",
-        type: "boolean",
-        required: false,
-        description: "Only for registries with self-signed or legacy certificates.",
-        default: false,
-        advanced: true
-      },
-      {
-        key: "timeoutMs",
-        label: "Timeout (ms)",
-        type: "number",
-        required: false,
-        description: "How long to wait for the registry before giving up.",
-        default: 30000,
-        advanced: true
-      },
-      {
-        key: "maxFileBytes",
-        label: "Max file size (bytes)",
-        type: "number",
-        required: false,
-        description: "Reject files larger than this.",
-        default: 50 * 1024 * 1024,
-        advanced: true
-      }
-    ]
-  };
-});
-
 // ../types/src/file-source/index.ts
 var init_file_source = __esm(() => {
   init_descriptor();
+  init_reference();
+  init_resolver();
 });
 
 // ../types/src/eval/compare-output.ts
@@ -56754,6 +57203,26 @@ var init_git_source = __esm(() => {
 // ../types/src/automation/triggers.ts
 var init_triggers = () => {};
 
+// ../types/src/webhook-delivery-settings.ts
+var WEBHOOK_REQUEST_TIMEOUT_MIN_MS = 1000, WEBHOOK_REQUEST_TIMEOUT_MAX_MS = 120000, WEBHOOK_RETRY_POLICIES, AllowPrivateDestinationsSchema, RequestTimeoutMsSchema, RetryPolicySchema, WebhookDeliverySettingsSchema, WebhookDeliverySettingsPatchSchema;
+var init_webhook_delivery_settings = __esm(() => {
+  init_zod();
+  WEBHOOK_RETRY_POLICIES = ["standard", "quick", "none"];
+  AllowPrivateDestinationsSchema = boolean2();
+  RequestTimeoutMsSchema = number2().int().min(WEBHOOK_REQUEST_TIMEOUT_MIN_MS).max(WEBHOOK_REQUEST_TIMEOUT_MAX_MS).multipleOf(1000);
+  RetryPolicySchema = _enum(WEBHOOK_RETRY_POLICIES);
+  WebhookDeliverySettingsSchema = object({
+    allowPrivateDestinations: AllowPrivateDestinationsSchema.optional(),
+    requestTimeoutMs: RequestTimeoutMsSchema.optional(),
+    retryPolicy: RetryPolicySchema.optional()
+  });
+  WebhookDeliverySettingsPatchSchema = object({
+    allowPrivateDestinations: AllowPrivateDestinationsSchema.nullable().optional(),
+    requestTimeoutMs: RequestTimeoutMsSchema.nullable().optional(),
+    retryPolicy: RetryPolicySchema.nullable().optional()
+  }).strict();
+});
+
 // ../types/src/webhooks.ts
 function validateWebhookHeaderCollection(input, ctx) {
   if (input.customHeaders) {
@@ -56976,6 +57445,8 @@ var init_src = __esm(() => {
   init_execution_row();
   init_run_expand();
   init_execution_tags();
+  init_document_parser_v2();
+  init_parse_v2_migration();
   init_validation();
   init_workflow2();
   init_file_source();
@@ -56983,8 +57454,10 @@ var init_src = __esm(() => {
   init_git_source();
   init_triggers();
   init_email_servers();
+  init_webhook_delivery_settings();
   init_webhooks();
   init_typed_script();
+  init_spreadsheet_evidence();
 });
 
 // node_modules/yaml/dist/nodes/identity.js
@@ -207035,7 +207508,7 @@ import { fileURLToPath as fileURLToPath8 } from "url";
 // package.json
 var package_default = {
   name: "@eigenpal/cli",
-  version: "0.20.27",
+  version: "0.20.29",
   description: "Eigenpal CLI — author and run document workflows from your terminal. Agent-ready.",
   keywords: [
     "eigenpal",
@@ -243863,6 +244336,20 @@ var COLUMNS = [
 ];
 function registerModelsCommands(program) {
   const models = program.command("models").description("Inspect models and providers configured for the current tenant environment (text, vision, OCR).");
+  addJsonFlag(withBaseUrl(models.command("parser-readiness").description("Inspect deployment-approved ai.parse-v2 defaults. Catalog state only; document smoke tests are required for live readiness."))).action(action(async (opts) => {
+    const config = resolveConfig(opts);
+    requireApiKey(config);
+    const result = await new ApiClient(config).get("/api/v1/parsing/readiness");
+    if (opts.json)
+      console.log(JSON.stringify(result));
+    else {
+      console.log(`Image reading: ${result.imageReading}
+OCR: ${result.providers.ocr ?? "none"}
+Vision: ${result.providers.vision ?? "none"}`);
+      for (const warning of result.warnings)
+        console.error(warning);
+    }
+  }));
   addJsonFlag(withBaseUrl(models.command("list").description("List configured text, vision, and OCR models. This is a catalog inventory from the server, not a live provider health probe. `health` is `configured` or `unconfigured` from local credentials. Pair with `--json` for scripting.").option("--capability <kind>", "Filter to `text`, `vision`, or `ocr` (matches the API `capability` query).").addHelpText("after", `
 Health
   configured     Credentials for this model are present in the environment.
@@ -247117,6 +247604,36 @@ async function deleteWorkflowFolder(pathOrId, opts) {
   success(`Deleted folder ${ui.bold(pathLabel)}`);
 }
 
+// src/commands/workflow/migrate-parser.ts
+init_src();
+import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { resolve as resolve9 } from "node:path";
+function registerParserMigrationCommand(workflow) {
+  workflow.command("migrate-parser <file>").description("Write a reviewable ai.parse-v2 workflow migration to a new file. Never pushes or changes the source.").requiredOption("--policy <policy>", "preserve backend restrictions, or auto to adopt automatic native/OCR/vision parsing").requiredOption("--out <file>", "New YAML output file (must not already exist)").option("--json", "Emit migration summary as JSON").action(action(async (file, options) => {
+    if (options.policy !== "preserve" && options.policy !== "auto")
+      throw new Error("--policy must be preserve or auto");
+    if (resolve9(file) === resolve9(options.out))
+      throw new Error("Migration output must differ from the source");
+    const source = $parse(await readFile4(file, "utf8"));
+    if (!source || typeof source !== "object" || Array.isArray(source))
+      throw new Error("Expected a workflow YAML object");
+    const migration = migrateWorkflowParsers(source, options.policy);
+    await writeFile3(options.out, $stringify(migration.definition), { flag: "wx" });
+    const summary = {
+      out: resolve9(options.out),
+      migratedSteps: migration.migratedSteps,
+      warnings: migration.warnings
+    };
+    if (options.json)
+      console.log(JSON.stringify(summary));
+    else {
+      console.log(`Wrote ${summary.out}; migrated ${summary.migratedSteps.length} parser step(s). Review and test before publishing.`);
+      for (const warning of summary.warnings)
+        console.error(warning);
+    }
+  }));
+}
+
 // src/commands/workflow/step-exec.ts
 init_src();
 var UNSUPPORTED_TYPE_EXIT = 2;
@@ -247146,7 +247663,7 @@ function registerStepExecCommands(workflow) {
 // src/commands/workflow/templates.ts
 init_src();
 import { existsSync as existsSync20, promises as fs20 } from "node:fs";
-import { basename as basename4, resolve as resolve9 } from "node:path";
+import { basename as basename4, resolve as resolve10 } from "node:path";
 function buildClient5(opts) {
   const config = resolveConfig(opts);
   requireApiKey(config);
@@ -247158,11 +247675,11 @@ function printJson5(value) {
 async function readJsonFixtureFile(fixturePath) {
   let raw;
   try {
-    raw = await fs20.readFile(resolve9(fixturePath), "utf8");
+    raw = await fs20.readFile(resolve10(fixturePath), "utf8");
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
     if (code === "ENOENT") {
-      throw new Error(`JSON fixture file not found: ${resolve9(fixturePath)}`);
+      throw new Error(`JSON fixture file not found: ${resolve10(fixturePath)}`);
     }
     throw err;
   }
@@ -247209,7 +247726,7 @@ function registerTemplateCommands(parent) {
   const templates = parent.command("templates").description("Manage workspace DOCX/XLSX templates (tmpl_…): upload, list, inspect, download, replace, delete, and smoke-fill.").addHelpText("after", TEMPLATES_EXAMPLES);
   const uploadCmd = templates.command("upload <file>").description("Upload a DOCX or XLSX file as a new tmpl_… resource with an immutable tmpr_… revision.").option("--name <name>", "Display name (defaults to the filename without extension)").option("--description <text>", "Optional description");
   addJsonFlag(withBaseUrl(uploadCmd)).action(action(async (file, opts) => {
-    const filePath = resolve9(file);
+    const filePath = resolve10(file);
     const bytes = await fs20.readFile(filePath);
     const client = buildClient5(opts);
     const template = await uploadWorkspaceTemplate(client, {
@@ -247274,7 +247791,7 @@ function registerTemplateCommands(parent) {
   }));
   const replaceCmd = templates.command("replace <template-id> <file>").description("Append an immutable revision and advance the tmpl_… pointer.");
   addJsonFlag(withBaseUrl(replaceCmd)).action(action(async (templateId, file, opts) => {
-    const filePath = resolve9(file);
+    const filePath = resolve10(file);
     const bytes = await fs20.readFile(filePath);
     const client = buildClient5(opts);
     const current = await getPublicTemplate(client, templateId);
@@ -247325,7 +247842,7 @@ function registerTemplateCommands(parent) {
       bytes = downloaded.bytes;
       filename = downloaded.filename;
     } else {
-      const filePath = resolve9(templateArg);
+      const filePath = resolve10(templateArg);
       if (!existsSync20(filePath)) {
         throw new Error(`Template file not found: ${filePath}. Pass a local .docx/.xlsx path or a tmpl_… id.`);
       }
@@ -247369,7 +247886,7 @@ function registerTemplateCommands(parent) {
 // src/commands/workflow/validation.ts
 init_src();
 import { existsSync as existsSync22, readdirSync as readdirSync7, readFileSync as readFileSync19, statSync as statSync7 } from "fs";
-import { join as join13, resolve as resolve10 } from "path";
+import { join as join13, resolve as resolve11 } from "path";
 
 // src/lib/template-diagnostics.ts
 init_src();
@@ -247986,7 +248503,7 @@ function parseDatasetFileRef(path, root) {
   return parts.join("/");
 }
 function rootDir(opts) {
-  return resolve10(opts.dir ?? process.cwd());
+  return resolve11(opts.dir ?? process.cwd());
 }
 async function onlineInvokeIssues(yamlText, opts) {
   const config = resolveConfig(opts);
@@ -247996,7 +248513,7 @@ async function onlineInvokeIssues(yamlText, opts) {
   return res.issues ?? [];
 }
 function discoverWorkflowProjectRoots(rootPath) {
-  const root = resolve10(rootPath);
+  const root = resolve11(rootPath);
   if (existsSync22(join13(root, "workflow.yaml")))
     return [root];
   const candidates = [
@@ -248043,8 +248560,8 @@ Note
 ` + `  project unless you pass --allow-external-templates.
 `);
   withBaseUrl(cmd).action(action(async (path, opts) => {
-    if (path && (!existsSync22(resolve10(path)) || !statSync7(resolve10(path)).isDirectory())) {
-      const target = resolve10(path);
+    if (path && (!existsSync22(resolve11(path)) || !statSync7(resolve11(path)).isDirectory())) {
+      const target = resolve11(path);
       const wfResult = validateWorkflowYaml(target);
       const wfOk = printIssues("workflow.yaml", target, wfResult.issues);
       if (wfOk) {
@@ -248060,7 +248577,7 @@ Note
         process.exit(1);
       return;
     }
-    const requestedRoot = path ? resolve10(path) : rootDir(opts);
+    const requestedRoot = path ? resolve11(path) : rootDir(opts);
     const projects = discoverWorkflowProjectRoots(requestedRoot);
     if (projects.length === 0) {
       if (!await validateProjectRoot(requestedRoot, opts))
@@ -248082,14 +248599,14 @@ Note
 }
 function registerEvaluatorsValidateCommand(parent) {
   parent.command("validate [path]").description("Validate an evaluators YAML file against the EvalConfig schema. Defaults to ./evaluators.yaml.").action((path) => {
-    const target = resolve10(path ?? "evaluators.yaml");
+    const target = resolve11(path ?? "evaluators.yaml");
     if (!printIssues("evaluators", target, validateEvaluatorsYaml(target)))
       process.exit(1);
   });
 }
 function registerDatasetValidateCommand(parent) {
   parent.command("validate [path]").description("Validate a dataset folder against the examples/<name>/{input,expected,meta} convention. Defaults to ./dataset/.").action((path) => {
-    const target = resolve10(path ?? "dataset");
+    const target = resolve11(path ?? "dataset");
     if (!printIssues("dataset", target, validateDatasetFolder(target)))
       process.exit(1);
   });
@@ -248203,6 +248720,7 @@ YAML's \`name:\` field). Both:
   $ eigenpal workflow pull my-extraction
 `);
   registerWorkflowCoreCommands(workflow);
+  registerParserMigrationCommand(workflow);
   registerWorkflowFolderCommands(workflow);
   registerEvaluatorsCommands(workflow);
   registerDatasetCommands2(workflow);