@blue-labs/language 4.1.1 → 5.0.0-rc.0

package/dist/conformance.mjs

@@ -0,0 +1,1258 @@
+import h from "node:fs";
+import a from "node:path";
+import { createHash as re } from "node:crypto";
+import { fileURLToPath as _ } from "node:url";
+import se from "js-yaml";
+import O from "node:assert/strict";
+import { am as v, c as P, p as C, q as ne, an as y, ao as L, ap as oe, aq as ae, ar as ce, y as le, s as ue, C as de, g as D, as as he, N as fe, at as pe, l as ye, au as ge, av as me } from "./Blue-B7SYp5QY.mjs";
+import "big.js";
+import { OBJECT_CONTRACTS as x } from "@blue-labs/repository-contract";
+class Ie {
+  static toBlueIdInput(e) {
+    return e.isListElementContext() ? v.getListElement(e.toNode(), 0) : v.get(e.toNode());
+  }
+}
+class u {
+  constructor(e, i = !1, r = !1, s = !0, o = !1) {
+    this.strictCanonical = i, this.resolvedStructural = r, this.strictBlueIdValidation = s, this.listElementContext = o, this.name = e.getName(), this.description = e.getDescription(), this.type = this.freezeChild(e.getType(), !1), this.itemType = this.freezeChild(e.getItemType(), !1), this.keyType = this.freezeChild(e.getKeyType(), !1), this.valueType = this.freezeChild(e.getValueType(), !1), this.value = e.getValue(), this.items = this.freezeItems(e.getItems()), this.properties = this.freezeProperties(e.getProperties()), this.contracts = this.freezeChild(e.getContractsNode(), !1), this.referenceBlueId = e.getReferenceBlueId(), this.schema = e.getSchema()?.clone(), this.mergePolicy = e.getMergePolicy(), this.previousBlueId = e.getPreviousBlueId(), this.position = e.getPosition(), this.blue = this.freezeChild(e.getBlue(), !1), this.inlineValue = e.isInlineValue(), this.validatePayloadShape(), this.blueIdValue = this.computeBlueId();
+  }
+  name;
+  description;
+  type;
+  itemType;
+  keyType;
+  valueType;
+  value;
+  items;
+  properties;
+  contracts;
+  referenceBlueId;
+  schema;
+  mergePolicy;
+  previousBlueId;
+  position;
+  blue;
+  inlineValue;
+  blueIdValue;
+  static empty() {
+    return new u(new P(), !0, !1);
+  }
+  static fromNode(e) {
+    return new u(e, !0, !1);
+  }
+  static fromResolvedNode(e) {
+    return new u(e, !1, !0, !1);
+  }
+  static fromUncheckedCanonicalNode(e) {
+    return new u(e, !0, !1, !1);
+  }
+  static calculateBlueId(e) {
+    return C.calculateBlueIdSync(
+      e.map((i) => i.toNode())
+    );
+  }
+  toNode() {
+    const e = new P().setName(this.name).setDescription(this.description).setType(this.type?.toNode()).setItemType(this.itemType?.toNode()).setKeyType(this.keyType?.toNode()).setValueType(this.valueType?.toNode()).setReferenceBlueId(this.referenceBlueId).setSchema(this.schema?.clone()).setMergePolicy(this.mergePolicy).setPreviousBlueId(this.previousBlueId).setPosition(this.position).setBlue(this.blue?.toNode()).setInlineValue(this.inlineValue);
+    return this.value !== void 0 && e.setValue(this.value), this.items !== void 0 && e.setItems(this.items.map((i) => i.toNode())), this.properties !== void 0 && e.setProperties(
+      Object.fromEntries(
+        Object.entries(this.properties).map(([i, r]) => [
+          i,
+          r.toNode()
+        ])
+      )
+    ), this.contracts !== void 0 && e.setContractsNode(this.contracts.toNode()), e;
+  }
+  blueId() {
+    return this.blueIdValue;
+  }
+  getName() {
+    return this.name;
+  }
+  getDescription() {
+    return this.description;
+  }
+  getType() {
+    return this.type;
+  }
+  getItemType() {
+    return this.itemType;
+  }
+  getKeyType() {
+    return this.keyType;
+  }
+  getValueType() {
+    return this.valueType;
+  }
+  getValue() {
+    return this.value;
+  }
+  getItems() {
+    return this.items;
+  }
+  getProperties() {
+    return this.properties;
+  }
+  getContracts() {
+    return this.contracts;
+  }
+  getReferenceBlueId() {
+    return this.referenceBlueId;
+  }
+  getSchema() {
+    return this.schema?.clone();
+  }
+  getMergePolicy() {
+    return this.mergePolicy;
+  }
+  getPreviousBlueId() {
+    return this.previousBlueId;
+  }
+  getPosition() {
+    return this.position;
+  }
+  getBlue() {
+    return this.blue;
+  }
+  isInlineValue() {
+    return this.inlineValue;
+  }
+  property(e) {
+    return e === x ? this.contracts : this.properties?.[e];
+  }
+  item(e) {
+    return e >= 0 ? this.items?.[e] : void 0;
+  }
+  at(e) {
+    const i = typeof e == "string" ? this.pointerSegments(e) : e.map(String);
+    return u.atSegments(this, i);
+  }
+  static atSegments(e, i) {
+    let r = e;
+    for (const s of i) {
+      if (r === void 0)
+        return;
+      r.items !== void 0 && s !== x ? r = r.item(u.parseArrayIndex(s)) : r = r.property(s);
+    }
+    return r;
+  }
+  pathIndex() {
+    const e = /* @__PURE__ */ new Map();
+    return this.indexPaths("/", e), e;
+  }
+  hasItems() {
+    return this.items !== void 0;
+  }
+  hasProperties() {
+    return this.properties !== void 0;
+  }
+  isReferenceOnly() {
+    return this.referenceBlueId !== void 0 && this.name === void 0 && this.description === void 0 && this.type === void 0 && this.itemType === void 0 && this.keyType === void 0 && this.valueType === void 0 && (this.value === void 0 || this.value === null) && this.items === void 0 && this.properties === void 0 && this.contracts === void 0 && this.schema === void 0 && this.mergePolicy === void 0 && this.previousBlueId === void 0 && this.position === void 0 && this.blue === void 0;
+  }
+  isPreviousOnly() {
+    return this.previousBlueId !== void 0 && this.name === void 0 && this.description === void 0 && this.type === void 0 && this.itemType === void 0 && this.keyType === void 0 && this.valueType === void 0 && (this.value === void 0 || this.value === null) && this.items === void 0 && this.properties === void 0 && this.contracts === void 0 && this.schema === void 0 && this.mergePolicy === void 0 && this.position === void 0 && this.blue === void 0 && this.referenceBlueId === void 0;
+  }
+  isStrictCanonical() {
+    return this.strictCanonical;
+  }
+  isResolvedStructural() {
+    return this.resolvedStructural;
+  }
+  isStrictBlueIdValidation() {
+    return this.strictBlueIdValidation;
+  }
+  isListElementContext() {
+    return this.listElementContext;
+  }
+  isEmptyNode() {
+    return this.name === void 0 && this.description === void 0 && this.type === void 0 && this.itemType === void 0 && this.keyType === void 0 && this.valueType === void 0 && (this.value === void 0 || this.value === null) && this.items === void 0 && this.properties === void 0 && this.contracts === void 0 && this.referenceBlueId === void 0 && this.schema === void 0 && this.mergePolicy === void 0 && this.previousBlueId === void 0 && this.position === void 0 && this.blue === void 0;
+  }
+  withProperty(e, i) {
+    const r = this.toNode();
+    if (e === x)
+      r.setContractsNode(this.nodeOrUndefined(i));
+    else if (i === void 0)
+      r.removeProperty(e);
+    else {
+      const s = i instanceof u ? i.toNode() : i.clone();
+      r.addProperty(e, s);
+    }
+    return new u(
+      r,
+      this.strictCanonical,
+      this.resolvedStructural,
+      this.strictBlueIdValidation,
+      this.listElementContext
+    );
+  }
+  withItems(e) {
+    const i = this.toNode();
+    return i.setItems(
+      e.map(
+        (r) => r instanceof u ? r.toNode() : r.clone()
+      )
+    ), new u(
+      i,
+      this.strictCanonical,
+      this.resolvedStructural,
+      this.strictBlueIdValidation,
+      this.listElementContext
+    );
+  }
+  withoutPosition() {
+    if (this.position === void 0)
+      return this;
+    const e = this.toNode();
+    return e.setPosition(void 0), new u(
+      e,
+      this.strictCanonical,
+      this.resolvedStructural,
+      this.strictBlueIdValidation,
+      this.listElementContext
+    );
+  }
+  freezeChild(e, i) {
+    return e === void 0 ? void 0 : new u(
+      e,
+      this.strictCanonical,
+      this.resolvedStructural,
+      this.strictBlueIdValidation,
+      i
+    );
+  }
+  freezeItems(e) {
+    if (e !== void 0)
+      return Object.freeze(
+        e.map(
+          (i) => new u(
+            i,
+            this.strictCanonical,
+            this.resolvedStructural,
+            this.strictBlueIdValidation,
+            !0
+          )
+        )
+      );
+  }
+  freezeProperties(e) {
+    if (e === void 0)
+      return;
+    const i = Object.entries(e).flatMap(([r, s]) => {
+      if (r === x)
+        return [];
+      const o = new u(
+        s,
+        this.strictCanonical,
+        this.resolvedStructural,
+        this.strictBlueIdValidation,
+        !1
+      );
+      return this.strictCanonical && o.isEmptyNode() ? [] : [[r, o]];
+    });
+    return i.length === 0 ? void 0 : Object.freeze(Object.fromEntries(i));
+  }
+  validatePayloadShape() {
+    if ([
+      this.value !== void 0 && this.value !== null,
+      this.items !== void 0,
+      this.properties !== void 0 && Object.keys(this.properties).length > 0
+    ].filter(Boolean).length > 1)
+      throw new Error(
+        "A Blue node may contain only one payload kind: value, items, or object fields."
+      );
+    if (this.strictCanonical && this.referenceBlueId !== void 0 && !this.isReferenceOnly())
+      throw new Error(
+        '"blueId" nodes must be reference-only and cannot contain sibling fields.'
+      );
+    if (this.strictCanonical && this.previousBlueId !== void 0) {
+      if (!this.isPreviousOnly())
+        throw new Error(
+          '"$previous" list anchors must be single-key list items.'
+        );
+      if (!this.listElementContext)
+        throw new Error(
+          '"$previous" is valid only as the first list item in direct BlueId input.'
+        );
+    }
+    if (this.strictCanonical && this.blue !== void 0)
+      throw new Error(
+        '"blue" is a preprocessing directive and must not appear in canonical BlueId input.'
+      );
+    if (this.strictCanonical && this.position !== void 0)
+      throw new Error('"$pos" overlays are not valid direct BlueId input.');
+  }
+  computeBlueId() {
+    return this.strictCanonical ? this.strictBlueIdValidation ? C.calculateBlueIdInputSync(
+      Ie.toBlueIdInput(this)
+    ) : C.calculateBlueIdSync(this.toNode()) : this.isReferenceOnly() ? this.referenceBlueId : C.calculateBlueIdWithResolvedBlueIdMetadataSync(
+      this.toNode()
+    );
+  }
+  nodeOrUndefined(e) {
+    if (e !== void 0)
+      return e instanceof u ? e.toNode() : e.clone();
+  }
+  indexPaths(e, i) {
+    i.set(e, this), this.items?.forEach(
+      (r, s) => r.indexPaths(this.appendPointer(e, String(s)), i)
+    ), Object.entries(this.properties ?? {}).forEach(
+      ([r, s]) => s.indexPaths(this.appendPointer(e, r), i)
+    ), this.contracts?.indexPaths(
+      this.appendPointer(e, x),
+      i
+    );
+  }
+  pointerSegments(e) {
+    return e === "" || e === "/" ? [] : e.replace(/^\//, "").split("/").filter((i) => i.length > 0).map((i) => i.replace(/~1/g, "/").replace(/~0/g, "~"));
+  }
+  appendPointer(e, i) {
+    const r = i.replace(/~/g, "~0").replace(/\//g, "~1");
+    return e === "/" ? `/${r}` : `${e}/${r}`;
+  }
+  static parseArrayIndex(e) {
+    const i = Number(e);
+    return Number.isInteger(i) && i >= 0 ? i : -1;
+  }
+}
+const J = "sha256:3387cb4b6626fc56cec91d584b2df7f37c229e396dee990750ac50e762a1bc1d", ve = 77;
+class Be {
+  constructor(e, i, r, s, o, E, p) {
+    this.specVersion = e, this.fixturePackageIdentity = i, this.passedIds = r, this.failed = s, this.identityMatches = o, this.requiredCoverage = E, this.exactFixtureSet = p;
+  }
+  fixturePackageIdentityMatchesFixtureFiles() {
+    return this.identityMatches;
+  }
+  hasRequiredFixtureCoverage() {
+    return this.requiredCoverage;
+  }
+  hasExactRequiredFixtureSet() {
+    return this.exactFixtureSet;
+  }
+  passedFixtureIds() {
+    return [...this.passedIds];
+  }
+  failedFixtureIds() {
+    return this.failed.map((e) => e.fixtureId);
+  }
+  failures() {
+    return [...this.failed];
+  }
+}
+const k = a.dirname(_(import.meta.url)), xe = Oe([
+  a.join(k, "fixtures/blue-language-1.0"),
+  a.join(k, "lib/conformance/fixtures/blue-language-1.0"),
+  a.resolve(
+    process.cwd(),
+    "libs/language/src/lib/conformance/fixtures/blue-language-1.0"
+  )
+]), N = a.join(xe, "fixtures"), Ee = a.join(N, "manifest.yaml");
+function Ce() {
+  return Se() === J;
+}
+function be() {
+  return R().length === ve;
+}
+function we() {
+  const t = new Set(
+    R().map((i) => i.path)
+  ), e = Ne(N).filter(
+    (i) => i !== "manifest.yaml"
+  );
+  return e.length === t.size && e.every((i) => t.has(i));
+}
+function R() {
+  const t = Pe();
+  if (!Array.isArray(t.fixtures))
+    throw new Error('Fixture manifest field "fixtures" must be a list.');
+  return t.fixtures.map((e) => {
+    if (!$(e))
+      throw new Error("Fixture manifest entries must be objects.");
+    const i = z(b(e, "path"));
+    return {
+      id: b(e, "id"),
+      category: b(e, "category"),
+      path: b(e, "path"),
+      operation: $(i) ? Re(i, "operation") : void 0
+    };
+  });
+}
+function Pe() {
+  return z("manifest.yaml");
+}
+function z(t) {
+  const e = se.load(
+    h.readFileSync(a.join(N, t), "utf8")
+  );
+  if (!$(e))
+    throw new Error(`Fixture ${t} must be an object.`);
+  return e;
+}
+function Se() {
+  const t = R(), e = re("sha256");
+  e.update(`manifest.yaml
+`, "utf8"), e.update(
+    Te(h.readFileSync(Ee, "utf8")),
+    "utf8"
+  );
+  for (const i of t)
+    e.update(`
+--- ${i.path}
+`, "utf8"), e.update(
+      H(
+        h.readFileSync(a.join(N, i.path), "utf8")
+      ),
+      "utf8"
+    );
+  return `sha256:${e.digest("hex")}`;
+}
+function Te(t) {
+  const e = H(t);
+  if (!/^fixturePackageIdentity:.*$/m.test(e))
+    throw new Error("Manifest is missing fixturePackageIdentity line.");
+  return e.replace(
+    /^fixturePackageIdentity:.*$/m,
+    'fixturePackageIdentity: ""'
+  );
+}
+function H(t) {
+  return t.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+}
+function Ne(t) {
+  return X(t).filter((e) => e.endsWith(".yaml") || e.endsWith(".yml")).map((e) => a.relative(t, e).split(a.sep).join("/")).sort();
+}
+function X(t) {
+  return h.readdirSync(t, { withFileTypes: !0 }).flatMap((e) => {
+    const i = a.join(t, e.name);
+    return e.isDirectory() ? X(i) : [i];
+  });
+}
+function b(t, e) {
+  const i = t[e];
+  if (i == null)
+    throw new Error(`Fixture field "${e}" is required.`);
+  return String(i);
+}
+function Re(t, e) {
+  const i = t[e];
+  return i == null ? void 0 : String(i);
+}
+function $(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+function Oe(t) {
+  for (const e of t)
+    if (h.existsSync(e) && h.statSync(e).isDirectory())
+      return e;
+  throw new Error(
+    `Blue Language conformance fixtures are missing. Checked: ${t.join(
+      ", "
+    )}`
+  );
+}
+function l(t, e) {
+  return new $e(t, e);
+}
+class $e {
+  constructor(e, i) {
+    this.actual = e, this.message = i, this.not = new je(e, i);
+  }
+  not;
+  toBe(e) {
+    O.equal(this.actual, e, this.message);
+  }
+  toEqual(e) {
+    O.deepEqual(this.actual, e, this.message);
+  }
+}
+class je {
+  constructor(e, i) {
+    this.actual = e, this.message = i;
+  }
+  toBe(e) {
+    O.notEqual(this.actual, e, this.message);
+  }
+}
+const Ae = /* @__PURE__ */ new Set([oe, ae, ce]);
+class d {
+  static hashProvider = new ne();
+  static calculateBlueIdSync(e) {
+    return this.calculateInputSync(v.get(e));
+  }
+  static calculateBlueIdAllowingCyclicPlaceholdersSync(e) {
+    return this.calculateInputSync(
+      v.getAllowingCyclicPlaceholders(e)
+    );
+  }
+  static calculateListBlueIdSync(e) {
+    return this.calculateInputSync(
+      e.map((i, r) => v.getListElement(i, r))
+    );
+  }
+  static calculateListBlueIdAllowingCyclicPlaceholdersSync(e) {
+    return this.calculateInputSync(
+      e.map(
+        (i, r) => v.getListElementAllowingCyclicPlaceholders(i, r)
+      )
+    );
+  }
+  static calculateInputSync(e) {
+    return this.calculateCleaned(this.cleanRoot(e));
+  }
+  static calculateCleaned(e) {
+    return this.isScalar(e) ? this.hashProvider.applySync(e) : Array.isArray(e) ? this.calculateList(e) : this.calculateMap(e);
+  }
+  static calculateMap(e) {
+    if (Object.keys(e).length === 1 && typeof e[y] == "string")
+      return e[y];
+    const i = {};
+    for (const r of Object.keys(e).sort()) {
+      const s = e[r];
+      Ae.has(r) ? i[r] = s : i[r] = {
+        [y]: this.calculateCleaned(s)
+      };
+    }
+    return this.hashProvider.applySync(i);
+  }
+  static calculateList(e) {
+    let i = this.hashProvider.applySync({ $list: "empty" }), r = 0;
+    e.length > 0 && this.isPreviousControl(e[0]) && (i = this.previousBlueId(e[0]), r = 1);
+    for (let s = r; s < e.length; s++) {
+      const o = this.calculateCleaned(e[s]);
+      i = this.hashProvider.applySync({
+        $listCons: {
+          elem: { [y]: o },
+          prev: { [y]: i }
+        }
+      });
+    }
+    return i;
+  }
+  static cleanRoot(e) {
+    if (e == null)
+      throw new Error("Root null is not valid BlueId input.");
+    if (this.isScalar(e))
+      return e;
+    if (Array.isArray(e))
+      return e.map((r) => this.cleanRoot(r));
+    const i = {};
+    for (const [r, s] of Object.entries(e)) {
+      const o = this.cleanObjectField(s);
+      o !== void 0 && (i[r] = o);
+    }
+    return i;
+  }
+  static cleanObjectField(e) {
+    if (e == null)
+      return;
+    if (this.isScalar(e))
+      return e;
+    if (Array.isArray(e))
+      return e.map((r) => this.cleanRoot(r));
+    const i = {};
+    for (const [r, s] of Object.entries(e)) {
+      const o = this.cleanObjectField(s);
+      o !== void 0 && (i[r] = o);
+    }
+    return Object.keys(i).length === 0 ? void 0 : i;
+  }
+  static isPreviousControl(e) {
+    if (typeof e != "object" || e === null || Array.isArray(e) || Object.keys(e).length !== 1)
+      return !1;
+    const i = e[L];
+    return typeof i == "object" && i !== null && !Array.isArray(i) && Object.keys(i).length === 1 && typeof i[y] == "string";
+  }
+  static previousBlueId(e) {
+    return e[L][y];
+  }
+  static isScalar(e) {
+    return typeof e == "string" || typeof e == "number" || typeof e == "boolean";
+  }
+}
+const M = a.dirname(_(import.meta.url)), S = et([
+  a.join(M, "fixtures/blue-language-1.0"),
+  a.join(M, "lib/conformance/fixtures/blue-language-1.0"),
+  a.resolve(
+    process.cwd(),
+    "libs/language/src/lib/conformance/fixtures/blue-language-1.0"
+  )
+]), G = a.join(S, "fixtures"), Fe = a.join(
+  S,
+  "registry",
+  "blue-language-1.0"
+), Ve = /* @__PURE__ */ new Set([
+  "parseSource",
+  "parseBlueIdInput",
+  "calculateBlueId",
+  "calculateCircularSetBlueIds",
+  "preprocess",
+  "resolve",
+  "canonicalize",
+  "calculateContentBlueId",
+  "calculateSemanticBlueId",
+  "expand",
+  "collapse",
+  "assertSameNodeBlueId",
+  "registryNodeHashesToPublishedBlueId",
+  "changingRegistryDescriptionChangesBlueId",
+  "lintPublishableDocumentation",
+  "assertViewPath"
+]), Le = /* @__PURE__ */ new Set([
+  "alsoDifferentFrom",
+  "alsoEquivalentTo",
+  "assertions",
+  "category",
+  "description",
+  "document",
+  "documents",
+  "expectBlueIdChanged",
+  "expectError",
+  "expectedBlueIds",
+  "expectedCanonicalOverlay",
+  "expectedCollapsed",
+  "expectedContentBlueId",
+  "expectedErrorCategories",
+  "expectedErrorCategory",
+  "expectedExpanded",
+  "expectedNodeBlueId",
+  "expectedParsed",
+  "expectedPreprocessed",
+  "expectedPublishedBlueId",
+  "expectedResolved",
+  "forbiddenJoinedTerms",
+  "id",
+  "input",
+  "left",
+  "matchRule",
+  "mutation",
+  "operation",
+  "provider",
+  "publishableFiles",
+  "registryKey",
+  "registryKind",
+  "requiredHeadings",
+  "right",
+  "semanticDescriptionIdentityBearing",
+  "source"
+]), W = {
+  Boolean: "Boolean.blue",
+  Dictionary: "Dictionary.blue",
+  Double: "Double.blue",
+  Integer: "Integer.blue",
+  List: "List.blue",
+  Text: "Text.blue"
+}, De = A(
+  a.join(G, "manifest.yaml")
+);
+if (process.env.CI && process.env.BLUE_FIXTURE)
+  throw new Error("BLUE_FIXTURE must not be set in CI conformance runs.");
+const ke = De.fixtures.filter((t) => {
+  const e = process.env.BLUE_FIXTURE;
+  return e === void 0 || t.id.includes(e);
+});
+function xt() {
+  return [...ke];
+}
+async function Et(t = {}) {
+  const e = R(), i = Ce(), r = be(), s = we(), o = [], E = [];
+  i || o.push(
+    w("manifest", "Manifest", "identity", "identity mismatch")
+  ), r || o.push(
+    w(
+      "manifest",
+      "Manifest",
+      "coverage",
+      "fixture coverage is incomplete"
+    )
+  ), s || o.push(
+    w(
+      "manifest",
+      "Manifest",
+      "fixture-set",
+      "fixture set is not exact"
+    )
+  );
+  for (const p of e)
+    try {
+      qe(p, t.mutateFixture), E.push(p.id);
+    } catch (V) {
+      o.push(
+        w(
+          p.id,
+          p.category,
+          p.operation ?? "unknown",
+          Me(V),
+          V
+        )
+      );
+    }
+  return new Be(
+    "1.0",
+    J,
+    E,
+    o,
+    i,
+    r,
+    s
+  );
+}
+function w(t, e, i, r, s) {
+  return {
+    fixtureId: t,
+    category: e,
+    operation: i,
+    message: r,
+    cause: s instanceof Error ? s.message : void 0,
+    classification: s instanceof Error ? s.name : void 0
+  };
+}
+function Me(t) {
+  return t instanceof Error ? t.message : String(t);
+}
+function qe(t, e) {
+  const i = A(
+    a.join(G, t.path)
+  ), r = e?.(t, i) ?? i;
+  l(r.id).toBe(t.id), l(r.category).toBe(t.category), Ue(r);
+}
+function Ue(t) {
+  if (Ke(t), j(t.operation), t.expectError === !0) {
+    Je(t);
+    return;
+  }
+  _e(t);
+  const e = Y(t);
+  switch (t.operation) {
+    case "calculateBlueId":
+    case "assertSameNodeBlueId":
+      l(e).toBe(
+        n(t.expectedNodeBlueId, "expectedNodeBlueId")
+      ), t.operation === "calculateBlueId" && (ot(e, t.alsoEquivalentTo), at(e, t.alsoDifferentFrom));
+      return;
+    case "calculateCircularSetBlueIds":
+      l(e).toEqual(n(t.expectedBlueIds, "expectedBlueIds"));
+      return;
+    case "calculateContentBlueId":
+    case "calculateSemanticBlueId":
+      l(e).toBe(
+        n(t.expectedContentBlueId, "expectedContentBlueId")
+      );
+      return;
+    case "parseSource":
+    case "parseBlueIdInput":
+      I(t.expectedParsed, e);
+      return;
+    case "preprocess":
+      I(t.expectedPreprocessed, e);
+      return;
+    case "resolve":
+      I(t.expectedResolved, e);
+      return;
+    case "canonicalize":
+      I(t.expectedCanonicalOverlay, e), ct(e);
+      return;
+    case "expand":
+      I(t.expectedExpanded, e), K(t, e, t.source);
+      return;
+    case "collapse":
+      I(t.expectedCollapsed, e), K(t, e, t.source);
+      return;
+    case "registryNodeHashesToPublishedBlueId":
+      l(e).toBe(
+        n(t.expectedPublishedBlueId, "expectedPublishedBlueId")
+      );
+      return;
+    case "changingRegistryDescriptionChangesBlueId":
+      l(e).toBe(
+        n(t.expectBlueIdChanged, "expectBlueIdChanged")
+      );
+      return;
+    case "lintPublishableDocumentation":
+    case "assertViewPath":
+      l(e).toBe(!0);
+      return;
+  }
+}
+function Y(t) {
+  j(t.operation);
+  const e = new ue({ nodeProvider: nt(t.provider) });
+  switch (t.operation) {
+    case "parseSource":
+      return c(n(t.source, "source"));
+    case "parseBlueIdInput": {
+      const i = c(n(t.input, "input"));
+      return d.calculateBlueIdSync(i), i;
+    }
+    case "calculateBlueId": {
+      const i = c(n(t.input, "input")), r = d.calculateBlueIdSync(i);
+      return l(u.fromNode(i).blueId()).toBe(r), r;
+    }
+    case "calculateCircularSetBlueIds": {
+      const r = c(n(t.documents, "documents")).getItems();
+      if (r === void 0)
+        throw new Error("calculateCircularSetBlueIds requires documents list.");
+      return new de({
+        calculateBlueId: (s) => Array.isArray(s) ? d.calculateListBlueIdAllowingCyclicPlaceholdersSync(
+          s
+        ) : d.calculateBlueIdAllowingCyclicPlaceholdersSync(
+          s
+        )
+      }).calculate(r).documentBlueIds;
+    }
+    case "preprocess":
+      return e.preprocess(c(n(t.source, "source")));
+    case "resolve":
+      return e.resolve(c(n(t.source, "source")));
+    case "canonicalize":
+      return q(e, c(n(t.source, "source")));
+    case "calculateContentBlueId":
+    case "calculateSemanticBlueId":
+      return d.calculateBlueIdSync(
+        q(e, c(n(t.source, "source")))
+      );
+    case "expand":
+      return B(c(n(t.source, "source")), e);
+    case "collapse":
+      return new P().setReferenceBlueId(
+        d.calculateBlueIdSync(
+          c(n(t.source, "source"))
+        )
+      );
+    case "assertSameNodeBlueId": {
+      const i = d.calculateBlueIdSync(
+        c(n(t.left, "left"))
+      ), r = d.calculateBlueIdSync(
+        c(n(t.right, "right"))
+      );
+      return l(i).toBe(r), i;
+    }
+    case "registryNodeHashesToPublishedBlueId":
+      return Ge(t);
+    case "changingRegistryDescriptionChangesBlueId":
+      return We(t);
+    case "lintPublishableDocumentation":
+      return Qe(t), !0;
+    case "assertViewPath":
+      return it(t), !0;
+  }
+}
+function Ke(t) {
+  for (const e of Object.keys(t))
+    if (!Le.has(e))
+      throw new Error(`Unsupported fixture field "${e}" in ${t.id}.`);
+}
+function _e(t) {
+  switch (j(t.operation), t.operation) {
+    case "calculateBlueId":
+    case "assertSameNodeBlueId":
+      n(t.expectedNodeBlueId, "expectedNodeBlueId");
+      return;
+    case "calculateCircularSetBlueIds":
+      n(t.expectedBlueIds, "expectedBlueIds");
+      return;
+    case "calculateContentBlueId":
+    case "calculateSemanticBlueId":
+      n(t.expectedContentBlueId, "expectedContentBlueId");
+      return;
+    case "parseSource":
+    case "parseBlueIdInput":
+      n(t.expectedParsed, "expectedParsed");
+      return;
+    case "preprocess":
+      n(t.expectedPreprocessed, "expectedPreprocessed");
+      return;
+    case "resolve":
+      n(t.expectedResolved, "expectedResolved");
+      return;
+    case "canonicalize":
+      n(t.expectedCanonicalOverlay, "expectedCanonicalOverlay");
+      return;
+    case "expand":
+      n(t.expectedExpanded, "expectedExpanded");
+      return;
+    case "collapse":
+      n(t.expectedCollapsed, "expectedCollapsed");
+      return;
+    case "registryNodeHashesToPublishedBlueId":
+      n(t.expectedPublishedBlueId, "expectedPublishedBlueId");
+      return;
+    case "changingRegistryDescriptionChangesBlueId":
+      n(t.expectBlueIdChanged, "expectBlueIdChanged");
+      return;
+    case "lintPublishableDocumentation":
+      if (n(t.publishableFiles, "publishableFiles"), (t.requiredHeadings?.length ?? 0) === 0 && (t.forbiddenJoinedTerms?.length ?? 0) === 0)
+        throw new Error(
+          "lintPublishableDocumentation requires at least one lint assertion."
+        );
+      return;
+    case "assertViewPath":
+      n(t.assertions, "assertions");
+      return;
+  }
+}
+function j(t) {
+  if (!Ve.has(t))
+    throw new Error(
+      `Unsupported Blue Language fixture operation: ${t}`
+    );
+}
+function Je(t) {
+  let e;
+  try {
+    Y(t);
+  } catch (i) {
+    e = i;
+  }
+  if (e === void 0)
+    throw new Error(
+      `Fixture ${t.id} expected an error, but none was thrown.`
+    );
+  ze(t, e);
+}
+function ze(t, e) {
+  const i = [
+    ...t.expectedErrorCategory === void 0 ? [] : [t.expectedErrorCategory],
+    ...t.expectedErrorCategories ?? []
+  ];
+  if (i.length === 0)
+    return;
+  const r = He(e);
+  if (r === void 0 || !i.includes(r))
+    throw new Error(
+      `Fixture ${t.id} expected error category ${i.join(
+        " or "
+      )}, got ${r ?? "unclassified"} from ${Q(
+        e
+      )}.`
+    );
+}
+function He(t) {
+  const e = me(t);
+  if (e !== void 0)
+    return e;
+  const i = Xe(t), r = Q(t).toLowerCase();
+  if (i === "BLUE_ID_MISMATCH" || r.includes("provider") && r.includes("blueid") && (r.includes("mismatch") || r.includes("returned content")) || r.includes("calculated blueid"))
+    return "ProviderBlueIdMismatch";
+  if (r.includes("duplicate preliminary") || r.includes("circular") || r.includes("cyclic"))
+    return "CircularSetError";
+  if (r.includes("$previous"))
+    return "ListControlViolation";
+  if (r.includes("unresolved alias") || r.includes("unresolved type alias") || r.includes("invalid blueid input") || r.includes("invalid blueid") || r.includes("$pos") || r.includes("$replace") || r.includes("empty-object list element") || r.includes("root null"))
+    return "InvalidBlueIdInput";
+  if (r.includes("applies to wrong kind") || r.includes("multiple of") || r.includes("multipleof") || r.includes("minimum") || r.includes("maxlength") || r.includes("minlength"))
+    return "SchemaViolation";
+  if (r.includes("schema") && (r.includes("vocabulary") || r.includes("schema.required") || r.includes("must be a list") || r.includes("must be an array") || r.includes("must be a boolean")))
+    return "SchemaVocabularyError";
+  if (r.includes("schema"))
+    return "SchemaViolation";
+}
+function Xe(t) {
+  return F(t) && typeof t.code == "string" ? t.code : void 0;
+}
+function Q(t) {
+  return t instanceof Error ? `${t.name}: ${t.message}` : String(t);
+}
+function Ge(t) {
+  const e = Z(t), i = ee(e), r = d.calculateBlueIdSync(i);
+  return l(r).toBe(he[e]), t.semanticDescriptionIdentityBearing === !0 && l(
+    d.calculateBlueIdSync(
+      te(i, { field: "description", append: " " })
+    )
+  ).not.toBe(r), r;
+}
+function We(t) {
+  const e = Z(t), i = ee(e), r = te(
+    i,
+    n(t.mutation, "mutation")
+  );
+  return d.calculateBlueIdSync(i) !== d.calculateBlueIdSync(r);
+}
+function Z(t) {
+  const e = n(t.registryKind, "registryKind");
+  if (e !== "Blue Language core type registry")
+    throw new Error(`Unsupported registry kind: ${e}`);
+  const i = n(t.registryKey, "registryKey");
+  if (!Ye(i))
+    throw new Error(`Unsupported core registry key: ${i}`);
+  return i;
+}
+function Ye(t) {
+  return t in W;
+}
+function ee(t) {
+  return lt(
+    a.join(Fe, W[t])
+  );
+}
+function te(t, e) {
+  const i = t.clone();
+  switch (e.field) {
+    case "description":
+      return i.setDescription(
+        `${i.getDescription() ?? ""}${e.append ?? ""}`
+      ), i;
+    default:
+      throw new Error(`Unsupported registry mutation field: ${e.field}`);
+  }
+}
+function Qe(t) {
+  const e = n(t.publishableFiles, "publishableFiles");
+  for (const i of e) {
+    const r = Ze(i);
+    for (const s of t.requiredHeadings ?? [])
+      if (!r.includes(s))
+        throw new Error(
+          `Publishable file ${i} is missing required heading: ${s}`
+        );
+    for (const s of t.forbiddenJoinedTerms ?? []) {
+      const o = tt(s);
+      if (r.includes(o))
+        throw new Error(
+          `Publishable file ${i} contains forbidden text: ${o}`
+        );
+    }
+  }
+}
+function Ze(t) {
+  const e = a.resolve(S, t), i = a.relative(S, e);
+  if (i.startsWith("..") || a.isAbsolute(i))
+    throw new Error(
+      `Publishable fixture path escapes fixture package: ${t}`
+    );
+  return h.readFileSync(e, "utf8");
+}
+function et(t) {
+  for (const e of t)
+    if (h.existsSync(e) && h.statSync(e).isDirectory())
+      return e;
+  throw new Error(
+    `Blue Language conformance fixtures are missing. Checked: ${t.join(
+      ", "
+    )}`
+  );
+}
+function tt(t) {
+  if (!Array.isArray(t.tokens) || typeof t.joiner != "string")
+    throw new Error("forbiddenJoinedTerms entries require tokens and joiner.");
+  return t.tokens.join(t.joiner);
+}
+function it(t) {
+  const e = T(c(n(t.document, "document"))), i = n(t.assertions, "assertions");
+  for (const r of i) {
+    const s = rt(e, r.path);
+    let o = !1;
+    if (r.expectedRoot === !0 && (l(s).toEqual(e), o = !0), r.expectedNode !== void 0 && (l(s).toEqual(
+      T(
+        c(n(r.expectedNode, "expectedNode"))
+      )
+    ), o = !0), !o)
+      throw new Error(
+        `View path assertion for ${r.path} has no expected value.`
+      );
+  }
+}
+function rt(t, e) {
+  if (e === "")
+    return t;
+  if (!e.startsWith("/"))
+    throw new Error(`Invalid view path: ${e}`);
+  return e.slice(1).split("/").reduce((i, r) => {
+    const s = st(r);
+    if (Array.isArray(i))
+      return /^(0|[1-9]\d*)$/.test(s) ? i[Number(s)] : void 0;
+    if (F(i))
+      return i[s];
+  }, t);
+}
+function st(t) {
+  return t.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function q(t, e) {
+  return new pe().reverseToCanonicalOverlay(
+    t.resolve(t.preprocess(e.clone()))
+  );
+}
+function nt(t) {
+  if (t == null)
+    return D(() => []);
+  if (!Array.isArray(t))
+    throw new Error("Fixture provider must be a list.");
+  const e = /* @__PURE__ */ new Map();
+  for (const i of t) {
+    if (!F(i))
+      throw new Error("Fixture provider entry must be an object.");
+    const r = String(i.requestedBlueId ?? i.blueId ?? ""), s = i.returnedNode ?? i.node;
+    if (r.length === 0 || s === void 0)
+      throw new Error(
+        "Fixture provider entries require requestedBlueId and node/returnedNode."
+      );
+    e.set(r, c(s));
+  }
+  return D((i) => {
+    const r = e.get(i);
+    return r === void 0 ? [] : [r.clone()];
+  });
+}
+function B(t, e) {
+  if (ie(t)) {
+    const r = t.getReferenceBlueId(), s = r ? e.getNodeProvider().fetchByBlueId(r) : null;
+    if (s === null || s.length === 0)
+      throw new Error(`No content found for blueId: ${r}`);
+    return s.length === 1 ? B(
+      U(s[0]),
+      e
+    ) : new P().setItems(
+      s.map(
+        (o) => B(U(o), e)
+      )
+    );
+  }
+  const i = t.clone();
+  return i.setType(m(i.getType(), e)), i.setItemType(m(i.getItemType(), e)), i.setKeyType(m(i.getKeyType(), e)), i.setValueType(m(i.getValueType(), e)), i.setBlue(m(i.getBlue(), e)), i.setContractsNode(m(i.getContractsNode(), e)), i.getItems() !== void 0 && i.setItems(
+    i.getItems()?.map((r) => B(r, e))
+  ), i.getProperties() !== void 0 && i.setProperties(
+    Object.fromEntries(
+      Object.entries(i.getProperties() ?? {}).map(([r, s]) => [
+        r,
+        B(s, e)
+      ])
+    )
+  ), i;
+}
+function m(t, e) {
+  return t === void 0 ? void 0 : B(t, e);
+}
+function U(t) {
+  const e = t.clone();
+  return e.getReferenceBlueId() !== void 0 && !ie(e) && e.setReferenceBlueId(void 0), e;
+}
+function I(t, e) {
+  const i = T(
+    c(n(t, "expectedNode"))
+  );
+  l(T(e)).toEqual(i);
+}
+function K(t, e, i) {
+  t.expectedNodeBlueId !== void 0 && (l(d.calculateBlueIdSync(e)).toBe(
+    t.expectedNodeBlueId
+  ), l(
+    d.calculateBlueIdSync(
+      c(n(i, "source"))
+    )
+  ).toBe(t.expectedNodeBlueId));
+}
+function ot(t, e) {
+  if (e == null)
+    return;
+  const i = Array.isArray(e) ? e : [e];
+  for (const r of i)
+    l(d.calculateBlueIdSync(c(r))).toBe(
+      t
+    );
+}
+function at(t, e) {
+  if (e == null)
+    return;
+  const i = Array.isArray(e) ? e : [e];
+  for (const r of i)
+    l(d.calculateBlueIdSync(c(r))).not.toBe(
+      t
+    );
+}
+function ct(t) {
+  d.calculateBlueIdSync(t), f(t, "/", !1);
+}
+function f(t, e, i) {
+  if (t !== void 0) {
+    if (t.getBlue() !== void 0)
+      throw new Error(`Canonical Overlay contains blue at ${e}`);
+    if (t.getPreviousBlueId() !== void 0)
+      throw new Error(`Canonical Overlay contains $previous at ${e}`);
+    if (t.getPosition() !== void 0)
+      throw new Error(`Canonical Overlay contains $pos at ${e}`);
+    if (t.getProperties()?.[ge] !== void 0)
+      throw new Error(`Canonical Overlay contains $replace at ${e}`);
+    if (i && ut(t) && !dt(t))
+      throw new Error(
+        `Canonical Overlay contains empty-object list element at ${e}`
+      );
+    f(
+      t.getType(),
+      g(e, "type"),
+      !1
+    ), f(
+      t.getItemType(),
+      g(e, "itemType"),
+      !1
+    ), f(
+      t.getKeyType(),
+      g(e, "keyType"),
+      !1
+    ), f(
+      t.getValueType(),
+      g(e, "valueType"),
+      !1
+    ), f(
+      t.getContractsNode(),
+      g(e, "contracts"),
+      !1
+    ), t.getItems()?.forEach(
+      (r, s) => f(
+        r,
+        g(e, String(s)),
+        !0
+      )
+    );
+    for (const [r, s] of Object.entries(t.getProperties() ?? {}))
+      f(s, g(e, r), !1);
+  }
+}
+function T(t) {
+  return ye.get(t, "official");
+}
+function c(t) {
+  return fe.deserialize(t);
+}
+function lt(t) {
+  return c(A(t));
+}
+function A(t) {
+  return n(
+    le(h.readFileSync(t, "utf8")),
+    t
+  );
+}
+function n(t, e) {
+  if (t === void 0)
+    throw new Error(`Fixture is missing required field: ${e}`);
+  return t;
+}
+function ie(t) {
+  return t.getReferenceBlueId() !== void 0 && t.getName() === void 0 && t.getDescription() === void 0 && t.getType() === void 0 && t.getItemType() === void 0 && t.getKeyType() === void 0 && t.getValueType() === void 0 && t.getValue() === void 0 && t.getItems() === void 0 && t.getProperties() === void 0 && t.getContractsNode() === void 0 && t.getSchema() === void 0 && t.getMergePolicy() === void 0;
+}
+function ut(t) {
+  return t.getName() === void 0 && t.getDescription() === void 0 && t.getType() === void 0 && t.getItemType() === void 0 && t.getKeyType() === void 0 && t.getValueType() === void 0 && t.getValue() === void 0 && t.getItems() === void 0 && t.getProperties() === void 0 && t.getContractsNode() === void 0 && t.getReferenceBlueId() === void 0 && t.getSchema() === void 0 && t.getMergePolicy() === void 0;
+}
+function dt(t) {
+  const e = t.getProperties();
+  return e !== void 0 && Object.keys(e).length === 1 && e.$empty?.getValue() === !0;
+}
+function g(t, e) {
+  return t === "/" || t.length === 0 ? `/${e}` : `${t}/${e}`;
+}
+function F(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+export {
+  ve as BLUE_LANGUAGE_1_0_FIXTURE_COUNT,
+  J as BLUE_LANGUAGE_1_0_FIXTURE_PACKAGE_IDENTITY,
+  Be as BlueLanguageConformanceReport,
+  Ce as fixturePackageIdentityMatchesFixtureFiles,
+  we as hasExactRequiredFixtureSet,
+  be as hasRequiredFixtureCoverage,
+  xt as languageConformanceFixtureEntries,
+  R as loadLanguageConformanceFixtureEntries,
+  Et as runLanguageConformanceSuite,
+  qe as runLanguageFixtureEntry,
+  Ue as runLanguageFixtureSpec
+};