@openpresentation/opf 0.12.2 → 0.14.0

package/dist/chunk-MWPMJE6P.js

@@ -1,622 +0,0 @@
-import { validatePresentation, unusedReferenceWarnings, validationDefinition, validateCatalogRecord } from './chunk-JKVKYVWL.js';
-import { catalogKinds, catalogEntries, catalogSchemaNames } from './chunk-E34DJ5LL.js';
-import { schemas, schemaEntries } from './chunk-4LAM3N6S.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) => typeof issue.params.code === "string" && issue.keyword === "opf" ? { ...schemaDiagnostic(issue), ruleId: `opf/${issue.params.code}` } : 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, replacedBy = issue.params.replacedBy;
-    if (typeof replacedBy === "string" && typeof id === "string") {
-      const target = catalogs.get(kind)?.get(replacedBy);
-      diagnostics.push({
-        ...schemaDiagnostic(issue),
-        ruleId: "opf/deprecated-catalog-id",
-        severity: "warning",
-        message: `Deprecated ${kind} catalog id ${JSON.stringify(id)}; use ${JSON.stringify(replacedBy)} instead.`,
-        help: "The deprecated id still resolves to its original record, so nothing breaks. Switch to the replacement when you next edit this reference.",
-        lookup: ["opf", "catalog", kind],
-        ...target ? { suggestions: [target] } : {}
-      });
-      continue;
-    }
-    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
-            });
-      }
-    }
-  }
-  for (const issue of unusedReferenceWarnings(document))
-    diagnostics.push({
-      ruleId: "opf/unused-reference",
-      severity: "warning",
-      scope: "document",
-      path: issue.path,
-      message: issue.message,
-      help: "Cite the reference from a text, bullet or list item run ({ text, cite: id }) so it is listed in that slide's footnote area, or remove the entry. Nothing is drawn for an uncited reference.",
-      definition: schemas.presentation.$id + "#/$defs/Reference",
-      lookup: ["opf", "schema", "presentation", "/$defs/Reference"],
-      validation: issue
-    });
-  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 };

package/dist/lint.d.ts

@@ -1,70 +0,0 @@
-import { C as CatalogKind } from './catalogs-BnI7JKcn.js';
-import { V as ValidationIssue } from './validator-DfG9yxba.js';
-import { J as JsonPrimitive } from './schemas-BSjlG8-R.js';
-import './presentation-DcF-MZcz.js';
-
-type LintSeverity = 'error' | 'warning' | 'info';
-interface LintLocation {
-    offset: number;
-    length: number;
-    line: number;
-    column: number;
-}
-interface LintSuggestion {
-    value: JsonPrimitive;
-    label: string;
-    origin: 'schema' | 'built-in' | 'loaded' | 'document' | 'contract';
-    definition: string;
-}
-interface LintDiagnostic {
-    ruleId: string;
-    severity: LintSeverity;
-    /** JSON Pointer into the document, or the explicitly supplied lint context. */
-    path: string;
-    scope: 'document' | 'context';
-    message: string;
-    help: string;
-    definition?: string;
-    lookup?: string[];
-    suggestions?: LintSuggestion[];
-    /** Full validation issue retained, including errors inside union alternatives. */
-    validation?: ValidationIssue;
-    /** Original-source UTF-16 offsets and one-based line/column. */
-    location?: LintLocation;
-}
-interface LintContract {
-    /** JSON Pointer pattern; a complete '*' segment matches one path segment. */
-    path: string;
-    allowedValues: JsonPrimitive[];
-    severity?: LintSeverity;
-    message?: string;
-    documentation?: string;
-}
-interface LintOptions {
-    /** Records already loaded by the host. This API never fetches catalog URLs. */
-    catalogs?: Partial<Record<CatalogKind, readonly unknown[]>>;
-    /** Explicit host policy. Document metadata is never interpreted as policy. */
-    contracts?: readonly LintContract[];
-}
-interface LintReport {
-    valid: boolean;
-    schemaValid: boolean | null;
-    diagnostics: LintDiagnostic[];
-    counts: Record<LintSeverity, number>;
-    checks: {
-        syntax: 'checked' | 'not-applicable';
-        schema: 'checked' | 'not-run';
-        catalogReferences: 'local-context' | 'not-run';
-        assetReferences: 'registry-only' | 'not-run';
-        contracts: 'checked' | 'not-run';
-        layout: 'not-checked';
-        fonts: 'not-checked';
-        nativeExport: 'not-checked';
-    };
-}
-/** Read-only lint with actionable schema, local catalog and explicit policy context. */
-declare function lintPresentation(document: unknown, options?: LintOptions): LintReport;
-/** Lint strict JSON source without normalizing whitespace or duplicate keys. */
-declare function lintSource(source: string, options?: LintOptions): LintReport;
-
-export { type LintContract, type LintDiagnostic, type LintLocation, type LintOptions, type LintReport, type LintSeverity, type LintSuggestion, lintPresentation, lintSource };