@openpresentation/opf 0.8.0 → 0.10.0

package/dist/{chunk-HIY26FJV.js → chunk-GCB6LGJM.js}

@@ -1,5 +1,5 @@
-import { MAX_COMPOSITION_DEPTH, tableGrid } from './chunk-NEQAPMS2.js';
-import { schemas } from './chunk-GQSK3T7X.js';
+import { MAX_COMPOSITION_DEPTH, tableGrid } from './chunk-BAWLYSUN.js';
+import { schemas, schemaEntries } from './chunk-GQSK3T7X.js';
 import { catalogSchemaNames } from './chunk-TWMRZ43O.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
@@ -409,6 +409,46 @@ var catalogIds = {
   ]
 };
 
+// src/validation-definitions.ts
+var schemaLocations;
+var issueLocations = /* @__PURE__ */ new WeakMap();
+function rememberValidationDefinition(issue, parentSchema, keyword) {
+  if (!parentSchema || typeof parentSchema !== "object") return;
+  if (!schemaLocations) {
+    schemaLocations = /* @__PURE__ */ new WeakMap();
+    for (const entry of schemaEntries) {
+      const stack = [
+        { value: entry.schema, pointer: "" }
+      ];
+      while (stack.length) {
+        const current = stack.pop();
+        if (!current?.value || typeof current.value !== "object")
+          continue;
+        schemaLocations.set(current.value, {
+          schemaName: entry.name,
+          pointer: current.pointer,
+          uri: `${entry.schema.$id}#${current.pointer}`
+        });
+        for (const [key, value] of Object.entries(current.value)) {
+          const segment = key.replaceAll("~", "~0").replaceAll("/", "~1");
+          stack.push({ value, pointer: `${current.pointer}/${segment}` });
+        }
+      }
+    }
+  }
+  const parent = schemaLocations.get(parentSchema);
+  if (!parent) return;
+  const suffix = `/${keyword.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+  issueLocations.set(issue, {
+    ...parent,
+    pointer: parent.pointer + suffix,
+    uri: parent.uri + suffix
+  });
+}
+function validationDefinition(issue) {
+  return issueLocations.get(issue);
+}
+
 // src/validator.ts
 var OPFValidationError = class extends Error {
   issues;
@@ -555,6 +595,7 @@ function getAjv() {
   }
   const instance = new Ajv2020({
     allErrors: true,
+    verbose: true,
     strict: false,
     allowUnionTypes: true
   });
@@ -593,13 +634,15 @@ function resolveValidator(schemaOrKind) {
   return { validate: validator };
 }
 function toIssue(error) {
-  return {
+  const issue = {
     path: error.instancePath || "/",
     message: error.message ?? "failed validation",
     keyword: error.keyword,
     schemaPath: error.schemaPath,
     params: error.params
   };
+  rememberValidationDefinition(issue, error.parentSchema, error.keyword);
+  return issue;
 }
 function semanticIssue(path, message, params = {}) {
   return {
@@ -1012,4 +1055,4 @@ function assertValidCatalogRecord(kind, value) {
   assertValid(value, kind);
 }
 
-export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, validate, validateCatalogRecord, validatePresentation };
+export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, validate, validateCatalogRecord, validatePresentation, validationDefinition };

package/dist/chunk-NPOKUFEX.js

@@ -0,0 +1,595 @@
+import { validatePresentation, validationDefinition, validateCatalogRecord } from './chunk-GCB6LGJM.js';
+import { schemas, schemaEntries } from './chunk-GQSK3T7X.js';
+import { catalogKinds, catalogEntries, catalogSchemaNames } from './chunk-TWMRZ43O.js';
+import { parseTree, printParseErrorCode, getNodePath } from 'jsonc-parser';
+
+var own = (value, key) => Object.hasOwn(value, key);
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var primitive = (value) => value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+var pointer = (parts2) => parts2.length ? "/" + parts2.map((part) => String(part).replaceAll("~", "~0").replaceAll("/", "~1")).join("/") : "";
+function parts(path) {
+  if (path === "") return [];
+  if (!path.startsWith("/") || /~(?![01])/.test(path))
+    throw new TypeError(`Invalid lint contract JSON Pointer: ${path}`);
+  return path.slice(1).split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+function at(value, path) {
+  return parts(path).reduce(
+    (current, key) => object(current) || Array.isArray(current) ? own(current, key) ? current[key] : void 0 : void 0,
+    value
+  );
+}
+function optionsChecked(options) {
+  if (!object(options) || Object.keys(options).some((key) => !["catalogs", "contracts"].includes(key)))
+    throw new TypeError("Lint options accept only catalogs and contracts.");
+  if (options.catalogs !== void 0 && (!object(options.catalogs) || Object.entries(options.catalogs).some(
+    ([kind, records]) => !catalogKinds.includes(kind) || !Array.isArray(records)
+  )))
+    throw new TypeError(
+      "Lint catalogs must map known catalog kinds to arrays of loaded records."
+    );
+  if (options.contracts !== void 0 && !Array.isArray(options.contracts))
+    throw new TypeError("Lint contracts must be an array.");
+  for (const contract of options.contracts ?? []) {
+    if (!object(contract) || Object.keys(contract).some(
+      (key) => ![
+        "path",
+        "allowedValues",
+        "severity",
+        "message",
+        "documentation"
+      ].includes(key)
+    ) || typeof contract.path !== "string" || !Array.isArray(contract.allowedValues) || !contract.allowedValues.every(primitive) || contract.severity !== void 0 && (typeof contract.severity !== "string" || !["error", "warning", "info"].includes(contract.severity)) || contract.message !== void 0 && typeof contract.message !== "string" || contract.documentation !== void 0 && typeof contract.documentation !== "string")
+      throw new TypeError(
+        "Invalid lint contract: provide a path and primitive allowedValues, with optional severity, message and documentation."
+      );
+    parts(contract.path);
+  }
+}
+function report(diagnostics, schemaValid, syntax) {
+  const counts = { error: 0, warning: 0, info: 0 };
+  for (const diagnostic of diagnostics) counts[diagnostic.severity]++;
+  return {
+    valid: counts.error === 0,
+    schemaValid,
+    diagnostics,
+    counts,
+    checks: {
+      syntax,
+      schema: schemaValid === null ? "not-run" : "checked",
+      catalogReferences: schemaValid === null ? "not-run" : "local-context",
+      assetReferences: schemaValid === null ? "not-run" : "registry-only",
+      contracts: schemaValid === null ? "not-run" : "checked",
+      layout: "not-checked",
+      fonts: "not-checked",
+      nativeExport: "not-checked"
+    }
+  };
+}
+function schemaDiagnostic(issue, schemaName = "presentation", prefix = "", scope = "document") {
+  const path = prefix + (issue.path === "/" ? "" : issue.path) + (issue.keyword === "additionalProperties" && typeof issue.params.additionalProperty === "string" ? pointer([issue.params.additionalProperty]) : ""), entry = schemaEntries.find((entry2) => entry2.name === schemaName);
+  if (!entry) throw new TypeError(`Unknown schema ${schemaName}`);
+  const precise = validationDefinition(issue);
+  const definition = precise?.uri ?? (issue.keyword === "opf" ? "packages/javascript/src/validator.ts" : issue.schemaPath.startsWith("#") ? entry.schema.$id + issue.schemaPath : issue.schemaPath);
+  const lookup = [
+    "opf",
+    "schema",
+    precise?.schemaName ?? schemaName,
+    precise?.pointer ?? (issue.keyword !== "opf" && issue.schemaPath.startsWith("#") ? issue.schemaPath.slice(1) : "")
+  ];
+  let help = "Inspect this schema constraint and preserve unrelated content. Errors inside oneOf/anyOf branches may describe alternatives; retain the intended form.";
+  if (issue.keyword === "required")
+    help = `Add the required ${JSON.stringify(issue.params.missingProperty)} field in this object, using the intended schema form.`;
+  else if (issue.keyword === "additionalProperties")
+    help = `Review ${JSON.stringify(issue.params.additionalProperty)} against this object's schema. Preserve custom metadata in document.extensions where appropriate; do not delete authored content to clear this error.`;
+  else if (issue.keyword === "enum")
+    help = "Choose one of this schema branch\u2019s allowed values; inspect the other alternatives if the field uses another form.";
+  else if (issue.keyword === "opf")
+    help = "Resolve the reported structural conflict while preserving every content field. Preview the result after editing.";
+  const allowed = Array.isArray(issue.params.allowedValues) ? issue.params.allowedValues.filter(primitive) : [];
+  return {
+    ruleId: "opf/schema",
+    severity: "error",
+    path,
+    scope,
+    message: issue.message,
+    help,
+    definition,
+    lookup,
+    validation: issue,
+    ...allowed.length ? {
+      suggestions: allowed.map((value) => ({
+        value,
+        label: String(value),
+        origin: "schema",
+        definition
+      }))
+    } : {}
+  };
+}
+function resolve(cursor, seen = /* @__PURE__ */ new Set()) {
+  const ref = cursor.schema.$ref;
+  if (typeof ref !== "string") return cursor;
+  const id = String(cursor.root.$id ?? "") + ref;
+  if (seen.has(id)) return { ...cursor, schema: {} };
+  seen.add(id);
+  const [base, fragment = ""] = ref.split("#"), root = base ? schemaEntries.find((entry) => entry.schema.$id === base)?.schema : cursor.root;
+  if (!root) return { ...cursor, schema: {} };
+  const target = at(root, fragment);
+  if (!object(target)) return { ...cursor, schema: {} };
+  const resolved = resolve(
+    { schema: target, root, path: fragment },
+    seen
+  );
+  const { $ref, ...rest } = cursor.schema;
+  return { ...resolved, schema: { ...resolved.schema, ...rest } };
+}
+function score(schema, value) {
+  const type = schema.type;
+  if (typeof type === "string" && (type === "array" ? !Array.isArray(value) : type === "object" ? !object(value) : type === "null" ? value !== null : type === "integer" ? !Number.isInteger(value) : typeof value !== type))
+    return -1e4;
+  if (own(schema, "const")) return schema.const === value ? 100 : -1e4;
+  let result = 1;
+  if (object(value) && object(schema.properties)) {
+    for (const [key, child] of Object.entries(schema.properties))
+      if (own(value, key) && object(child))
+        result += own(child, "const") ? child.const === value[key] ? 100 : -1e3 : 1;
+  }
+  if (Array.isArray(schema.required)) {
+    for (const key of schema.required)
+      if (typeof key === "string" && (!object(value) || !own(value, key)))
+        result -= 2;
+  }
+  return result;
+}
+function active(cursor, value) {
+  const resolved = resolve(cursor), alternatives = resolved.schema.oneOf ?? resolved.schema.anyOf;
+  if (!Array.isArray(alternatives)) return resolved;
+  const keyword = resolved.schema.oneOf ? "oneOf" : "anyOf";
+  const candidates = alternatives.filter(object).map(
+    (schema, index) => active(
+      {
+        schema,
+        root: resolved.root,
+        path: `${resolved.path}/${keyword}/${index}`
+      },
+      value
+    )
+  );
+  const selected = candidates.sort((a, b) => score(b.schema, value) - score(a.schema, value))[0];
+  return selected ? { ...selected, baseSchemas: [...selected.baseSchemas ?? [], resolved] } : resolved;
+}
+function catalogIn(schema) {
+  const text = String(schema.description ?? "");
+  if (/\bfont-scheme id\b/.test(text)) return "fontSchemes";
+  return catalogKinds.find(
+    (kind) => text.includes(`catalogs.${kind}`) || new RegExp(`\\b${kind}['\u2019]? catalog`).test(text)
+  );
+}
+var languageTagSyntax = new RegExp(
+  "^(?:(?:[a-z]{2,3}(?:-[a-z]{3}){0,3}|[a-z]{4}|[a-z]{5,8})(?:-[a-z]{4})?(?:-(?:[a-z]{2}|[0-9]{3}))?(?:-(?:[a-z0-9]{5,8}|[0-9][a-z0-9]{3}))*(?:-[0-9a-wy-z](?:-[a-z0-9]{2,8})+)*(?:-x(?:-[a-z0-9]{1,8})+)?|x(?:-[a-z0-9]{1,8})+)$",
+  "i"
+);
+var irregularLanguageTags = /* @__PURE__ */ new Set([
+  "en-gb-oed",
+  "i-ami",
+  "i-bnn",
+  "i-default",
+  "i-enochian",
+  "i-hak",
+  "i-klingon",
+  "i-lux",
+  "i-mingo",
+  "i-navajo",
+  "i-pwn",
+  "i-tao",
+  "i-tay",
+  "i-tsu",
+  "sgn-be-fr",
+  "sgn-be-nl",
+  "sgn-ch-de"
+]);
+function childCursor(cursors, key) {
+  for (const keyword of [
+    "properties",
+    "patternProperties",
+    "additionalProperties"
+  ]) {
+    for (const cursor of cursors) {
+      const declarations = cursor.schema[keyword];
+      if (!object(declarations)) continue;
+      const name = keyword === "properties" ? key : keyword === "patternProperties" ? Object.keys(declarations).find(
+        (pattern) => new RegExp(pattern).test(key)
+      ) : void 0;
+      const schema = keyword === "additionalProperties" ? declarations : name === void 0 ? void 0 : declarations[name];
+      if (object(schema))
+        return {
+          schema,
+          root: cursor.root,
+          path: `${cursor.path}/${keyword}${name === void 0 ? "" : pointer([name])}`
+        };
+    }
+  }
+  return void 0;
+}
+function fields(document) {
+  const result = [], stack = [
+    {
+      value: document,
+      path: [],
+      cursor: {
+        schema: schemas.presentation,
+        root: schemas.presentation,
+        path: ""
+      },
+      ancestors: []
+    }
+  ];
+  while (stack.length) {
+    const entry = stack.pop();
+    if (!entry) break;
+    if (entry.ancestors.includes(entry.value)) continue;
+    const resolved = resolve(entry.cursor), selected = active(entry.cursor, entry.value), description = String(resolved.schema.description ?? "");
+    const assetReference = [resolved, selected].some(
+      (cursor) => cursor.root.$id === schemas.presentation.$id && (cursor.path === "/$defs/Asset" || cursor.path === "/$defs/Asset/oneOf/0" || cursor.path === "/$defs/Watermark/properties/src") || String(cursor.schema.description ?? "").includes("asset:") || Array.isArray(cursor.schema.examples) && cursor.schema.examples.some(
+        (example) => typeof example === "string" && example.startsWith("asset:")
+      )
+    );
+    result.push({
+      path: pointer(entry.path),
+      value: entry.value,
+      cursor: resolved,
+      kind: catalogIn(resolved.schema),
+      description,
+      assetReference
+    });
+    const ancestors = [...entry.ancestors, entry.value];
+    const cursors = [selected, ...selected.baseSchemas ?? [], resolved];
+    const arrayCursor = cursors.find((cursor) => object(cursor.schema.items));
+    if (Array.isArray(entry.value) && arrayCursor)
+      entry.value.forEach((value, index) => {
+        stack.push({
+          value,
+          path: [...entry.path, index],
+          cursor: {
+            schema: arrayCursor.schema.items,
+            root: arrayCursor.root,
+            path: `${arrayCursor.path}/items`
+          },
+          ancestors
+        });
+      });
+    else if (object(entry.value))
+      for (const [key, value] of Object.entries(entry.value)) {
+        if (entry.path.length === 0 && key === "catalogs") continue;
+        const cursor = childCursor(cursors, key);
+        if (!cursor) continue;
+        stack.push({
+          value,
+          path: [...entry.path, key],
+          cursor,
+          ancestors
+        });
+      }
+  }
+  return result;
+}
+function catalogContext(document, options, diagnostics) {
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of catalogEntries) {
+    const kind = entry.kind, map = /* @__PURE__ */ new Map();
+    result.set(kind, map);
+    for (const record of entry.records)
+      map.set(record.id, {
+        value: record.id,
+        label: String(
+          record.name ?? record.id
+        ),
+        origin: "built-in",
+        definition: `spec/${entry.dir}/${entry.index.records.find((item) => item.id === record.id)?.file ?? `${record.id}.json`}`
+      });
+    const local = object(document) && object(document.catalogs) && object(document.catalogs[kind]) ? document.catalogs[kind] : {};
+    if (local.source !== void 0)
+      diagnostics.push({
+        ruleId: "opf/catalog-source",
+        severity: "info",
+        scope: "document",
+        path: `/catalogs/${kind}/source`,
+        message: "External catalog source was not fetched.",
+        help: "This lint run checks built-in, supplied and inline records only. Load external catalogs in the host and pass their records explicitly to verify that context."
+      });
+    for (const group of [
+      {
+        records: options.catalogs?.[kind] ?? [],
+        origin: "loaded",
+        scope: "context",
+        path: `/catalogs/${kind}`
+      },
+      {
+        records: Array.isArray(local.records) ? local.records : [],
+        origin: "document",
+        scope: "document",
+        path: `/catalogs/${kind}/records`
+      }
+    ]) {
+      const seen = /* @__PURE__ */ new Set();
+      group.records.forEach((value, index) => {
+        const path = `${group.path}/${index}`, schemaName = catalogSchemaNames[kind], record = object(value) ? { $schema: schemas[schemaName].$id, ...value } : value;
+        const validation = validateCatalogRecord(kind, record);
+        for (const issue of validation.errors)
+          diagnostics.push({
+            ...schemaDiagnostic(issue, schemaName, path, group.scope),
+            ruleId: "opf/catalog-record"
+          });
+        if (!object(value) || typeof value.id !== "string") return;
+        if (seen.has(value.id))
+          diagnostics.push({
+            ruleId: "opf/catalog-record",
+            severity: "error",
+            scope: group.scope,
+            path: `${path}/id`,
+            message: `Duplicate ${kind} record id ${JSON.stringify(value.id)} in this catalog.`,
+            help: "Give distinct records distinct IDs, or combine the intended override explicitly. Preserve their authored content."
+          });
+        seen.add(value.id);
+        if (!validation.valid) {
+          map.delete(value.id);
+          return;
+        }
+        map.set(value.id, {
+          value: value.id,
+          label: typeof value.name === "string" ? value.name : value.id,
+          origin: group.origin,
+          definition: `${group.scope}#${path}`
+        });
+      });
+    }
+  }
+  return result;
+}
+function distance(a, b) {
+  a = a.slice(0, 128);
+  b = b.slice(0, 128);
+  let row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 0; i < a.length; i++) {
+    const next = [i + 1];
+    for (let j = 0; j < b.length; j++)
+      next.push(
+        Math.min(
+          (next[j] ?? Infinity) + 1,
+          (row[j + 1] ?? Infinity) + 1,
+          (row[j] ?? Infinity) + (a[i] === b[j] ? 0 : 1)
+        )
+      );
+    row = next;
+  }
+  return row[b.length] ?? Math.max(a.length, b.length);
+}
+function lintPresentation(document, options = {}) {
+  optionsChecked(options);
+  const validation = validatePresentation(document), diagnostics = validation.errors.map((issue) => schemaDiagnostic(issue));
+  const catalogs = catalogContext(document, options, diagnostics), seen = /* @__PURE__ */ new Set();
+  const assetValues = object(document) && object(document.assets) ? document.assets : {};
+  for (const field of fields(document)) {
+    if (typeof field.value === "string" && field.value.startsWith("asset:") && field.assetReference) {
+      const id = field.value.slice(6);
+      if (!own(assetValues, id))
+        diagnostics.push({
+          ruleId: "opf/asset-reference",
+          severity: "error",
+          scope: "document",
+          path: field.path,
+          message: `Asset ${JSON.stringify(id)} is missing from the document registry.`,
+          help: "Supply the intended asset in document.assets or choose the correct existing asset ID. External files and URLs are not fetched or verified.",
+          definition: schemas.presentation.$id + "#/$defs/Assets",
+          lookup: ["opf", "schema", "presentation", "/$defs/Assets"],
+          suggestions: Object.keys(assetValues).sort(
+            (a, b) => distance(id, a) - distance(id, b) || (a < b ? -1 : a > b ? 1 : 0)
+          ).slice(0, 5).map((id2) => ({
+            value: `asset:${id2}`,
+            label: id2,
+            origin: "document",
+            definition: `document#${pointer(["assets", id2])}`
+          }))
+        });
+    }
+    if (!field.path || !field.kind) continue;
+    const { kind } = field;
+    if (kind === "languages" && field.path === "/language" && typeof field.value === "string" && (languageTagSyntax.test(field.value) || irregularLanguageTags.has(field.value.toLowerCase())))
+      continue;
+    if (kind !== "layouts" && /free-form/i.test(field.description)) continue;
+    if (kind === "narratives" && (object(field.value) || field.cursor.root.$id === schemas.presentation.$id && field.cursor.path === "/$defs/Narrative/properties/id"))
+      continue;
+    const value = object(field.value) ? field.value.id : field.value, path = object(field.value) ? `${field.path}/id` : field.path;
+    if (typeof value !== "string" || !value || /^(?:https?:|pkg:)/i.test(value) || catalogs.get(kind)?.has(value) || seen.has(path))
+      continue;
+    seen.add(path);
+    const suggestions = [...catalogs.get(kind)?.values() ?? []].sort(
+      (a, b) => distance(value, String(a.value)) - distance(value, String(b.value)) || (String(a.value) < String(b.value) ? -1 : String(a.value) > String(b.value) ? 1 : 0)
+    ).slice(0, 5);
+    const definition = String(field.cursor.root.$id) + `#${field.cursor.path}`;
+    diagnostics.push({
+      ruleId: "opf/catalog-reference",
+      severity: "warning",
+      scope: "document",
+      path,
+      message: `Unknown ${kind} catalog id ${JSON.stringify(value)} in the available local context.`,
+      help: kind === "layouts" ? "Choose an available layout or supply the intended custom record. Engine-defined layouts may be valid; preview with the target renderer before changing content." : "Choose an available record or supply the intended custom catalog context. External references and native rendering are not verified by this check.",
+      definition,
+      lookup: ["opf", "catalog", kind],
+      suggestions
+    });
+  }
+  const reportedCycles = /* @__PURE__ */ new Set();
+  for (const id of Object.keys(assetValues)) {
+    const chain = [], seenIds = /* @__PURE__ */ new Set();
+    let current = id;
+    while (current !== void 0 && own(assetValues, current)) {
+      if (seenIds.has(current)) {
+        const cycle = chain.slice(chain.indexOf(current));
+        if (!cycle.some((id2) => reportedCycles.has(id2))) {
+          for (const id2 of cycle) reportedCycles.add(id2);
+          diagnostics.push({
+            ruleId: "opf/asset-cycle",
+            severity: "error",
+            scope: "document",
+            path: pointer(["assets", current]),
+            message: `Asset references form a cycle: ${[...cycle, current].map((id2) => JSON.stringify(id2)).join(" \u2192 ")}.`,
+            help: "Replace one link with the intended concrete source. Preserve the original asset metadata; no files or URLs were fetched."
+          });
+        }
+        break;
+      }
+      seenIds.add(current);
+      chain.push(current);
+      const value = assetValues[current], source = object(value) ? value.src : value;
+      current = typeof source === "string" && source.startsWith("asset:") ? source.slice(6) : void 0;
+    }
+  }
+  for (const issue of validation.warnings) {
+    const kind = issue.params.kind, id = issue.params.id;
+    if (seen.has(issue.path) || typeof id === "string" && catalogs.get(kind)?.has(id))
+      continue;
+    diagnostics.push({
+      ...schemaDiagnostic(issue),
+      ruleId: "opf/catalog-reference",
+      severity: "warning",
+      help: "Inspect the referenced catalog and supply the intended record if this is a custom context."
+    });
+  }
+  for (const [index, contract] of (options.contracts ?? []).entries()) {
+    const pattern = parts(contract.path), stack = [{ value: document, path: [], depth: 0 }];
+    while (stack.length) {
+      const entry = stack.pop();
+      if (!entry) break;
+      if (entry.depth === pattern.length) {
+        if (contract.allowedValues.some((value) => Object.is(value, entry.value)))
+          continue;
+        const path = pointer(entry.path), definition = contract.documentation ?? `context#/contracts/${index}`, values = {
+          path,
+          value: JSON.stringify(entry.value),
+          allowed: contract.allowedValues.map((value) => JSON.stringify(value)).join(", "),
+          file: definition
+        };
+        const message = (contract.message ?? "This value is outside the allowed values for {{path}}.").replace(
+          /\{\{(path|value|allowed|file)\}\}/g,
+          (_, key) => values[key] ?? ""
+        );
+        diagnostics.push({
+          ruleId: "opf/contract",
+          severity: contract.severity ?? "error",
+          scope: "document",
+          path,
+          message,
+          help: `Use one of the configured values: ${values.allowed}. This is an explicit host policy; no source was changed.`,
+          definition,
+          suggestions: contract.allowedValues.map((value) => ({
+            value,
+            label: String(value),
+            origin: "contract",
+            definition
+          }))
+        });
+      } else if (object(entry.value) || Array.isArray(entry.value)) {
+        const key = pattern[entry.depth];
+        for (const [name, value] of Object.entries(entry.value))
+          if (key === "*" || key === name)
+            stack.push({
+              value,
+              path: [...entry.path, name],
+              depth: entry.depth + 1
+            });
+      }
+    }
+  }
+  return report(diagnostics, validation.valid, "not-applicable");
+}
+function lintSource(source, options = {}) {
+  optionsChecked(options);
+  const errors = [], tree = parseTree(
+    source.startsWith("\uFEFF") ? " " + source.slice(1) : source,
+    errors,
+    {
+      disallowComments: true,
+      allowTrailingComma: false,
+      allowEmptyContent: false
+    }
+  );
+  const lineStarts = [0];
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === "\r") {
+      if (source[i + 1] === "\n") i++;
+      lineStarts.push(i + 1);
+    } else if (source[i] === "\n") lineStarts.push(i + 1);
+  }
+  const location = (offset, length) => {
+    let lo = 0, hi = lineStarts.length;
+    while (lo + 1 < hi) {
+      const mid = lo + hi >> 1;
+      if ((lineStarts[mid] ?? 0) <= offset) lo = mid;
+      else hi = mid;
+    }
+    return {
+      offset,
+      length,
+      line: lo + 1,
+      column: offset - (lineStarts[lo] ?? 0) + 1
+    };
+  };
+  if (errors.length || !tree)
+    return report(
+      errors.map((error) => ({
+        ruleId: "json/syntax",
+        severity: "error",
+        scope: "document",
+        path: "",
+        message: printParseErrorCode(error.error),
+        help: "Repair the JSON syntax at this source range. No content or whitespace has been rewritten.",
+        location: location(error.offset, error.length)
+      })),
+      null,
+      "checked"
+    );
+  const diagnostics = [], stack = [tree];
+  while (stack.length) {
+    const node = stack.pop();
+    if (!node) break;
+    if (node.type === "object") {
+      const keys = /* @__PURE__ */ new Set();
+      for (const property of node.children ?? []) {
+        const key = property.children?.[0];
+        if (!key) continue;
+        if (keys.has(key.value))
+          diagnostics.push({
+            ruleId: "json/duplicate-key",
+            severity: "error",
+            scope: "document",
+            path: pointer(getNodePath(key)),
+            message: `Duplicate JSON property ${JSON.stringify(key.value)}.`,
+            help: "Resolve the duplicate explicitly, preserving the intended content from both occurrences. JSON.parse would otherwise hide an earlier value.",
+            location: location(key.offset, key.length)
+          });
+        keys.add(key.value);
+      }
+    }
+    stack.push(...node.children ?? []);
+  }
+  const result = lintPresentation(
+    JSON.parse(source.replace(/^\uFEFF/, "")),
+    options
+  );
+  for (const diagnostic of result.diagnostics) {
+    if (diagnostic.scope === "document") {
+      let node = tree;
+      for (const part of parts(diagnostic.path))
+        node = node?.type === "array" ? node.children?.[Number(part)] : node?.type === "object" ? node.children?.find(
+          (property) => property.children?.[0]?.value === part
+        )?.children?.[1] : void 0;
+      if (node) diagnostic.location = location(node.offset, node.length);
+    }
+    diagnostics.push(diagnostic);
+  }
+  return report(diagnostics, result.schemaValid, "checked");
+}
+
+export { lintPresentation, lintSource };