@absolutejs/artifacts 0.2.1 → 0.3.0

package/README.md

@@ -232,6 +232,27 @@ const deck = await generators.generate(artifacts, {
 });
 ```
 
+Generators may expose a `validate` function. The bundled
+`validateGeneratedArtifactFormats` validator checks CSV row structure, RFC 822
+headers, ZIP readability, and PPTX package/XML integrity before persistence.
+Generate several independent artifacts with one atomic receipt through the same
+registry:
+
+```ts
+const receipt = await generators.generateBatch(artifacts, {
+  ownerId: member.id,
+  items: [
+    { createdBy: "agent", key: "deck", kind: "presentation", title: "Deck" },
+    { createdBy: "agent", key: "email", kind: "email", title: "Email" },
+  ],
+  provenance: { tool: "campaign_generator" },
+});
+```
+
+Generation validators run after every output is staged and before anything is
+committed. Validation failures return a rolled-back completion receipt keyed to
+the invalid output.
+
 ## RAG ingestion
 
 The optional `@absolutejs/artifacts/rag` entry point resolves one current or
@@ -250,7 +271,10 @@ const upsert = await buildRAGUpsertInputFromUploads({ uploads });
 
 `createArtifactRAGIndexCoordinator` wraps that conversion with durable
 `pending`, `indexed`, and `failed` state. It removes document IDs from the
-previous indexed revision after the replacement succeeds.
+previous indexed revision after the replacement succeeds. Set `failureMode` to
+`"isolate_uploads"` to index structured content and assets independently. A bad
+asset then produces a typed partial receipt while preserving successful
+document ids; obsolete ids are removed only after a fully successful revision.
 
 ## Events and retention
 

package/dist/index.js

@@ -58,35 +58,635 @@ var defineArtifactRegistry = (definitions) => ({
 // src/generators.ts
 var createArtifactGeneratorRegistry = (initial = []) => {
   const generators = new Map(initial.map((generator) => [generator.kind, generator]));
+  const generateResult = async (input) => {
+    const generator = generators.get(input.kind);
+    if (!generator) {
+      throw new ArtifactError("generator_unavailable", `No generator is registered for ${input.kind} artifacts`);
+    }
+    const context = { ownerId: input.ownerId };
+    const result = await generator.generate(input, context);
+    const issues = await generator.validate?.(result, input, context) ?? [];
+    if (issues.length > 0) {
+      throw new ArtifactError("batch_validation_failed", issues.map((issue) => `${issue.code}: ${issue.message}`).join("; "));
+    }
+    return result;
+  };
+  const bundleInput = (input, result) => ({
+    assets: result.assets,
+    content: result.content,
+    createdBy: input.createdBy,
+    kind: input.kind,
+    metadata: {
+      ...result.metadata,
+      ...result.warnings?.length ? { generationWarnings: result.warnings } : {}
+    },
+    provenance: result.provenance,
+    title: result.title ?? input.title ?? `Generated ${input.kind}`
+  });
   return {
     generate: async (service, input) => {
-      const generator = generators.get(input.kind);
-      if (!generator) {
-        throw new ArtifactError("generator_unavailable", `No generator is registered for ${input.kind} artifacts`);
-      }
-      const result = await generator.generate(input, {
-        ownerId: input.ownerId
-      });
-      const artifact = await service.createBundle(input.ownerId, {
-        assets: result.assets,
-        content: result.content,
-        createdBy: input.createdBy,
-        kind: input.kind,
-        metadata: {
-          ...result.metadata,
-          ...result.warnings?.length ? { generationWarnings: result.warnings } : {}
-        },
-        provenance: result.provenance,
-        title: result.title ?? input.title ?? `Generated ${input.kind}`
-      });
+      const result = await generateResult(input);
+      const artifact = await service.createBundle(input.ownerId, bundleInput(input, result));
       return artifact;
     },
+    generateBatch: async (service, input) => {
+      const generated = await Promise.all(input.items.map(async (item) => {
+        const generationInput = {
+          createdBy: item.createdBy,
+          input: item.input,
+          kind: item.kind,
+          ownerId: input.ownerId,
+          prompt: item.prompt,
+          title: item.title
+        };
+        const generator = generators.get(item.kind);
+        if (!generator) {
+          throw new ArtifactError("generator_unavailable", `No generator is registered for ${item.kind} artifacts`);
+        }
+        const context = { ownerId: input.ownerId };
+        const result = await generator.generate(generationInput, context);
+        const issues = await generator.validate?.(result, generationInput, context) ?? [];
+        return {
+          artifact: bundleInput(generationInput, result),
+          evidence: item.evidence,
+          generationIssues: issues,
+          key: item.key
+        };
+      }));
+      const staged = await service.stageBatch(input.ownerId, {
+        bundleId: input.bundleId,
+        commitMode: input.commitMode,
+        evidence: input.evidence,
+        items: generated.map(({ generationIssues: _issues, ...item }) => item),
+        metadata: input.metadata,
+        provenance: input.provenance
+      }, {
+        validators: [
+          () => generated.flatMap((item) => item.generationIssues.map((generationIssue) => ({
+            ...generationIssue,
+            itemKey: item.key
+          }))),
+          ...input.validators ?? []
+        ]
+      });
+      return staged.commit();
+    },
     kinds: () => [...generators.keys()],
     register: (generator) => {
       generators.set(generator.kind, generator);
     }
   };
 };
+// node_modules/fflate/esm/index.mjs
+import { createRequire } from "module";
+var require2 = createRequire("/");
+var _a;
+var Worker;
+var isMarkedAsUntransferable;
+try {
+  _a = require2("worker_threads"), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable;
+} catch (e) {}
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0]);
+var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0;i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1;i < 30; ++i) {
+    for (var j = b[i];j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0;i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = function(cd, mb, r) {
+  var s = cd.length;
+  var i2 = 0;
+  var l = new u16(mb);
+  for (;i2 < s; ++i2) {
+    if (cd[i2])
+      ++l[cd[i2] - 1];
+  }
+  var le = new u16(mb);
+  for (i2 = 1;i2 < mb; ++i2) {
+    le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i2 = 0;i2 < s; ++i2) {
+      if (cd[i2]) {
+        var sv = i2 << 4 | cd[i2];
+        var r_1 = mb - cd[i2];
+        var v = le[cd[i2] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1;v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i2 = 0;i2 < s; ++i2) {
+      if (cd[i2]) {
+        co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
+      }
+    }
+  }
+  return co;
+};
+var flt = new u8(288);
+for (i = 0;i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144;i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256;i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280;i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0;i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m = a[0];
+  for (var i2 = 1;i2 < a.length; ++i2) {
+    if (a[i2] > m)
+      m = a[i2];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i2 = 0;i2 < hcLen; ++i2) {
+          clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i2 = 0;i2 < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i2++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i2++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (;; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i2 = sym - 257, b = fleb[i2];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i2];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (;bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (;bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u8(0);
+var b2 = function(d, b) {
+  return d[b] | d[b + 1] << 8;
+};
+var b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var b8 = function(d, b) {
+  return b4(d, b) + b4(d, b + 4) * 4294967296;
+};
+function inflateSync(data, opts) {
+  return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder;
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {}
+var dutf8 = function(d) {
+  for (var r = "", i2 = 0;; ) {
+    var c = d[i2++];
+    var eb = (c > 127) + (c > 223) + (c > 239);
+    if (i2 + eb > d.length)
+      return { s: r, r: slc(d, i2 - 1) };
+    if (!eb)
+      r += String.fromCharCode(c);
+    else if (eb == 3) {
+      c = ((c & 15) << 18 | (d[i2++] & 63) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+    } else if (eb & 1)
+      r += String.fromCharCode((c & 31) << 6 | d[i2++] & 63);
+    else
+      r += String.fromCharCode((c & 15) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63);
+  }
+};
+function strFromU8(dat, latin1) {
+  if (latin1) {
+    var r = "";
+    for (var i2 = 0;i2 < dat.length; i2 += 16384)
+      r += String.fromCharCode.apply(null, dat.subarray(i2, i2 + 16384));
+    return r;
+  } else if (td) {
+    return td.decode(dat);
+  } else {
+    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+    if (r.length)
+      err(8);
+    return s;
+  }
+}
+var slzh = function(d, b) {
+  return b + 30 + b2(d, b + 26) + b2(d, b + 28);
+};
+var zh = function(d, b, z) {
+  var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
+  var _a2 = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
+  return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
+};
+var z64hs = function(d, b, l, z, sc, su, off) {
+  var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
+  var nf = nsc + nsu + noff;
+  if (z && nf) {
+    for (;b + 4 < e; b += 4 + b2(d, b + 2)) {
+      if (b2(d, b) == 1) {
+        return [
+          nsc ? b8(d, b + 4 + 8 * nsu) : sc,
+          nsu ? b8(d, b + 4) : su,
+          noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off,
+          1
+        ];
+      }
+    }
+    if (z < 2)
+      err(13);
+  }
+  return [sc, su, off, 0];
+};
+function unzipSync(data, opts) {
+  var files = {};
+  var e = data.length - 22;
+  for (;b4(data, e) != 101010256; --e) {
+    if (!e || data.length - e > 65558)
+      err(13);
+  }
+  var c = b2(data, e + 8);
+  if (!c)
+    return {};
+  var o = b4(data, e + 16);
+  var z = b4(data, e - 20) == 117853008;
+  if (z) {
+    var ze = b4(data, e - 12);
+    z = b4(data, ze) == 101075792;
+    if (z) {
+      c = b4(data, ze + 32);
+      o = b4(data, ze + 48);
+    }
+  }
+  var fltr = opts && opts.filter;
+  for (var i2 = 0;i2 < c; ++i2) {
+    var _a2 = zh(data, o, z), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+    o = no;
+    if (!fltr || fltr({
+      name: fn,
+      size: sc,
+      originalSize: su,
+      compression: c_2
+    })) {
+      if (!c_2)
+        files[fn] = slc(data, b, b + sc);
+      else if (c_2 == 8)
+        files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+      else
+        err(14, "unknown compression type " + c_2);
+    }
+  }
+  return files;
+}
+
+// src/validation.ts
+var decode = (data) => new TextDecoder().decode(data);
+var issue = (code, message, path) => ({
+  code,
+  message,
+  ...path ? { path } : {}
+});
+var parseCsvRows = (value) => {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  for (let index = 0;index < value.length; index += 1) {
+    const character = value[index];
+    if (character === '"') {
+      if (quoted && value[index + 1] === '"') {
+        field += '"';
+        index += 1;
+      } else {
+        quoted = !quoted;
+      }
+    } else if (character === "," && !quoted) {
+      row.push(field);
+      field = "";
+    } else if ((character === `
+` || character === "\r") && !quoted) {
+      if (character === "\r" && value[index + 1] === `
+`)
+        index += 1;
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+    } else {
+      field += character;
+    }
+  }
+  if (quoted)
+    throw new Error("CSV contains an unterminated quoted field");
+  if (field.length > 0 || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows.filter((candidate) => candidate.some((cell) => cell.length > 0));
+};
+var validateCsv = (data, path) => {
+  const rows = parseCsvRows(decode(data));
+  if (rows.length === 0)
+    return [issue("csv_empty", "CSV has no rows", path)];
+  const columns = rows[0].length;
+  const inconsistent = rows.findIndex((row) => row.length !== columns);
+  return inconsistent < 0 ? [] : [
+    issue("csv_column_mismatch", `CSV row ${inconsistent + 1} has ${rows[inconsistent].length} columns; expected ${columns}`, path)
+  ];
+};
+var validateEmail = (data, path) => {
+  const value = decode(data).replace(/\r\n?/g, `
+`);
+  const separator = value.indexOf(`
+
+`);
+  if (separator < 0) {
+    return [
+      issue("email_missing_body_separator", "Email must contain headers followed by a blank line and body", path)
+    ];
+  }
+  const headers = value.slice(0, separator);
+  const required = ["to", "subject"].filter((name) => !new RegExp(`^${name}:\\s*\\S+`, "imu").test(headers));
+  return required.map((name) => issue("email_missing_header", `Email is missing a non-empty ${name} header`, path));
+};
+var validateXml = (value) => {
+  const stack = [];
+  const withoutOpaqueSections = value.replace(/<!--[\s\S]*?-->/gu, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/gu, "").replace(/<\?[\s\S]*?\?>/gu, "");
+  for (const match of withoutOpaqueSections.matchAll(/<\s*(\/?)\s*([\w:.-]+)([^>]*)>/gu)) {
+    const closing = match[1] === "/";
+    const name = match[2];
+    const suffix = match[3] ?? "";
+    if (!closing && suffix.trimEnd().endsWith("/"))
+      continue;
+    if (!closing) {
+      stack.push(name);
+      continue;
+    }
+    const expected = stack.pop();
+    if (expected !== name) {
+      throw new Error(expected ? `expected closing tag for <${expected}> but found </${name}>` : `unexpected closing tag </${name}>`);
+    }
+  }
+  if (stack.length > 0)
+    throw new Error(`unclosed tag <${stack.at(-1)}>`);
+};
+var validateZip = (data, path, officePresentation) => {
+  let entries;
+  try {
+    entries = unzipSync(data);
+  } catch (error) {
+    return [
+      issue("zip_invalid", `ZIP archive could not be opened: ${error instanceof Error ? error.message : String(error)}`, path)
+    ];
+  }
+  const names = Object.keys(entries).filter((name) => !name.endsWith("/"));
+  if (names.length === 0) {
+    return [issue("zip_empty", "ZIP archive has no files", path)];
+  }
+  if (!officePresentation)
+    return [];
+  const required = ["[Content_Types].xml", "ppt/presentation.xml"];
+  const missing = required.filter((name) => !entries[name]);
+  if (!names.some((name) => /^ppt\/slides\/slide\d+\.xml$/u.test(name))) {
+    missing.push("ppt/slides/slide*.xml");
+  }
+  const issues = missing.map((name) => issue("presentation_entry_missing", `Presentation is missing ${name}`, path));
+  for (const name of names.filter((candidate) => candidate.endsWith(".xml") || candidate.endsWith(".rels"))) {
+    try {
+      validateXml(decode(entries[name]));
+    } catch (error) {
+      issues.push(issue("presentation_xml_invalid", `${name}: ${error instanceof Error ? error.message : String(error)}`, path));
+    }
+  }
+  return issues;
+};
+var validateGeneratedArtifactFormats = (result) => (result.assets ?? []).flatMap((asset, index) => {
+  const mediaType = asset.mediaType.toLowerCase();
+  const path = `assets[${index}](${asset.name})`;
+  try {
+    if (mediaType.includes("csv"))
+      return validateCsv(asset.data, path);
+    if (mediaType === "message/rfc822")
+      return validateEmail(asset.data, path);
+    if (mediaType.includes("presentationml.presentation")) {
+      return validateZip(asset.data, path, true);
+    }
+    if (mediaType.includes("zip"))
+      return validateZip(asset.data, path, false);
+    return [];
+  } catch (error) {
+    return [
+      issue("format_invalid", error instanceof Error ? error.message : String(error), path)
+    ];
+  }
+});
 // src/standardKinds.ts
 import { Type } from "typebox";
 var FileArtifactContentSchema = Type.Object({
@@ -1108,5 +1708,6 @@ export {
   createMemoryArtifactStore,
   defineArtifactRegistry,
   isJsonValue,
-  standardArtifactDefinitions
+  standardArtifactDefinitions,
+  validateGeneratedArtifactFormats
 };

package/dist/rag.js

@@ -1,6 +1,15 @@
 // @bun
 // src/rag.ts
 import { Buffer } from "buffer";
+
+class ArtifactRAGPartialIndexError extends Error {
+  receipt;
+  constructor(receipt) {
+    super(`Artifact ${receipt.artifactId} indexed ${receipt.indexedUploads}/${receipt.totalUploads} uploads; ${receipt.failures.length} failed`);
+    this.name = "ArtifactRAGPartialIndexError";
+    this.receipt = receipt;
+  }
+}
 var artifactMetadata = (artifact) => ({
   artifactId: artifact.id,
   artifactKind: artifact.kind,
@@ -49,6 +58,58 @@ var createArtifactRAGIndexCoordinator = (options) => ({
     });
     try {
       const uploads = await artifactToRAGUploads(artifact, options.reader);
+      if (options.failureMode === "isolate_uploads") {
+        const documentIds = [];
+        const failures = [];
+        let indexedUploads = 0;
+        for (const upload of uploads) {
+          try {
+            const indexed2 = await options.target.index([upload], { artifact });
+            documentIds.push(...indexed2.documentIds);
+            indexedUploads += 1;
+          } catch (error) {
+            failures.push({
+              contentType: upload.contentType ?? "application/octet-stream",
+              error: error instanceof Error ? error.message : String(error),
+              name: upload.name ?? "unnamed upload",
+              source: upload.source ?? `artifact:${artifact.id}`
+            });
+          }
+        }
+        const receipt = {
+          artifactId: artifact.id,
+          documentIds,
+          failures,
+          indexedUploads,
+          revision: artifact.revision,
+          status: failures.length === 0 ? "indexed" : indexedUploads > 0 ? "partial" : "failed",
+          totalUploads: uploads.length
+        };
+        if (failures.length > 0) {
+          await options.service.markIndexing(artifact.ownerId, artifact.id, {
+            documentIds: [
+              ...new Set([...previous?.documentIds ?? [], ...documentIds])
+            ],
+            error: JSON.stringify({ failures, receipt }),
+            revision: artifact.revision,
+            status: receipt.status
+          });
+          throw new ArtifactRAGPartialIndexError(receipt);
+        }
+        if (previous?.documentIds.length && options.target.remove) {
+          const currentIds = new Set(documentIds);
+          const obsoleteIds = previous.documentIds.filter((documentId) => !currentIds.has(documentId));
+          if (obsoleteIds.length) {
+            await options.target.remove(obsoleteIds, { artifact });
+          }
+        }
+        await options.service.markIndexing(artifact.ownerId, artifact.id, {
+          documentIds,
+          revision: artifact.revision,
+          status: "indexed"
+        });
+        return receipt;
+      }
       const indexed = await options.target.index(uploads, { artifact });
       if (previous?.documentIds.length && options.target.remove) {
         const currentIds = new Set(indexed.documentIds);
@@ -62,8 +123,18 @@ var createArtifactRAGIndexCoordinator = (options) => ({
         revision: artifact.revision,
         status: "indexed"
       });
-      return indexed;
+      return {
+        artifactId: artifact.id,
+        documentIds: indexed.documentIds,
+        failures: [],
+        indexedUploads: uploads.length,
+        revision: artifact.revision,
+        status: "indexed",
+        totalUploads: uploads.length
+      };
     } catch (error) {
+      if (error instanceof ArtifactRAGPartialIndexError)
+        throw error;
       await options.service.markIndexing(artifact.ownerId, artifact.id, {
         documentIds: previous?.documentIds,
         error: error instanceof Error ? error.message : String(error),
@@ -75,6 +146,7 @@ var createArtifactRAGIndexCoordinator = (options) => ({
   }
 });
 export {
+  ArtifactRAGPartialIndexError,
   artifactToRAGUploads,
   createArtifactRAGIndexCoordinator
 };

package/dist/src/generators.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactAssetWriteInput, ArtifactBundleCreateInput, ArtifactProvenance, ArtifactRecord, JsonObject, JsonValue } from "./types";
+import type { ArtifactAssetWriteInput, ArtifactBatchCompletionReceipt, ArtifactBatchCreateInput, ArtifactBatchValidator, ArtifactBundleCreateInput, ArtifactEvidenceReference, ArtifactProvenance, ArtifactRecord, JsonObject, JsonValue } from "./types";
 export type ArtifactGenerationInput = {
     createdBy: string;
     input?: JsonObject;
@@ -22,12 +22,35 @@ export type ArtifactGenerator = {
     generate(input: ArtifactGenerationInput, context: ArtifactGenerationContext): Promise<ArtifactGenerationResult>;
     kind: string;
     name: string;
+    validate?(result: ArtifactGenerationResult, input: ArtifactGenerationInput, context: ArtifactGenerationContext): ArtifactGenerationValidationIssue[] | Promise<ArtifactGenerationValidationIssue[]>;
+};
+export type ArtifactGenerationValidationIssue = {
+    code: string;
+    message: string;
+    path?: string;
 };
 export type ArtifactBundleCreator = {
     createBundle(ownerId: string, input: ArtifactBundleCreateInput): Promise<ArtifactRecord>;
 };
+export type ArtifactBatchGeneratorService = ArtifactBundleCreator & {
+    stageBatch(ownerId: string, input: ArtifactBatchCreateInput, options?: {
+        validators?: ArtifactBatchValidator[];
+    }): Promise<{
+        commit(): Promise<ArtifactBatchCompletionReceipt>;
+    }>;
+};
+export type ArtifactBatchGenerationItem = Omit<ArtifactGenerationInput, "ownerId"> & {
+    evidence?: ArtifactEvidenceReference[];
+    key: string;
+};
+export type ArtifactBatchGenerationInput = Omit<ArtifactBatchCreateInput, "items"> & {
+    items: ArtifactBatchGenerationItem[];
+    ownerId: string;
+    validators?: ArtifactBatchValidator[];
+};
 export declare const createArtifactGeneratorRegistry: (initial?: ArtifactGenerator[]) => {
     generate: (service: ArtifactBundleCreator, input: ArtifactGenerationInput) => Promise<ArtifactRecord>;
+    generateBatch: (service: ArtifactBatchGeneratorService, input: ArtifactBatchGenerationInput) => Promise<ArtifactBatchCompletionReceipt>;
     kinds: () => string[];
     register: (generator: ArtifactGenerator) => void;
 };

package/dist/src/index.d.ts

@@ -7,7 +7,8 @@
  * retains authorization, persistence, URLs, UI, and delivery policy.
  */
 export { defineArtifactRegistry, type ArtifactContent, type ArtifactKindDefinition, type ArtifactKindDefinitions, type ArtifactRegistry, } from "./registry";
-export { createArtifactGeneratorRegistry, type ArtifactBundleCreator, type ArtifactGenerationContext, type ArtifactGenerationInput, type ArtifactGenerationResult, type ArtifactGenerator, type ArtifactGeneratorRegistry, } from "./generators";
+export { createArtifactGeneratorRegistry, type ArtifactBundleCreator, type ArtifactGenerationContext, type ArtifactGenerationInput, type ArtifactGenerationResult, type ArtifactGenerator, type ArtifactGeneratorRegistry, type ArtifactBatchGenerationInput, type ArtifactBatchGenerationItem, type ArtifactBatchGeneratorService, type ArtifactGenerationValidationIssue, } from "./generators";
+export { validateGeneratedArtifactFormats } from "./validation";
 export { STANDARD_ARTIFACT_KIND_NAMES, standardArtifactDefinitions, } from "./standardKinds";
 export { createArtifactRendererRegistry, type ArtifactRenderer, type ArtifactRendererRegistry, type ArtifactRenderResult, } from "./renderers";
 export { createArtifactService, type ArtifactPublisher, type ArtifactService, type ArtifactServiceOptions, } from "./service";

package/dist/src/rag.d.ts

@@ -26,21 +26,39 @@ export type ArtifactRAGIndexStateWriter = {
         documentIds?: string[];
         error?: string;
         revision: number;
-        status: "failed" | "indexed" | "pending" | "stale";
+        status: "failed" | "indexed" | "partial" | "pending" | "stale";
     }): Promise<unknown>;
 };
+export type ArtifactRAGIndexFailure = {
+    contentType: string;
+    error: string;
+    name: string;
+    source: string;
+};
+export type ArtifactRAGIndexReceipt = {
+    artifactId: string;
+    documentIds: string[];
+    failures: ArtifactRAGIndexFailure[];
+    indexedUploads: number;
+    revision: number;
+    status: "failed" | "indexed" | "partial";
+    totalUploads: number;
+};
+export declare class ArtifactRAGPartialIndexError extends Error {
+    readonly receipt: ArtifactRAGIndexReceipt;
+    constructor(receipt: ArtifactRAGIndexReceipt);
+}
 /**
  * Resolve an artifact revision into upload inputs accepted by @absolutejs/rag.
  * Storage URIs remain opaque; only the supplied reader is allowed to access bytes.
  */
 export declare const artifactToRAGUploads: (artifact: ArtifactRecord, reader: ArtifactRAGAssetReader, options?: ArtifactRAGUploadOptions) => Promise<RAGDocumentUploadInput[]>;
 export declare const createArtifactRAGIndexCoordinator: (options: {
+    failureMode?: "fail_fast" | "isolate_uploads";
     reader: ArtifactRAGAssetReader;
     service: ArtifactRAGIndexStateWriter;
     target: ArtifactRAGIndexTarget;
 }) => {
-    index: (artifact: ArtifactRecord) => Promise<{
-        documentIds: string[];
-    }>;
+    index: (artifact: ArtifactRecord) => Promise<ArtifactRAGIndexReceipt>;
 };
 export type ArtifactRAGIndexCoordinator = ReturnType<typeof createArtifactRAGIndexCoordinator>;

package/dist/src/types.d.ts

@@ -94,7 +94,7 @@ export type ArtifactEventQuery = {
     processed?: boolean;
     type?: ArtifactEventType;
 };
-export type ArtifactIndexingStatus = "failed" | "indexed" | "pending" | "stale";
+export type ArtifactIndexingStatus = "failed" | "indexed" | "partial" | "pending" | "stale";
 export type ArtifactIndexingState = {
     artifactId: string;
     documentIds: string[];

package/dist/src/validation.d.ts

@@ -0,0 +1,3 @@
+import type { ArtifactGenerationResult, ArtifactGenerationValidationIssue } from "./generators";
+/** Validate common generated download formats before an artifact is committed. */
+export declare const validateGeneratedArtifactFormats: (result: ArtifactGenerationResult) => ArtifactGenerationValidationIssue[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absolutejs/artifacts",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Typed, versioned artifacts for AI products — schemas, lifecycle, storage, rendering, publishing, revisions, and agent tools without prescribing a database or host.",
   "author": "Alex Kahn",
   "license": "BUSL-1.1",
@@ -60,6 +60,7 @@
     "@absolutejs/manifest": "^0.10.0",
     "@sinclair/typebox": "^0.34.0",
     "drizzle-typebox": "1.0.0-beta.14-a36c63d",
+    "fflate": "^0.8.2",
     "typebox": "^1.3.16"
   },
   "peerDependencies": {