@convert-buddy/importer-contracts 0.1.0-beta.1

package/dist/index.js

@@ -0,0 +1,1125 @@
+// src/canonical.ts
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function canonicalizeValue(value, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("Canonical JSON numbers must be finite");
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (ancestors.has(value)) throw new TypeError("Canonical JSON cannot contain cycles");
+    const nextAncestors = new Set(ancestors).add(value);
+    return value.map((entry) => canonicalizeValue(entry, nextAncestors));
+  }
+  if (isPlainRecord(value)) {
+    if (ancestors.has(value)) throw new TypeError("Canonical JSON cannot contain cycles");
+    const nextAncestors = new Set(ancestors).add(value);
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(value).sort()) {
+      const child = value[key];
+      if (child === void 0) throw new TypeError(`Canonical JSON property ${JSON.stringify(key)} is undefined`);
+      result[key] = canonicalizeValue(child, nextAncestors);
+    }
+    return result;
+  }
+  throw new TypeError("Value is not canonical JSON");
+}
+function canonicalStringify(value) {
+  return JSON.stringify(canonicalizeValue(value, /* @__PURE__ */ new Set()));
+}
+function canonicalByteLength(value) {
+  return new TextEncoder().encode(canonicalStringify(value)).byteLength;
+}
+function cloneJsonValue(value) {
+  return canonicalizeValue(value, /* @__PURE__ */ new Set());
+}
+
+// src/dates.ts
+function isCalendarDate(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return false;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return year >= 1 && month >= 1 && month <= 12 && day >= 1 && day <= days[month - 1];
+}
+function isOffsetDateTime(value) {
+  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?(Z|[+-]\d{2}:\d{2})$/.exec(value);
+  if (!match || !isCalendarDate(match[1])) return false;
+  if (Number(match[2]) > 23 || Number(match[3]) > 59 || Number(match[4] ?? 0) > 59) return false;
+  const zone = match[6];
+  if (zone !== "Z" && (Number(zone.slice(1, 3)) > 23 || Number(zone.slice(4)) > 59)) return false;
+  return Number.isFinite(Date.parse(value));
+}
+function parseCalendarFormats(value, formats) {
+  const results = /* @__PURE__ */ new Set();
+  for (const format of formats) {
+    const normalized = format.replace(/yyyy/g, "YYYY").replace(/dd/g, "DD");
+    const parts = normalized.split(/(YYYY|MM|DD)/);
+    const tokens = [];
+    const pattern = parts.map((part) => {
+      if (["YYYY", "MM", "DD"].includes(part)) {
+        tokens.push(part);
+        return part === "YYYY" ? "(\\d{4})" : "(\\d{2})";
+      }
+      return part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }).join("");
+    if (tokens.length !== 3 || new Set(tokens).size !== 3) continue;
+    const match = new RegExp(`^${pattern}$`).exec(value);
+    if (!match) continue;
+    const values = Object.fromEntries(tokens.map((token, index) => [token, match[index + 1]]));
+    const date = `${values.YYYY}-${values.MM}-${values.DD}`;
+    if (isCalendarDate(date)) results.add(date);
+  }
+  return results.size === 1 ? [...results][0] : void 0;
+}
+
+// src/limits.ts
+var DEFAULT_CONTRACT_LIMITS = Object.freeze({
+  maxAliasesPerField: 32,
+  maxCanonicalBytes: 256 * 1024,
+  maxDescriptionLength: 2e3,
+  maxDictionaryEntries: 256,
+  maxFields: 512,
+  maxMappings: 512,
+  maxOperationsPerMapping: 12,
+  maxPatternLength: 256,
+  maxRecordPathLength: 512,
+  maxSamplesPerField: 3,
+  maxSampleLength: 128,
+  maxStringLength: 512,
+  maxWarnings: 128
+});
+function resolveContractLimits(overrides) {
+  const limits = { ...DEFAULT_CONTRACT_LIMITS, ...overrides };
+  for (const [key, value] of Object.entries(limits)) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`Contract limit ${key} must be a positive safe integer`);
+    }
+  }
+  return Object.freeze(limits);
+}
+
+// src/validation-helpers.ts
+var FORBIDDEN_PROPERTY_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var ContractValidationError = class extends TypeError {
+  issues;
+  constructor(contractName, issues) {
+    super(`${contractName} is invalid: ${issues[0]?.message ?? "unknown validation error"}`);
+    this.name = "ContractValidationError";
+    this.issues = Object.freeze(issues.map((issue) => Object.freeze({ ...issue })));
+  }
+};
+var ValidationContext = class {
+  constructor(limits) {
+    this.limits = limits;
+  }
+  limits;
+  issues = [];
+  issue(code, path, message) {
+    this.issues.push({ code, path, message });
+  }
+  finish(contractName, value) {
+    if (value === void 0 || this.issues.length > 0) {
+      throw new ContractValidationError(contractName, this.issues);
+    }
+    return value;
+  }
+};
+function isPlainRecord2(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function readStrictObject(context, value, path, allowedKeys) {
+  if (!isPlainRecord2(value)) {
+    context.issue("invalid_type", path, "Expected an object");
+    return void 0;
+  }
+  const allowed = new Set(allowedKeys);
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) {
+      context.issue("unknown_property", `${path}.${key}`, `Unknown property ${JSON.stringify(key)}`);
+    }
+    if (FORBIDDEN_PROPERTY_NAMES.has(key)) {
+      context.issue("invalid_value", `${path}.${key}`, `Forbidden property name ${JSON.stringify(key)}`);
+    }
+  }
+  return value;
+}
+function readString(context, value, path, options = {}) {
+  if (typeof value !== "string") {
+    context.issue(value === void 0 ? "missing_value" : "invalid_type", path, "Expected a string");
+    return void 0;
+  }
+  const maxLength = options.maxLength ?? context.limits.maxStringLength;
+  if (!options.allowEmpty && value.trim().length === 0 || value.length > maxLength) {
+    context.issue(
+      "invalid_value",
+      path,
+      value.length > maxLength ? `String exceeds ${maxLength} characters` : "String must not be empty"
+    );
+  }
+  if (options.pattern && !options.pattern.test(value)) {
+    context.issue("invalid_value", path, "String has an invalid format");
+  }
+  return value;
+}
+function readFiniteNumber(context, value, path, options = {}) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    context.issue(value === void 0 ? "missing_value" : "invalid_type", path, "Expected a finite number");
+    return void 0;
+  }
+  if (options.integer && !Number.isSafeInteger(value)) {
+    context.issue("invalid_value", path, "Expected a safe integer");
+  }
+  if (options.min !== void 0 && value < options.min) {
+    context.issue("invalid_value", path, `Value must be at least ${options.min}`);
+  }
+  if (options.max !== void 0 && value > options.max) {
+    context.issue("invalid_value", path, `Value must be at most ${options.max}`);
+  }
+  return value;
+}
+function readBoolean(context, value, path) {
+  if (typeof value !== "boolean") {
+    context.issue("invalid_type", path, "Expected a boolean");
+    return void 0;
+  }
+  return value;
+}
+function assertUnique(context, values, path) {
+  const seen = /* @__PURE__ */ new Set();
+  values.forEach((value, index) => {
+    if (seen.has(value)) {
+      context.issue("duplicate_value", `${path}[${index}]`, `Duplicate value ${JSON.stringify(value)}`);
+    }
+    seen.add(value);
+  });
+}
+function readJsonValue(context, value, path, depth = 0) {
+  if (depth > 20) {
+    context.issue("limit_exceeded", path, "JSON value exceeds the maximum nesting depth of 20");
+    return void 0;
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      context.issue("invalid_value", path, "JSON numbers must be finite");
+      return void 0;
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (value.length > context.limits.maxDictionaryEntries) {
+      context.issue("limit_exceeded", path, "JSON array is too large");
+    }
+    const result = [];
+    value.forEach((entry, index) => {
+      const parsed = readJsonValue(context, entry, `${path}[${index}]`, depth + 1);
+      if (parsed !== void 0) result.push(parsed);
+    });
+    return result;
+  }
+  if (isPlainRecord2(value)) {
+    const keys = Object.keys(value);
+    if (keys.length > context.limits.maxDictionaryEntries) {
+      context.issue("limit_exceeded", path, "JSON object has too many properties");
+    }
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const key of keys) {
+      if (FORBIDDEN_PROPERTY_NAMES.has(key)) {
+        context.issue("invalid_value", `${path}.${key}`, `Forbidden property name ${JSON.stringify(key)}`);
+        continue;
+      }
+      const parsed = readJsonValue(context, value[key], `${path}.${key}`, depth + 1);
+      if (parsed !== void 0) result[key] = parsed;
+    }
+    return result;
+  }
+  context.issue("invalid_type", path, "Expected a JSON-serializable value");
+  return void 0;
+}
+function assertCanonicalSize(context, value, path) {
+  if (canonicalByteLength(value) > context.limits.maxCanonicalBytes) {
+    context.issue(
+      "limit_exceeded",
+      path,
+      `Canonical payload exceeds ${context.limits.maxCanonicalBytes} bytes`
+    );
+  }
+}
+function cloneContract(value) {
+  return cloneJsonValue(value);
+}
+function validateSafePattern(context, pattern, path) {
+  if (pattern.length > context.limits.maxPatternLength) {
+    context.issue("limit_exceeded", path, `Pattern exceeds ${context.limits.maxPatternLength} characters`);
+    return;
+  }
+  try {
+    new RegExp(pattern, "u");
+  } catch {
+    context.issue("invalid_value", path, "Pattern is not a valid Unicode regular expression");
+    return;
+  }
+  const hasBackReference = /\\[1-9]/u.test(pattern);
+  const hasLookaroundOrNamedGroup = /\(\?(?:[=!<]|P?<)/u.test(pattern);
+  const hasNestedQuantifier = /\([^)]*(?:\+|\*|\{\d+(?:,\d*)?\})[^)]*\)(?:\+|\*|\{\d+(?:,\d*)?\})/u.test(pattern);
+  const hasRepeatedWildcard = /\.\*(?:[^|)]*\.\*)/u.test(pattern);
+  if (hasBackReference || hasLookaroundOrNamedGroup || hasNestedQuantifier || hasRepeatedWildcard) {
+    context.issue("unsafe_pattern", path, "Pattern uses a disallowed potentially unsafe construct");
+  }
+}
+function isSafeFieldPath(path) {
+  return !path.split(/[.[\]]+/u).filter(Boolean).some((segment) => FORBIDDEN_PROPERTY_NAMES.has(segment));
+}
+
+// src/delivery.ts
+var DELIVERY_PROTOCOL_VERSION = 1;
+var DEFAULT_MAX_DELIVERY_BATCH_BYTES = 2 * 1024 * 1024;
+var DEFAULT_MAX_DELIVERY_BATCH_RECORDS = 1e4;
+var DEFAULT_DELIVERY_SIGNATURE_TOLERANCE_SECONDS = 5 * 60;
+var DELIVERY_HEADERS = Object.freeze({
+  apiKey: "x-convert-buddy-key",
+  batchId: "x-convert-buddy-batch-id",
+  destination: "x-convert-buddy-destination",
+  importId: "x-convert-buddy-import-id",
+  signature: "x-convert-buddy-signature",
+  signatureTimestamp: "x-convert-buddy-signature-timestamp"
+});
+var IDENTIFIER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/u;
+var TIMESTAMP_PATTERN = /^(?:0|[1-9]\d{0,15})$/u;
+var SIGNATURE_PATTERN = /^v1=([0-9a-f]{64})$/u;
+var encoder = new TextEncoder();
+function asArrayBuffer(bytes) {
+  return new Uint8Array(bytes).buffer;
+}
+function positiveSafeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError(`${name} must be a positive safe integer`);
+  }
+  return value;
+}
+function signingSecretBytes(secret) {
+  const bytes = typeof secret === "string" ? encoder.encode(secret) : new Uint8Array(secret);
+  if (bytes.byteLength < 32) throw new TypeError("Delivery signing secrets must contain at least 32 bytes");
+  return bytes;
+}
+function signaturePayload(input) {
+  if (!IDENTIFIER_PATTERN.test(input.importId)) throw new TypeError("Invalid delivery import ID");
+  if (!IDENTIFIER_PATTERN.test(input.batchId)) throw new TypeError("Invalid delivery batch ID");
+  if (!TIMESTAMP_PATTERN.test(input.timestamp)) throw new TypeError("Invalid delivery timestamp");
+  const prefix = encoder.encode(
+    `convert-buddy.delivery.v1
+${input.timestamp}
+${input.importId}
+${input.batchId}
+`
+  );
+  const payload = new Uint8Array(prefix.byteLength + input.rawBody.byteLength);
+  payload.set(prefix);
+  payload.set(input.rawBody, prefix.byteLength);
+  return payload;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(value) {
+  const bytes = new Uint8Array(value.length / 2);
+  for (let index = 0; index < bytes.length; index += 1) {
+    bytes[index] = Number.parseInt(value.slice(index * 2, index * 2 + 2), 16);
+  }
+  return bytes;
+}
+async function importHmacKey(secret, usage) {
+  return crypto.subtle.importKey(
+    "raw",
+    asArrayBuffer(signingSecretBytes(secret)),
+    { hash: "SHA-256", name: "HMAC" },
+    false,
+    [usage]
+  );
+}
+function parseAcceptedRecordBatchV1(input, options = {}) {
+  const limits = resolveContractLimits(options.limits);
+  const maxRecords = positiveSafeInteger(
+    options.maxRecords ?? DEFAULT_MAX_DELIVERY_BATCH_RECORDS,
+    "maxRecords"
+  );
+  const maxBatchBytes = positiveSafeInteger(
+    options.maxBatchBytes ?? DEFAULT_MAX_DELIVERY_BATCH_BYTES,
+    "maxBatchBytes"
+  );
+  const context = new ValidationContext(limits);
+  const object = readStrictObject(context, input, "$", ["version", "records"]);
+  if (!object) return context.finish("AcceptedRecordBatchV1", void 0);
+  if (object.version !== DELIVERY_PROTOCOL_VERSION) {
+    context.issue("invalid_value", "$.version", "Expected delivery protocol version 1");
+  }
+  if (!Array.isArray(object.records)) {
+    context.issue(
+      object.records === void 0 ? "missing_value" : "invalid_type",
+      "$.records",
+      "Expected an array of records"
+    );
+    return context.finish("AcceptedRecordBatchV1", void 0);
+  }
+  if (object.records.length > maxRecords) {
+    context.issue("limit_exceeded", "$.records", `Batch exceeds ${maxRecords} records`);
+  }
+  const records = [];
+  object.records.forEach((record, index) => {
+    if (!isPlainRecord2(record)) {
+      context.issue("invalid_type", `$.records[${index}]`, "Expected a record object");
+      return;
+    }
+    const parsed = readJsonValue(context, record, `$.records[${index}]`);
+    if (parsed && !Array.isArray(parsed) && typeof parsed === "object") {
+      records.push(parsed);
+    }
+  });
+  const result = { version: 1, records };
+  if (canonicalByteLength(result) > maxBatchBytes) {
+    context.issue("limit_exceeded", "$", `Batch exceeds ${maxBatchBytes} canonical bytes`);
+  }
+  return cloneContract(context.finish("AcceptedRecordBatchV1", result));
+}
+async function signDeliveryRequestV1(signingSecret, input) {
+  const key = await importHmacKey(signingSecret, "sign");
+  const signature = await crypto.subtle.sign("HMAC", key, asArrayBuffer(signaturePayload(input)));
+  return `v1=${bytesToHex(new Uint8Array(signature))}`;
+}
+async function verifyDeliverySignatureV1(input) {
+  const match = SIGNATURE_PATTERN.exec(input.signature);
+  if (!match?.[1]) return false;
+  const timestamp = Number(input.timestamp);
+  if (!Number.isSafeInteger(timestamp)) return false;
+  const now = input.nowEpochSeconds ?? Math.floor(Date.now() / 1e3);
+  const tolerance = positiveSafeInteger(
+    input.toleranceSeconds ?? DEFAULT_DELIVERY_SIGNATURE_TOLERANCE_SECONDS,
+    "toleranceSeconds"
+  );
+  if (!Number.isSafeInteger(now) || Math.abs(now - timestamp) > tolerance) return false;
+  try {
+    const key = await importHmacKey(input.signingSecret, "verify");
+    return crypto.subtle.verify(
+      "HMAC",
+      key,
+      asArrayBuffer(hexToBytes(match[1])),
+      asArrayBuffer(signaturePayload(input))
+    );
+  } catch {
+    return false;
+  }
+}
+
+// src/fingerprint.ts
+function describeSourceStructure(profile) {
+  const descriptor = {
+    version: 1,
+    format: profile.format,
+    fields: profile.fields.map((field) => ({
+      path: field.path,
+      normalizedName: field.normalizedName,
+      inferredTypes: field.inferredTypes.filter((entry) => entry.ratio >= 0.05).map((entry) => entry.type).sort()
+    })).sort((left, right) => left.path.localeCompare(right.path, "en"))
+  };
+  if (profile.recordPath !== void 0) descriptor.recordPath = profile.recordPath;
+  return descriptor;
+}
+async function computeStructureFingerprint(profile) {
+  if (!globalThis.crypto?.subtle) {
+    throw new Error("Web Crypto SubtleCrypto is required to compute a structure fingerprint");
+  }
+  const descriptor = describeSourceStructure(profile);
+  const bytes = new TextEncoder().encode(canonicalStringify(descriptor));
+  const digest = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes));
+  return Array.from(digest, (value) => value.toString(16).padStart(2, "0")).join("");
+}
+
+// src/types.ts
+var TARGET_FIELD_TYPES = [
+  "string",
+  "integer",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "enum"
+];
+var SOURCE_FORMATS = ["csv", "xml", "json", "ndjson", "xlsx"];
+var SOURCE_INFERRED_TYPES = [
+  ...TARGET_FIELD_TYPES,
+  "null",
+  "object",
+  "array",
+  "unknown"
+];
+
+// src/source-profile.ts
+var SOURCE_FORMAT_SET = new Set(SOURCE_FORMATS);
+var SOURCE_TYPE_SET = new Set(SOURCE_INFERRED_TYPES);
+var SHA256_PATTERN = /^[a-f0-9]{64}$/u;
+function parseInferredType(context, value, path) {
+  const object = readStrictObject(context, value, path, ["type", "ratio"]);
+  if (!object) return void 0;
+  const typeValue = readString(context, object.type, `${path}.type`, { maxLength: 32 });
+  const type = typeValue && SOURCE_TYPE_SET.has(typeValue) ? typeValue : void 0;
+  if (typeValue !== void 0 && type === void 0) {
+    context.issue("invalid_value", `${path}.type`, `Unsupported inferred type ${JSON.stringify(typeValue)}`);
+  }
+  const ratio = readFiniteNumber(context, object.ratio, `${path}.ratio`, { min: 0, max: 1 });
+  return type !== void 0 && ratio !== void 0 ? { type, ratio } : void 0;
+}
+function parseSourceField(context, value, path, allowSamples) {
+  const object = readStrictObject(
+    context,
+    value,
+    path,
+    ["path", "normalizedName", "inferredTypes", "nullRatio", "distinctEstimate", "samples"]
+  );
+  if (!object) return void 0;
+  const sourcePath = readString(context, object.path, `${path}.path`, {
+    maxLength: context.limits.maxRecordPathLength
+  });
+  if (sourcePath !== void 0 && !isSafeFieldPath(sourcePath)) {
+    context.issue("invalid_value", `${path}.path`, "Source path contains a forbidden segment");
+  }
+  const normalizedName = readString(context, object.normalizedName, `${path}.normalizedName`);
+  const nullRatio = readFiniteNumber(context, object.nullRatio, `${path}.nullRatio`, { min: 0, max: 1 });
+  let inferredTypes;
+  if (!Array.isArray(object.inferredTypes) || object.inferredTypes.length === 0) {
+    context.issue("invalid_type", `${path}.inferredTypes`, "Expected a non-empty inferred type array");
+  } else {
+    inferredTypes = object.inferredTypes.map((entry, index) => parseInferredType(context, entry, `${path}.inferredTypes[${index}]`)).filter((entry) => entry !== void 0);
+    assertUnique(context, inferredTypes.map((entry) => entry.type), `${path}.inferredTypes.*.type`);
+    const ratioTotal = inferredTypes.reduce((total, entry) => total + entry.ratio, 0);
+    if (ratioTotal > 1.000001) {
+      context.issue("invalid_value", `${path}.inferredTypes`, "Inferred type ratios must not total more than 1");
+    }
+  }
+  if (sourcePath === void 0 || normalizedName === void 0 || nullRatio === void 0 || !inferredTypes) {
+    return void 0;
+  }
+  const field = { path: sourcePath, normalizedName, inferredTypes, nullRatio };
+  if (object.distinctEstimate !== void 0) {
+    const distinctEstimate = readFiniteNumber(context, object.distinctEstimate, `${path}.distinctEstimate`, {
+      min: 0,
+      integer: true
+    });
+    if (distinctEstimate !== void 0) field.distinctEstimate = distinctEstimate;
+  }
+  if (object.samples !== void 0) {
+    if (!allowSamples) {
+      context.issue("invalid_value", `${path}.samples`, "Samples are disabled unless explicitly allowed");
+    } else if (!Array.isArray(object.samples)) {
+      context.issue("invalid_type", `${path}.samples`, "Expected a string array");
+    } else {
+      if (object.samples.length > context.limits.maxSamplesPerField) {
+        context.issue("limit_exceeded", `${path}.samples`, "Too many sample values");
+      }
+      field.samples = object.samples.map(
+        (entry, index) => readString(context, entry, `${path}.samples[${index}]`, {
+          allowEmpty: true,
+          maxLength: context.limits.maxSampleLength
+        })
+      ).filter((entry) => entry !== void 0);
+    }
+  }
+  return field;
+}
+function parseSourceProfileV1(input, options = {}) {
+  const context = new ValidationContext(resolveContractLimits(options.limits));
+  const object = readStrictObject(context, input, "$", ["version", "format", "structureFingerprint", "recordPath", "fields"]);
+  if (!object) return context.finish("SourceProfileV1", void 0);
+  if (object.version !== 1) context.issue("invalid_value", "$.version", "Expected version 1");
+  const formatValue = readString(context, object.format, "$.format", { maxLength: 16 });
+  const format = formatValue && SOURCE_FORMAT_SET.has(formatValue) ? formatValue : void 0;
+  if (formatValue !== void 0 && format === void 0) {
+    context.issue("invalid_value", "$.format", `Unsupported source format ${JSON.stringify(formatValue)}`);
+  }
+  const structureFingerprint = readString(context, object.structureFingerprint, "$.structureFingerprint", {
+    maxLength: 64,
+    pattern: SHA256_PATTERN
+  });
+  let fields;
+  if (!Array.isArray(object.fields) || object.fields.length === 0) {
+    context.issue("invalid_type", "$.fields", "Expected a non-empty source field array");
+  } else {
+    if (object.fields.length > context.limits.maxFields) {
+      context.issue("limit_exceeded", "$.fields", `Profile exceeds ${context.limits.maxFields} fields`);
+    }
+    fields = object.fields.map((entry, index) => parseSourceField(context, entry, `$.fields[${index}]`, options.allowSamples === true)).filter((entry) => entry !== void 0);
+    assertUnique(context, fields.map((field) => field.path), "$.fields.*.path");
+  }
+  if (format === void 0 || structureFingerprint === void 0 || fields === void 0) {
+    return context.finish("SourceProfileV1", void 0);
+  }
+  const profile = { version: 1, format, structureFingerprint, fields };
+  if (object.recordPath !== void 0) {
+    const recordPath = readString(context, object.recordPath, "$.recordPath", {
+      maxLength: context.limits.maxRecordPathLength
+    });
+    if (recordPath !== void 0) profile.recordPath = recordPath;
+  }
+  assertCanonicalSize(context, profile, "$");
+  return context.finish("SourceProfileV1", cloneContract(profile));
+}
+
+// src/target-schema.ts
+var CONTRACT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var TARGET_FIELD_TYPE_SET = new Set(TARGET_FIELD_TYPES);
+var UNKNOWN_FIELD_POLICIES = /* @__PURE__ */ new Set(["ignore", "reject", "preserve"]);
+function valueMatchesType(value, type) {
+  switch (type) {
+    case "string":
+    case "enum":
+      return typeof value === "string";
+    case "date":
+      return typeof value === "string" && isCalendarDate(value);
+    case "datetime":
+      return typeof value === "string" && isOffsetDateTime(value);
+    case "integer":
+      return typeof value === "number" && Number.isSafeInteger(value);
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "boolean":
+      return typeof value === "boolean";
+  }
+}
+function parseConstraints(context, value, path, type) {
+  if (value === void 0) return void 0;
+  const object = readStrictObject(
+    context,
+    value,
+    path,
+    ["min", "max", "minLength", "maxLength", "pattern", "values"]
+  );
+  if (!object) return void 0;
+  const result = {};
+  if (object.min !== void 0) {
+    const parsed = readFiniteNumber(context, object.min, `${path}.min`);
+    if (parsed !== void 0) result.min = parsed;
+  }
+  if (object.max !== void 0) {
+    const parsed = readFiniteNumber(context, object.max, `${path}.max`);
+    if (parsed !== void 0) result.max = parsed;
+  }
+  if (result.min !== void 0 && result.max !== void 0 && result.min > result.max) {
+    context.issue("invalid_value", path, "min must not exceed max");
+  }
+  if ((result.min !== void 0 || result.max !== void 0) && type !== "integer" && type !== "number") {
+    context.issue("invalid_value", path, `Numeric constraints are incompatible with ${type}`);
+  }
+  if (object.minLength !== void 0) {
+    const parsed = readFiniteNumber(context, object.minLength, `${path}.minLength`, {
+      min: 0,
+      integer: true
+    });
+    if (parsed !== void 0) result.minLength = parsed;
+  }
+  if (object.maxLength !== void 0) {
+    const parsed = readFiniteNumber(context, object.maxLength, `${path}.maxLength`, {
+      min: 0,
+      integer: true
+    });
+    if (parsed !== void 0) result.maxLength = parsed;
+  }
+  if (result.minLength !== void 0 && result.maxLength !== void 0 && result.minLength > result.maxLength) {
+    context.issue("invalid_value", path, "minLength must not exceed maxLength");
+  }
+  if ((result.minLength !== void 0 || result.maxLength !== void 0) && type !== "string" && type !== "enum") {
+    context.issue("invalid_value", path, `Length constraints are incompatible with ${type}`);
+  }
+  if (object.pattern !== void 0) {
+    const parsed = readString(context, object.pattern, `${path}.pattern`, {
+      maxLength: context.limits.maxPatternLength
+    });
+    if (parsed !== void 0) {
+      validateSafePattern(context, parsed, `${path}.pattern`);
+      result.pattern = parsed;
+    }
+    if (type !== "string") {
+      context.issue("invalid_value", `${path}.pattern`, `pattern is incompatible with ${type}`);
+    }
+  }
+  if (object.values !== void 0) {
+    if (!Array.isArray(object.values) || object.values.length === 0) {
+      context.issue("invalid_type", `${path}.values`, "Expected a non-empty string array");
+    } else {
+      if (object.values.length > context.limits.maxDictionaryEntries) {
+        context.issue("limit_exceeded", `${path}.values`, "Enum contains too many values");
+      }
+      const values = object.values.map(
+        (entry, index) => readString(context, entry, `${path}.values[${index}]`, {
+          maxLength: context.limits.maxStringLength
+        })
+      ).filter((entry) => entry !== void 0);
+      assertUnique(context, values, `${path}.values`);
+      result.values = values;
+    }
+    if (type !== "enum") {
+      context.issue("invalid_value", `${path}.values`, "values is only valid for enum fields");
+    }
+  } else if (type === "enum") {
+    context.issue("missing_value", `${path}.values`, "Enum fields require an allowed values list");
+  }
+  return result;
+}
+function parseField(context, value, path) {
+  const object = readStrictObject(
+    context,
+    value,
+    path,
+    ["key", "label", "type", "required", "aliases", "description", "defaultValue", "constraints"]
+  );
+  if (!object) return void 0;
+  const key = readString(context, object.key, `${path}.key`, { maxLength: 128 });
+  if (key !== void 0 && !isSafeFieldPath(key)) {
+    context.issue("invalid_value", `${path}.key`, "Field key contains a forbidden path segment");
+  }
+  const label = readString(context, object.label, `${path}.label`);
+  const typeValue = readString(context, object.type, `${path}.type`, { maxLength: 32 });
+  const type = typeValue && TARGET_FIELD_TYPE_SET.has(typeValue) ? typeValue : void 0;
+  if (typeValue !== void 0 && type === void 0) {
+    context.issue("invalid_value", `${path}.type`, `Unsupported target field type ${JSON.stringify(typeValue)}`);
+  }
+  if (key === void 0 || label === void 0 || type === void 0) return void 0;
+  const field = { key, label, type };
+  if (object.required !== void 0) {
+    const required = readBoolean(context, object.required, `${path}.required`);
+    if (required !== void 0) field.required = required;
+  }
+  if (object.aliases !== void 0) {
+    if (!Array.isArray(object.aliases)) {
+      context.issue("invalid_type", `${path}.aliases`, "Expected a string array");
+    } else {
+      if (object.aliases.length > context.limits.maxAliasesPerField) {
+        context.issue("limit_exceeded", `${path}.aliases`, "Field has too many aliases");
+      }
+      const aliases = object.aliases.map((entry, index) => readString(context, entry, `${path}.aliases[${index}]`)).filter((entry) => entry !== void 0);
+      assertUnique(context, aliases, `${path}.aliases`);
+      field.aliases = aliases;
+    }
+  }
+  if (object.description !== void 0) {
+    const description = readString(context, object.description, `${path}.description`, {
+      maxLength: context.limits.maxDescriptionLength
+    });
+    if (description !== void 0) field.description = description;
+  }
+  if (Object.hasOwn(object, "defaultValue")) {
+    const defaultValue = readJsonValue(context, object.defaultValue, `${path}.defaultValue`);
+    if (defaultValue !== void 0) {
+      field.defaultValue = defaultValue;
+      if (!valueMatchesType(defaultValue, type)) {
+        context.issue("invalid_value", `${path}.defaultValue`, `Default value is incompatible with ${type}`);
+      }
+    }
+  }
+  const constraints = parseConstraints(context, object.constraints, `${path}.constraints`, type);
+  if (constraints !== void 0) field.constraints = constraints;
+  if (type === "enum" && typeof field.defaultValue === "string" && constraints?.values && !constraints.values.includes(field.defaultValue)) {
+    context.issue("invalid_value", `${path}.defaultValue`, "Enum default is not in constraints.values");
+  }
+  return field;
+}
+function parseTargetSchemaV1(input, options = {}) {
+  const context = new ValidationContext(resolveContractLimits(options.limits));
+  const object = readStrictObject(context, input, "$", ["version", "id", "name", "fields", "unknownFields"]);
+  if (!object) return context.finish("TargetSchemaV1", void 0);
+  if (object.version !== 1) context.issue("invalid_value", "$.version", "Expected version 1");
+  const id = readString(context, object.id, "$.id", { maxLength: 128, pattern: CONTRACT_ID_PATTERN });
+  const name = readString(context, object.name, "$.name");
+  const unknownFieldsValue = readString(context, object.unknownFields, "$.unknownFields", { maxLength: 16 });
+  const unknownFields = unknownFieldsValue && UNKNOWN_FIELD_POLICIES.has(unknownFieldsValue) ? unknownFieldsValue : void 0;
+  if (unknownFieldsValue !== void 0 && unknownFields === void 0) {
+    context.issue("invalid_value", "$.unknownFields", "Expected ignore, reject, or preserve");
+  }
+  let fields;
+  if (!Array.isArray(object.fields) || object.fields.length === 0) {
+    context.issue("invalid_type", "$.fields", "Expected a non-empty field array");
+  } else {
+    if (object.fields.length > context.limits.maxFields) {
+      context.issue("limit_exceeded", "$.fields", `Schema exceeds ${context.limits.maxFields} fields`);
+    }
+    fields = object.fields.map((entry, index) => parseField(context, entry, `$.fields[${index}]`)).filter((entry) => entry !== void 0);
+    assertUnique(context, fields.map((field) => field.key), "$.fields.*.key");
+  }
+  if (id === void 0 || name === void 0 || unknownFields === void 0 || fields === void 0) {
+    return context.finish("TargetSchemaV1", void 0);
+  }
+  const schema = { version: 1, id, name, fields, unknownFields };
+  assertCanonicalSize(context, schema, "$");
+  return context.finish("TargetSchemaV1", cloneContract(schema));
+}
+function isTargetValueCompatible(value, type) {
+  return valueMatchesType(value, type);
+}
+
+// src/schema-builder.ts
+var TargetSchemaBuilderV1 = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  #fields = [];
+  field(field) {
+    this.#fields.push(structuredClone(field));
+    return this;
+  }
+  fields(fields) {
+    for (const field of fields) this.field(field);
+    return this;
+  }
+  build() {
+    return Object.freeze(parseTargetSchemaV1({
+      version: 1,
+      id: this.options.id,
+      name: this.options.name,
+      unknownFields: this.options.unknownFields ?? "ignore",
+      fields: this.#fields
+    }));
+  }
+};
+function defineTargetSchemaV1(schema) {
+  return Object.freeze(parseTargetSchemaV1(schema));
+}
+
+// src/transform-plan.ts
+var TARGET_TYPE_SET = new Set(TARGET_FIELD_TYPES.filter((type) => type !== "enum"));
+var REASON_CODE_PATTERN = /^[a-z][a-z0-9_.-]{0,63}$/u;
+var WARNING_CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,63}$/u;
+function operationStage(operation) {
+  switch (operation.op) {
+    case "trim":
+    case "lowercase":
+    case "uppercase":
+    case "replace":
+    case "enum_map":
+      return 0;
+    case "split":
+    case "join":
+      return 1;
+    case "coerce":
+    case "parse_date":
+      return 2;
+    case "default":
+      return 3;
+  }
+}
+function parseStringArray(context, value, path, maximum) {
+  if (!Array.isArray(value)) {
+    context.issue("invalid_type", path, "Expected a string array");
+    return void 0;
+  }
+  if (value.length > maximum) context.issue("limit_exceeded", path, `Array exceeds ${maximum} entries`);
+  const result = value.map((entry, index) => readString(context, entry, `${path}[${index}]`)).filter((entry) => entry !== void 0);
+  assertUnique(context, result, path);
+  return result;
+}
+function parseOperation(context, value, path, targetField) {
+  if (!isPlainRecord2(value)) {
+    context.issue("invalid_type", path, "Expected an operation object");
+    return void 0;
+  }
+  const op = readString(context, value.op, `${path}.op`, { maxLength: 32 });
+  if (!op) return void 0;
+  switch (op) {
+    case "trim":
+    case "lowercase":
+    case "uppercase": {
+      readStrictObject(context, value, path, ["op"]);
+      if (targetField.type !== "string" && targetField.type !== "enum") {
+        context.issue("incompatible_operation", path, `${op} is incompatible with ${targetField.type}`);
+      }
+      return { op };
+    }
+    case "coerce": {
+      const object = readStrictObject(context, value, path, ["op", "type"]);
+      if (!object) return void 0;
+      const typeValue = readString(context, object.type, `${path}.type`, { maxLength: 16 });
+      const type = typeValue && TARGET_TYPE_SET.has(typeValue) ? typeValue : void 0;
+      if (typeValue !== void 0 && type === void 0) {
+        context.issue("invalid_value", `${path}.type`, `Unsupported coercion type ${JSON.stringify(typeValue)}`);
+      }
+      const expected = targetField.type === "enum" ? "string" : targetField.type;
+      if (type !== void 0 && type !== expected) {
+        context.issue("incompatible_operation", path, `Coercion to ${type} cannot produce target type ${targetField.type}`);
+      }
+      return type === void 0 ? void 0 : { op: "coerce", type };
+    }
+    case "parse_date": {
+      const object = readStrictObject(context, value, path, ["op", "formats"]);
+      if (!object) return void 0;
+      const formats = parseStringArray(context, object.formats, `${path}.formats`, 12);
+      if (formats?.length === 0) context.issue("invalid_value", `${path}.formats`, "At least one date format is required");
+      if (targetField.type !== "date" && targetField.type !== "datetime") {
+        context.issue("incompatible_operation", path, `parse_date is incompatible with ${targetField.type}`);
+      }
+      return formats ? { op: "parse_date", formats } : void 0;
+    }
+    case "replace": {
+      const object = readStrictObject(context, value, path, ["op", "pattern", "replacement"]);
+      if (!object) return void 0;
+      const pattern = readString(context, object.pattern, `${path}.pattern`, {
+        maxLength: context.limits.maxPatternLength
+      });
+      const replacement = readString(context, object.replacement, `${path}.replacement`, {
+        allowEmpty: true,
+        maxLength: context.limits.maxStringLength
+      });
+      if (pattern !== void 0) validateSafePattern(context, pattern, `${path}.pattern`);
+      if (targetField.type !== "string" && targetField.type !== "enum") {
+        context.issue("incompatible_operation", path, `replace is incompatible with ${targetField.type}`);
+      }
+      return pattern !== void 0 && replacement !== void 0 ? { op: "replace", pattern, replacement } : void 0;
+    }
+    case "enum_map": {
+      const object = readStrictObject(context, value, path, ["op", "values"]);
+      if (!object) return void 0;
+      if (!isPlainRecord2(object.values)) {
+        context.issue("invalid_type", `${path}.values`, "Expected a string dictionary");
+        return void 0;
+      }
+      const entries = Object.entries(object.values);
+      if (entries.length > context.limits.maxDictionaryEntries) {
+        context.issue("limit_exceeded", `${path}.values`, "Enum map has too many entries");
+      }
+      const values = /* @__PURE__ */ Object.create(null);
+      for (const [key, entry] of entries) {
+        const parsedKey = readString(context, key, `${path}.values.${key}.key`);
+        const parsedValue = readString(context, entry, `${path}.values.${key}`);
+        if (parsedKey !== void 0 && parsedValue !== void 0) values[parsedKey] = parsedValue;
+        if (parsedValue !== void 0 && targetField.type === "enum" && targetField.constraints?.values && !targetField.constraints.values.includes(parsedValue)) {
+          context.issue("incompatible_operation", `${path}.values.${key}`, "Mapped value is not allowed by the target enum");
+        }
+      }
+      if (targetField.type !== "enum" && targetField.type !== "string") {
+        context.issue("incompatible_operation", path, `enum_map is incompatible with ${targetField.type}`);
+      }
+      return { op: "enum_map", values };
+    }
+    case "split": {
+      const object = readStrictObject(context, value, path, ["op", "separator", "index"]);
+      if (!object) return void 0;
+      const separator = readString(context, object.separator, `${path}.separator`, { maxLength: 32 });
+      const index = readFiniteNumber(context, object.index, `${path}.index`, { min: 0, max: 1024, integer: true });
+      return separator !== void 0 && index !== void 0 ? { op: "split", separator, index } : void 0;
+    }
+    case "join": {
+      const object = readStrictObject(context, value, path, ["op", "separator"]);
+      if (!object) return void 0;
+      const separator = readString(context, object.separator, `${path}.separator`, {
+        allowEmpty: true,
+        maxLength: 32
+      });
+      return separator === void 0 ? void 0 : { op: "join", separator };
+    }
+    case "default": {
+      const object = readStrictObject(context, value, path, ["op", "value"]);
+      if (!object) return void 0;
+      const defaultValue = readJsonValue(context, object.value, `${path}.value`);
+      if (defaultValue !== void 0 && !isTargetValueCompatible(defaultValue, targetField.type)) {
+        context.issue("incompatible_operation", `${path}.value`, `Default is incompatible with ${targetField.type}`);
+      }
+      return defaultValue === void 0 ? void 0 : { op: "default", value: defaultValue };
+    }
+    default:
+      context.issue("invalid_value", `${path}.op`, `Unknown transform operation ${JSON.stringify(op)}`);
+      return void 0;
+  }
+}
+function validateOperationSequence(context, operations, sources, path) {
+  let previousStage = 0;
+  const counts = /* @__PURE__ */ new Map();
+  operations.forEach((operation, index) => {
+    const stage = operationStage(operation);
+    if (stage < previousStage) {
+      context.issue("incompatible_operation", `${path}[${index}]`, "Operations are not in deterministic execution order");
+    }
+    previousStage = stage;
+    counts.set(operation.op, (counts.get(operation.op) ?? 0) + 1);
+  });
+  for (const singleton of ["split", "join", "coerce", "parse_date", "default"]) {
+    if ((counts.get(singleton) ?? 0) > 1) {
+      context.issue("incompatible_operation", path, `${singleton} may appear at most once`);
+    }
+  }
+  if ((counts.get("split") ?? 0) > 0 && sources.length !== 1) {
+    context.issue("incompatible_operation", path, "split requires exactly one source");
+  }
+  if ((counts.get("join") ?? 0) > 0 && sources.length < 2) {
+    context.issue("incompatible_operation", path, "join requires at least two sources");
+  }
+  if ((counts.get("coerce") ?? 0) > 0 && (counts.get("parse_date") ?? 0) > 0) {
+    context.issue("incompatible_operation", path, "coerce and parse_date cannot be combined");
+  }
+}
+function parseMapping(context, value, path, sourcePaths, targetFields) {
+  const object = readStrictObject(context, value, path, ["sources", "target", "confidence", "reasonCode", "operations"]);
+  if (!object) return void 0;
+  const sources = parseStringArray(context, object.sources, `${path}.sources`, 16);
+  if (sources?.length === 0) context.issue("invalid_value", `${path}.sources`, "At least one source is required");
+  sources?.forEach((source, index) => {
+    if (!sourcePaths.has(source)) {
+      context.issue("unknown_source", `${path}.sources[${index}]`, `Unknown source path ${JSON.stringify(source)}`);
+    }
+  });
+  const target = readString(context, object.target, `${path}.target`, { maxLength: 128 });
+  const targetField = target ? targetFields.get(target) : void 0;
+  if (target !== void 0 && !targetField) {
+    context.issue("unknown_target", `${path}.target`, `Unknown target field ${JSON.stringify(target)}`);
+  }
+  const confidence = readFiniteNumber(context, object.confidence, `${path}.confidence`, { min: 0, max: 1 });
+  const reasonCode = readString(context, object.reasonCode, `${path}.reasonCode`, {
+    maxLength: 64,
+    pattern: REASON_CODE_PATTERN
+  });
+  let operations;
+  if (!Array.isArray(object.operations)) {
+    context.issue("invalid_type", `${path}.operations`, "Expected an operation array");
+  } else if (targetField) {
+    if (object.operations.length > context.limits.maxOperationsPerMapping) {
+      context.issue("limit_exceeded", `${path}.operations`, "Mapping has too many operations");
+    }
+    operations = object.operations.map((entry, index) => parseOperation(context, entry, `${path}.operations[${index}]`, targetField)).filter((entry) => entry !== void 0);
+    if (sources) validateOperationSequence(context, operations, sources, `${path}.operations`);
+  }
+  return sources && target && targetField && confidence !== void 0 && reasonCode && operations ? { sources, target, confidence, reasonCode, operations } : void 0;
+}
+function parseWarning(context, value, path) {
+  const object = readStrictObject(context, value, path, ["code", "message"]);
+  if (!object) return void 0;
+  const code = readString(context, object.code, `${path}.code`, { maxLength: 64, pattern: WARNING_CODE_PATTERN });
+  const message = readString(context, object.message, `${path}.message`, {
+    maxLength: context.limits.maxDescriptionLength
+  });
+  return code && message ? { code, message } : void 0;
+}
+function parseTransformPlanV1(input, planContext, options = {}) {
+  const context = new ValidationContext(resolveContractLimits(options.limits));
+  const object = readStrictObject(
+    context,
+    input,
+    "$",
+    ["version", "sourceFingerprint", "targetSchemaVersionId", "mappings", "unmappedSources", "unsatisfiedTargets", "warnings"]
+  );
+  if (!object) return context.finish("TransformPlanV1", void 0);
+  if (object.version !== 1) context.issue("invalid_value", "$.version", "Expected version 1");
+  const sourceFingerprint = readString(context, object.sourceFingerprint, "$.sourceFingerprint", { maxLength: 64 });
+  if (sourceFingerprint !== void 0 && sourceFingerprint !== planContext.sourceProfile.structureFingerprint) {
+    context.issue("fingerprint_mismatch", "$.sourceFingerprint", "Plan fingerprint does not match the source profile");
+  }
+  const targetSchemaVersionId = readString(context, object.targetSchemaVersionId, "$.targetSchemaVersionId", {
+    maxLength: 128
+  });
+  if (targetSchemaVersionId !== void 0 && targetSchemaVersionId !== planContext.targetSchemaVersionId) {
+    context.issue("schema_version_mismatch", "$.targetSchemaVersionId", "Plan schema version does not match the requested version");
+  }
+  const sourcePaths = new Set(planContext.sourceProfile.fields.map((field) => field.path));
+  const targetFields = new Map(planContext.targetSchema.fields.map((field) => [field.key, field]));
+  let mappings;
+  if (!Array.isArray(object.mappings)) {
+    context.issue("invalid_type", "$.mappings", "Expected a mapping array");
+  } else {
+    if (object.mappings.length > context.limits.maxMappings) {
+      context.issue("limit_exceeded", "$.mappings", "Plan has too many mappings");
+    }
+    mappings = object.mappings.map((entry, index) => parseMapping(context, entry, `$.mappings[${index}]`, sourcePaths, targetFields)).filter((entry) => entry !== void 0);
+    assertUnique(context, mappings.map((mapping) => mapping.target), "$.mappings.*.target");
+  }
+  const unmappedSources = parseStringArray(context, object.unmappedSources, "$.unmappedSources", context.limits.maxFields);
+  unmappedSources?.forEach((source, index) => {
+    if (!sourcePaths.has(source)) {
+      context.issue("unknown_source", `$.unmappedSources[${index}]`, `Unknown source path ${JSON.stringify(source)}`);
+    }
+  });
+  const unsatisfiedTargets = parseStringArray(
+    context,
+    object.unsatisfiedTargets,
+    "$.unsatisfiedTargets",
+    context.limits.maxFields
+  );
+  unsatisfiedTargets?.forEach((target, index) => {
+    if (!targetFields.has(target)) {
+      context.issue("unknown_target", `$.unsatisfiedTargets[${index}]`, `Unknown target field ${JSON.stringify(target)}`);
+    }
+  });
+  let warnings;
+  if (!Array.isArray(object.warnings)) {
+    context.issue("invalid_type", "$.warnings", "Expected a warning array");
+  } else {
+    if (object.warnings.length > context.limits.maxWarnings) {
+      context.issue("limit_exceeded", "$.warnings", "Plan has too many warnings");
+    }
+    warnings = object.warnings.map((entry, index) => parseWarning(context, entry, `$.warnings[${index}]`)).filter((entry) => entry !== void 0);
+  }
+  if (mappings && unmappedSources) {
+    const mappedSources = new Set(mappings.flatMap((mapping) => mapping.sources));
+    unmappedSources.forEach((source, index) => {
+      if (mappedSources.has(source)) {
+        context.issue("invalid_value", `$.unmappedSources[${index}]`, "A source cannot be both mapped and unmapped");
+      }
+    });
+  }
+  if (mappings && unsatisfiedTargets) {
+    const mappedTargets = new Set(mappings.map((mapping) => mapping.target));
+    unsatisfiedTargets.forEach((target, index) => {
+      if (mappedTargets.has(target)) {
+        context.issue("invalid_value", `$.unsatisfiedTargets[${index}]`, "A target cannot be both mapped and unsatisfied");
+      }
+    });
+  }
+  if (sourceFingerprint === void 0 || targetSchemaVersionId === void 0 || mappings === void 0 || unmappedSources === void 0 || unsatisfiedTargets === void 0 || warnings === void 0) {
+    return context.finish("TransformPlanV1", void 0);
+  }
+  const plan = {
+    version: 1,
+    sourceFingerprint,
+    targetSchemaVersionId,
+    mappings,
+    unmappedSources,
+    unsatisfiedTargets,
+    warnings
+  };
+  assertCanonicalSize(context, plan, "$");
+  return context.finish("TransformPlanV1", cloneContract(plan));
+}
+export {
+  ContractValidationError,
+  DEFAULT_CONTRACT_LIMITS,
+  DEFAULT_DELIVERY_SIGNATURE_TOLERANCE_SECONDS,
+  DEFAULT_MAX_DELIVERY_BATCH_BYTES,
+  DEFAULT_MAX_DELIVERY_BATCH_RECORDS,
+  DELIVERY_HEADERS,
+  DELIVERY_PROTOCOL_VERSION,
+  SOURCE_FORMATS,
+  SOURCE_INFERRED_TYPES,
+  TARGET_FIELD_TYPES,
+  TargetSchemaBuilderV1,
+  canonicalByteLength,
+  canonicalStringify,
+  cloneJsonValue,
+  computeStructureFingerprint,
+  defineTargetSchemaV1,
+  describeSourceStructure,
+  isCalendarDate,
+  isOffsetDateTime,
+  isTargetValueCompatible,
+  parseAcceptedRecordBatchV1,
+  parseCalendarFormats,
+  parseSourceProfileV1,
+  parseTargetSchemaV1,
+  parseTransformPlanV1,
+  resolveContractLimits,
+  signDeliveryRequestV1,
+  verifyDeliverySignatureV1
+};