@asterdoc/render 0.0.0-stage → 0.9.0

package/dist/chunk-ICQLU4FL.js

@@ -0,0 +1,630 @@
+import {
+  bindingDataPath,
+  pathSegments
+} from "./chunk-4QVR6LUY.js";
+
+// src/text/field-formatter.ts
+import { MISSING_RATING_SCALE, UNSUPPORTED_LIST_JOIN } from "@asterdoc/format";
+var organizationPartyKeys = /* @__PURE__ */ new Set(["legalName", "domicile", "entityType", "entityId", "taxId"]);
+function inferredPartyType(value) {
+  return Object.keys(value).some((key) => organizationPartyKeys.has(key)) ? "organization" : "person";
+}
+var rawValues = /* @__PURE__ */ new WeakMap();
+var renderedValues = /* @__PURE__ */ new WeakMap();
+var FormattedFieldValue = class {
+  constructor(value, text) {
+    if (value !== null && typeof value === "object") {
+      for (const [key, member] of Object.entries(value)) {
+        if (key === "toString" || key === "__proto__" || key === "constructor" || key === "prototype") continue;
+        Object.defineProperty(this, key, { configurable: false, enumerable: true, value: member, writable: false });
+      }
+    }
+    rawValues.set(this, value);
+    renderedValues.set(this, text);
+  }
+  get raw() {
+    return rawValues.get(this);
+  }
+  toString() {
+    return renderedValues.get(this) ?? "";
+  }
+};
+function unwrapFormattedValue(value) {
+  return value instanceof FormattedFieldValue ? value.raw : value;
+}
+var ArtifactFieldFormatError = class extends Error {
+  path;
+  fieldType;
+  status;
+  issues;
+  constructor(path, fieldType, status, issues, cause) {
+    const detail = issues.map((entry) => entry.message).join("; ") || `Unable to format ${fieldType}.`;
+    super(`Cannot format ${path} (${fieldType}, ${status}): ${detail}`, cause instanceof Error ? { cause } : void 0);
+    this.name = "ArtifactFieldFormatError";
+    this.path = path;
+    this.fieldType = fieldType;
+    this.status = status;
+    this.issues = issues;
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissing(value) {
+  return value === null || value === void 0;
+}
+function childPath(path, segment) {
+  return typeof segment === "number" ? `${path}[${segment}]` : `${path}.${segment}`;
+}
+function formatIssue(path, fieldType, code, message) {
+  return new ArtifactFieldFormatError(path, fieldType, "invalid", [{ code, message, path, kind: fieldType }]);
+}
+function progressiveText(options, status) {
+  if (!options?.progressive) return void 0;
+  return status === "missing" ? options.progressive.missing ?? "\u2014" : options.progressive.incomplete ?? "\u2026";
+}
+function missingValue(value, path, fieldType, options) {
+  const text = progressiveText(options, "missing");
+  return text === void 0 ? value : new FormattedFieldValue(value, text);
+}
+function presentIssuePath(path, issuePath) {
+  if (!issuePath) return path;
+  if (issuePath === path || issuePath.startsWith(`${path}.`) || issuePath.startsWith(`${path}[`)) return issuePath;
+  return issuePath.startsWith("[") ? `${path}${issuePath}` : `${path}.${issuePath}`;
+}
+function presentIssues(issues, path, fieldType) {
+  return issues.map((issue) => ({
+    ...issue,
+    path: presentIssuePath(path, issue.path),
+    kind: issue.kind ?? fieldType
+  }));
+}
+function presentResult(result, value, path, fieldType, options) {
+  if (result.success) return new FormattedFieldValue(value, result.value);
+  if (result.status === "missing") return missingValue(value, path, fieldType, options);
+  if (result.status === "incomplete") {
+    const text = progressiveText(options, "incomplete");
+    if (text !== void 0) return new FormattedFieldValue(value, text);
+  }
+  throw new ArtifactFieldFormatError(path, fieldType, result.status, presentIssues(result.issues, path, fieldType));
+}
+function guardFormatting(path, fieldType, run) {
+  try {
+    return run();
+  } catch (error) {
+    if (error instanceof ArtifactFieldFormatError) throw error;
+    throw new ArtifactFieldFormatError(path, fieldType, "error", [{
+      code: "formatter_error",
+      message: error instanceof Error ? error.message : "Unexpected formatter failure.",
+      path,
+      kind: fieldType,
+      cause: error
+    }], error);
+  }
+}
+function callFormatter(path, fieldType, value, call, options) {
+  return guardFormatting(path, fieldType, () => presentResult(call(), value, path, fieldType, options));
+}
+function callFormatterWithFallback(path, fieldType, value, call, fallback) {
+  return guardFormatting(path, fieldType, () => {
+    const result = call();
+    const fellShort = !result.success && result.status === "unsupported" && result.issues.some((entry) => entry.code === fallback.code);
+    if (!fellShort) return presentResult(result, value, path, fieldType, fallback.options);
+    const substitute = fallback.substitute();
+    if (!substitute.success) return presentResult(substitute, value, path, fieldType, fallback.options);
+    return new FormattedFieldValue(value, substitute.value);
+  });
+}
+function recordInput(value, path, fieldType) {
+  if (isRecord(value)) return value;
+  throw formatIssue(path, fieldType, "invalid_value", `Expected an object for ${fieldType}.`);
+}
+function dateInput(value, path, fieldType) {
+  if (typeof value === "string" || value instanceof Date) return value;
+  throw formatIssue(path, fieldType, "invalid_value", `Expected an ISO string or Date for ${fieldType}.`);
+}
+function stringInput(value, path, fieldType) {
+  if (typeof value === "string") return value;
+  throw formatIssue(path, fieldType, "invalid_value", `Expected a string for ${fieldType}.`);
+}
+function numberInput(value, path, fieldType) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  throw formatIssue(path, fieldType, "invalid_value", `Expected a finite number for ${fieldType}.`);
+}
+function booleanInput(value, path, fieldType) {
+  if (typeof value === "boolean") return value;
+  throw formatIssue(path, fieldType, "invalid_value", "Expected a boolean value.");
+}
+function optionInput(value, path, fieldType) {
+  if (typeof value === "string" || typeof value === "number" && Number.isFinite(value)) return value;
+  throw formatIssue(path, fieldType, "invalid_value", `Expected a string or number ${fieldType} value.`);
+}
+function optionListInput(value, path, fieldType) {
+  if (!Array.isArray(value)) throw formatIssue(path, fieldType, "invalid_value", `Expected an array of ${fieldType} values.`);
+  return value.map((entry) => optionInput(entry, path, fieldType));
+}
+function commaJoinedLabels(formatter, values, options) {
+  const labels = [];
+  for (const value of values) {
+    const result = formatter.safeFormatEnum(value, { options });
+    if (!result.success) return result;
+    labels.push(result.value);
+  }
+  return { success: true, status: "formatted", value: labels.join(", ") };
+}
+function formatLeaf(formatter, field, value, path, options) {
+  if (isMissing(value)) return missingValue(value, path, field.type, options);
+  try {
+    switch (field.type) {
+      case "money":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatMoney(recordInput(value, path, field.type), options?.money), options);
+      case "address":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatAddress(recordInput(value, path, field.type)), options);
+      case "phone":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatPhone(typeof value === "string" ? value : recordInput(value, path, field.type)), options);
+      case "person":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatPerson(recordInput(value, path, field.type)), options);
+      case "organization":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatOrganization(recordInput(value, path, field.type)), options);
+      case "coordinate":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatCoordinate(recordInput(value, path, field.type)), options);
+      case "bbox":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatBbox(recordInput(value, path, field.type)), options);
+      case "duration":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatDuration(stringInput(value, path, field.type)), options);
+      case "identification":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatIdentification(recordInput(value, path, field.type)), options);
+      case "date":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatDate(dateInput(value, path, field.type)), options);
+      case "datetime":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatDatetime(dateInput(value, path, field.type)), options);
+      case "time":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatTime(stringInput(value, path, field.type)), options);
+      case "number":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatNumber(numberInput(value, path, field.type)), options);
+      case "percentage":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatPercentage(numberInput(value, path, field.type)), options);
+      case "boolean":
+        return callFormatter(path, field.type, value, () => formatter.safeFormatBoolean(booleanInput(value, path, field.type)), options);
+      case "enum":
+        if (options?.choices === "value") {
+          const choice = optionInput(value, path, field.type);
+          return new FormattedFieldValue(value, String(choice));
+        }
+        return callFormatter(path, field.type, value, () => formatter.safeFormatEnum(optionInput(value, path, field.type), { options: field.enum }), options);
+      case "multiselect":
+        if (options?.choices === "value") {
+          return new FormattedFieldValue(value, optionListInput(value, path, field.type).map(String).join(", "));
+        }
+        return callFormatterWithFallback(
+          path,
+          field.type,
+          value,
+          () => formatter.safeFormatMultiselect(optionListInput(value, path, field.type), { options: field.enum }),
+          {
+            code: UNSUPPORTED_LIST_JOIN,
+            substitute: () => commaJoinedLabels(formatter, optionListInput(value, path, field.type), field.enum),
+            options
+          }
+        );
+      case "text":
+      case "email":
+      case "uuid":
+      case "uri":
+        return stringInput(value, path, field.type);
+      // An absent `max` is left out, so a formatter-level rating scale still applies.
+      case "rating":
+        return callFormatterWithFallback(
+          path,
+          field.type,
+          value,
+          () => formatter.safeFormatRating(numberInput(value, path, field.type), field.max === void 0 ? {} : { max: field.max }),
+          {
+            code: MISSING_RATING_SCALE,
+            substitute: () => formatter.safeFormatNumber(numberInput(value, path, field.type)),
+            options
+          }
+        );
+    }
+  } catch (error) {
+    if (error instanceof ArtifactFieldFormatError) throw error;
+    throw new ArtifactFieldFormatError(path, field.type, "error", [{
+      code: "field_format_error",
+      message: error instanceof Error ? error.message : "Unexpected field formatting failure.",
+      path,
+      kind: field.type,
+      cause: error
+    }], error);
+  }
+}
+function formatFieldValue(formatter, field, value, path, options) {
+  if (field.type === "list") {
+    if (isMissing(value)) return missingValue(value, path, field.type, options);
+    if (!Array.isArray(value)) throw formatIssue(path, field.type, "invalid_value", "Expected an array for a list field.");
+    return value.map((item, index) => formatFieldValue(formatter, field.item, item, childPath(path, index), options));
+  }
+  if (field.type === "fieldset") {
+    if (isMissing(value)) return missingValue(value, path, field.type, options);
+    if (!isRecord(value)) throw formatIssue(path, field.type, "invalid_value", "Expected an object for a fieldset.");
+    const result = { ...value };
+    for (const [key, child] of Object.entries(field.fields)) {
+      if (Object.prototype.hasOwnProperty.call(value, key) || options?.progressive) {
+        result[key] = formatFieldValue(formatter, child, value[key], childPath(path, key), options);
+      }
+    }
+    return result;
+  }
+  return formatLeaf(formatter, field, value, path, options);
+}
+function formatDefinitionValue(formatter, type, value, path, options) {
+  if (isMissing(value)) return missingValue(value, path, type, options);
+  try {
+    switch (type) {
+      case "money":
+        return callFormatter(path, type, value, () => formatter.safeFormatMoney(recordInput(value, path, type), options?.money), options);
+      case "address":
+        return callFormatter(path, type, value, () => formatter.safeFormatAddress(recordInput(value, path, type)), options);
+      case "phone":
+        return callFormatter(path, type, value, () => formatter.safeFormatPhone(typeof value === "string" ? value : recordInput(value, path, type)), options);
+      case "person":
+        return callFormatter(path, type, value, () => formatter.safeFormatPerson(recordInput(value, path, type)), options);
+      case "organization":
+        return callFormatter(path, type, value, () => formatter.safeFormatOrganization(recordInput(value, path, type)), options);
+      case "party": {
+        const party = recordInput(value, path, type);
+        return callFormatter(path, type, value, () => formatter.safeFormatParty(party, { partyType: inferredPartyType(party) }), options);
+      }
+      case "coordinate":
+        return callFormatter(path, type, value, () => formatter.safeFormatCoordinate(recordInput(value, path, type)), options);
+      case "bbox":
+        return callFormatter(path, type, value, () => formatter.safeFormatBbox(recordInput(value, path, type)), options);
+      case "duration":
+        return callFormatter(path, type, value, () => formatter.safeFormatDuration(stringInput(value, path, type)), options);
+      case "identification":
+        return callFormatter(path, type, value, () => formatter.safeFormatIdentification(recordInput(value, path, type)), options);
+      case "attachment":
+        return callFormatter(path, type, value, () => formatter.safeFormatAttachment(recordInput(value, path, type)), options);
+      case "signature":
+        return callFormatter(path, type, value, () => formatter.safeFormatSignature(recordInput(value, path, type)), options);
+      case "date":
+        return callFormatter(path, type, value, () => formatter.safeFormatDate(dateInput(value, path, type)), options);
+      case "datetime":
+        return callFormatter(path, type, value, () => formatter.safeFormatDatetime(dateInput(value, path, type)), options);
+      case "time":
+        return callFormatter(path, type, value, () => formatter.safeFormatTime(stringInput(value, path, type)), options);
+      case "number":
+        return callFormatter(path, type, value, () => formatter.safeFormatNumber(numberInput(value, path, type)), options);
+      // A computed value carries no field, so only a formatter-level scale can apply.
+      case "rating":
+        return callFormatterWithFallback(
+          path,
+          type,
+          value,
+          () => formatter.safeFormatRating(numberInput(value, path, type)),
+          {
+            code: MISSING_RATING_SCALE,
+            substitute: () => formatter.safeFormatNumber(numberInput(value, path, type)),
+            options
+          }
+        );
+      case "integer": {
+        const number = numberInput(value, path, type);
+        if (!Number.isInteger(number)) throw formatIssue(path, type, "invalid_value", "Expected an integer value.");
+        return callFormatter(path, type, value, () => formatter.safeFormatNumber(number), options);
+      }
+      case "percentage":
+        return callFormatter(path, type, value, () => formatter.safeFormatPercentage(numberInput(value, path, type)), options);
+      case "boolean":
+        return callFormatter(path, type, value, () => formatter.safeFormatBoolean(booleanInput(value, path, type)), options);
+      case "string":
+        return stringInput(value, path, type);
+      default:
+        throw new ArtifactFieldFormatError(path, type, "unsupported", [{ code: "unsupported_type", message: `Unsupported computed value type ${JSON.stringify(type)}.`, path, kind: type }]);
+    }
+  } catch (error) {
+    if (error instanceof ArtifactFieldFormatError) throw error;
+    throw new ArtifactFieldFormatError(path, type, "error", [{ code: "computed_format_error", message: error instanceof Error ? error.message : "Unexpected computed value formatting failure.", path, kind: type, cause: error }], error);
+  }
+}
+function formatParties(formatter, form, value, path, options, role) {
+  if (isMissing(value)) return missingValue(value, path, "party", options);
+  if (Array.isArray(value)) return value.map((entry, index) => formatParties(formatter, form, entry, childPath(path, index), options, role));
+  const party = recordInput(value, path, "party");
+  const partyType = role ? form.parties?.[role]?.partyType : void 0;
+  const resolvedPartyType = partyType === "person" || partyType === "organization" ? partyType : inferredPartyType(party);
+  return callFormatter(path, "party", value, () => formatter.safeFormatParty(party, { partyType: resolvedPartyType }), options);
+}
+function formatAnnexes(formatter, form, value, options) {
+  if (!isRecord(value)) {
+    if (isMissing(value)) return options?.progressive ? {} : value;
+    throw formatIssue("annexes", "attachment", "invalid_value", "Expected annexes to be an object.");
+  }
+  const result = { ...value };
+  for (const [key, annexValue] of Object.entries(value)) {
+    const path = `annexes.${key}`;
+    const definition = form.annexes?.[key];
+    if (!definition && !form.allowAdditionalAnnexes) throw formatIssue(path, "attachment", "unknown_path", `Unknown annex ${JSON.stringify(key)}.`);
+    if (isMissing(annexValue)) result[key] = missingValue(annexValue, path, "attachment", options);
+    else result[key] = callFormatter(path, "attachment", annexValue, () => formatter.safeFormatAttachment(recordInput(annexValue, path, "attachment")), options);
+  }
+  for (const key of Object.keys(form.annexes ?? {})) {
+    if (!Object.prototype.hasOwnProperty.call(result, key) && options?.progressive) {
+      result[key] = missingValue(void 0, `annexes.${key}`, "attachment", options);
+    }
+  }
+  return result;
+}
+function formatDefs(formatter, definitions, values, options) {
+  if (!isRecord(values)) {
+    if (isMissing(values)) return values;
+    throw formatIssue("defs", "computed", "invalid_value", "Expected computed values to be an object.");
+  }
+  const result = { ...values };
+  for (const [key, definition] of Object.entries(definitions ?? {})) {
+    if (Object.prototype.hasOwnProperty.call(values, key)) {
+      result[key] = formatDefinitionValue(formatter, definition.type, values[key], `defs.${key}`, options);
+    } else if (options?.progressive) {
+      result[key] = missingValue(void 0, `defs.${key}`, definition.type, options);
+    }
+  }
+  for (const key of Object.keys(values)) {
+    if (!definitions?.[key]) throw formatIssue(`defs.${key}`, "computed", "unknown_path", `Unknown computed value ${JSON.stringify(key)}.`);
+  }
+  return result;
+}
+function formatFieldData(data, form, formatter, options) {
+  const result = { ...data };
+  const nestedFields = isRecord(data.fields);
+  const fieldValues = isRecord(data.fields) ? data.fields : data;
+  const formattedFields = { ...fieldValues };
+  for (const [key, field] of Object.entries(form.fields ?? {})) {
+    if (Object.prototype.hasOwnProperty.call(fieldValues, key) || options?.progressive) {
+      formattedFields[key] = formatFieldValue(formatter, field, fieldValues[key], `fields.${key}`, options);
+    }
+  }
+  if (nestedFields) result.fields = formattedFields;
+  else Object.assign(result, formattedFields);
+  if (Object.prototype.hasOwnProperty.call(data, "parties") || options?.progressive && form.parties) {
+    const parties = data.parties;
+    if (!isMissing(parties) && !isRecord(parties)) throw formatIssue("parties", "party", "invalid_value", "Expected parties to be an object.");
+    const partyValues = isRecord(parties) ? parties : {};
+    const formattedParties = { ...partyValues };
+    for (const [role, value] of Object.entries(partyValues)) {
+      if (!form.parties?.[role]) throw formatIssue(`parties.${role}`, "party", "unknown_path", `Unknown party role ${JSON.stringify(role)}.`);
+      formattedParties[role] = formatParties(formatter, form, value, `parties.${role}`, options, role);
+    }
+    for (const role of Object.keys(form.parties ?? {})) {
+      if (!Object.prototype.hasOwnProperty.call(formattedParties, role) && options?.progressive) {
+        formattedParties[role] = formatParties(formatter, form, void 0, `parties.${role}`, options, role);
+      }
+    }
+    result.parties = formattedParties;
+  }
+  if (Object.prototype.hasOwnProperty.call(data, "defs")) result.defs = formatDefs(formatter, form.defs, data.defs, options);
+  if (Object.prototype.hasOwnProperty.call(data, "defs") === false && options?.progressive && form.defs) {
+    result.defs = formatDefs(formatter, form.defs, {}, options);
+  }
+  if (Object.prototype.hasOwnProperty.call(data, "annexes") || options?.progressive && form.annexes) {
+    result.annexes = formatAnnexes(formatter, form, data.annexes, options);
+  }
+  return result;
+}
+var signingRoots = /* @__PURE__ */ new Set(["_signers", "_captures"]);
+function isIndex(segment) {
+  return /^\d+$/.test(segment) && Number.isSafeInteger(Number(segment));
+}
+var anyPath = /* @__PURE__ */ Symbol("any-path");
+var leafPath = Object.freeze({});
+var blockedPathSegments = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function objectPath(entries) {
+  return Object.freeze(entries);
+}
+function mergePaths(...nodes) {
+  if (nodes.some((node) => node === anyPath)) return anyPath;
+  return objectPath(Object.assign({}, ...nodes));
+}
+var moneyPath = objectPath({ amount: leafPath, currency: leafPath });
+var addressPath = objectPath({
+  line1: leafPath,
+  line2: leafPath,
+  locality: leafPath,
+  region: leafPath,
+  postalCode: leafPath,
+  country: leafPath
+});
+var phonePath = objectPath({ number: leafPath, type: leafPath, extension: leafPath });
+var personPath = objectPath({ name: leafPath, title: leafPath, firstName: leafPath, middleName: leafPath, lastName: leafPath, suffix: leafPath });
+var organizationPath = objectPath({
+  name: leafPath,
+  legalName: leafPath,
+  domicile: leafPath,
+  entityType: leafPath,
+  entityId: leafPath,
+  taxId: leafPath
+});
+var coordinatePath = objectPath({ lat: leafPath, lon: leafPath });
+var bboxPath = objectPath({
+  southWest: coordinatePath,
+  northEast: coordinatePath
+});
+var identificationPath = objectPath({
+  type: leafPath,
+  number: leafPath,
+  issuer: leafPath,
+  issueDate: leafPath,
+  expiryDate: leafPath
+});
+var attachmentPath = objectPath({ name: leafPath, mimeType: leafPath, checksum: leafPath });
+var signaturePath = objectPath({ image: leafPath, timestamp: leafPath, method: leafPath, type: leafPath, metadata: anyPath });
+var signerPath = objectPath({
+  signerId: leafPath,
+  capacity: leafPath,
+  _role: leafPath,
+  _partyId: leafPath,
+  id: leafPath,
+  signer: objectPath({
+    id: leafPath,
+    person: personPath,
+    adopted: objectPath({ signature: signaturePath, initials: signaturePath })
+  })
+});
+var partyRuntimePath = objectPath({
+  id: leafPath,
+  _role: leafPath,
+  signatories: objectPath({ "#": signerPath }),
+  _captures: anyPath,
+  _signers: anyPath
+});
+var pathNodesByType = {
+  money: moneyPath,
+  address: addressPath,
+  phone: phonePath,
+  person: personPath,
+  organization: organizationPath,
+  party: mergePaths(personPath, organizationPath, partyRuntimePath),
+  coordinate: coordinatePath,
+  bbox: bboxPath,
+  identification: identificationPath,
+  attachment: attachmentPath,
+  signature: signaturePath,
+  string: leafPath,
+  text: leafPath,
+  email: leafPath,
+  uuid: leafPath,
+  uri: leafPath,
+  duration: leafPath,
+  date: leafPath,
+  datetime: leafPath,
+  time: leafPath,
+  number: leafPath,
+  integer: leafPath,
+  percentage: leafPath,
+  rating: leafPath,
+  boolean: leafPath,
+  enum: leafPath,
+  multiselect: leafPath
+};
+function pathNodeForType(type) {
+  return pathNodesByType[type];
+}
+function hasOwn(value, key) {
+  return value !== null && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key);
+}
+function validatePathSyntax(path) {
+  if (!path || path.startsWith(".") || path.endsWith(".") || path.includes("..")) return false;
+  return path.split(".").every((segment) => /^[^.[\]]+(?:\[\d+\])*$/.test(segment));
+}
+function validatePathNode(node, segments, index, path, fieldType) {
+  if (index >= segments.length || node === anyPath) return;
+  const segment = segments[index];
+  if (blockedPathSegments.has(segment)) {
+    throw formatIssue(path, fieldType, "unknown_path", `Blocked path segment ${JSON.stringify(segment)}.`);
+  }
+  let child;
+  if (Object.prototype.hasOwnProperty.call(node, segment)) {
+    child = node[segment];
+  } else if (Object.prototype.hasOwnProperty.call(node, "#")) {
+    if (!isIndex(segment)) {
+      throw formatIssue(path, fieldType, "unknown_path", `Expected a safe numeric index before ${JSON.stringify(segment)}.`);
+    }
+    child = node["#"];
+  } else if (Object.prototype.hasOwnProperty.call(node, "*")) {
+    child = node["*"];
+  }
+  if (!child) {
+    throw formatIssue(path, fieldType, "unknown_path", `Unknown ${fieldType} member ${JSON.stringify(segment)}.`);
+  }
+  validatePathNode(child, segments, index + 1, path, fieldType);
+}
+function validateDeclaredField(field, segments, index, path) {
+  if (index >= segments.length) return;
+  const segment = segments[index];
+  if (field.type === "list") {
+    if (!isIndex(segment)) throw formatIssue(path, field.type, "unknown_path", `Expected a list index before ${JSON.stringify(segment)}.`);
+    return validateDeclaredField(field.item, segments, index + 1, path);
+  }
+  if (field.type === "fieldset") {
+    const child = hasOwn(field.fields, segment) ? field.fields[segment] : void 0;
+    if (!child) throw formatIssue(path, field.type, "unknown_path", `Unknown nested field ${JSON.stringify(segment)}.`);
+    return validateDeclaredField(child, segments, index + 1, path);
+  }
+  const node = pathNodeForType(field.type);
+  if (!node) throw formatIssue(path, field.type, "unsupported_path", `Unsupported field type ${JSON.stringify(field.type)}.`);
+  validatePathNode(node, segments, index, path, field.type);
+}
+function validatePartyPath(form, segments, path) {
+  const role = segments[0];
+  const definition = role && hasOwn(form.parties, role) ? form.parties?.[role] : void 0;
+  if (!role || !definition) throw formatIssue(path, "party", "unknown_path", `Unknown party role ${JSON.stringify(role)}.`);
+  if (segments.length === 1) return;
+  const max = definition.max ?? 1;
+  const segment = segments[1];
+  const indexed = isIndex(segment);
+  const isCollection = max > 1;
+  if (indexed) {
+    if (!isCollection) throw formatIssue(path, "party", "unknown_path", `Party role ${JSON.stringify(role)} does not accept an index.`);
+    if (Number(segment) >= max) throw formatIssue(path, "party", "unknown_path", `Party index ${segment} is outside the declared maximum of ${max}.`);
+    if (segments.length === 2) return;
+    validatePathNode(partyPathNode(definition.partyType), segments, 2, path, "party");
+    return;
+  }
+  if (isCollection) throw formatIssue(path, "party", "unknown_path", `Party role ${JSON.stringify(role)} requires an index.`);
+  validatePathNode(partyPathNode(definition.partyType), segments, 1, path, "party");
+}
+function partyPathNode(partyType) {
+  const identity = partyType === "person" ? personPath : partyType === "organization" ? organizationPath : mergePaths(personPath, organizationPath);
+  return mergePaths(identity, partyRuntimePath);
+}
+function validateBindingPath(form, sourcePath, bindingKey) {
+  const path = bindingDataPath(sourcePath);
+  if (!validatePathSyntax(path)) throw formatIssue(`bindings.${bindingKey}`, "path", "unknown_path", `Malformed field path ${JSON.stringify(sourcePath)}.`);
+  const segments = pathSegments(path);
+  if (segments.length === 0) throw formatIssue(`bindings.${bindingKey}`, "path", "unknown_path", `Unknown field path ${JSON.stringify(sourcePath)}.`);
+  const root = segments[0];
+  if (root === "parties") {
+    validatePartyPath(form, segments.slice(1), sourcePath);
+    return;
+  }
+  if (root === "defs") {
+    const definitionKey = segments[1];
+    const definition = definitionKey && hasOwn(form.defs, definitionKey) ? form.defs?.[definitionKey] : void 0;
+    if (!definition) throw formatIssue(sourcePath, "computed", "unknown_path", `Unknown computed value ${JSON.stringify(definitionKey)}.`);
+    if (segments.length > 2) {
+      const node = pathNodeForType(definition.type);
+      if (!node) throw formatIssue(sourcePath, "computed", "unsupported_path", `Unsupported computed value type ${JSON.stringify(definition.type)}.`);
+      validatePathNode(node, segments, 2, sourcePath, definition.type);
+    }
+    return;
+  }
+  if (root === "annexes") {
+    const annex = segments[1];
+    if (!annex || !hasOwn(form.annexes, annex) && !form.allowAdditionalAnnexes) {
+      throw formatIssue(sourcePath, "attachment", "unknown_path", `Unknown annex ${JSON.stringify(annex)}.`);
+    }
+    if (segments.length > 2) validatePathNode(attachmentPath, segments, 2, sourcePath, "attachment");
+    return;
+  }
+  const field = form.fields?.[root];
+  if (field) {
+    validateDeclaredField(field, segments, 1, sourcePath);
+    return;
+  }
+  if (signingRoots.has(root)) return;
+  throw formatIssue(sourcePath, "path", "unknown_path", `Unknown field path ${JSON.stringify(sourcePath)}.`);
+}
+function validateFieldBindings(form, bindings) {
+  for (const [bindingKey, sourcePath] of Object.entries(bindings)) {
+    validateBindingPath(form, sourcePath, bindingKey);
+  }
+}
+
+export {
+  FormattedFieldValue,
+  unwrapFormattedValue,
+  ArtifactFieldFormatError,
+  formatFieldValue,
+  formatDefinitionValue,
+  formatParties,
+  formatFieldData,
+  validateFieldBindings
+};