@blue-labs/repository-generator 4.0.2-rc.0 → 4.1.0

package/dist/generateRepository-B7eem2l_.mjs

@@ -0,0 +1,969 @@
+import * as D from "path";
+import k from "path";
+import A from "fs";
+import { Properties as G, yamlBlueParse as q, MergingProcessors as B, Blue as j, createNodeProvider as H, BlueNode as X, BlueIdCalculator as Z } from "@blue-labs/language";
+import { OBJECT_CONTRACTS as Q, RESERVED_ATTRIBUTES_POINTER_SEGMENTS as ee, validateAttributesAddedPointer as te, parsePointer as ne, OBJECT_SCHEMA as T, validateStableDoesNotDependOnDev as re } from "@blue-labs/repository-contract";
+import oe from "fast-json-patch";
+import se from "js-yaml";
+const V = /* @__PURE__ */ new Set([...G.CORE_TYPES]), x = G.CORE_TYPE_NAME_TO_BLUE_ID_MAP, O = "Blue Repository", m = {
+  Dev: "dev",
+  Stable: "stable"
+}, ie = /* @__PURE__ */ new Set([
+  ".git",
+  ".github",
+  ".husky",
+  "node_modules",
+  ".nx",
+  ".vscode",
+  ".idea"
+]);
+function ae(e) {
+  const r = A.readdirSync(e, { withFileTypes: !0 }), n = /* @__PURE__ */ new Map();
+  for (const t of r) {
+    if (!t.isDirectory() || ie.has(t.name))
+      continue;
+    const o = k.join(e, t.name), s = W(o);
+    if (s.length !== 0)
+      for (const a of s) {
+        const c = a.endsWith(".dev.blue") ? m.Dev : m.Stable, i = ce(a), f = ue(i, a), u = `${t.name}/${f}`, l = n.get(u);
+        if (l)
+          throw l.status !== c ? new Error(
+            `Type ${u} has both stable and dev definitions (${l.filePath} and ${a}).`
+          ) : new Error(
+            `Type ${u} is defined multiple times (${l.filePath} and ${a}).`
+          );
+        const y = fe(i, a);
+        n.set(u, {
+          packageName: t.name,
+          typeName: f,
+          status: c,
+          content: i,
+          filePath: a,
+          references: y
+        });
+      }
+  }
+  return n;
+}
+function ce(e) {
+  const r = A.readFileSync(e, "utf8"), n = q(r);
+  if (!C(n))
+    throw new Error(`Type file ${e} must contain a YAML object.`);
+  return n;
+}
+function ue(e, r) {
+  if (!C(e) || typeof e.name != "string")
+    throw new Error(`Type file ${r} is missing required "name" field.`);
+  return e.name;
+}
+function W(e) {
+  const r = A.readdirSync(e, { withFileTypes: !0 }), n = [];
+  for (const t of r) {
+    if (t.isDirectory()) {
+      n.push(...W(k.join(e, t.name)));
+      continue;
+    }
+    (t.name.endsWith(".blue") || t.name.endsWith(".dev.blue")) && n.push(k.join(e, t.name));
+  }
+  return n;
+}
+function fe(e, r) {
+  const n = /* @__PURE__ */ new Set(), t = (o) => {
+    if (Array.isArray(o)) {
+      o.forEach((a) => t(a));
+      return;
+    }
+    if (!C(o))
+      return;
+    const s = (a) => {
+      if (typeof a == "string" && !V.has(a)) {
+        if (!a.includes("/"))
+          throw new Error(
+            `Invalid type reference "${a}" in ${r}. Use <Package>/<Type> for non-primitive references.`
+          );
+        n.add(a);
+      }
+    };
+    s(o.type), s(o.itemType), s(o.keyType), s(o.valueType), Object.values(o).forEach((a) => t(a));
+  };
+  return t(e), n;
+}
+function C(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function le(e) {
+  const r = /* @__PURE__ */ new Map();
+  for (const [n, t] of e) {
+    const o = /* @__PURE__ */ new Set();
+    for (const s of t.references) {
+      if (!e.has(s))
+        throw new Error(
+          `Type ${n} references unknown alias ${s}. Ensure the target type exists.`
+        );
+      o.add(s);
+    }
+    r.set(n, o);
+  }
+  return r;
+}
+function de(e) {
+  const r = [], n = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), o = [], s = /* @__PURE__ */ new Set();
+  let a = 0;
+  const c = (i) => {
+    n.set(i, a), t.set(i, a), a += 1, o.push(i), s.add(i);
+    for (const u of e.get(i) ?? []) {
+      if (!n.has(u)) {
+        c(u), t.set(
+          i,
+          Math.min(
+            t.get(i) ?? 0,
+            t.get(u) ?? 0
+          )
+        );
+        continue;
+      }
+      s.has(u) && t.set(
+        i,
+        Math.min(t.get(i) ?? 0, n.get(u) ?? 0)
+      );
+    }
+    if (t.get(i) !== n.get(i))
+      return;
+    const f = [];
+    for (; o.length > 0; ) {
+      const u = o.pop();
+      if (!u || (s.delete(u), f.push(u), u === i))
+        break;
+    }
+    r.push(f.sort((u, l) => u.localeCompare(l)));
+  };
+  for (const i of e.keys())
+    n.has(i) || c(i);
+  return r;
+}
+function pe(e) {
+  const r = de(e), n = /* @__PURE__ */ new Map();
+  r.forEach((c, i) => {
+    c.forEach((f) => n.set(f, i));
+  });
+  const t = /* @__PURE__ */ new Map();
+  r.forEach(
+    (c, i) => t.set(i, /* @__PURE__ */ new Set())
+  );
+  for (const [c, i] of e) {
+    const f = n.get(c);
+    if (f !== void 0)
+      for (const u of i) {
+        const l = n.get(u);
+        l !== void 0 && l !== f && t.get(f)?.add(l);
+      }
+  }
+  const o = [], s = /* @__PURE__ */ new Set(), a = (c) => {
+    if (!s.has(c)) {
+      s.add(c);
+      for (const i of t.get(c) ?? [])
+        a(i);
+      o.push(c);
+    }
+  };
+  for (const c of t.keys())
+    a(c);
+  return o.map((c) => r[c] ?? []);
+}
+function ye(e, r) {
+  const n = /* @__PURE__ */ new Map(), t = (o, s = /* @__PURE__ */ new Set()) => {
+    if (n.has(o))
+      return n.get(o) ?? !1;
+    if (s.has(o))
+      return !1;
+    s.add(o);
+    const a = e.get(o) || /* @__PURE__ */ new Set();
+    for (const c of a) {
+      const i = r.get(c);
+      if (i && (i.status === m.Dev || t(c, s)))
+        return s.delete(o), n.set(o, !0), !0;
+    }
+    return s.delete(o), n.set(o, !1), !1;
+  };
+  for (const [o, s] of r)
+    if (s.status === m.Stable && t(o))
+      throw new Error(
+        `Stable type ${o} depends on a dev type. Stable types may only depend on other stable types.`
+      );
+}
+function I(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function h(e) {
+  return I(e) ? Object.getPrototypeOf(e) === Object.prototype : !1;
+}
+function S(e) {
+  if (Array.isArray(e))
+    return e.map((r) => S(r));
+  if (h(e)) {
+    const r = {};
+    for (const [n, t] of Object.entries(e))
+      r[n] = S(t);
+    return r;
+  }
+  return e;
+}
+function P(e) {
+  return e.map((r) => ({
+    repositoryVersionIndex: r.repositoryVersionIndex,
+    typeBlueId: r.typeBlueId,
+    attributesAdded: [...r.attributesAdded]
+  }));
+}
+const ge = /^\$\{([\s\S]*)\}$/;
+class me {
+  process(r, n) {
+    const t = n.getValue();
+    if (U(t)) {
+      const o = n.clone();
+      return o.setValue(t), o.setProperties(void 0), o.setItems(void 0), o.setType(void 0), o;
+    }
+    return r;
+  }
+  postProcess(r, n) {
+    const t = n.getValue();
+    if (U(t) && r.getValue() !== t) {
+      const o = r.clone();
+      return o.setValue(t), o;
+    }
+    return r;
+  }
+}
+function U(e) {
+  return typeof e != "string" || !ge.test(e) ? !1 : e.indexOf("${") === e.lastIndexOf("${");
+}
+function he() {
+  return new B.SequentialMergingProcessor([
+    new B.ValuePropagator(),
+    new me(),
+    new B.TypeAssigner(),
+    new B.ListProcessor(),
+    new B.DictionaryProcessor(),
+    new B.MetadataPropagator(),
+    new B.BasicTypesVerifier()
+  ]);
+}
+const Y = "00000000000000000000000000000000000000000000";
+function we(e, r, n, t) {
+  const o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), c = new j(), i = H((l) => be(l) ? [new X().setReferenceBlueId(l)] : Ie(a, l).map(
+    (y) => c.jsonValueToNode(y)
+  )), u = { blue: new j({
+    nodeProvider: i,
+    mergingProcessor: he()
+  }), contentByBlueId: a };
+  for (const l of e) {
+    if (Ee(l, n)) {
+      ve({
+        component: l,
+        discovered: r,
+        previousTypes: t,
+        aliasToBlueId: o,
+        aliasToStorageContent: s,
+        context: u
+      });
+      continue;
+    }
+    const y = l[0];
+    if (!y)
+      continue;
+    const g = r.get(y);
+    g && Be({
+      alias: y,
+      type: g,
+      previousTypes: t,
+      aliasToBlueId: o,
+      aliasToStorageContent: s,
+      context: u
+    });
+  }
+  return { aliasToBlueId: o, aliasToStorageContent: s };
+}
+function Ie(e, r) {
+  const n = J(r);
+  if (n === void 0)
+    return [];
+  const t = e.get(n.baseBlueId);
+  if (t === void 0)
+    return [];
+  if (n.index === void 0)
+    return Array.isArray(t) ? t : [t];
+  if (!Array.isArray(t))
+    return n.index === 0 ? [t] : [];
+  const o = t[n.index];
+  return o === void 0 ? [] : [o];
+}
+function J(e) {
+  const r = e.indexOf("#");
+  if (r === -1)
+    return { baseBlueId: e };
+  const n = e.slice(0, r), t = e.slice(r + 1), o = Number(t);
+  if (!(!Number.isInteger(o) || o < 0))
+    return { baseBlueId: n, index: o };
+}
+function be(e) {
+  return e === Y || /^this#\d+$/.test(e);
+}
+function $(e, r, n = !1, t = !1) {
+  if (Array.isArray(e))
+    return e.map(
+      (s) => $(
+        s,
+        r,
+        n,
+        t
+      )
+    );
+  if (!I(e))
+    return e;
+  const o = {};
+  for (const [s, a] of Object.entries(e)) {
+    const c = t || s === Q;
+    if ((s === "type" || s === "itemType" || s === "keyType" || s === "valueType") && typeof a == "string" && !(n && c)) {
+      if (V.has(a)) {
+        const i = x[a];
+        if (!i)
+          throw new Error(`Missing primitive BlueId for ${a}.`);
+        o[s] = { blueId: i };
+      } else {
+        const i = a, f = r(i);
+        if (!f)
+          throw new Error(`Missing BlueId for alias ${i}.`);
+        o[s] = { blueId: f };
+      }
+      continue;
+    }
+    o[s] = $(
+      a,
+      r,
+      n,
+      c
+    );
+  }
+  return o;
+}
+function Be({
+  alias: e,
+  type: r,
+  previousTypes: n,
+  aliasToBlueId: t,
+  aliasToStorageContent: o,
+  context: s
+}) {
+  const { node: a, storageContent: c } = N(
+    r,
+    (g) => t.get(g),
+    s.blue
+  ), i = V.has(r.typeName), f = i ? Pe(r.typeName) : s.blue.calculateBlueIdSync(a), u = K(
+    n,
+    r,
+    c
+  ), l = u?.blueId ?? f, y = u?.content ?? c;
+  t.set(e, l), o.set(e, y), i || s.contentByBlueId.set(l, y), s.blue.registerBlueIds({ [e]: l });
+}
+function ve({
+  component: e,
+  discovered: r,
+  previousTypes: n,
+  aliasToBlueId: t,
+  aliasToStorageContent: o,
+  context: s
+}) {
+  const a = new Set(e), c = /* @__PURE__ */ new Map();
+  e.forEach((d, p) => c.set(d, p));
+  const i = e.map((d) => {
+    const p = M(r, d), { node: b } = N(
+      p,
+      (w) => a.has(w) ? Y : t.get(w),
+      s.blue
+    );
+    return {
+      alias: d,
+      preliminaryBlueId: s.blue.calculateBlueIdSync(b)
+    };
+  });
+  Te(i), i.sort(ke);
+  const f = /* @__PURE__ */ new Map();
+  i.forEach(({ alias: d }, p) => {
+    f.set(d, p);
+  });
+  const u = /* @__PURE__ */ new Map();
+  for (const d of e) {
+    const p = M(r, d), b = N(
+      p,
+      (w) => {
+        if (!a.has(w))
+          return t.get(w);
+        const _ = f.get(w);
+        if (_ === void 0)
+          throw new Error(`Failed to resolve cyclic reference ${w}.`);
+        return `this#${_}`;
+      },
+      s.blue
+    );
+    u.set(d, b);
+  }
+  const l = Ae(
+    e,
+    r,
+    n,
+    u
+  );
+  if (l) {
+    for (const d of e) {
+      const p = l.get(d);
+      if (!p)
+        throw new Error(`Failed to preserve cyclic BlueId for type ${d}.`);
+      t.set(d, p.blueId), o.set(d, p.content), s.blue.registerBlueIds({ [d]: p.blueId });
+    }
+    Se(s.contentByBlueId, l);
+    return;
+  }
+  const y = i.map(({ alias: d }) => {
+    const p = u.get(d);
+    if (!p)
+      throw new Error(`Failed to build cyclic content for type ${d}.`);
+    return p.node;
+  }), g = i.map(({ alias: d }) => {
+    const p = u.get(d);
+    if (!p)
+      throw new Error(`Failed to build cyclic content for type ${d}.`);
+    return p.storageContent;
+  }), E = s.blue.calculateBlueIdSync(y);
+  s.contentByBlueId.set(E, g), i.forEach(({ alias: d }, p) => {
+    const b = u.get(d);
+    if (!b)
+      throw new Error(`Failed to build cyclic content for type ${d}.`);
+    const w = `${E}#${p}`;
+    t.set(d, w), o.set(d, b.storageContent), s.blue.registerBlueIds({ [d]: w });
+  });
+}
+function Ee(e, r) {
+  if (e.length > 1)
+    return !0;
+  const n = e[0];
+  return n ? r.get(n)?.has(n) ?? !1 : !1;
+}
+function N(e, r, n) {
+  const t = $(
+    S(e.content),
+    r
+  ), o = n.jsonValueToNode(t);
+  return {
+    node: o,
+    storageContent: n.nodeToJson(o, "official")
+  };
+}
+function M(e, r) {
+  const n = e.get(r);
+  if (!n)
+    throw new Error(`Unknown type alias ${r}.`);
+  return n;
+}
+function Ae(e, r, n, t) {
+  const o = /* @__PURE__ */ new Map();
+  for (const s of e) {
+    const a = M(r, s), c = t.get(s);
+    if (!c)
+      throw new Error(`Failed to build cyclic content for type ${s}.`);
+    const i = K(
+      n,
+      a,
+      c.storageContent
+    );
+    if (!i)
+      return null;
+    o.set(s, i);
+  }
+  return o;
+}
+function K(e, r, n) {
+  const t = e.get(r.packageName)?.get(r.typeName), o = t?.versions?.at(-1)?.typeBlueId;
+  return !o || !t || !h(t.content) || !R(t.content, n) ? null : {
+    blueId: o,
+    content: S(t.content)
+  };
+}
+function Se(e, r) {
+  const n = /* @__PURE__ */ new Map();
+  for (const { blueId: t, content: o } of r.values()) {
+    const s = J(t);
+    if (!s || s.index === void 0) {
+      e.set(t, o);
+      continue;
+    }
+    const a = n.get(s.baseBlueId) ?? [];
+    a.push({ index: s.index, content: o }), n.set(s.baseBlueId, a);
+  }
+  for (const [t, o] of n) {
+    const a = [...o].sort((c, i) => c.index - i.index).map((c, i) => {
+      if (c.index !== i)
+        throw new Error(
+          `Cyclic repository content for ${t} is missing index ${i}.`
+        );
+      return c.content;
+    });
+    e.set(t, a);
+  }
+}
+function Te(e) {
+  const r = /* @__PURE__ */ new Map();
+  for (const n of e) {
+    const t = r.get(n.preliminaryBlueId);
+    if (t)
+      throw new Error(
+        `Direct cyclic type set has ambiguous canonical ordering: ${t} and ${n.alias} share preliminary BlueId '${n.preliminaryBlueId}'.`
+      );
+    r.set(n.preliminaryBlueId, n.alias);
+  }
+}
+function ke(e, r) {
+  return e.preliminaryBlueId < r.preliminaryBlueId ? -1 : e.preliminaryBlueId > r.preliminaryBlueId ? 1 : 0;
+}
+function R(e, r) {
+  if (e === r)
+    return !0;
+  if (Array.isArray(e) || Array.isArray(r))
+    return !Array.isArray(e) || !Array.isArray(r) || e.length !== r.length ? !1 : e.every((n, t) => R(n, r[t]));
+  if (h(e) || h(r)) {
+    if (!h(e) || !h(r))
+      return !1;
+    const n = Object.keys(e).sort(), t = Object.keys(r).sort();
+    return n.length !== t.length ? !1 : n.every(
+      (o, s) => o === t[s] && R(e[o], r[o])
+    );
+  }
+  return !1;
+}
+function Pe(e) {
+  const r = x[e];
+  if (!r)
+    throw new Error(`Missing primitive BlueId for ${e}.`);
+  return r;
+}
+const F = new Set(Object.values(x)), $e = /* @__PURE__ */ new Set([
+  "type",
+  "itemType",
+  "valueType",
+  "keyType"
+]), Ne = /* @__PURE__ */ new Set(["name", "description"]), v = {
+  Unchanged: "unchanged",
+  NonBreaking: "non-breaking",
+  Breaking: "breaking"
+};
+function Me(e, r, n, t, o) {
+  const s = oe.compare(
+    e,
+    r
+  );
+  if (s.length === 0)
+    return { status: v.Unchanged, attributesAdded: [] };
+  const a = [];
+  let c = !1;
+  for (const i of s) {
+    if (Oe(i, e, o)) {
+      c = !0;
+      continue;
+    }
+    if (i.op !== "add")
+      return { status: v.Breaking, attributesAdded: [] };
+    if (!Ve(i))
+      return { status: v.Breaking, attributesAdded: [] };
+    a.push(i.path);
+  }
+  return a.length === 0 && !c ? {
+    status: v.Breaking,
+    attributesAdded: []
+  } : (a.length > 0 && Re(a, n, t), { status: v.NonBreaking, attributesAdded: a });
+}
+function Re(e, r, n) {
+  for (const t of e)
+    try {
+      te(t);
+    } catch (o) {
+      throw new Error(
+        `Invalid attribute pointer "${t}" for ${r}/${n}: ${o.message}`
+      );
+    }
+}
+function Ve(e) {
+  if (e.op !== "add")
+    return !1;
+  const r = z(e.path);
+  if (r.length === 0)
+    return !1;
+  const n = r.at(-1);
+  return n && /^\d+$/.test(n) || n && $e.has(n) || r.some(
+    (t) => ee.has(t)
+  ) ? !1 : I(e.value) ? !xe(e.value) : n ? Ne.has(n) : !1;
+}
+function z(e) {
+  try {
+    return ne(e);
+  } catch {
+    return [];
+  }
+}
+function xe(e) {
+  const r = [e];
+  for (; r.length; ) {
+    const n = r.pop();
+    if (n) {
+      if (Object.prototype.hasOwnProperty.call(n, "value") || Object.prototype.hasOwnProperty.call(n, "items"))
+        return !0;
+      if (Object.prototype.hasOwnProperty.call(n, T)) {
+        const t = n[T];
+        if (I(t) && t.required === !0)
+          return !0;
+      }
+      for (const [t, o] of Object.entries(n))
+        t !== T && I(o) && r.push(o);
+    }
+  }
+  return !1;
+}
+function Oe(e, r, n) {
+  if (e.op !== "replace" || typeof e.path != "string")
+    return !1;
+  const t = z(e.path);
+  if (t.length < 2)
+    return !1;
+  const o = t.at(-1), s = t.at(-2);
+  if (!(o === "blueId" && s !== void 0 && (s === "type" || s === "itemType" || s === "keyType" || s === "valueType")))
+    return !1;
+  const a = Ce(r, t), c = typeof a == "string" ? a : I(a) && typeof a.blueId == "string" ? a.blueId : null, i = typeof e.value == "string" ? e.value : I(e.value) && typeof e.value.blueId == "string" ? e.value.blueId : null;
+  if (c && F.has(c) || i && F.has(i) || !c || !i)
+    return !1;
+  const f = n.get(c), u = n.get(i);
+  if (!f || !u)
+    return !1;
+  for (const l of f)
+    if (u.has(l))
+      return !0;
+  return !1;
+}
+function Ce(e, r) {
+  let n = e;
+  for (const t of r)
+    if (Array.isArray(n)) {
+      const o = Number(t);
+      if (Number.isNaN(o) || o < 0 || o >= n.length)
+        return;
+      n = n[o];
+    } else if (I(n))
+      n = n[t];
+    else
+      return;
+  return n;
+}
+function _e(e) {
+  const r = /* @__PURE__ */ new Map();
+  if (!e)
+    return r;
+  for (const n of e.packages || []) {
+    if (typeof n.name != "string")
+      continue;
+    const t = /* @__PURE__ */ new Map();
+    for (const o of n.types || []) {
+      const s = o.content, a = h(s) && typeof s.name == "string" ? s.name : void 0;
+      a && t.set(a, o);
+    }
+    r.set(n.name, t);
+  }
+  return r;
+}
+function De(e, r) {
+  for (const [n, t] of r)
+    for (const [o, s] of t) {
+      const a = `${n}/${o}`;
+      if (!e.has(a) && s.status === m.Stable)
+        throw new Error(
+          `Stable type ${a} was removed. Breaking changes require a new logical type name.`
+        );
+    }
+}
+function je({
+  discovered: e,
+  previousTypes: r,
+  aliasToBlueId: n,
+  aliasToStorageContent: t,
+  nextRepoVersionIndex: o
+}) {
+  const s = /* @__PURE__ */ new Map(), a = Ue(r, n);
+  for (const [c, i] of e) {
+    const f = n.get(c);
+    if (!f)
+      throw new Error(`Failed to compute BlueId for type ${c}.`);
+    const u = r.get(i.packageName)?.get(i.typeName) ?? null;
+    if (u && u.status === m.Stable && i.status === m.Dev)
+      throw new Error(
+        `Type ${c} was stable previously and cannot be downgraded to dev. Use a new logical name instead.`
+      );
+    const l = t.get(c) ?? i.content, y = i.status === m.Dev ? Fe({ blueId: f, nextRepoVersionIndex: o, previousType: u }) : !u || u.status === m.Dev ? Le({ blueId: f, nextRepoVersionIndex: o }) : Ge({
+      alias: c,
+      blueId: f,
+      nextRepoVersionIndex: o,
+      previousType: u,
+      currentContent: l,
+      packageName: i.packageName,
+      typeName: i.typeName,
+      blueIdAliases: a
+    });
+    y.content = l, y.status = i.status;
+    const g = s.get(i.packageName) ?? [];
+    g.push(y), s.set(i.packageName, g);
+  }
+  return s;
+}
+function Ue(e, r) {
+  const n = /* @__PURE__ */ new Map(), t = (o, s) => {
+    const a = n.get(o);
+    if (a) {
+      a.add(s);
+      return;
+    }
+    n.set(o, /* @__PURE__ */ new Set([s]));
+  };
+  for (const [o, s] of e)
+    for (const [a, c] of s) {
+      const i = `${o}/${a}`;
+      for (const f of c.versions ?? [])
+        typeof f.typeBlueId == "string" && t(f.typeBlueId, i);
+    }
+  for (const [o, s] of r)
+    t(s, o);
+  return n;
+}
+function Fe({
+  blueId: e,
+  nextRepoVersionIndex: r,
+  previousType: n
+}) {
+  const t = n && n.status === m.Dev ? n : null, o = t?.versions?.length === 1 ? t.versions[0] : null, s = o && o.typeBlueId === e;
+  return {
+    status: m.Dev,
+    content: {},
+    versions: s && t?.versions ? P(t.versions) : [
+      {
+        repositoryVersionIndex: r,
+        typeBlueId: e,
+        attributesAdded: []
+      }
+    ]
+  };
+}
+function Le({
+  blueId: e,
+  nextRepoVersionIndex: r
+}) {
+  return {
+    status: m.Stable,
+    content: {},
+    versions: [
+      {
+        repositoryVersionIndex: r,
+        typeBlueId: e,
+        attributesAdded: []
+      }
+    ]
+  };
+}
+function Ge({
+  alias: e,
+  blueId: r,
+  nextRepoVersionIndex: n,
+  previousType: t,
+  currentContent: o,
+  packageName: s,
+  typeName: a,
+  blueIdAliases: c
+}) {
+  if (!h(t.content))
+    throw new Error(
+      `Type ${e} has non-object content; cannot compute diff for stable versioning.`
+    );
+  const i = Me(
+    t.content,
+    o,
+    s,
+    a,
+    c
+  );
+  if (i.status === v.Unchanged) {
+    const f = P(t.versions || []), u = f.at(-1);
+    if (u && u.typeBlueId !== r)
+      throw new Error(
+        `Type ${e} content is unchanged but BlueId differs from previous metadata.`
+      );
+    return {
+      status: m.Stable,
+      content: {},
+      versions: f
+    };
+  }
+  if (i.status === v.NonBreaking)
+    return {
+      status: m.Stable,
+      content: {},
+      versions: [
+        ...P(t.versions || []),
+        {
+          repositoryVersionIndex: n,
+          typeBlueId: r,
+          attributesAdded: i.attributesAdded
+        }
+      ]
+    };
+  throw new Error(
+    `Breaking change detected in stable type ${e}. Introduce a new type name for breaking changes.`
+  );
+}
+function qe(e) {
+  return Array.from(e.entries()).map(([r, n]) => ({
+    name: r,
+    types: n.map((t) => ({
+      ...t,
+      versions: [...t.versions].sort(
+        (o, s) => o.repositoryVersionIndex - s.repositoryVersionIndex
+      )
+    })).sort((t, o) => {
+      const s = h(t.content) && typeof t.content.name == "string" ? t.content.name : "", a = h(o.content) && typeof o.content.name == "string" ? o.content.name : "";
+      return s.localeCompare(a);
+    })
+  })).sort((r, n) => r.name.localeCompare(n.name));
+}
+function L(e) {
+  return Z.INSTANCE.calculateSync(
+    e
+  );
+}
+function We(e, r, n) {
+  const t = r?.repositoryVersions.at(-1), o = !t || t !== n, s = r?.repositoryVersions ? [...r.repositoryVersions] : [];
+  return o && s.push(n), { document: {
+    name: O,
+    packages: e,
+    repositoryVersions: s
+  }, changed: o };
+}
+function Ye(e, r, n) {
+  const t = {
+    name: O,
+    repositoryVersions: r,
+    packages: Je(e, n)
+  };
+  re(t);
+}
+function Je(e, r) {
+  const n = {};
+  for (const t of e) {
+    const o = Ke(t.name, r), s = {}, a = {};
+    for (const c of t.types) {
+      const i = c.versions?.[c.versions.length - 1]?.typeBlueId;
+      if (!i)
+        throw new Error(
+          `Type ${t.name} is missing a current BlueId in versions.`
+        );
+      const f = ze(c);
+      s[i] = {
+        status: c.status,
+        name: f,
+        versions: c.versions ?? []
+      }, a[i] = c.content;
+    }
+    n[t.name] = {
+      name: t.name,
+      aliases: o,
+      typesMeta: s,
+      contents: a,
+      schemas: {}
+    };
+  }
+  return n;
+}
+function Ke(e, r) {
+  const n = {}, t = `${e}/`;
+  return r.forEach((o, s) => {
+    s.startsWith(t) && (n[s] = o);
+  }), n;
+}
+function ze(e) {
+  const r = h(e.content) && typeof e.content.name == "string" ? e.content.name : null;
+  if (!r)
+    throw new Error('Type content is missing required "name" field.');
+  return r;
+}
+function He(e) {
+  if (!A.existsSync(e))
+    return { previous: null };
+  const r = A.readFileSync(e, "utf8"), n = q(r);
+  if (!n || !I(n))
+    throw new Error("Existing BlueRepository.blue is not a valid object.");
+  const t = n, o = t.packages, s = t.repositoryVersions, a = Array.isArray(o) && o.every(
+    (l) => I(l) && typeof l.name == "string" && Array.isArray(l.types)
+  ), c = Array.isArray(s) && s.every((l) => typeof l == "string");
+  if (!a || !c)
+    throw new Error(
+      "Invalid BlueRepository.blue structure: expected { packages: BluePackage[], repositoryVersions: string[] }"
+    );
+  const i = o, f = s, u = {
+    name: typeof t.name == "string" ? t.name : O,
+    packages: i,
+    repositoryVersions: f
+  };
+  return { existingYaml: r, previous: u };
+}
+function Xe(e) {
+  return se.dump(e, { lineWidth: -1 });
+}
+function st(e) {
+  const r = D.resolve(e.repoRoot), n = D.resolve(e.blueRepositoryPath), { existingYaml: t, previous: o } = He(n), s = ae(r), a = _e(o);
+  De(s, a);
+  const c = le(s), i = pe(c);
+  ye(c, s);
+  const { aliasToBlueId: f, aliasToStorageContent: u } = we(
+    i,
+    s,
+    c,
+    a
+  ), l = o ? o.repositoryVersions.length : 0, y = je({
+    discovered: s,
+    previousTypes: a,
+    aliasToBlueId: f,
+    aliasToStorageContent: u,
+    nextRepoVersionIndex: l
+  }), g = qe(y), E = o && Ze(o.packages, g) ? o.repositoryVersions.at(-1) ?? L(g) : L(g), { document: d, changed: p } = We(
+    g,
+    o,
+    E
+  );
+  Ye(
+    d.packages,
+    d.repositoryVersions,
+    f
+  );
+  const b = Xe(d);
+  if (o && !p && t && t !== b)
+    throw new Error(
+      "BlueRepository.blue content differs from regenerated output while RepoBlueId is unchanged. Please revert manual edits or rerun in write mode."
+    );
+  return e.verbose && console.info(
+    `[repository-generator] RepoBlueId: ${E} (${p ? "changed" : "unchanged"})`
+  ), {
+    document: d,
+    currentRepoBlueId: E,
+    previousRepoBlueId: o?.repositoryVersions.at(-1),
+    changed: p || !t,
+    yaml: b,
+    existingYaml: t
+  };
+}
+function Ze(e, r) {
+  return JSON.stringify(e) === JSON.stringify(r);
+}
+export {
+  st as g
+};