@boject/cli 0.0.1-rc.1

package/dist/perf/index.js

@@ -0,0 +1,1023 @@
+#!/usr/bin/env node
+
+// src/perf/prng.ts
+function rng(seed) {
+  let state = seed | 0;
+  if (state === 0) state = 1;
+  return () => {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    return (state >>> 0) / 4294967296;
+  };
+}
+function pickN(arr, n, rand) {
+  if (n > 0 && arr.length === 0)
+    throw new Error("pickN: cannot pick from empty array");
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    out.push(arr[Math.floor(rand() * arr.length)]);
+  }
+  return out;
+}
+function pickOne(arr, rand) {
+  if (arr.length === 0) throw new Error("pickOne: array must not be empty");
+  return arr[Math.floor(rand() * arr.length)];
+}
+function sampleWithoutReplacement(arr, n, rand) {
+  if (n >= arr.length) return [...arr];
+  const pool = [...arr];
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const idx = Math.floor(rand() * pool.length);
+    out.push(pool[idx]);
+    pool.splice(idx, 1);
+  }
+  return out;
+}
+function intInRange(min, max, rand) {
+  return Math.floor(rand() * (max - min + 1)) + min;
+}
+
+// src/perf/topoSort.ts
+var CycleRequiresNullError = class extends Error {
+  /**
+   * The set of nodes that remained when the algorithm got stuck.
+   * This is a *superset* of the actual cycle — it includes any node
+   * that was waiting on the cycle, transitively. The `requiredEdges`
+   * field is the precise set of edges that prevented further progress.
+   */
+  residual;
+  requiredEdges;
+  constructor(residual, requiredEdges) {
+    super(
+      `Stuck on residual nodes [${residual.join(", ")}]: cycle through them has only required edges; cannot defer. Make at least one edge optional. Required edges: ${requiredEdges.map((e) => `${e.from}.${e.field} \u2192 ${e.to}`).join(", ")}`
+    );
+    this.name = "CycleRequiresNullError";
+    this.residual = residual;
+    this.requiredEdges = requiredEdges;
+  }
+};
+function topoSort(identifiers, edges) {
+  const remainingEdges = [...edges];
+  const order = [];
+  const deferredEdges = [];
+  const remainingNodes = new Set(identifiers);
+  while (remainingNodes.size > 0) {
+    const ready = [...remainingNodes].find(
+      (n) => !remainingEdges.some((e) => e.from === n && remainingNodes.has(e.to))
+    );
+    if (ready) {
+      order.push(ready);
+      remainingNodes.delete(ready);
+      for (let i = remainingEdges.length - 1; i >= 0; i--) {
+        if (remainingEdges[i].from === ready) remainingEdges.splice(i, 1);
+      }
+      continue;
+    }
+    const cycleEdges = remainingEdges.filter(
+      (e) => remainingNodes.has(e.from) && remainingNodes.has(e.to)
+    );
+    const optional = cycleEdges.find((e) => !e.required);
+    if (!optional) {
+      throw new CycleRequiresNullError(
+        [...remainingNodes],
+        cycleEdges.filter((e) => e.required)
+      );
+    }
+    deferredEdges.push(optional);
+    const idx = remainingEdges.indexOf(optional);
+    remainingEdges.splice(idx, 1);
+  }
+  return { order, deferredEdges };
+}
+
+// src/perf/valueGen/lorem.ts
+var LOREM = "Lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua Ut enim ad minim veniam quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur Excepteur sint occaecat cupidatat non proident sunt in culpa qui officia deserunt mollit anim id est laborum Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium totam rem aperiam".split(" ");
+
+// src/perf/valueGen/scalars.ts
+function titleCase(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function generateEntryTitle(opts) {
+  const wordCount = intInRange(3, 6, opts.rand);
+  const words = pickN(LOREM, wordCount, opts.rand).map(titleCase).join(" ");
+  return `${words} #${opts.index}`;
+}
+function generateSlug(opts) {
+  const base = opts.entryTitle.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  return `${base}-${opts.index}`;
+}
+function generateText(opts) {
+  const value = pickN(LOREM, intInRange(4, 10, opts.rand), opts.rand).join(" ");
+  if (opts.unique && opts.seenValues) {
+    if (opts.seenValues.has(value)) {
+      const deduplicated = `${value}-${opts.index}`;
+      opts.seenValues.add(deduplicated);
+      return deduplicated;
+    }
+    opts.seenValues.add(value);
+  }
+  return value;
+}
+function generateTextarea(opts) {
+  const paragraphCount = intInRange(1, 3, opts.rand);
+  const paragraphs = [];
+  for (let i = 0; i < paragraphCount; i++) {
+    paragraphs.push(
+      pickN(LOREM, intInRange(40, 80, opts.rand), opts.rand).join(" ")
+    );
+  }
+  return paragraphs.join("\n\n");
+}
+function generateNumber(opts) {
+  if (opts.unique) {
+    return opts.index * 1e5 + intInRange(0, 99999, opts.rand);
+  }
+  return intInRange(0, 999999, opts.rand);
+}
+function generateBoolean(opts) {
+  return opts.rand() < 0.5;
+}
+function generateDatetime(opts) {
+  const span = opts.window.to.getTime() - opts.window.from.getTime();
+  const ts = opts.window.from.getTime() + Math.floor(opts.rand() * span);
+  return new Date(ts).toISOString();
+}
+function generateSelect(opts) {
+  if (opts.choices.length === 0) {
+    throw new Error(
+      "SELECT field requires options.choices \u2014 refusing to synthesise an empty value"
+    );
+  }
+  return pickOne(opts.choices, opts.rand);
+}
+
+// src/perf/valueGen/richtext.ts
+var LINK_INSERTION_PROBABILITY = 0.4;
+var MAX_EMBEDS_PER_DOC = 2;
+function paragraph(rand, linkPool) {
+  const wordCount = intInRange(70, 110, rand);
+  const text = pickN(LOREM, wordCount, rand).join(" ");
+  const usableLinkPool = linkPool.filter((p) => p.entryIds.length > 0);
+  const words = text.split(" ");
+  const canInsertLink = usableLinkPool.length > 0 && words.length >= 13 && rand() < LINK_INSERTION_PROBABILITY;
+  if (!canInsertLink) {
+    return {
+      type: "paragraph",
+      content: [{ type: "text", text }]
+    };
+  }
+  const linkStart = intInRange(2, words.length - 10, rand);
+  const linkLen = intInRange(3, 7, rand);
+  const prefix = words.slice(0, linkStart).join(" ");
+  const linked = words.slice(linkStart, linkStart + linkLen).join(" ");
+  const suffix = words.slice(linkStart + linkLen).join(" ");
+  const target = pickOne(usableLinkPool, rand);
+  const mark = {
+    type: "cmsLink",
+    attrs: {
+      contentTypeId: target.contentTypeId,
+      contentTypeIdentifier: target.contentTypeIdentifier,
+      entryId: pickOne(target.entryIds, rand)
+    }
+  };
+  return {
+    type: "paragraph",
+    content: [
+      { type: "text", text: prefix + " " },
+      { type: "text", text: linked, marks: [mark] },
+      { type: "text", text: " " + suffix }
+    ]
+  };
+}
+function heading(level, rand) {
+  return {
+    type: "heading",
+    attrs: { level },
+    content: [{ type: "text", text: pickN(LOREM, 5, rand).join(" ") }]
+  };
+}
+function bulletList(rand) {
+  const items = [];
+  const count = intInRange(3, 5, rand);
+  for (let i = 0; i < count; i++) {
+    items.push({
+      type: "listItem",
+      content: [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: pickN(LOREM, 8, rand).join(" ") }]
+        }
+      ]
+    });
+  }
+  return { type: "bulletList", content: items };
+}
+function embedNode(rand, pool) {
+  const usable = pool.filter((p) => p.entryIds.length > 0);
+  if (usable.length === 0) return null;
+  const target = pickOne(usable, rand);
+  return {
+    type: "cmsEmbed",
+    attrs: {
+      contentTypeId: target.contentTypeId,
+      contentTypeIdentifier: target.contentTypeIdentifier,
+      entryId: pickOne(target.entryIds, rand)
+    }
+  };
+}
+function generateRichtext(opts) {
+  const { rand, refPool } = opts;
+  const linkPool = refPool?.link ?? [];
+  const embedPool = refPool?.embed ?? [];
+  const content = [
+    heading(1, rand),
+    paragraph(rand, linkPool),
+    paragraph(rand, linkPool)
+  ];
+  const embedCount = intInRange(0, MAX_EMBEDS_PER_DOC, rand);
+  for (let i = 0; i < embedCount; i++) {
+    const node = embedNode(rand, embedPool);
+    if (node) content.push(node);
+  }
+  content.push(
+    heading(2, rand),
+    paragraph(rand, linkPool),
+    bulletList(rand),
+    paragraph(rand, linkPool),
+    heading(2, rand),
+    paragraph(rand, linkPool)
+  );
+  return { type: "doc", content };
+}
+
+// src/perf/valueGen/relations.ts
+function generateRelation(opts) {
+  const usable = opts.pool.filter((p) => p.entryIds.length > 0);
+  if (usable.length === 0) return null;
+  const target = pickOne(usable, opts.rand);
+  return {
+    contentTypeId: target.contentTypeId,
+    contentTypeIdentifier: target.contentTypeIdentifier,
+    entryId: pickOne(target.entryIds, opts.rand)
+  };
+}
+function generateMultirelation(opts) {
+  const usable = opts.pool.filter((p) => p.entryIds.length > 0);
+  if (usable.length === 0) return [];
+  const totalAvailable = usable.reduce((s, p) => s + p.entryIds.length, 0);
+  const cap = Math.min(opts.fanout.max, totalAvailable);
+  if (cap < opts.fanout.min) return [];
+  const n = intInRange(opts.fanout.min, cap, opts.rand);
+  if (n === 0) return [];
+  const flat = [];
+  for (const p of usable) {
+    for (const eid of p.entryIds) {
+      flat.push({
+        contentTypeId: p.contentTypeId,
+        contentTypeIdentifier: p.contentTypeIdentifier,
+        entryId: eid
+      });
+    }
+  }
+  return sampleWithoutReplacement(flat, n, opts.rand);
+}
+
+// src/perf/valueGen/image.ts
+function nextUuid(rand) {
+  const hex = (n, width) => Math.floor(rand() * Math.pow(16, n)).toString(16).padStart(width, "0");
+  const segments = [
+    hex(8, 8),
+    hex(4, 4),
+    // Force version-4 nibble in the third group.
+    "4" + hex(3, 3),
+    // Force variant nibble (8/9/a/b) in the fourth group.
+    (Math.floor(rand() * 4) + 8).toString(16) + hex(3, 3),
+    hex(8, 8) + hex(4, 4)
+  ];
+  return segments.join("-");
+}
+function generateImage(opts) {
+  const { rand, index } = opts;
+  const storageKey = nextUuid(rand);
+  const width = intInRange(800, 3e3, rand);
+  const height = intInRange(800, 3e3, rand);
+  return {
+    storageKey,
+    mimeType: "image/jpeg",
+    width,
+    height,
+    fileSize: width * height * 3,
+    originalName: `image-${index}.jpg`,
+    focalPointX: 0.5,
+    focalPointY: 0.5
+  };
+}
+
+// src/vendor/slugify.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/vendor/fieldTypes.ts
+var FIELD_TYPES = {
+  ENTRY_TITLE: "ENTRY_TITLE",
+  SLUG: "SLUG",
+  TEXT: "TEXT",
+  TEXTAREA: "TEXTAREA",
+  NUMBER: "NUMBER",
+  BOOLEAN: "BOOLEAN",
+  DATETIME: "DATETIME",
+  SELECT: "SELECT",
+  RICHTEXT: "RICHTEXT",
+  RELATION: "RELATION",
+  MULTIRELATION: "MULTIRELATION",
+  IMAGE: "IMAGE"
+};
+var FIELD_TYPE_NAMES = Object.values(FIELD_TYPES);
+var FIELD_TYPES_SET = new Set(
+  FIELD_TYPE_NAMES
+);
+var FIELD_TYPE_LABELS = {
+  ENTRY_TITLE: "Entry Title",
+  SLUG: "Slug",
+  TEXT: "Text",
+  TEXTAREA: "Textarea",
+  NUMBER: "Number",
+  BOOLEAN: "Boolean",
+  DATETIME: "Date/Time",
+  SELECT: "Select",
+  RICHTEXT: "Rich Text",
+  RELATION: "Relation",
+  MULTIRELATION: "Multi Relation",
+  IMAGE: "Image"
+};
+var FIELD_TYPE_OPTIONS = FIELD_TYPE_NAMES.map((value) => ({
+  label: FIELD_TYPE_LABELS[value],
+  value
+}));
+
+// src/vendor/contentStatus.ts
+var CONTENT_STATUSES = {
+  DRAFT: "DRAFT",
+  PUBLISHED: "PUBLISHED",
+  CHANGED: "CHANGED",
+  ARCHIVED: "ARCHIVED"
+};
+var CONTENT_STATUS_NAMES = Object.values(CONTENT_STATUSES);
+var CONTENT_STATUSES_SET = new Set(
+  CONTENT_STATUS_NAMES
+);
+
+// src/perf/generate.ts
+var DEFAULT_FANOUT = { min: 0, max: 5 };
+var DEFAULT_TARGET_CAP = 200;
+function nextUuid2(rand) {
+  const hex = (n, width) => Math.floor(rand() * Math.pow(16, n)).toString(16).padStart(width, "0");
+  const segments = [
+    hex(8, 8),
+    hex(4, 4),
+    // Force version-4 nibble in the third group.
+    "4" + hex(3, 3),
+    // Force variant nibble (8/9/a/b) in the fourth group.
+    (Math.floor(rand() * 4) + 8).toString(16) + hex(3, 3),
+    hex(8, 8) + hex(4, 4)
+  ];
+  return segments.join("-");
+}
+function generatePerfData(bundle, options) {
+  const types = bundle.contentTypes ?? [];
+  const target = types.find(
+    (t) => t.identifier === options.contentTypeIdentifier
+  );
+  if (!target) {
+    throw new Error(
+      `Unknown content type "${options.contentTypeIdentifier}". Available: ${types.map((t) => t.identifier).join(", ") || "(none)"}`
+    );
+  }
+  const window = options.datetimeWindow ?? defaultWindow();
+  const fanout = options.multirelationFanout ?? DEFAULT_FANOUT;
+  const seed = options.seed ?? 1;
+  const warnings = [];
+  const publishedAtIso = new Date(window.from.getTime()).toISOString();
+  const identifierToType = new Map(
+    types.map((t) => [t.identifier, t])
+  );
+  const idToIdentifier = buildIdToIdentifierMap(types);
+  const reachable = collectReachable(target, identifierToType, idToIdentifier);
+  const edges = buildEdges(reachable, identifierToType, idToIdentifier);
+  const sorted = topoSort(
+    reachable.map((t) => t.identifier),
+    edges
+  );
+  const sizeFor = (id) => {
+    if (id === options.contentTypeIdentifier) return options.count;
+    if (options.targetCount) return options.targetCount(id);
+    return Math.min(options.count, DEFAULT_TARGET_CAP);
+  };
+  const idPools = /* @__PURE__ */ new Map();
+  const groups = [];
+  const rand = rng(seed);
+  const deferredByType = /* @__PURE__ */ new Map();
+  for (const e of sorted.deferredEdges) {
+    const list = deferredByType.get(e.from) ?? [];
+    list.push(e);
+    deferredByType.set(e.from, list);
+  }
+  for (const identifier of sorted.order) {
+    const ct = identifierToType.get(identifier);
+    const count = sizeFor(identifier);
+    const deferred = deferredByType.get(identifier) ?? [];
+    const deferredFieldIds = new Set(deferred.map((e) => e.field));
+    const fieldByIdentifier = new Map(ct.fields.map((f) => [f.identifier, f]));
+    const entries = [];
+    const patches = [];
+    const uniqueTrackers = /* @__PURE__ */ new Map();
+    const slugField = ct.fields.find((f) => f.type === FIELD_TYPES.SLUG);
+    for (let i = 0; i < count; i++) {
+      const entryId = nextUuid2(rand);
+      const data = {};
+      let entryTitle = "";
+      for (const field of ct.fields) {
+        if (deferredFieldIds.has(field.identifier)) continue;
+        if (field.type === FIELD_TYPES.SLUG) continue;
+        const value = generateFieldValue({
+          field,
+          rand,
+          index: i,
+          window,
+          fanout,
+          uniqueTrackers,
+          idPools,
+          idToIdentifier,
+          warnings,
+          contentTypeIdentifier: ct.identifier
+        });
+        if (value === void 0) continue;
+        data[field.identifier] = value;
+        if (field.type === FIELD_TYPES.ENTRY_TITLE)
+          entryTitle = value;
+      }
+      if (slugField && !deferredFieldIds.has(slugField.identifier)) {
+        const slugValue = generateSlug({
+          entryTitle: entryTitle || `entry-${i}`,
+          index: i
+        });
+        data[slugField.identifier] = slugValue;
+      }
+      const slugForEnvelope = slugField ? data[slugField.identifier] : null;
+      entries.push({
+        id: entryId,
+        contentTypeId: ct.id,
+        contentTypeIdentifier: ct.identifier,
+        entryTitle,
+        entryKey: slugify(entryTitle),
+        slug: slugForEnvelope ?? null,
+        versions: [
+          {
+            status: CONTENT_STATUSES.PUBLISHED,
+            data,
+            publishedAt: publishedAtIso
+          }
+        ]
+      });
+    }
+    idPools.set(ct.identifier, {
+      contentTypeId: ct.identifier,
+      contentTypeIdentifier: ct.identifier,
+      entryIds: entries.map((e) => e.id)
+    });
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      const fieldUpdates = {};
+      for (const edge of deferred) {
+        const field = fieldByIdentifier.get(edge.field);
+        if (!field) continue;
+        const value = generateFieldValue({
+          field,
+          rand,
+          index: i,
+          window,
+          fanout,
+          uniqueTrackers,
+          idPools,
+          idToIdentifier,
+          warnings,
+          contentTypeIdentifier: ct.identifier
+        });
+        if (value === void 0) continue;
+        fieldUpdates[field.identifier] = value;
+      }
+      if (Object.keys(fieldUpdates).length > 0) {
+        patches.push({ entryId: entry.id, fieldUpdates });
+      }
+    }
+    groups.push({
+      contentTypeIdentifier: ct.identifier,
+      entries,
+      patches: patches.length > 0 ? patches : void 0
+    });
+  }
+  return { groups, warnings };
+}
+function buildIdToIdentifierMap(types) {
+  const out = /* @__PURE__ */ new Map();
+  for (const t of types) {
+    if (t.id) out.set(t.id, t.identifier);
+  }
+  return out;
+}
+function resolveFieldTargetIdentifiers(targetIds, targetIdentifiers, idToIdentifier) {
+  if (targetIdentifiers && targetIdentifiers.length > 0) {
+    return targetIdentifiers;
+  }
+  if (!targetIds) return [];
+  const out = [];
+  for (const id of targetIds) {
+    if (typeof id !== "string") continue;
+    const ident = idToIdentifier.get(id);
+    if (ident) out.push(ident);
+  }
+  return out;
+}
+function collectReachable(root, identifierToType, idToIdentifier) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const queue = [root];
+  while (queue.length > 0) {
+    const t = queue.shift();
+    if (seen.has(t.identifier)) continue;
+    seen.add(t.identifier);
+    out.push(t);
+    for (const f of t.fields) {
+      if (f.type !== FIELD_TYPES.RELATION && f.type !== FIELD_TYPES.MULTIRELATION)
+        continue;
+      const targets = resolveFieldTargetIdentifiers(
+        f.options?.targetContentTypeIds,
+        f.options?.targetContentTypeIdentifiers,
+        idToIdentifier
+      );
+      for (const ident of targets) {
+        const target = identifierToType.get(ident);
+        if (target && !seen.has(target.identifier)) queue.push(target);
+      }
+    }
+  }
+  return out;
+}
+function buildEdges(types, identifierToType, idToIdentifier) {
+  const edges = [];
+  for (const t of types) {
+    for (const f of t.fields) {
+      if (f.type !== FIELD_TYPES.RELATION && f.type !== FIELD_TYPES.MULTIRELATION)
+        continue;
+      const targets = resolveFieldTargetIdentifiers(
+        f.options?.targetContentTypeIds,
+        f.options?.targetContentTypeIdentifiers,
+        idToIdentifier
+      );
+      for (const ident of targets) {
+        const target = identifierToType.get(ident);
+        if (!target) continue;
+        const required = f.type === FIELD_TYPES.RELATION && f.required;
+        edges.push({
+          from: t.identifier,
+          to: target.identifier,
+          field: f.identifier,
+          required
+        });
+      }
+    }
+  }
+  return edges;
+}
+function generateFieldValue(ctx) {
+  const { field } = ctx;
+  switch (field.type) {
+    case FIELD_TYPES.ENTRY_TITLE:
+      return generateEntryTitle({ rand: ctx.rand, index: ctx.index });
+    case FIELD_TYPES.SLUG:
+      return void 0;
+    case FIELD_TYPES.TEXT: {
+      const key = `${ctx.contentTypeIdentifier}.${field.identifier}`;
+      let tracker = ctx.uniqueTrackers.get(key);
+      if (!tracker) {
+        tracker = /* @__PURE__ */ new Set();
+        ctx.uniqueTrackers.set(key, tracker);
+      }
+      return generateText({
+        rand: ctx.rand,
+        unique: field.unique === true,
+        index: ctx.index,
+        seenValues: tracker
+      });
+    }
+    case FIELD_TYPES.TEXTAREA:
+      return generateTextarea({ rand: ctx.rand });
+    case FIELD_TYPES.NUMBER:
+      return generateNumber({
+        rand: ctx.rand,
+        unique: field.unique === true,
+        index: ctx.index
+      });
+    case FIELD_TYPES.BOOLEAN:
+      return generateBoolean({ rand: ctx.rand });
+    case FIELD_TYPES.DATETIME:
+      return generateDatetime({ rand: ctx.rand, window: ctx.window });
+    case FIELD_TYPES.SELECT:
+      return generateSelect({
+        rand: ctx.rand,
+        choices: field.options?.choices ?? []
+      });
+    case FIELD_TYPES.RICHTEXT: {
+      const refPool = buildRichtextRefPool(
+        field,
+        ctx.idPools,
+        ctx.idToIdentifier
+      );
+      return generateRichtext({ rand: ctx.rand, refPool });
+    }
+    case FIELD_TYPES.RELATION: {
+      const pool = buildRelationPool(field, ctx.idPools, ctx.idToIdentifier);
+      return generateRelation({ rand: ctx.rand, pool });
+    }
+    case FIELD_TYPES.MULTIRELATION: {
+      const pool = buildRelationPool(field, ctx.idPools, ctx.idToIdentifier);
+      return generateMultirelation({
+        rand: ctx.rand,
+        pool,
+        fanout: ctx.fanout
+      });
+    }
+    case FIELD_TYPES.IMAGE:
+      return generateImage({ rand: ctx.rand, index: ctx.index });
+    default:
+      ctx.warnings.push(
+        `unknown field type "${field.type}" on ${ctx.contentTypeIdentifier}.${field.identifier}`
+      );
+      return void 0;
+  }
+}
+function buildRelationPool(field, idPools, idToIdentifier) {
+  const targetIdentifiers = resolveFieldTargetIdentifiers(
+    field.options?.targetContentTypeIds,
+    field.options?.targetContentTypeIdentifiers,
+    idToIdentifier
+  );
+  const pool = [];
+  for (const ident of targetIdentifiers) {
+    const entry = idPools.get(ident);
+    if (entry) pool.push(entry);
+  }
+  return pool;
+}
+function buildRichtextRefPool(field, idPools, idToIdentifier) {
+  const embedTargets = resolveFieldTargetIdentifiers(
+    field.options?.targetContentTypeIds,
+    field.options?.targetContentTypeIdentifiers,
+    idToIdentifier
+  );
+  const linkTargets = resolveFieldTargetIdentifiers(
+    field.options?.linkTargetContentTypeIds,
+    void 0,
+    idToIdentifier
+  );
+  if (embedTargets.length === 0 && linkTargets.length === 0) return null;
+  return {
+    embed: matchPools(embedTargets, idPools),
+    link: matchPools(linkTargets, idPools)
+  };
+}
+function matchPools(targetIds, idPools) {
+  const out = [];
+  for (const tid of targetIds) {
+    const entry = idPools.get(tid);
+    if (entry) {
+      out.push({
+        contentTypeId: entry.contentTypeId,
+        contentTypeIdentifier: entry.contentTypeIdentifier,
+        entryIds: entry.entryIds
+      });
+    }
+  }
+  return out;
+}
+var DEFAULT_WINDOW_END_MS = Date.UTC(2026, 0, 1);
+var FIVE_YEARS_MS = 5 * 365 * 24 * 60 * 60 * 1e3;
+function defaultWindow() {
+  const to = new Date(DEFAULT_WINDOW_END_MS);
+  const from = new Date(DEFAULT_WINDOW_END_MS - FIVE_YEARS_MS);
+  return { from, to };
+}
+
+// src/perf/rewriteSyntheticIds.ts
+function rewriteSyntheticIds(data, map) {
+  return walk(data);
+  function walk(value) {
+    if (value === null || typeof value !== "object") return value;
+    if (Array.isArray(value)) return value.map(walk);
+    const obj = value;
+    if (typeof obj.entryId === "string" && typeof obj.contentTypeId === "string" && Object.keys(obj).length <= 4) {
+      const real = map.get(obj.entryId);
+      const next2 = { ...obj };
+      if (real) next2.entryId = real;
+      return next2;
+    }
+    const next = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (k === "attrs" && v && typeof v === "object" && typeof v.entryId === "string") {
+        const attrs = v;
+        const real = map.get(attrs.entryId);
+        next[k] = real ? { ...attrs, entryId: real } : { ...attrs };
+      } else {
+        next[k] = walk(v);
+      }
+    }
+    return next;
+  }
+}
+function findUnresolvedRefs(data, map) {
+  const unresolved = /* @__PURE__ */ new Set();
+  walk(data);
+  return unresolved;
+  function walk(value) {
+    if (value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const v of value) walk(v);
+      return;
+    }
+    const obj = value;
+    if (typeof obj.entryId === "string" && typeof obj.contentTypeId === "string" && Object.keys(obj).length <= 4) {
+      if (!map.has(obj.entryId)) unresolved.add(obj.entryId);
+      return;
+    }
+    for (const [k, v] of Object.entries(obj)) {
+      if (k === "attrs" && v && typeof v === "object" && typeof v.entryId === "string") {
+        const attrs = v;
+        if (!map.has(attrs.entryId)) unresolved.add(attrs.entryId);
+      } else {
+        walk(v);
+      }
+    }
+  }
+}
+function rewriteContentTypeIds(data, typeIdByIdentifier) {
+  return walk(data);
+  function walk(value) {
+    if (value === null || typeof value !== "object") return value;
+    if (Array.isArray(value)) return value.map(walk);
+    const obj = value;
+    if (typeof obj.entryId === "string" && typeof obj.contentTypeId === "string" && Object.keys(obj).length <= 4) {
+      const realCt = typeIdByIdentifier.get(obj.contentTypeId);
+      const next2 = { ...obj };
+      if (realCt) next2.contentTypeId = realCt;
+      return next2;
+    }
+    const next = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (k === "attrs" && v && typeof v === "object" && typeof v.entryId === "string") {
+        const attrs = v;
+        const ct = typeof attrs.contentTypeId === "string" ? typeIdByIdentifier.get(attrs.contentTypeId) : void 0;
+        next[k] = ct ? { ...attrs, contentTypeId: ct } : { ...attrs };
+      } else {
+        next[k] = walk(v);
+      }
+    }
+    return next;
+  }
+}
+
+// src/perf/seedErrors.ts
+var SEED_DUPLICATE_THRESHOLD = 0.5;
+var SeedMostlyDuplicateError = class extends Error {
+  constructor(inserted, skipped, total) {
+    const pct = Math.round(skipped / total * 100);
+    super(
+      `Seed step skipped ${skipped} of ${total} entries (${pct}%) due to uniqueness conflicts. This likely means the target DB already contains entries with these titles/slugs. Pass --seed <n> for a different deterministic set, or reset the target DB first with \`boject perf reset --database-url <url>\`.`
+    );
+    this.inserted = inserted;
+    this.skipped = skipped;
+    this.total = total;
+    this.name = "SeedMostlyDuplicateError";
+  }
+};
+
+// src/perf/writeViaSql.ts
+var MissingContentTypeError = class extends Error {
+  constructor(identifier) {
+    super(
+      `Content type "${identifier}" not found in target database. Run "boject schema apply" first.`
+    );
+    this.identifier = identifier;
+    this.name = "MissingContentTypeError";
+  }
+};
+async function writeViaSql(client, generated, opts = {}) {
+  const batchSize = opts.batchSize ?? 500;
+  const idMap = /* @__PURE__ */ new Map();
+  let inserted = 0;
+  let skipped = 0;
+  const skippedIds = /* @__PURE__ */ new Set();
+  const typeIdByIdentifier = /* @__PURE__ */ new Map();
+  for (const group of generated.groups) {
+    const r = await client.query(
+      'SELECT id FROM "ContentType" WHERE identifier = $1',
+      [group.contentTypeIdentifier]
+    );
+    const row = r.rows[0];
+    if (!row?.id)
+      throw new MissingContentTypeError(group.contentTypeIdentifier);
+    typeIdByIdentifier.set(group.contentTypeIdentifier, row.id);
+  }
+  for (const group of generated.groups) {
+    const contentTypeId = typeIdByIdentifier.get(group.contentTypeIdentifier);
+    for (let start = 0; start < group.entries.length; start += batchSize) {
+      const slice = group.entries.slice(start, start + batchSize);
+      const refValid = slice.filter((e) => {
+        const data = e.versions?.[0]?.data;
+        const unresolved = findUnresolvedRefs(data, idMap);
+        return ![...unresolved].some((id) => skippedIds.has(id));
+      });
+      for (const e of slice) {
+        if (!refValid.includes(e) && e.id) skippedIds.add(e.id);
+      }
+      skipped += slice.length - refValid.length;
+      const { insertedIds } = await insertEnvelopes(
+        client,
+        refValid,
+        contentTypeId
+      );
+      const survivors = refValid.filter((e) => e.id && insertedIds.has(e.id));
+      for (const e of refValid) {
+        if (!survivors.includes(e) && e.id) skippedIds.add(e.id);
+      }
+      skipped += refValid.length - survivors.length;
+      await insertVersions(client, survivors, idMap, typeIdByIdentifier);
+      for (const e of survivors) {
+        if (!e.id) {
+          throw new Error(
+            "Bundle entry is missing an id; cannot map for ID rewriting"
+          );
+        }
+        idMap.set(e.id, e.id);
+      }
+      inserted += survivors.length;
+    }
+  }
+  const patchTs = generated.groups[0]?.entries[0]?.versions?.[0]?.publishedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  for (const group of generated.groups) {
+    if (!group.patches) continue;
+    for (const patch of group.patches) {
+      if (skippedIds.has(patch.entryId)) {
+        process.stderr.write(
+          `[perf:seed] skipping patch \u2014 target entry ${patch.entryId} was skipped this run
+`
+        );
+        continue;
+      }
+      const unresolved = findUnresolvedRefs(patch.fieldUpdates, idMap);
+      if ([...unresolved].some((id) => skippedIds.has(id))) {
+        process.stderr.write(
+          `[perf:seed] skipping patch on ${patch.entryId} \u2014 fieldUpdates reference skipped entries
+`
+        );
+        continue;
+      }
+      const realEntryId = idMap.get(patch.entryId) ?? patch.entryId;
+      const rewrittenIds = rewriteSyntheticIds(patch.fieldUpdates, idMap);
+      const rewritten = rewriteContentTypeIds(
+        rewrittenIds,
+        typeIdByIdentifier
+      );
+      await applyPatch(client, realEntryId, rewritten, patchTs);
+    }
+  }
+  const total = inserted + skipped;
+  if (total > 0 && skipped / total > SEED_DUPLICATE_THRESHOLD) {
+    throw new SeedMostlyDuplicateError(inserted, skipped, total);
+  }
+  return { inserted, skipped };
+}
+async function insertEnvelopes(client, entries, contentTypeId) {
+  if (entries.length === 0) return { insertedIds: /* @__PURE__ */ new Set() };
+  const valuesPlaceholders = [];
+  const params = [];
+  let p = 1;
+  for (const e of entries) {
+    if (!e.versions?.[0]) {
+      throw new Error(
+        `Bundle entry ${e.id ?? "<unknown>"} has no versions; refusing to insert envelope`
+      );
+    }
+    const ts = e.versions[0].publishedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    valuesPlaceholders.push(
+      `($${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++})`
+    );
+    params.push(e.id, contentTypeId, e.entryTitle, e.entryKey, e.slug, ts, ts);
+  }
+  const result = await client.query(
+    `INSERT INTO "ContentEntry" ("id", "contentTypeId", "entryTitle", "entryKey", "slug", "createdAt", "updatedAt") VALUES ${valuesPlaceholders.join(", ")} ON CONFLICT DO NOTHING RETURNING id`,
+    params
+  );
+  const insertedIds = new Set(result.rows.map((r) => r.id));
+  return { insertedIds };
+}
+async function insertVersions(client, entries, idMap, typeIdByIdentifier) {
+  if (entries.length === 0) return;
+  const valuesPlaceholders = [];
+  const params = [];
+  let p = 1;
+  for (const e of entries) {
+    if (!e.versions?.[0]) {
+      throw new Error(
+        `Bundle entry ${e.id ?? "<unknown>"} has no versions; refusing to insert version`
+      );
+    }
+    const v = e.versions[0];
+    const ts = v.publishedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    const dataWithRealEntryIds = rewriteSyntheticIds(v.data, idMap);
+    const data = rewriteContentTypeIds(
+      dataWithRealEntryIds,
+      typeIdByIdentifier
+    );
+    valuesPlaceholders.push(
+      `(gen_random_uuid(), $${p++}, 'PUBLISHED', $${p++}, $${p++}::jsonb, $${p++}, $${p++}, $${p++})`
+    );
+    params.push(
+      e.id,
+      e.entryTitle,
+      JSON.stringify(data),
+      v.publishedAt,
+      ts,
+      ts
+    );
+  }
+  await client.query(
+    `INSERT INTO "ContentEntryVersion" ("id", "entryId", "status", "entryTitle", "data", "publishedAt", "createdAt", "updatedAt") VALUES ${valuesPlaceholders.join(", ")}`,
+    params
+  );
+}
+async function applyPatch(client, entryId, fieldUpdates, ts) {
+  await client.query(
+    `UPDATE "ContentEntryVersion" SET "data" = "data" || $1::jsonb, "updatedAt" = $2 WHERE "entryId" = $3 AND "status" = 'PUBLISHED'`,
+    [JSON.stringify(fieldUpdates), ts, entryId]
+  );
+}
+
+// src/perf/allowedDatabase.ts
+var DisallowedDatabaseError = class extends Error {
+  constructor(databaseUrl, dbName) {
+    super(
+      `Refusing to operate on database "${dbName}" (${redact(databaseUrl)}): name must end in "_perf" or "_staging". Pass --allow-database ${dbName} to override. Reset operations TRUNCATE every entry in the named database, not just perf-seeded rows \u2014 only override for disposable / cloned databases.`
+    );
+    this.databaseUrl = databaseUrl;
+    this.dbName = dbName;
+    this.name = "DisallowedDatabaseError";
+  }
+};
+var UnparseableDatabaseUrlError = class extends Error {
+  constructor(databaseUrl) {
+    super(
+      `Could not parse database name from URL (${redact(databaseUrl)}): expected a connection string of the form postgres://user:pass@host/<dbname>.`
+    );
+    this.databaseUrl = databaseUrl;
+    this.name = "UnparseableDatabaseUrlError";
+  }
+};
+function extractDatabaseName(databaseUrl) {
+  let url;
+  try {
+    url = new URL(databaseUrl);
+  } catch {
+    throw new UnparseableDatabaseUrlError(databaseUrl);
+  }
+  const name = url.pathname.replace(/^\//, "");
+  if (!name) throw new UnparseableDatabaseUrlError(databaseUrl);
+  return name;
+}
+function assertAllowedDatabase(databaseUrl, allowDatabase) {
+  const dbName = extractDatabaseName(databaseUrl);
+  if (/_perf$/.test(dbName) || /_staging$/.test(dbName)) return;
+  if (allowDatabase.includes(dbName)) return;
+  throw new DisallowedDatabaseError(databaseUrl, dbName);
+}
+function redact(url) {
+  return url.replace(/\/\/[^@]*@/, "//<redacted>@");
+}
+
+// src/perf/resetPerfDb.ts
+async function resetPerfDb(opts) {
+  assertAllowedDatabase(opts.databaseUrl, opts.allowDatabase ?? []);
+  await opts.runQuery(
+    `TRUNCATE TABLE "ContentEntryVersion" RESTART IDENTITY CASCADE`
+  );
+  await opts.runQuery(`TRUNCATE TABLE "ContentEntry" RESTART IDENTITY CASCADE`);
+}
+export {
+  CycleRequiresNullError,
+  MissingContentTypeError,
+  generatePerfData,
+  resetPerfDb,
+  writeViaSql
+};