@openparser/lineage 1.0.2

package/dist/profile/index.js

@@ -0,0 +1,1298 @@
+// src/profile/labels.ts
+var ACTIVITY_LABELS = {
+  ocr: "Parse",
+  extract: "Schema-constrained extraction",
+  transform: "Transform",
+  grounding_resolution: "Grounding resolution and validation",
+  "review.confirm": "Human review"
+};
+function activityLabel(activity) {
+  return activity.name ?? ACTIVITY_LABELS[activity.type] ?? activity.type;
+}
+
+// src/traverse.ts
+function buildReverseEdges(doc) {
+  const edges = /* @__PURE__ */ new Map();
+  for (const id of Object.keys(doc.entities)) edges.set(id, []);
+  for (const derivation of doc.derivations) {
+    if (!(derivation.output in doc.entities)) continue;
+    for (const input of derivation.inputs) {
+      if (!(input.entity in doc.entities)) continue;
+      edges.get(derivation.output).push(input.entity);
+    }
+  }
+  return edges;
+}
+function collectReachable(start, edges) {
+  if (!edges.has(start)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [...edges.get(start) ?? []];
+  while (stack.length > 0) {
+    const id = stack.pop();
+    if (seen.has(id)) continue;
+    seen.add(id);
+    for (const next of edges.get(id) ?? []) {
+      if (!seen.has(next)) stack.push(next);
+    }
+  }
+  return [...seen];
+}
+function entityAncestors(doc, entityId) {
+  return collectReachable(entityId, buildReverseEdges(doc));
+}
+
+// src/fields.ts
+function fieldPointer(entity) {
+  return entity.path ?? "";
+}
+function fieldConfidence(entity) {
+  const assertions = entity.confidence;
+  if (!assertions || assertions.length === 0) return void 0;
+  return assertions.find((assertion) => assertion.scope === "extraction") ?? assertions[0];
+}
+function dottedPathFromPointer(pointer) {
+  if (pointer === "" || pointer === "/") return "";
+  return pointer.replace(/^\//, "").split("/").map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~")).join(".");
+}
+function toField(id, entity) {
+  const pointer = fieldPointer(entity);
+  const confidence = fieldConfidence(entity);
+  return {
+    id,
+    pointer,
+    dottedPath: dottedPathFromPointer(pointer),
+    value: entity.value,
+    confidence,
+    confidenceOrigin: confidence ? confidence.kind : "not_reported",
+    entity
+  };
+}
+function fields(doc) {
+  const result = [];
+  for (const id of doc.outputs) {
+    const entity = doc.entities[id];
+    if (!entity) continue;
+    if (fieldPointer(entity) === "") continue;
+    result.push(toField(id, entity));
+  }
+  return result;
+}
+function fieldTrace(doc, pointer) {
+  const field = fields(doc).find((candidate) => candidate.pointer === pointer);
+  if (!field) return void 0;
+  const ancestorIds = entityAncestors(doc, field.id);
+  const evidence = ancestorIds.filter((id) => {
+    const entity = doc.entities[id];
+    return entity?.kind === "collection" || entity?.kind === "evidence";
+  }).sort().map((id) => ({ id, entity: doc.entities[id] }));
+  const relevant = /* @__PURE__ */ new Set([field.id, ...ancestorIds]);
+  const activities = [
+    ...new Set(doc.derivations.filter((d) => relevant.has(d.output)).map((d) => d.activity))
+  ].sort();
+  return { field, evidence, activities };
+}
+
+// src/profile/grounding.ts
+var DROPPED_SOURCES_ATTR = "openparser:droppedSourceIds";
+function droppedSourceIds(producer) {
+  const dropped = producer?.attributes?.[DROPPED_SOURCES_ATTR];
+  return Array.isArray(dropped) ? dropped.filter((id) => typeof id === "string") : [];
+}
+function groundingStatus(options) {
+  if (options.evidenceCount === 0) return "ungrounded";
+  return options.droppedSourceIds.length > 0 ? "partial" : "grounded";
+}
+function collectDroppedSourceIds(doc, entityIds) {
+  const relevant = new Set(entityIds);
+  const seen = /* @__PURE__ */ new Set();
+  const dropped = [];
+  for (const derivation of doc.derivations) {
+    if (!relevant.has(derivation.output)) continue;
+    for (const id of droppedSourceIds(derivation)) {
+      if (seen.has(id)) continue;
+      seen.add(id);
+      dropped.push(id);
+    }
+  }
+  return dropped;
+}
+function fieldGrounding(doc, pointer) {
+  const trace = fieldTrace(doc, pointer);
+  if (!trace) return void 0;
+  const ancestorIds = entityAncestors(doc, trace.field.id);
+  const dropped = collectDroppedSourceIds(doc, [trace.field.id, ...ancestorIds]);
+  return {
+    status: groundingStatus({ evidenceCount: trace.evidence.length, droppedSourceIds: dropped }),
+    droppedSourceIds: dropped
+  };
+}
+
+// src/profile/recognition.ts
+var CITED_RECOGNITION_METHOD = "cited_minimum_context_downblend";
+var REGION_RECOGNITION_METHOD = "region_word_minimum";
+var CONTEXT_BLEND_WEIGHT = 0.15;
+function downwardBlendCitedMinimum(citedMin, contextMean) {
+  if (contextMean === void 0) return citedMin;
+  const blended = citedMin * (1 - CONTEXT_BLEND_WEIGHT) + contextMean * CONTEXT_BLEND_WEIGHT;
+  return Math.min(citedMin, blended);
+}
+function aggregateCitedWordConfidences(words) {
+  if (words.length === 0) return void 0;
+  const cited = words.filter((word) => word.cited !== false);
+  const context = words.filter((word) => word.cited === false);
+  const active = cited.length > 0 ? cited : words;
+  const activeScores = active.map((word) => word.confidence);
+  const contextMean = cited.length > 0 && context.length > 0 ? context.reduce((sum, word) => sum + word.confidence, 0) / context.length : void 0;
+  const citedMin = Math.min(...activeScores);
+  return {
+    score: downwardBlendCitedMinimum(citedMin, contextMean),
+    minimum: citedMin,
+    maximum: Math.max(...activeScores),
+    sampleCount: active.length,
+    method: cited.length > 0 ? CITED_RECOGNITION_METHOD : REGION_RECOGNITION_METHOD,
+    ...contextMean !== void 0 ? { contextMean, contextSampleCount: context.length } : {}
+  };
+}
+function citedSpanInText(regionText, candidates) {
+  if (!regionText) return { start: -1, end: -1 };
+  for (const candidate of candidates) {
+    const quote = candidate?.trim();
+    if (!quote) continue;
+    let start = regionText.indexOf(quote);
+    if (start < 0) start = regionText.toLowerCase().indexOf(quote.toLowerCase());
+    if (start >= 0) return { start, end: start + quote.length };
+  }
+  return { start: -1, end: -1 };
+}
+function wordOverlapsSpan(regionText, word, cursor, span) {
+  if (!word.text) return { overlaps: false, nextCursor: cursor };
+  const at = regionText.indexOf(word.text, cursor);
+  if (at < 0) return { overlaps: false, nextCursor: cursor };
+  const wordEnd = at + word.text.length;
+  return {
+    overlaps: span.start >= 0 && at < span.end && wordEnd > span.start,
+    nextCursor: wordEnd
+  };
+}
+function annotateWordsWithCitation(regionText, words, options) {
+  const span = citedSpanInText(regionText, [options?.extractedText]);
+  const hasQuoteSpan = span.start >= 0;
+  let cursor = 0;
+  return words.map((word) => {
+    const { overlaps, nextCursor } = wordOverlapsSpan(regionText, word, cursor, span);
+    cursor = nextCursor;
+    const inLineage = Boolean(
+      word.id && options?.lineageWordIds?.has(word.id) || options?.lineageWordTexts?.has(word.text)
+    );
+    return { ...word, cited: hasQuoteSpan ? overlaps : inLineage };
+  });
+}
+
+// src/profile/transform-validation.ts
+import Decimal from "decimal.js";
+import { DateTime } from "luxon";
+import { createHash } from "node:crypto";
+import { z as z2 } from "zod";
+
+// src/common.ts
+import { z } from "zod";
+var LineageIdSchema = z.string().trim().min(1).max(512);
+var JsonValueSchema = z.json();
+var AttributesSchema = z.record(z.string().min(1), JsonValueSchema);
+var JsonPointerSchema = z.string().max(2048).regex(/^(?:\/(?:[^~/]|~0|~1)*)*$/, "path must be an RFC 6901 JSON Pointer");
+var LINEAGE_FORMAT = "lineage@1";
+var LineageFormatSchema = z.literal(LINEAGE_FORMAT);
+var TimestampSchema = z.iso.datetime({ offset: true }).max(64);
+
+// src/profile/transform-validation.ts
+var TRANSFORM_VERIFICATION_DOCS = "https://docs.openparser.dev/lineage/openparser/transform-verification";
+var TRANSFORM_PROOF_ATTRIBUTE = "openparser:transformProof";
+var MAX_TRANSFORM_PROOF_BYTES = 2048;
+var MAX_TRANSFORM_INTENT_PARAMETER_BYTES = 1024;
+var TRANSFORM_DOCS_ANCHORS = [
+  "date-time-format",
+  "numeric-format",
+  "quantity-magnitude",
+  "unit-conversion",
+  "currency-code",
+  "boolean-alias",
+  "text-normalization",
+  "enum-alias"
+];
+var TransformProofClassSchema = z2.enum([
+  "safe_equivalence",
+  "exact_conversion",
+  "policy_application"
+]);
+var FORMAT_TOKENS = [
+  ["yyyyy", "year", "full"],
+  ["yyyy", "year", "full"],
+  ["yyy", "year", "short"],
+  ["yy", "year", "short"],
+  ["y", "year", "short"],
+  ["uuuuu", "year", "full"],
+  ["uuuu", "year", "full"],
+  ["uuu", "year", "short"],
+  ["uu", "year", "short"],
+  ["u", "year", "short"],
+  ["MMMMM", "month"],
+  ["MMMM", "month"],
+  ["MMM", "month"],
+  ["MM", "month"],
+  ["M", "month"],
+  ["LLLLL", "month"],
+  ["LLLL", "month"],
+  ["LLL", "month"],
+  ["LL", "month"],
+  ["L", "month"],
+  ["dd", "day"],
+  ["d", "day"],
+  ["HH", "hour"],
+  ["H", "hour"],
+  ["hh", "hour"],
+  ["h", "hour"],
+  ["kk", "hour"],
+  ["k", "hour"],
+  ["mm", "minute"],
+  ["m", "minute"],
+  ["ss", "second"],
+  ["s", "second"],
+  ["SSS", "millisecond"],
+  ["SS", "millisecond"],
+  ["S", "millisecond"],
+  ["ZZZZZ", "offset"],
+  ["ZZZZ", "offset"],
+  ["ZZZ", "offset"],
+  ["ZZ", "offset"],
+  ["Z", "offset"],
+  ["zzz", "zone"],
+  ["zz", "zone"],
+  ["z", "zone"]
+].toSorted((left, right) => right[0].length - left[0].length);
+function unquotedFormatChunks(format) {
+  const chunks = [];
+  let i = 0;
+  let current = "";
+  while (i < format.length) {
+    if (format[i] === "'") {
+      if (current) chunks.push(current);
+      current = "";
+      i += 1;
+      while (i < format.length) {
+        if (format[i] === "'" && format[i + 1] === "'") {
+          i += 2;
+          continue;
+        }
+        if (format[i] === "'") {
+          i += 1;
+          break;
+        }
+        i += 1;
+      }
+      continue;
+    }
+    current += format[i];
+    i += 1;
+  }
+  if (current) chunks.push(current);
+  return chunks;
+}
+function inspectFormat(format) {
+  const components = {
+    yearQuality: "none",
+    month: false,
+    day: false,
+    hour: false,
+    minute: false,
+    second: false,
+    millisecond: false,
+    offset: false,
+    zone: false
+  };
+  for (const chunk of unquotedFormatChunks(format)) {
+    let i = 0;
+    while (i < chunk.length) {
+      const match = FORMAT_TOKENS.find(([token]) => chunk.startsWith(token, i));
+      if (!match) {
+        i += 1;
+        continue;
+      }
+      const [, field, yearQuality] = match;
+      if (field === "year") {
+        if (yearQuality === "short" || components.yearQuality === "short") {
+          components.yearQuality = "short";
+        } else {
+          components.yearQuality = "full";
+        }
+      } else {
+        components[field] = true;
+      }
+      i += match[0].length;
+    }
+  }
+  return components;
+}
+function formatHasRequiredKindTokens(kind, components) {
+  if (components.yearQuality === "short") return false;
+  if (kind === "date") {
+    return components.yearQuality === "full" && components.month && components.day && !components.hour && !components.minute && !components.second && !components.millisecond && !components.offset && !components.zone;
+  }
+  if (kind === "time") {
+    return components.hour && components.minute && components.second && components.yearQuality === "none" && !components.month && !components.day;
+  }
+  return components.yearQuality === "full" && components.month && components.day && components.hour && components.minute && components.second;
+}
+function optionalTimeComponentsAlign(source, target) {
+  return source.millisecond === target.millisecond && source.offset === target.offset && source.zone === target.zone;
+}
+function dateTimeFormatIssue(kind, sourceFormats, targetFormat) {
+  const target = inspectFormat(targetFormat);
+  if (!formatHasRequiredKindTokens(kind, target)) {
+    return "target format must preserve every required component and must not use a two-digit year";
+  }
+  for (const format of sourceFormats) {
+    const source = inspectFormat(format);
+    if (!formatHasRequiredKindTokens(kind, source)) {
+      return "source format must preserve every required component and must not use a two-digit year";
+    }
+    if (!optionalTimeComponentsAlign(source, target)) {
+      return "source and target formats must not add or drop milliseconds, offset, or zone";
+    }
+  }
+  return void 0;
+}
+var DATE_SOURCE_CATALOG_ID = "openparser.transform.date-source-catalog";
+var DATE_SOURCE_CATALOG_VERSION = 1;
+var FORMAT_ONLY_DATE_TARGETS = {
+  date: "yyyy-MM-dd",
+  "date-time": "yyyy-MM-dd'T'HH:mm:ssZZ",
+  time: "HH:mm:ssZZ"
+};
+var DATE_SOURCE_CATALOG_V1 = {
+  date: [
+    "yyyy-MM-dd",
+    "yyyy/MM/dd",
+    "yyyy.MM.dd",
+    "d MMMM yyyy",
+    "dd MMMM yyyy",
+    "MMMM d, yyyy",
+    "MMMM dd, yyyy",
+    "d MMM yyyy",
+    "dd MMM yyyy",
+    "MMM d, yyyy",
+    "MMM dd, yyyy",
+    "d 'day of' MMMM yyyy",
+    "dd 'day of' MMMM yyyy"
+  ],
+  "date-time": ["yyyy-MM-dd'T'HH:mm:ssZZ", "yyyy-MM-dd'T'HH:mm:ssZ"],
+  time: ["HH:mm:ssZZ", "HH:mm:ssZ"]
+};
+function trustedDateSourceFormats(kind, targetFormat = FORMAT_ONLY_DATE_TARGETS[kind]) {
+  return DATE_SOURCE_CATALOG_V1[kind].filter(
+    (format) => dateTimeFormatIssue(kind, [format], targetFormat) === void 0
+  );
+}
+function formatOnlyDateTimeParameters(kind) {
+  return {
+    kind,
+    sourceFormats: trustedDateSourceFormats(kind, FORMAT_ONLY_DATE_TARGETS[kind]),
+    targetFormat: FORMAT_ONLY_DATE_TARGETS[kind],
+    locale: "en-US",
+    zonePolicy: kind === "date" ? "civil" : "preserve",
+    sourceCatalog: {
+      id: DATE_SOURCE_CATALOG_ID,
+      version: DATE_SOURCE_CATALOG_VERSION
+    }
+  };
+}
+var DateSourceCatalogRefSchema = z2.object({
+  id: z2.literal(DATE_SOURCE_CATALOG_ID),
+  version: z2.literal(DATE_SOURCE_CATALOG_VERSION)
+}).strict();
+var DateTimeParametersSchema = z2.object({
+  kind: z2.enum(["date", "date-time", "time"]),
+  sourceFormats: z2.array(z2.string().min(1).max(128)).max(16).default([]),
+  targetFormat: z2.string().min(1).max(128),
+  locale: z2.string().min(2).max(64).default("en-US"),
+  zonePolicy: z2.enum(["civil", "preserve", "utc", "named"]).default("civil"),
+  zone: z2.string().min(1).max(128).optional(),
+  sourceCatalog: DateSourceCatalogRefSchema.optional()
+}).strict().superRefine((value, ctx) => {
+  if (value.zonePolicy === "named" && !value.zone) {
+    ctx.addIssue({ code: "custom", path: ["zone"], message: "named zone policy requires zone" });
+  }
+  if (value.kind === "date" && value.zonePolicy !== "civil") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["zonePolicy"],
+      message: "date-only transforms must remain civil"
+    });
+  }
+  if (/[Zz]/.test(value.targetFormat) && value.zonePolicy === "civil") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["zonePolicy"],
+      message: "target formats with an offset require preserve, utc, or named zone policy"
+    });
+  }
+});
+var NumericParametersSchema = z2.object({
+  decimalSeparator: z2.enum([".", ","]).default("."),
+  groupingSeparator: z2.enum([",", ".", " ", "\xA0"]).optional(),
+  prefixes: z2.array(z2.string().max(16)).max(16).default([]),
+  suffixes: z2.array(z2.string().max(16)).max(16).default([]),
+  accountingParentheses: z2.boolean().default(false)
+}).strict().superRefine((value, ctx) => {
+  if (value.groupingSeparator === value.decimalSeparator) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["groupingSeparator"],
+      message: "grouping and decimal separators must differ"
+    });
+  }
+});
+function policyMap(keyMax, maxKeys, schema) {
+  return z2.record(z2.string().min(1).max(keyMax), schema).refine((value) => Object.keys(value).length <= maxKeys, `at most ${maxKeys} keys`);
+}
+var QuantityParametersSchema = z2.object({
+  allowedUnits: policyMap(32, 16, z2.string().min(1).max(32)),
+  targetUnit: z2.string().min(1).max(32)
+}).strict();
+var UnitConversionParametersSchema = z2.object({
+  sourceUnits: z2.array(z2.string().min(1).max(32)).min(1).max(32),
+  targetUnit: z2.string().min(1).max(32)
+}).strict();
+var CurrencyParametersSchema = z2.object({
+  acceptedCodes: z2.array(z2.string().regex(/^[A-Z]{3}$/)).min(1).max(64),
+  aliases: policyMap(64, 16, z2.string().regex(/^[A-Z]{3}$/)).default({}),
+  symbolMap: policyMap(8, 16, z2.string().regex(/^[A-Z]{3}$/)).default({})
+}).strict();
+var BooleanParametersSchema = z2.object({
+  aliases: policyMap(64, 16, z2.boolean()),
+  caseSensitive: z2.boolean().default(false)
+}).strict();
+var TextNormalizationParametersSchema = z2.object({
+  operations: z2.array(z2.enum(["trim", "collapse_whitespace", "lowercase", "uppercase", "nfkc"])).min(1).max(8),
+  locale: z2.string().min(2).max(64).default("en-US")
+}).strict();
+var EnumAliasParametersSchema = z2.object({
+  aliases: policyMap(256, 16, z2.union([z2.string().max(256), z2.number()])),
+  caseSensitive: z2.boolean().default(true)
+}).strict();
+var TransformIntentSchema = z2.discriminatedUnion("operation", [
+  z2.object({ operation: z2.literal("date_time_format"), parameters: DateTimeParametersSchema }).strict(),
+  z2.object({ operation: z2.literal("numeric_format"), parameters: NumericParametersSchema }).strict(),
+  z2.object({ operation: z2.literal("quantity_magnitude"), parameters: QuantityParametersSchema }).strict(),
+  z2.object({ operation: z2.literal("unit_conversion"), parameters: UnitConversionParametersSchema }).strict(),
+  z2.object({ operation: z2.literal("currency_code"), parameters: CurrencyParametersSchema }).strict(),
+  z2.object({ operation: z2.literal("boolean_alias"), parameters: BooleanParametersSchema }).strict(),
+  z2.object({
+    operation: z2.literal("text_normalization"),
+    parameters: TextNormalizationParametersSchema
+  }).strict(),
+  z2.object({ operation: z2.literal("enum_alias"), parameters: EnumAliasParametersSchema }).strict()
+]);
+var TRANSFORM_OPERATIONS = [
+  "date_time_format",
+  "numeric_format",
+  "quantity_magnitude",
+  "unit_conversion",
+  "currency_code",
+  "boolean_alias",
+  "text_normalization",
+  "enum_alias"
+];
+var TransformClaimSchema = z2.object({
+  operation: z2.enum(["", ...TRANSFORM_OPERATIONS]),
+  parameters: z2.record(z2.string().max(64), z2.union([z2.string().max(128), z2.number(), z2.boolean()])).refine((value) => Object.keys(value).length <= 16, "at most 16 claim parameters").default({}),
+  reason: z2.string().max(2e3),
+  confidence: z2.enum(["", "low", "medium", "high"])
+}).strict();
+var TRANSFORM_PROOF_OPERAND_KEYS = [
+  "bounded",
+  "canonical",
+  "magnitude",
+  "mappedValue",
+  "matchedSourceFormat",
+  "output",
+  "outputCode",
+  "outputDecimal",
+  "outputHash",
+  "policyHash",
+  "resolvedCode",
+  "sourceDecimal",
+  "sourceHash",
+  "sourceMagnitude",
+  "sourceUnit",
+  "targetMagnitude",
+  "targetUnit"
+];
+function sanitizeProofOperands(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const next = Object.fromEntries(
+    Object.entries(value).filter(
+      ([key]) => TRANSFORM_PROOF_OPERAND_KEYS.includes(key)
+    )
+  );
+  return Object.keys(next).length ? next : void 0;
+}
+var TransformProofHashSchema = z2.object({
+  algorithm: z2.literal("sha256"),
+  digest: z2.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var TransformProofOperandValueSchema = z2.union([
+  z2.string().max(128),
+  z2.number().finite(),
+  z2.boolean(),
+  TransformProofHashSchema
+]);
+function recordSize(maxKeys, schema) {
+  return z2.record(z2.string().min(1).max(64), schema).refine((value) => Object.keys(value).length <= maxKeys, `at most ${maxKeys} keys`);
+}
+function isTrustedTransformDocsHref(href) {
+  if (href === TRANSFORM_VERIFICATION_DOCS) return true;
+  const prefix = `${TRANSFORM_VERIFICATION_DOCS}#`;
+  if (!href.startsWith(prefix)) return false;
+  const anchor = href.slice(prefix.length);
+  return TRANSFORM_DOCS_ANCHORS.includes(anchor);
+}
+function trustedTransformDocsHref(methodId) {
+  if (!methodId) return TRANSFORM_VERIFICATION_DOCS;
+  const descriptor = TRANSFORM_VALIDATORS.find((entry) => entry.methodId === methodId);
+  return descriptor ? `${TRANSFORM_VERIFICATION_DOCS}#${descriptor.docsAnchor}` : TRANSFORM_VERIFICATION_DOCS;
+}
+var proofByteLength = (input) => new TextEncoder().encode(JSON.stringify(input)).byteLength;
+function trustedIntentParametersFitProof(parameters) {
+  return proofByteLength(parameters) <= MAX_TRANSFORM_INTENT_PARAMETER_BYTES;
+}
+var TransformProofSchema = z2.object({
+  methodId: z2.string().min(1).max(128),
+  methodVersion: z2.number().int().positive(),
+  result: z2.enum(["verified", "contradicted", "not_applicable"]),
+  proofClass: TransformProofClassSchema,
+  scope: z2.string().min(1).max(256),
+  trustedParameters: recordSize(32, JsonValueSchema),
+  operands: recordSize(16, TransformProofOperandValueSchema).refine(
+    (value) => Object.keys(value).every(
+      (key) => TRANSFORM_PROOF_OPERAND_KEYS.includes(key)
+    ),
+    "unsupported proof operand key"
+  ).optional(),
+  checks: recordSize(32, z2.boolean()),
+  implementation: z2.object({
+    library: z2.string().min(1).max(128),
+    version: z2.string().min(1).max(64),
+    runtime: z2.string().min(1).max(128).optional(),
+    locale: z2.string().min(1).max(64).optional(),
+    zone: z2.string().min(1).max(128).optional()
+  }).strict(),
+  limitations: z2.string().min(1).max(512),
+  docsHref: z2.string().max(256).refine(isTrustedTransformDocsHref, "untrusted transform docs href")
+}).strict().superRefine((value, ctx) => {
+  if (proofByteLength(value) > MAX_TRANSFORM_PROOF_BYTES) {
+    ctx.addIssue({
+      code: "custom",
+      message: `transform proof exceeds ${MAX_TRANSFORM_PROOF_BYTES} bytes`
+    });
+  }
+});
+function parseTransformProof(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const record = value;
+  const methodId = typeof record.methodId === "string" ? record.methodId : void 0;
+  const candidate = {
+    methodId: record.methodId,
+    methodVersion: record.methodVersion,
+    result: record.result,
+    proofClass: record.proofClass,
+    scope: record.scope,
+    trustedParameters: record.trustedParameters,
+    ...sanitizeProofOperands(record.operands) ? { operands: sanitizeProofOperands(record.operands) } : {},
+    checks: record.checks,
+    implementation: record.implementation,
+    limitations: record.limitations,
+    docsHref: trustedTransformDocsHref(methodId)
+  };
+  const parsed = TransformProofSchema.safeParse(candidate);
+  return parsed.success ? parsed.data : void 0;
+}
+var DECIMAL_VERSION = "10.6.0";
+var LUXON_VERSION = "3.7.2";
+var ISO_4217_CODES = new Set(
+  "AED AFN ALL AMD ANG AOA ARS AUD AWG AZN BAM BBD BDT BGN BHD BIF BMD BND BOB BOV BRL BSD BTN BWP BYN BZD CAD CDF CHE CHF CHW CLF CLP CNY COP COU CRC CUC CUP CVE CZK DJF DKK DOP DZD EGP ERN ETB EUR FJD FKP GBP GEL GHS GIP GMD GNF GTQ GYD HKD HNL HRK HTG HUF IDR ILS INR IQD IRR ISK JMD JOD JPY KES KGS KHR KMF KPW KRW KWD KYD KZT LAK LBP LKR LRD LSL LYD MAD MDL MGA MKD MMK MNT MOP MRU MUR MVR MWK MXN MXV MYR MZN NAD NGN NIO NOK NPR NZD OMR PAB PEN PGK PHP PKR PLN PYG QAR RON RSD RUB RWF SAR SBD SCR SDG SEK SGD SHP SLE SLL SOS SRD SSP STN SVC SYP SZL THB TJS TMT TND TOP TRY TTD TWD TZS UAH UGX USD USN UYI UYU UYW UZS VED VES VND VUV WST XAF XAG XAU XBA XBB XBC XBD XCD XDR XOF XPD XPF XPT XSU XTS XUA XXX YER ZAR ZMW ZWG ZWL".split(
+    " "
+  )
+);
+function descriptorBase(input) {
+  return {
+    ...input,
+    parameterJsonSchema: input.parameterJsonSchema ?? z2.toJSONSchema(input.parameterSchema)
+  };
+}
+function sha256Operand(value) {
+  return {
+    algorithm: "sha256",
+    digest: createHash("sha256").update(value, "utf8").digest("hex")
+  };
+}
+function boundedOperand(value) {
+  return value.length <= 128 ? value : sha256Operand(value);
+}
+function proof(descriptor, result, parameters, extras) {
+  const jsonParameters = JSON.parse(JSON.stringify(parameters));
+  const jsonOperands = extras.operands ? JSON.parse(JSON.stringify(extras.operands)) : void 0;
+  const value = {
+    methodId: descriptor.methodId,
+    methodVersion: descriptor.version,
+    result,
+    proofClass: extras.proofClass ?? descriptor.proofClass,
+    scope: descriptor.summary,
+    trustedParameters: jsonParameters,
+    ...jsonOperands ? { operands: jsonOperands } : {},
+    checks: extras.checks,
+    implementation: {
+      library: descriptor.library.name,
+      version: descriptor.library.version,
+      ...extras.runtime ? { runtime: extras.runtime.slice(0, 128) } : {},
+      ...extras.locale ? { locale: extras.locale } : {},
+      ...extras.zone ? { zone: extras.zone } : {}
+    },
+    limitations: descriptor.limitations,
+    docsHref: `${TRANSFORM_VERIFICATION_DOCS}#${descriptor.docsAnchor}`
+  };
+  const next = boundedProof(value);
+  return { result: next.result, proof: next };
+}
+function isIncompleteTrustedPolicy(parameters) {
+  return typeof parameters === "object" && parameters !== null && !Array.isArray(parameters) && Object.keys(parameters).length === 1 && parameters.bounded === true;
+}
+function downgradeProofTooLarge(value) {
+  const digest = sha256Operand(JSON.stringify(value.trustedParameters ?? {}));
+  const parsed = TransformProofSchema.safeParse({
+    methodId: value.methodId,
+    methodVersion: value.methodVersion,
+    result: "not_applicable",
+    proofClass: value.proofClass,
+    scope: value.scope,
+    trustedParameters: {
+      reason: "proof_too_large",
+      policyHash: digest
+    },
+    operands: { policyHash: digest },
+    checks: { proofFitsBound: false },
+    implementation: value.implementation,
+    limitations: value.limitations,
+    docsHref: value.docsHref
+  });
+  if (!parsed.success) {
+    throw new Error("transform proof descriptor exceeds bounded metadata limit");
+  }
+  return parsed.data;
+}
+function boundedProof(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("transform proof descriptor exceeds bounded metadata limit");
+  }
+  const record = value;
+  const parsed = TransformProofSchema.safeParse(value);
+  if (parsed.success) {
+    if (parsed.data.result === "verified" && isIncompleteTrustedPolicy(parsed.data.trustedParameters)) {
+      return downgradeProofTooLarge(record);
+    }
+    return parsed.data;
+  }
+  return downgradeProofTooLarge(record);
+}
+function escaped(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function outputDecimal(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return new Decimal(value.toString());
+  if (typeof value === "string" && /^[+-]?\d+(?:\.\d+)?$/.test(value)) return new Decimal(value);
+  return void 0;
+}
+function parseTrustedDecimal(quote, parameters) {
+  let text = quote.normalize("NFKC").trim();
+  let negative = false;
+  if (parameters.accountingParentheses && text.startsWith("(") && text.endsWith(")")) {
+    negative = true;
+    text = text.slice(1, -1).trim();
+  }
+  const stripEdge = (values, edge) => {
+    const match = [...values].sort((a, b) => b.length - a.length).find((value) => edge === "prefix" ? text.startsWith(value) : text.endsWith(value));
+    if (!match) return;
+    text = edge === "prefix" ? text.slice(match.length).trim() : text.slice(0, text.length - match.length).trim();
+  };
+  stripEdge(parameters.prefixes, "prefix");
+  stripEdge(parameters.suffixes, "suffix");
+  const decimal = escaped(parameters.decimalSeparator);
+  const grouping = parameters.groupingSeparator ? escaped(parameters.groupingSeparator) : void 0;
+  const integer = grouping ? `(?:\\d{1,3}(?:${grouping}\\d{3})+|\\d+)` : "\\d+";
+  if (!new RegExp(`^[+-]?${integer}(?:${decimal}\\d+)?$`).test(text)) return void 0;
+  const canonical = text.replaceAll(parameters.groupingSeparator ?? "\0", "").replace(parameters.decimalSeparator, ".");
+  try {
+    const parsed = new Decimal(canonical);
+    return negative ? parsed.negated() : parsed;
+  } catch {
+    return void 0;
+  }
+}
+function dateTimeRuntime() {
+  if (typeof process === "undefined") return void 0;
+  return `node ${process.versions.node}; ICU ${process.versions.icu ?? "unknown"}`;
+}
+function canonicalDateTime(kind, value, components) {
+  if (kind === "date") return value.toFormat("yyyy-MM-dd");
+  const fraction = components.millisecond ? ".SSS" : "";
+  if (kind === "time") {
+    const offset = components.offset ? "ZZ" : "";
+    const zone = components.zone ? " zzz" : "";
+    return value.toFormat(`HH:mm:ss${fraction}${offset}${zone}`).trim();
+  }
+  if (components.offset || components.zone) return value.toUTC().toISO() ?? "";
+  return value.toFormat(`yyyy-MM-dd'T'HH:mm:ss${fraction}`);
+}
+var dateTimeBase = descriptorBase({
+  operation: "date_time_format",
+  methodId: "openparser.transform.date-time-format.v1",
+  version: 1,
+  label: "Date/time formatting",
+  summary: "Exact reformatting of one civil date/time value or instant",
+  docsAnchor: "date-time-format",
+  acceptedSourceTypes: ["string"],
+  acceptedOutputTypes: ["string"],
+  proofClass: "safe_equivalence",
+  parameterSchema: DateTimeParametersSchema,
+  library: { name: "luxon", version: LUXON_VERSION },
+  limitations: "Only explicit Luxon formats with four-digit years; source and target must preserve the same required components. Two-digit years, defaulted fields, and silent millisecond/offset/zone changes are not proven. Format-only JSON Schema date intent uses the versioned built-in source catalog; a claim source_format cannot add or narrow that catalog."
+});
+function resolveTrustedDateTimeParameters(parameters) {
+  if (parameters.sourceFormats.length === 0 || parameters.sourceCatalog) {
+    return {
+      ...parameters,
+      sourceFormats: trustedDateSourceFormats(parameters.kind, parameters.targetFormat),
+      sourceCatalog: {
+        id: DATE_SOURCE_CATALOG_ID,
+        version: DATE_SOURCE_CATALOG_VERSION
+      }
+    };
+  }
+  return parameters;
+}
+function prioritizeSourceFormats(formats, preferred) {
+  if (!preferred || !formats.includes(preferred)) return formats;
+  return [preferred, ...formats.filter((format) => format !== preferred)];
+}
+var dateTimeValidator = {
+  ...dateTimeBase,
+  verify({ quote, output, parameters, preferredSourceFormat }) {
+    const parsed = DateTimeParametersSchema.safeParse(parameters);
+    if (!parsed.success || typeof output !== "string") {
+      return proof(dateTimeBase, "not_applicable", {}, { checks: { parametersValid: false } });
+    }
+    const p = resolveTrustedDateTimeParameters(parsed.data);
+    if (p.sourceFormats.length === 0) {
+      return proof(dateTimeBase, "not_applicable", p, {
+        checks: {
+          sourceTokensValid: false,
+          targetTokensValid: formatHasRequiredKindTokens(p.kind, inspectFormat(p.targetFormat)),
+          fullSourceConsumed: false,
+          sourceRoundTrip: false
+        },
+        locale: p.locale
+      });
+    }
+    const zone = p.zonePolicy === "utc" ? "UTC" : p.zonePolicy === "named" ? p.zone : void 0;
+    const targetComponents = inspectFormat(p.targetFormat);
+    const preferred = preferredSourceFormat && p.sourceFormats.includes(preferredSourceFormat) ? preferredSourceFormat : void 0;
+    const candidates = prioritizeSourceFormats(p.sourceFormats, preferred).flatMap((format) => {
+      const sourceComponents = inspectFormat(format);
+      if (!formatHasRequiredKindTokens(p.kind, sourceComponents) || !formatHasRequiredKindTokens(p.kind, targetComponents) || !optionalTimeComponentsAlign(sourceComponents, targetComponents)) {
+        return [];
+      }
+      const value = DateTime.fromFormat(quote, format, {
+        locale: p.locale,
+        zone,
+        setZone: p.zonePolicy !== "civil"
+      });
+      if (!value.isValid || value.toFormat(format) !== quote) return [];
+      if (p.zonePolicy === "named" && value.getPossibleOffsets().length !== 1) return [];
+      return [{ value, format, components: sourceComponents }];
+    });
+    if (!candidates.length) {
+      return proof(dateTimeBase, "not_applicable", p, {
+        checks: {
+          sourceTokensValid: true,
+          targetTokensValid: formatHasRequiredKindTokens(p.kind, targetComponents),
+          fullSourceConsumed: false,
+          sourceRoundTrip: false,
+          unambiguous: false
+        },
+        locale: p.locale,
+        zone
+      });
+    }
+    const canonical = candidates.map(
+      ({ value, components }) => canonicalDateTime(p.kind, value, components)
+    );
+    const converged = new Set(canonical).size === 1;
+    const rendered = candidates[0].value.toFormat(p.targetFormat);
+    const target = DateTime.fromFormat(rendered, p.targetFormat, {
+      locale: p.locale,
+      zone,
+      setZone: p.zonePolicy !== "civil"
+    });
+    const targetRoundTrip = target.isValid && target.toFormat(p.targetFormat) === rendered;
+    const exactOutput = output === rendered;
+    const result = converged && targetRoundTrip && exactOutput ? "verified" : "contradicted";
+    const matchedSourceFormat = preferred && candidates.some((candidate) => candidate.format === preferred) ? preferred : candidates[0].format;
+    return proof(dateTimeBase, result, p, {
+      operands: {
+        sourceHash: sha256Operand(quote),
+        matchedSourceFormat: boundedOperand(matchedSourceFormat),
+        canonical: boundedOperand(canonical[0]),
+        output: boundedOperand(output)
+      },
+      checks: {
+        sourceTokensValid: true,
+        targetTokensValid: true,
+        componentsPreserved: true,
+        fullSourceConsumed: true,
+        sourceRoundTrip: true,
+        formatsConverged: converged,
+        targetRoundTrip,
+        exactOutput
+      },
+      runtime: dateTimeRuntime(),
+      locale: p.locale,
+      zone: zone ?? p.zonePolicy
+    });
+  }
+};
+var numericBase = descriptorBase({
+  operation: "numeric_format",
+  methodId: "openparser.transform.numeric-format.v1",
+  version: 1,
+  label: "Numeric formatting",
+  summary: "Exact decimal equivalence after a declared representation change",
+  docsAnchor: "numeric-format",
+  acceptedSourceTypes: ["string"],
+  acceptedOutputTypes: ["number", "integer", "string"],
+  proofClass: "safe_equivalence",
+  parameterSchema: NumericParametersSchema,
+  library: { name: "decimal.js", version: DECIMAL_VERSION },
+  limitations: "Only declared separators and edge affixes are accepted."
+});
+var numericValidator = {
+  ...numericBase,
+  verify({ quote, output, parameters }) {
+    const parsed = NumericParametersSchema.safeParse(parameters);
+    const right = outputDecimal(output);
+    if (!parsed.success || !right) {
+      return proof(numericBase, "not_applicable", {}, { checks: { parametersValid: false } });
+    }
+    const left = parseTrustedDecimal(quote, parsed.data);
+    if (!left) {
+      return proof(numericBase, "not_applicable", parsed.data, {
+        checks: { wholeQuoteMatched: false }
+      });
+    }
+    const exact = left.eq(right);
+    return proof(numericBase, exact ? "verified" : "contradicted", parsed.data, {
+      operands: { sourceDecimal: left.toString(), outputDecimal: right.toString() },
+      checks: { wholeQuoteMatched: true, exactDecimalEquality: exact }
+    });
+  }
+};
+var quantityBase = descriptorBase({
+  operation: "quantity_magnitude",
+  methodId: "openparser.transform.quantity-magnitude.v1",
+  version: 1,
+  label: "Quantity magnitude",
+  summary: "Removal of an explicitly accepted unit while preserving magnitude",
+  docsAnchor: "quantity-magnitude",
+  acceptedSourceTypes: ["string"],
+  acceptedOutputTypes: ["number", "integer", "string"],
+  proofClass: "safe_equivalence",
+  parameterSchema: QuantityParametersSchema,
+  library: { name: "decimal.js", version: DECIMAL_VERSION },
+  limitations: "The complete quote must be one quantity and the unit must be allowlisted."
+});
+var quantityValidator = {
+  ...quantityBase,
+  verify({ quote, output, parameters }) {
+    const parsed = QuantityParametersSchema.safeParse(parameters);
+    const right = outputDecimal(output);
+    if (!parsed.success || !right) {
+      return proof(quantityBase, "not_applicable", {}, { checks: { parametersValid: false } });
+    }
+    const aliases = Object.keys(parsed.data.allowedUnits).sort((a, b) => b.length - a.length);
+    const match = quote.normalize("NFKC").trim().match(new RegExp(`^([+-]?\\d+(?:\\.\\d+)?)\\s*(${aliases.map(escaped).join("|")})$`, "i"));
+    if (!match) {
+      return proof(quantityBase, "not_applicable", parsed.data, {
+        checks: { wholeQuoteMatched: false }
+      });
+    }
+    const canonicalUnit = Object.entries(parsed.data.allowedUnits).find(
+      ([alias]) => alias.toLocaleLowerCase("en-US") === match[2].toLocaleLowerCase("en-US")
+    )?.[1];
+    const exact = canonicalUnit === parsed.data.targetUnit && new Decimal(match[1]).eq(right);
+    return proof(quantityBase, exact ? "verified" : "contradicted", parsed.data, {
+      operands: {
+        magnitude: match[1],
+        sourceUnit: canonicalUnit,
+        targetUnit: parsed.data.targetUnit
+      },
+      checks: {
+        wholeQuoteMatched: true,
+        acceptedUnit: Boolean(canonicalUnit),
+        exactMagnitude: exact
+      }
+    });
+  }
+};
+var UNIT_RATIOS = {
+  mm: { dimension: "length", baseRatio: "0.001" },
+  cm: { dimension: "length", baseRatio: "0.01" },
+  m: { dimension: "length", baseRatio: "1" },
+  km: { dimension: "length", baseRatio: "1000" },
+  in: { dimension: "length", baseRatio: "0.0254" },
+  ft: { dimension: "length", baseRatio: "0.3048" },
+  s: { dimension: "duration", baseRatio: "1" },
+  min: { dimension: "duration", baseRatio: "60" },
+  h: { dimension: "duration", baseRatio: "3600" },
+  day: { dimension: "duration", baseRatio: "86400" },
+  month: { dimension: "calendar_duration", baseRatio: "1" },
+  year: { dimension: "calendar_duration", baseRatio: "12" },
+  g: { dimension: "mass", baseRatio: "1" },
+  kg: { dimension: "mass", baseRatio: "1000" },
+  lb: { dimension: "mass", baseRatio: "453.59237" }
+};
+var unitBase = descriptorBase({
+  operation: "unit_conversion",
+  methodId: "openparser.transform.unit-conversion.v1",
+  version: 1,
+  label: "Unit conversion",
+  summary: "Exact conversion between allowlisted units in one dimension",
+  docsAnchor: "unit-conversion",
+  acceptedSourceTypes: ["string"],
+  acceptedOutputTypes: ["number", "integer", "string"],
+  proofClass: "exact_conversion",
+  parameterSchema: UnitConversionParametersSchema,
+  library: { name: "decimal.js + OpenParser unit table", version: `${DECIMAL_VERSION}/1` },
+  limitations: "Only the versioned unit table is supported; no contextual or ambiguous units."
+});
+var unitValidator = {
+  ...unitBase,
+  verify({ quote, output, parameters }) {
+    const parsed = UnitConversionParametersSchema.safeParse(parameters);
+    const right = outputDecimal(output);
+    if (!parsed.success || !right) {
+      return proof(unitBase, "not_applicable", {}, { checks: { parametersValid: false } });
+    }
+    const match = quote.normalize("NFKC").trim().match(/^([+-]?\d+(?:\.\d+)?)\s*([A-Za-z]+)$/);
+    const sourceUnit = match?.[2];
+    const source = sourceUnit ? UNIT_RATIOS[sourceUnit] : void 0;
+    const target = UNIT_RATIOS[parsed.data.targetUnit];
+    if (!match || !sourceUnit || !parsed.data.sourceUnits.includes(sourceUnit) || !source || !target) {
+      return proof(unitBase, "not_applicable", parsed.data, {
+        checks: { wholeQuoteMatched: Boolean(match), supportedUnits: false }
+      });
+    }
+    if (source.dimension !== target.dimension) {
+      return proof(unitBase, "contradicted", parsed.data, {
+        operands: { sourceUnit, targetUnit: parsed.data.targetUnit },
+        checks: { sameDimension: false }
+      });
+    }
+    const converted = new Decimal(match[1]).mul(source.baseRatio).div(target.baseRatio);
+    const exact = converted.eq(right);
+    return proof(unitBase, exact ? "verified" : "contradicted", parsed.data, {
+      operands: {
+        sourceMagnitude: match[1],
+        sourceUnit,
+        targetMagnitude: converted.toString(),
+        targetUnit: parsed.data.targetUnit
+      },
+      checks: { wholeQuoteMatched: true, sameDimension: true, exactDecimalEquality: exact }
+    });
+  }
+};
+function findBoundedTokens(text, token) {
+  const indices = [];
+  const pattern = new RegExp(`(?<![A-Za-z0-9])${escaped(token)}(?![A-Za-z0-9])`, "gi");
+  for (const match of text.matchAll(pattern)) {
+    if (match.index !== void 0) indices.push(match.index);
+  }
+  return indices;
+}
+function collectCurrencySignals(text, parameters) {
+  const signals = [];
+  const isoCodes = /* @__PURE__ */ new Set([...ISO_4217_CODES, ...parameters.acceptedCodes]);
+  for (const code of isoCodes) {
+    for (const index of findBoundedTokens(text, code)) {
+      signals.push({ code: code.toUpperCase(), index, kind: "iso" });
+    }
+  }
+  for (const [alias, code] of Object.entries(parameters.aliases)) {
+    for (const index of findBoundedTokens(text, alias)) {
+      signals.push({ code, index, kind: "alias" });
+    }
+  }
+  const covered = new Array(text.length).fill(false);
+  const symbols = Object.entries(parameters.symbolMap).toSorted(
+    (left, right) => right[0].length - left[0].length
+  );
+  for (const [symbol, code] of symbols) {
+    let from = 0;
+    while (from <= text.length - symbol.length) {
+      const index = text.indexOf(symbol, from);
+      if (index < 0) break;
+      from = index + 1;
+      const before = index === 0 ? "" : text[index - 1];
+      if (/\p{L}/u.test(before)) continue;
+      if (covered.slice(index, index + symbol.length).some(Boolean)) continue;
+      for (let i = index; i < index + symbol.length; i += 1) covered[i] = true;
+      signals.push({ code, index, kind: "symbol" });
+    }
+  }
+  return signals;
+}
+var currencyBase = descriptorBase({
+  operation: "currency_code",
+  methodId: "openparser.transform.currency-code.v1",
+  version: 1,
+  label: "Currency code derivation",
+  summary: "Derivation of an ISO code from an explicit token or declared symbol policy",
+  docsAnchor: "currency-code",
+  acceptedSourceTypes: ["string"],
+  acceptedOutputTypes: ["string"],
+  proofClass: "safe_equivalence",
+  parameterSchema: CurrencyParametersSchema,
+  library: { name: "OpenParser ISO currency token table", version: "1" },
+  limitations: "A bare $ proves nothing unless trusted intent maps that standalone token. $ inside C$, A$, NZ$, HK$, or S$ is not a USD signal. Conflicting ISO codes or currency signals are not applied."
+});
+var currencyValidator = {
+  ...currencyBase,
+  verify({ quote, output, parameters }) {
+    const parsed = CurrencyParametersSchema.safeParse(parameters);
+    if (!parsed.success || typeof output !== "string") {
+      return proof(currencyBase, "not_applicable", {}, { checks: { parametersValid: false } });
+    }
+    const text = quote.normalize("NFKC").trim();
+    const accepted = new Set(parsed.data.acceptedCodes);
+    const signals = collectCurrencySignals(text, parsed.data);
+    const codes = [...new Set(signals.map((signal) => signal.code))];
+    if (codes.length > 1) {
+      return proof(currencyBase, "not_applicable", parsed.data, {
+        checks: { trustedTokenFound: true, unambiguous: false }
+      });
+    }
+    const code = codes[0];
+    if (!code || !accepted.has(code)) {
+      return proof(currencyBase, "not_applicable", parsed.data, {
+        checks: { trustedTokenFound: false, unambiguous: true }
+      });
+    }
+    const policy = signals.every((signal) => signal.kind === "symbol");
+    const exact = output === code;
+    return proof(currencyBase, exact ? "verified" : "contradicted", parsed.data, {
+      proofClass: policy ? "policy_application" : "safe_equivalence",
+      operands: { resolvedCode: code, outputCode: output },
+      checks: { trustedTokenFound: true, unambiguous: true, exactOutput: exact }
+    });
+  }
+};
+var booleanBase = descriptorBase({
+  operation: "boolean_alias",
+  methodId: "openparser.transform.boolean-alias.v1",
+  version: 1,
+  label: "Boolean alias",
+  summary: "Application of a trusted exact alias map to a whole quote",
+  docsAnchor: "boolean-alias",
+  acceptedSourceTypes: ["string"],
+  acceptedOutputTypes: ["boolean"],
+  proofClass: "policy_application",
+  parameterSchema: BooleanParametersSchema,
+  library: { name: "OpenParser alias matcher", version: "1" },
+  limitations: "No sentiment, negation, or natural-language interpretation."
+});
+var booleanValidator = {
+  ...booleanBase,
+  verify({ quote, output, parameters }) {
+    const parsed = BooleanParametersSchema.safeParse(parameters);
+    if (!parsed.success || typeof output !== "boolean") {
+      return proof(booleanBase, "not_applicable", {}, { checks: { parametersValid: false } });
+    }
+    const normalize = (value) => parsed.data.caseSensitive ? value : value.toLocaleLowerCase("en-US");
+    const match = Object.entries(parsed.data.aliases).find(
+      ([alias]) => normalize(alias) === normalize(quote.normalize("NFKC").trim())
+    );
+    if (!match) {
+      return proof(booleanBase, "not_applicable", parsed.data, {
+        checks: { wholeQuoteMatched: false }
+      });
+    }
+    const exact = match[1] === output;
+    return proof(booleanBase, exact ? "verified" : "contradicted", parsed.data, {
+      operands: { mappedValue: match[1], output },
+      checks: { wholeQuoteMatched: true, exactOutput: exact }
+    });
+  }
+};
+function applyTextOperations(value, parameters) {
+  return parameters.operations.reduce((text, operation) => {
+    switch (operation) {
+      case "trim":
+        return text.trim();
+      case "collapse_whitespace":
+        return text.replace(/\s+/g, " ");
+      case "lowercase":
+        return text.toLocaleLowerCase(parameters.locale);
+      case "uppercase":
+        return text.toLocaleUpperCase(parameters.locale);
+      case "nfkc":
+        return text.normalize("NFKC");
+    }
+  }, value);
+}
+var textBase = descriptorBase({
+  operation: "text_normalization",
+  methodId: "openparser.transform.text-normalization.v1",
+  version: 1,
+  label: "Controlled text normalization",
+  summary: "Application of an ordered, enumerated text normalization plan",
+  docsAnchor: "text-normalization",
+  acceptedSourceTypes: ["string"],
+  acceptedOutputTypes: ["string"],
+  proofClass: "policy_application",
+  parameterSchema: TextNormalizationParametersSchema,
+  library: { name: "ECMAScript String", version: "ES2024" },
+  limitations: "Only the recorded operations run; semantic paraphrasing is never verified."
+});
+var textValidator = {
+  ...textBase,
+  verify({ quote, output, parameters }) {
+    const parsed = TextNormalizationParametersSchema.safeParse(parameters);
+    if (!parsed.success || typeof output !== "string") {
+      return proof(textBase, "not_applicable", {}, { checks: { parametersValid: false } });
+    }
+    const normalized = applyTextOperations(quote, parsed.data);
+    const exact = output === normalized;
+    return proof(textBase, exact ? "verified" : "contradicted", parsed.data, {
+      operands: { sourceHash: sha256Operand(quote), outputHash: sha256Operand(output) },
+      checks: { operationsApplied: true, exactOutput: exact },
+      locale: parsed.data.locale
+    });
+  }
+};
+var enumBase = descriptorBase({
+  operation: "enum_alias",
+  methodId: "openparser.transform.enum-alias.v1",
+  version: 1,
+  label: "Enum alias",
+  summary: "Application of a trusted exact alias table",
+  docsAnchor: "enum-alias",
+  acceptedSourceTypes: ["string"],
+  acceptedOutputTypes: ["string", "number", "integer"],
+  proofClass: "policy_application",
+  parameterSchema: EnumAliasParametersSchema,
+  library: { name: "OpenParser alias matcher", version: "1" },
+  limitations: "Only exact whole-quote aliases are accepted."
+});
+var enumValidator = {
+  ...enumBase,
+  verify({ quote, output, parameters }) {
+    const parsed = EnumAliasParametersSchema.safeParse(parameters);
+    if (!parsed.success || typeof output !== "string" && typeof output !== "number") {
+      return proof(enumBase, "not_applicable", {}, { checks: { parametersValid: false } });
+    }
+    const normalize = (value) => parsed.data.caseSensitive ? value : value.toLocaleLowerCase("en-US");
+    const match = Object.entries(parsed.data.aliases).find(
+      ([alias]) => normalize(alias) === normalize(quote.normalize("NFKC").trim())
+    );
+    if (!match) {
+      return proof(enumBase, "not_applicable", parsed.data, {
+        checks: { wholeQuoteMatched: false }
+      });
+    }
+    const exact = match[1] === output;
+    return proof(enumBase, exact ? "verified" : "contradicted", parsed.data, {
+      operands: {
+        mappedValue: typeof match[1] === "string" ? boundedOperand(match[1]) : match[1],
+        output: typeof output === "string" ? boundedOperand(output) : output
+      },
+      checks: { wholeQuoteMatched: true, exactOutput: exact }
+    });
+  }
+};
+var TRANSFORM_VALIDATORS = [
+  dateTimeValidator,
+  numericValidator,
+  quantityValidator,
+  unitValidator,
+  currencyValidator,
+  booleanValidator,
+  textValidator,
+  enumValidator
+];
+var VALIDATOR_BY_OPERATION = new Map(
+  TRANSFORM_VALIDATORS.map((descriptor) => [descriptor.operation, descriptor])
+);
+function transformValidatorDescriptor(operation) {
+  return VALIDATOR_BY_OPERATION.get(operation);
+}
+function claimedDateSourceFormat(claim) {
+  if (!claim || claim.operation !== "date_time_format") return void 0;
+  const value = claim.parameters.source_format;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function verifyTransform(input) {
+  const intent = TransformIntentSchema.parse(input.intent);
+  const descriptor = transformValidatorDescriptor(intent.operation);
+  const hinted = claimedDateSourceFormat(input.claim);
+  return descriptor.verify({
+    quote: input.quote,
+    output: input.output,
+    parameters: intent.parameters,
+    ...intent.operation === "date_time_format" && hinted ? { preferredSourceFormat: hinted } : {}
+  });
+}
+export {
+  CITED_RECOGNITION_METHOD,
+  CONTEXT_BLEND_WEIGHT,
+  DATE_SOURCE_CATALOG_ID,
+  DATE_SOURCE_CATALOG_V1,
+  DATE_SOURCE_CATALOG_VERSION,
+  FORMAT_ONLY_DATE_TARGETS,
+  MAX_TRANSFORM_INTENT_PARAMETER_BYTES,
+  MAX_TRANSFORM_PROOF_BYTES,
+  REGION_RECOGNITION_METHOD,
+  TRANSFORM_DOCS_ANCHORS,
+  TRANSFORM_OPERATIONS,
+  TRANSFORM_PROOF_ATTRIBUTE,
+  TRANSFORM_PROOF_OPERAND_KEYS,
+  TRANSFORM_VALIDATORS,
+  TRANSFORM_VERIFICATION_DOCS,
+  TransformClaimSchema,
+  TransformIntentSchema,
+  TransformProofClassSchema,
+  TransformProofSchema,
+  activityLabel,
+  aggregateCitedWordConfidences,
+  annotateWordsWithCitation,
+  citedSpanInText,
+  dateTimeFormatIssue,
+  downwardBlendCitedMinimum,
+  droppedSourceIds,
+  fieldGrounding,
+  formatOnlyDateTimeParameters,
+  groundingStatus,
+  isTrustedTransformDocsHref,
+  parseTransformProof,
+  transformValidatorDescriptor,
+  trustedDateSourceFormats,
+  trustedIntentParametersFitProof,
+  trustedTransformDocsHref,
+  verifyTransform
+};