@cdot65/prisma-airs-cli 2.12.0 → 3.0.1

package/dist/dlp-5XKWITZX.js

@@ -0,0 +1,710 @@
+// src/dlp/index.ts
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import { join as join5 } from "path";
+
+// src/dlp/embed/docx.ts
+import { Document, HeadingLevel, Packer, Paragraph, ShadingType, TextRun } from "docx";
+
+// src/dlp/rng.ts
+function makeRng(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function pick(rng, xs) {
+  return xs[Math.floor(rng() * xs.length)];
+}
+function digits(rng, n) {
+  let out = "";
+  for (let i = 0; i < n; i++) {
+    out += Math.floor(rng() * 10).toString();
+  }
+  return out;
+}
+function subSeed(seed, index) {
+  return Math.imul(seed ^ 2654435769, 2246822507) + index * 668265263 >>> 0;
+}
+
+// src/dlp/lorem.ts
+var WORDS = [
+  "lorem",
+  "ipsum",
+  "dolor",
+  "sit",
+  "amet",
+  "consectetur",
+  "adipiscing",
+  "elit",
+  "sed",
+  "do",
+  "eiusmod",
+  "tempor",
+  "incididunt",
+  "ut",
+  "labore",
+  "et",
+  "dolore",
+  "magna",
+  "aliqua",
+  "enim",
+  "ad",
+  "minim",
+  "veniam",
+  "quis",
+  "nostrud",
+  "exercitation",
+  "ullamco",
+  "laboris",
+  "nisi",
+  "aliquip",
+  "ex",
+  "ea",
+  "commodo",
+  "consequat",
+  "duis",
+  "aute",
+  "irure",
+  "in",
+  "reprehenderit",
+  "voluptate",
+  "velit",
+  "esse",
+  "cillum",
+  "fugiat",
+  "nulla",
+  "pariatur",
+  "excepteur",
+  "sint"
+];
+function sentence(rng) {
+  const len = 8 + Math.floor(rng() * 8);
+  const words = Array.from({ length: len }, () => pick(rng, WORDS));
+  const text = words.join(" ");
+  return `${text.charAt(0).toUpperCase()}${text.slice(1)}.`;
+}
+function lorem(rng, paragraphs) {
+  return Array.from({ length: paragraphs }, () => {
+    const sentences = 3 + Math.floor(rng() * 3);
+    return Array.from({ length: sentences }, () => sentence(rng)).join(" ");
+  }).join("\n\n");
+}
+
+// src/dlp/embed/docx.ts
+var join = (p) => p.map((v) => `${v.category}: ${v.value}`).join(" | ");
+function bodyParagraphs() {
+  return lorem(makeRng(1), 2).split("\n\n").map((t) => new Paragraph({ children: [new TextRun(t)] }));
+}
+async function build(extra, core = {}) {
+  const doc = new Document({
+    title: core.title,
+    subject: core.subject,
+    keywords: core.keywords,
+    sections: [
+      {
+        children: [
+          new Paragraph({ text: "Generated Document", heading: HeadingLevel.HEADING_1 }),
+          ...bodyParagraphs(),
+          ...extra
+        ]
+      }
+    ]
+  });
+  return Packer.toBuffer(doc);
+}
+var docxTechniques = {
+  "core-props": {
+    id: "core-props",
+    format: "docx",
+    label: "core document properties",
+    embed: (_clean, p) => build([], { title: join(p), subject: join(p), keywords: join(p) })
+  },
+  "hidden-run": {
+    id: "hidden-run",
+    format: "docx",
+    label: "hidden (vanish) run",
+    embed: (_clean, p) => build([new Paragraph({ children: [new TextRun({ text: join(p), vanish: true })] })])
+  },
+  visible: {
+    id: "visible",
+    format: "docx",
+    label: "visible body text (foreground != background)",
+    embed: (_clean, p) => build([new Paragraph({ children: [new TextRun(join(p))] })])
+  },
+  "visible-samecolor": {
+    id: "visible-samecolor",
+    format: "docx",
+    label: "visible run, same color as background (camouflaged)",
+    embed: (_clean, p) => build([
+      new Paragraph({
+        children: [
+          new TextRun({
+            text: join(p),
+            color: "D9D9D9",
+            shading: { type: ShadingType.CLEAR, color: "auto", fill: "D9D9D9" }
+          })
+        ]
+      })
+    ])
+  }
+};
+
+// src/dlp/embed/jpeg.ts
+import piexif from "piexifjs";
+
+// src/dlp/embed/overlay.ts
+import sharp from "sharp";
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+async function renderVisibleText(clean, payload, format) {
+  const meta = await sharp(clean).metadata();
+  const w = meta.width ?? 256;
+  const h = meta.height ?? 192;
+  const lines = payload.map(
+    (v, i) => `<text x="8" y="${18 + i * 16}" font-family="sans-serif" font-size="11" fill="#000000">${esc(`${v.category}: ${v.value}`)}</text>`
+  ).join("");
+  const bandH = Math.min(h, 18 + payload.length * 16);
+  const overlay = `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}"><rect x="0" y="0" width="${w}" height="${bandH}" fill="#fafafa"/>${lines}</svg>`;
+  const img = sharp(clean).composite([{ input: Buffer.from(overlay), top: 0, left: 0 }]);
+  return format === "png" ? img.png().toBuffer() : img.jpeg({ quality: 90 }).toBuffer();
+}
+
+// src/dlp/embed/jpeg.ts
+var join2 = (p) => p.map((v) => `${v.category}: ${v.value}`).join(" | ");
+function u16(n) {
+  const b = Buffer.alloc(2);
+  b.writeUInt16BE(n, 0);
+  return b;
+}
+function setExif(clean, text) {
+  const zeroth = {};
+  zeroth[piexif.ImageIFD.ImageDescription] = text;
+  zeroth[piexif.ImageIFD.Artist] = text;
+  zeroth[piexif.ImageIFD.Copyright] = text;
+  const exifStr = piexif.dump({
+    "0th": zeroth,
+    Exif: {},
+    GPS: {},
+    Interop: {},
+    "1st": {},
+    thumbnail: null
+  });
+  return Buffer.from(piexif.insert(exifStr, clean.toString("binary")), "binary");
+}
+var jpegTechniques = {
+  exif: {
+    id: "exif",
+    format: "jpeg",
+    label: "EXIF ImageDescription/Artist/Copyright",
+    embed: (c, p) => setExif(c, join2(p))
+  },
+  com: {
+    id: "com",
+    format: "jpeg",
+    label: "COM comment segment",
+    embed: (c, p) => {
+      const d = Buffer.from(`DLP ${join2(p)}`, "utf8");
+      return Buffer.concat([
+        c.subarray(0, 2),
+        Buffer.from([255, 254]),
+        u16(d.length + 2),
+        d,
+        c.subarray(2)
+      ]);
+    }
+  },
+  trailer: {
+    id: "trailer",
+    format: "jpeg",
+    label: "bytes after EOI",
+    embed: (c, p) => Buffer.concat([c, Buffer.from(`
+DLP ${join2(p)}
+`, "utf8")])
+  },
+  visible: {
+    id: "visible",
+    format: "jpeg",
+    label: "visible rendered text (dark on light)",
+    embed: (c, p) => renderVisibleText(c, p, "jpeg")
+  }
+};
+
+// src/dlp/embed/pdf.ts
+import { inflateSync } from "zlib";
+import { PDFDocument, rgb } from "pdf-lib";
+var join3 = (p) => p.map((v) => `${v.category}: ${v.value}`).join(" | ");
+async function setMeta(clean, p) {
+  const doc = await PDFDocument.load(clean);
+  doc.setTitle(join3(p));
+  doc.setSubject(join3(p));
+  doc.setKeywords(p.map((v) => v.value));
+  doc.setAuthor(p.find((v) => v.category === "email")?.value ?? "synthetic");
+  return Buffer.from(await doc.save());
+}
+async function hiddenText(clean, p) {
+  const doc = await PDFDocument.load(clean);
+  const page = doc.getPage(0);
+  let y = 760;
+  for (const v of p) {
+    page.drawText(`${v.category}: ${v.value}`, { x: 40, y, size: 6, color: rgb(1, 1, 1) });
+    y -= 8;
+  }
+  return Buffer.from(await doc.save());
+}
+var trailer = (clean, p) => Buffer.concat([clean, Buffer.from(`
+% DLP ${join3(p)}
+`, "utf8")]);
+async function visibleText(clean, p, sameColor) {
+  const doc = await PDFDocument.load(clean);
+  const page = doc.getPage(0);
+  const bg = rgb(0.93, 0.93, 0.85);
+  page.drawRectangle({ x: 36, y: 592, width: 524, height: 136, color: bg });
+  let y = 712;
+  for (const v of p) {
+    page.drawText(`${v.category}: ${v.value}`, {
+      x: 44,
+      y,
+      size: 9,
+      color: sameColor ? bg : rgb(0, 0, 0)
+    });
+    y -= 14;
+  }
+  return Buffer.from(await doc.save());
+}
+var pdfTechniques = {
+  meta: {
+    id: "meta",
+    format: "pdf",
+    label: "document info dict",
+    embed: (c, p) => setMeta(c, p)
+  },
+  "hidden-text": {
+    id: "hidden-text",
+    format: "pdf",
+    label: "white (hidden) text layer",
+    embed: (c, p) => hiddenText(c, p)
+  },
+  trailer: {
+    id: "trailer",
+    format: "pdf",
+    label: "bytes after %%EOF",
+    embed: (c, p) => trailer(c, p)
+  },
+  visible: {
+    id: "visible",
+    format: "pdf",
+    label: "visible page text (dark on light band)",
+    embed: (c, p) => visibleText(c, p, false)
+  },
+  "visible-samecolor": {
+    id: "visible-samecolor",
+    format: "pdf",
+    label: "visible page text, same color as background (camouflaged)",
+    embed: (c, p) => visibleText(c, p, true)
+  }
+};
+
+// src/dlp/embed/png.ts
+import sharp2 from "sharp";
+
+// src/dlp/embed/png-chunks.ts
+import { deflateSync, inflateSync as inflateSync2 } from "zlib";
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(buf) {
+  let c = 4294967295;
+  for (let i = 0; i < buf.length; i++) {
+    c = CRC_TABLE[(c ^ buf[i]) & 255] ^ c >>> 8;
+  }
+  return (c ^ 4294967295) >>> 0;
+}
+function buildChunk(type, data) {
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(data.length, 0);
+  const typeBuf = Buffer.from(type, "latin1");
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(Buffer.concat([typeBuf, data])), 0);
+  return Buffer.concat([len, typeBuf, data, crc]);
+}
+function insertBeforeIEND(png2, extra) {
+  let off = 8;
+  while (off + 8 <= png2.length) {
+    const len = png2.readUInt32BE(off);
+    const type = png2.toString("latin1", off + 4, off + 8);
+    if (type === "IEND") {
+      break;
+    }
+    off += 12 + len;
+  }
+  return Buffer.concat([png2.subarray(0, off), extra, png2.subarray(off)]);
+}
+var tEXt = (keyword, text) => buildChunk(
+  "tEXt",
+  Buffer.concat([Buffer.from(keyword, "latin1"), Buffer.from([0]), Buffer.from(text, "latin1")])
+);
+var zTXt = (keyword, text) => buildChunk(
+  "zTXt",
+  Buffer.concat([
+    Buffer.from(keyword, "latin1"),
+    Buffer.from([0, 0]),
+    deflateSync(Buffer.from(text, "latin1"))
+  ])
+);
+var iTXt = (keyword, text) => buildChunk(
+  "iTXt",
+  Buffer.concat([
+    Buffer.from(keyword, "latin1"),
+    Buffer.from([0, 0, 0, 0, 0]),
+    Buffer.from(text, "utf8")
+  ])
+);
+
+// src/dlp/embed/png.ts
+var join4 = (p) => p.map((v) => `${v.category}: ${v.value}`).join(" | ");
+async function lsbEmbed(png2, text) {
+  const { data, info } = await sharp2(png2).raw().toBuffer({ resolveWithObject: true });
+  const payload = Buffer.from(text, "utf8");
+  const header = Buffer.alloc(4);
+  header.writeUInt32BE(payload.length, 0);
+  const blob = Buffer.concat([header, payload]);
+  const bits = blob.length * 8;
+  if (bits > data.length) {
+    throw new Error("cover image too small for stego payload");
+  }
+  for (let i = 0; i < bits; i++) {
+    const bit = blob[i >> 3] >> 7 - (i & 7) & 1;
+    data[i] = data[i] & 254 | bit;
+  }
+  return sharp2(data, {
+    raw: { width: info.width, height: info.height, channels: info.channels }
+  }).png().toBuffer();
+}
+var pngTechniques = {
+  "text-chunks": {
+    id: "text-chunks",
+    format: "png",
+    label: "tEXt/zTXt/iTXt chunks",
+    embed: (c, p) => insertBeforeIEND(
+      c,
+      Buffer.concat([
+        tEXt("Comment", join4(p)),
+        zTXt("Description", join4(p)),
+        iTXt("Keywords", join4(p))
+      ])
+    )
+  },
+  trailer: {
+    id: "trailer",
+    format: "png",
+    label: "bytes after IEND",
+    embed: (c, p) => Buffer.concat([c, Buffer.from(`
+DLP ${join4(p)}
+`, "utf8")])
+  },
+  "stego-lsb": {
+    id: "stego-lsb",
+    format: "png",
+    label: "LSB steganography",
+    embed: (c, p) => lsbEmbed(c, join4(p))
+  },
+  visible: {
+    id: "visible",
+    format: "png",
+    label: "visible rendered text (dark on light)",
+    embed: (c, p) => renderVisibleText(c, p, "png")
+  }
+};
+
+// src/dlp/embed/svg.ts
+var line = (vals) => vals.map((v) => `${v.category}: ${v.value}`).join(" | ");
+function inject(clean, snippet) {
+  const s = clean.toString("utf8");
+  const idx = s.indexOf(">") + 1;
+  return Buffer.from(s.slice(0, idx) + snippet + s.slice(idx), "utf8");
+}
+function appendBeforeClose(clean, snippet) {
+  const s = clean.toString("utf8");
+  const idx = s.lastIndexOf("</svg>");
+  return Buffer.from(s.slice(0, idx) + snippet + s.slice(idx), "utf8");
+}
+var svgTechniques = {
+  meta: {
+    id: "meta",
+    format: "svg",
+    label: "metadata + desc",
+    embed: (c, p) => inject(c, `<metadata>${line(p)}</metadata><desc>${line(p)}</desc>`)
+  },
+  "hidden-text": {
+    id: "hidden-text",
+    format: "svg",
+    label: "off-canvas <text>",
+    embed: (c, p) => inject(
+      c,
+      p.map((v) => `<text x="-9999" y="-9999">${v.category}: ${v.value}</text>`).join("")
+    )
+  },
+  comment: {
+    id: "comment",
+    format: "svg",
+    label: "XML comment",
+    embed: (c, p) => inject(c, `<!-- ${line(p)} -->`)
+  },
+  visible: {
+    id: "visible",
+    format: "svg",
+    label: "visible on-canvas text (dark on light)",
+    embed: (c, p) => appendBeforeClose(
+      c,
+      `<rect x="6" y="6" width="228" height="${Math.min(148, 12 + p.length * 15)}" fill="#fafafa"/>` + p.map(
+        (v, i) => `<text x="10" y="${20 + i * 15}" font-size="10" fill="#111111">${v.category}: ${v.value}</text>`
+      ).join("")
+    )
+  }
+};
+
+// src/dlp/embed/index.ts
+var techniquesByFormat = {
+  pdf: Object.values(pdfTechniques),
+  png: Object.values(pngTechniques),
+  jpeg: Object.values(jpegTechniques),
+  svg: Object.values(svgTechniques),
+  docx: Object.values(docxTechniques)
+};
+var ALL_TECHNIQUE_IDS = [
+  ...new Set(
+    Object.values(techniquesByFormat).flat().map((t) => t.id)
+  )
+];
+
+// src/dlp/generate/docx.ts
+async function docx(rng) {
+  const { Document: Document2, HeadingLevel: HeadingLevel2, Packer: Packer2, Paragraph: Paragraph2, TextRun: TextRun2 } = await import("docx");
+  const paragraphs = lorem(rng, 3).split("\n\n").map((p) => new Paragraph2({ children: [new TextRun2(p)] }));
+  const doc = new Document2({
+    sections: [
+      {
+        children: [
+          new Paragraph2({ text: "Generated Document", heading: HeadingLevel2.HEADING_1 }),
+          ...paragraphs
+        ]
+      }
+    ]
+  });
+  return Packer2.toBuffer(doc);
+}
+
+// src/dlp/generate/jpeg.ts
+import sharp3 from "sharp";
+
+// src/dlp/generate/raster.ts
+function raster(rng) {
+  const width = 256;
+  const height = 192;
+  const channels = 3;
+  const data = Buffer.alloc(width * height * channels);
+  const rb = Math.floor(rng() * 256);
+  const gb = Math.floor(rng() * 256);
+  const bb = Math.floor(rng() * 256);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const i = (y * width + x) * channels;
+      data[i] = x + rb & 255;
+      data[i + 1] = y + gb & 255;
+      data[i + 2] = x + y + bb & 255;
+    }
+  }
+  return { data, width, height, channels };
+}
+
+// src/dlp/generate/jpeg.ts
+async function jpeg(rng) {
+  const { data, width, height, channels } = raster(rng);
+  return sharp3(data, { raw: { width, height, channels } }).jpeg({ quality: 90 }).toBuffer();
+}
+
+// src/dlp/generate/pdf.ts
+import { PDFDocument as PDFDocument2, StandardFonts } from "pdf-lib";
+async function pdf(rng) {
+  const doc = await PDFDocument2.create();
+  const font = await doc.embedFont(StandardFonts.Helvetica);
+  const page = doc.addPage([612, 792]);
+  page.drawText(lorem(rng, 3), {
+    x: 54,
+    y: 720,
+    size: 11,
+    font,
+    lineHeight: 15,
+    maxWidth: 504
+  });
+  const bytes = await doc.save();
+  return Buffer.from(bytes);
+}
+
+// src/dlp/generate/png.ts
+import sharp4 from "sharp";
+async function png(rng) {
+  const { data, width, height, channels } = raster(rng);
+  return sharp4(data, { raw: { width, height, channels } }).png().toBuffer();
+}
+
+// src/dlp/generate/svg.ts
+function svg(rng) {
+  const width = 240;
+  const height = 160;
+  const fill = pick(rng, ["#673ab7", "#2196f3", "#4caf50", "#ff9800"]);
+  const cx = 40 + Math.floor(rng() * 160);
+  const xml = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img"><title>Generated image</title><desc>A generated placeholder graphic.</desc><rect width="${width}" height="${height}" fill="#ffffff"/><circle cx="${cx}" cy="80" r="48" fill="${fill}"/></svg>`;
+  return Buffer.from(xml, "utf8");
+}
+
+// src/dlp/generate/index.ts
+var generators = {
+  pdf,
+  png,
+  jpeg,
+  svg,
+  docx
+};
+var EXT = {
+  pdf: "pdf",
+  png: "png",
+  jpeg: "jpg",
+  svg: "svg",
+  docx: "docx"
+};
+
+// src/dlp/manifest.ts
+import { writeFile } from "fs/promises";
+function buildManifest(entries) {
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    count: entries.length,
+    entries
+  };
+}
+async function writeManifest(path, manifest) {
+  await writeFile(path, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+
+// src/dlp/payload.ts
+var BASE32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+function luhnValid(pan) {
+  if (pan.length === 0) {
+    return false;
+  }
+  let sum = 0;
+  let alt = false;
+  for (let i = pan.length - 1; i >= 0; i--) {
+    let d = pan.charCodeAt(i) - 48;
+    if (alt) {
+      d *= 2;
+      if (d > 9) {
+        d -= 9;
+      }
+    }
+    sum += d;
+    alt = !alt;
+  }
+  return sum % 10 === 0;
+}
+function testPan(rng) {
+  const body = `4${digits(rng, 14)}`;
+  for (let c = 0; c < 10; c++) {
+    const candidate = `${body}${c}`;
+    if (luhnValid(candidate)) {
+      return candidate;
+    }
+  }
+  return `${body}0`;
+}
+var ssn = (rng) => `9${digits(rng, 2)}-${digits(rng, 2)}-${digits(rng, 4)}`;
+var phone = (rng) => `555-01${digits(rng, 2)}`;
+var email = (rng) => `${pick(rng, ["john.public", "jane.doe", "sam.roe"])}.${digits(rng, 3)}@${pick(rng, [
+  "example.com",
+  "example.org",
+  "example.net"
+])}`;
+var awsKey = (rng) => `AKIA${Array.from({ length: 9 }, () => pick(rng, [...BASE32])).join("")}EXAMPLE`;
+var dob = (rng) => {
+  const year = 1960 + Math.floor(rng() * 40);
+  const month = String(1 + Math.floor(rng() * 12)).padStart(2, "0");
+  const day = String(1 + Math.floor(rng() * 28)).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+};
+function makePayload(rng) {
+  const pan = testPan(rng);
+  return [
+    { category: "ssn", value: ssn(rng) },
+    { category: "credit_card", value: pan.replace(/(\d{4})(?=\d)/g, "$1 ").trim() },
+    { category: "email", value: email(rng) },
+    { category: "phone", value: phone(rng) },
+    { category: "aws_key", value: awsKey(rng) },
+    { category: "passport", value: `X${digits(rng, 8)}` },
+    { category: "dob", value: dob(rng) }
+  ];
+}
+
+// src/dlp/index.ts
+async function generateCorpus(opts) {
+  const seed = opts.seed ?? Math.floor(Math.random() * 2147483647);
+  const entries = [];
+  const byFormat = {};
+  let cleanCount = 0;
+  let typeIndex = 0;
+  for (const fmt of opts.types) {
+    const ext = EXT[fmt];
+    const cleanDir = join5(opts.out, "clean", fmt);
+    const dirtyDir = join5(opts.out, "dirty", fmt);
+    await mkdir(cleanDir, { recursive: true });
+    await mkdir(dirtyDir, { recursive: true });
+    byFormat[fmt] = { clean: 0, dirty: 0 };
+    const wanted = techniquesByFormat[fmt].filter(
+      (t) => opts.techniques === "all" || opts.techniques.includes(t.id)
+    );
+    for (let i = 0; i < opts.count; i++) {
+      const fileSeed = subSeed(seed, typeIndex * 1e3 + i);
+      const base = `${fmt}-${fileSeed.toString(16).padStart(8, "0")}`;
+      const cleanBuf = Buffer.from(await generators[fmt](makeRng(fileSeed)));
+      const cleanPath = join5(cleanDir, `${base}.${ext}`);
+      await writeFile2(cleanPath, cleanBuf);
+      cleanCount++;
+      byFormat[fmt].clean++;
+      let tIdx = 0;
+      for (const technique of wanted) {
+        const payload = makePayload(makeRng(subSeed(fileSeed, 7919 + tIdx)));
+        const dirtyBuf = Buffer.from(await technique.embed(cleanBuf, payload));
+        const dirtyPath = join5(dirtyDir, `${base}__${technique.id}.${ext}`);
+        await writeFile2(dirtyPath, dirtyBuf);
+        entries.push({
+          format: fmt,
+          technique: technique.id,
+          clean: cleanPath,
+          dirty: dirtyPath,
+          values: payload
+        });
+        byFormat[fmt].dirty++;
+        tIdx++;
+      }
+    }
+    typeIndex++;
+  }
+  const manifestPath = join5(opts.out, "manifest.json");
+  await writeManifest(manifestPath, buildManifest(entries));
+  return { clean: cleanCount, dirty: entries.length, out: opts.out, manifestPath, seed, byFormat };
+}
+export {
+  generateCorpus
+};