@sweberdev/witness 0.0.0-stage → 0.1.0

package/dist/ai-sdk.cjs

@@ -0,0 +1,921 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ai-sdk.ts
+var ai_sdk_exports = {};
+__export(ai_sdk_exports, {
+  witnessImageMiddleware: () => witnessImageMiddleware,
+  witnessMiddleware: () => witnessMiddleware,
+  witnessProviderMetadata: () => witnessProviderMetadata
+});
+module.exports = __toCommonJS(ai_sdk_exports);
+
+// src/inflate.ts
+var LENGTH_BASE = [
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  13,
+  15,
+  17,
+  19,
+  23,
+  27,
+  31,
+  35,
+  43,
+  51,
+  59,
+  67,
+  83,
+  99,
+  115,
+  131,
+  163,
+  195,
+  227,
+  258
+];
+var LENGTH_EXTRA = [
+  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
+];
+var DIST_BASE = [
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577
+];
+var DIST_EXTRA = [
+  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
+];
+var CODE_LENGTH_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+function buildTree(lengths, offset, count) {
+  const tree = { counts: new Uint16Array(16), symbols: new Uint16Array(count) };
+  for (let i = 0; i < count; i++) {
+    const length = lengths[offset + i] ?? 0;
+    tree.counts[length] = (tree.counts[length] ?? 0) + 1;
+  }
+  tree.counts[0] = 0;
+  const offsets = new Uint16Array(16);
+  let sum = 0;
+  for (let i = 0; i < 16; i++) {
+    offsets[i] = sum;
+    sum += tree.counts[i] ?? 0;
+  }
+  for (let i = 0; i < count; i++) {
+    const length = lengths[offset + i] ?? 0;
+    if (length) {
+      const at = offsets[length] ?? 0;
+      tree.symbols[at] = i;
+      offsets[length] = at + 1;
+    }
+  }
+  return tree;
+}
+var fixed = null;
+function fixedTrees() {
+  if (!fixed) {
+    const lengths = new Uint8Array(288);
+    lengths.fill(8, 0, 144);
+    lengths.fill(9, 144, 256);
+    lengths.fill(7, 256, 280);
+    lengths.fill(8, 280, 288);
+    fixed = { lit: buildTree(lengths, 0, 288), dist: buildTree(new Uint8Array(30).fill(5), 0, 30) };
+  }
+  return fixed;
+}
+var Reader = class {
+  constructor(data) {
+    this.data = data;
+    this.pos = 0;
+    this.bit = 0;
+    this.bits = 0;
+  }
+  getBit() {
+    if (this.bits === 0) {
+      if (this.pos >= this.data.length) throw new Error("inflate: unexpected end of data");
+      this.bit = this.data[this.pos++] ?? 0;
+      this.bits = 8;
+    }
+    const value = this.bit & 1;
+    this.bit >>>= 1;
+    this.bits--;
+    return value;
+  }
+  read(count, base = 0) {
+    let value = 0;
+    for (let i = 0; i < count; i++) value |= this.getBit() << i;
+    return value + base;
+  }
+  decode(tree) {
+    let sum = 0;
+    let cur = 0;
+    let len = 0;
+    do {
+      cur = 2 * cur + this.getBit();
+      len++;
+      if (len > 15) throw new Error("inflate: invalid code");
+      sum += tree.counts[len] ?? 0;
+      cur -= tree.counts[len] ?? 0;
+    } while (cur >= 0);
+    return tree.symbols[sum + cur] ?? 0;
+  }
+};
+function dynamicTrees(r) {
+  const hlit = r.read(5, 257);
+  const hdist = r.read(5, 1);
+  const hclen = r.read(4, 4);
+  const codeLengths = new Uint8Array(19);
+  for (let i = 0; i < hclen; i++) codeLengths[CODE_LENGTH_ORDER[i] ?? 0] = r.read(3);
+  const codeTree = buildTree(codeLengths, 0, 19);
+  const lengths = new Uint8Array(hlit + hdist);
+  for (let n = 0; n < hlit + hdist; ) {
+    const sym = r.decode(codeTree);
+    if (sym < 16) {
+      lengths[n++] = sym;
+      continue;
+    }
+    let repeat;
+    let value = 0;
+    if (sym === 16) {
+      if (n === 0) throw new Error("inflate: invalid repeat");
+      value = lengths[n - 1] ?? 0;
+      repeat = r.read(2, 3);
+    } else if (sym === 17) {
+      repeat = r.read(3, 3);
+    } else {
+      repeat = r.read(7, 11);
+    }
+    while (repeat-- > 0) lengths[n++] = value;
+  }
+  return { lit: buildTree(lengths, 0, hlit), dist: buildTree(lengths, hlit, hdist) };
+}
+function inflateZlib(data, maxLength = 16 * 1024 * 1024) {
+  if (data.length < 2 || ((data[0] ?? 0) & 15) !== 8 || ((data[0] ?? 0) << 8 | (data[1] ?? 0)) % 31 !== 0) {
+    throw new Error("inflate: not a zlib stream");
+  }
+  const r = new Reader(data);
+  r.pos = 2;
+  let out = new Uint8Array(Math.max(1024, data.length * 4));
+  let length = 0;
+  const push = (byte) => {
+    if (length >= out.length) {
+      if (out.length >= maxLength) throw new Error("inflate: output too large");
+      const next = new Uint8Array(Math.min(maxLength, out.length * 2));
+      next.set(out);
+      out = next;
+    }
+    out[length++] = byte;
+  };
+  let final = 0;
+  do {
+    final = r.getBit();
+    const type = r.read(2);
+    if (type === 0) {
+      r.bits = 0;
+      if (r.pos + 4 > data.length) throw new Error("inflate: unexpected end of data");
+      const len = (data[r.pos] ?? 0) | (data[r.pos + 1] ?? 0) << 8;
+      r.pos += 4;
+      if (r.pos + len > data.length) throw new Error("inflate: unexpected end of data");
+      for (let i = 0; i < len; i++) push(data[r.pos++] ?? 0);
+    } else if (type === 1 || type === 2) {
+      const { lit, dist } = type === 1 ? fixedTrees() : dynamicTrees(r);
+      for (; ; ) {
+        const sym = r.decode(lit);
+        if (sym === 256) break;
+        if (sym < 256) {
+          push(sym);
+          continue;
+        }
+        const index = sym - 257;
+        const len = r.read(LENGTH_EXTRA[index] ?? 0, LENGTH_BASE[index] ?? 0);
+        const distSym = r.decode(dist);
+        const offset = r.read(DIST_EXTRA[distSym] ?? 0, DIST_BASE[distSym] ?? 0);
+        if (offset > length) throw new Error("inflate: invalid distance");
+        for (let i = 0; i < len; i++) push(out[length - offset] ?? 0);
+      }
+    } else {
+      throw new Error("inflate: invalid block type");
+    }
+  } while (!final);
+  return out.subarray(0, length);
+}
+
+// src/marking.ts
+var IPTC_BASE = "http://cv.iptc.org/newscodes/digitalsourcetype/";
+var DEFAULT_SOURCE = {
+  generated: "trainedAlgorithmicMedia",
+  edited: "compositeWithTrainedAlgorithmicMedia",
+  deepfake: "trainedAlgorithmicMedia"
+};
+function iptcSourceType(type) {
+  return IPTC_BASE + type;
+}
+function createMarking(input = {}) {
+  const kind = input.kind ?? "generated";
+  const createdAt = input.createdAt instanceof Date ? input.createdAt.toISOString() : input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const marking = {
+    kind,
+    sourceType: input.sourceType ?? DEFAULT_SOURCE[kind],
+    createdAt,
+    humanReviewed: input.humanReviewed ?? false
+  };
+  if (input.generator) marking.generator = input.generator;
+  if (input.generatorVersion) marking.generatorVersion = input.generatorVersion;
+  if (input.provider) marking.provider = input.provider;
+  if (input.disclosureUrl) marking.disclosureUrl = input.disclosureUrl;
+  if (input.description) marking.description = input.description;
+  return marking;
+}
+function generatorName(m) {
+  if (!m.generator) return "";
+  return m.generatorVersion ? `${m.generator} ${m.generatorVersion}` : m.generator;
+}
+
+// src/image.ts
+var XMP_NS = "http://ns.adobe.com/xap/1.0/\0";
+var WITNESS_NS = "https://packages.sweber.dev/witness/ns/1.0/";
+function detectImageFormat(bytes) {
+  if (bytes.length >= 8 && bytes[0] === 137 && ascii(bytes, 1, 3) === "PNG") return "png";
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "jpeg";
+  }
+  if (bytes.length >= 12 && ascii(bytes, 0, 4) === "RIFF" && ascii(bytes, 8, 4) === "WEBP") {
+    return "webp";
+  }
+  return null;
+}
+function markImage(bytes, input = {}, options = {}) {
+  const format = detectImageFormat(bytes);
+  if (!format) return { bytes, status: "unsupported", format };
+  if (options.c2pa !== "overwrite" && hasC2pa(bytes, format)) {
+    return { bytes, status: "skipped-c2pa", format };
+  }
+  const marking = "sourceType" in input && "humanReviewed" in input ? input : createMarking(input);
+  const existing = readXmp(bytes, format);
+  const xmp = buildXmp(marking, existing);
+  const out = format === "png" ? writePng(bytes, xmp) : format === "jpeg" ? writeJpeg(bytes, xmp) : writeWebp(bytes, xmp);
+  return { bytes: out, status: "marked", format };
+}
+function buildXmp(marking, existing) {
+  const description = buildDescription(marking);
+  if (existing?.includes("</rdf:RDF>")) {
+    const cleaned = existing.replace(/<rdf:Description\b[^>]*witness:marker="1"[^>]*\/>\s*/g, "").replace(
+      /<rdf:Description\b[^>]*witness:marker="1"[^>]*>[\s\S]*?<\/rdf:Description>\s*/g,
+      ""
+    );
+    return cleaned.replace("</rdf:RDF>", `${description}
+</rdf:RDF>`);
+  }
+  return [
+    '<?xpacket begin="\uFEFF" id="W5M0MpCehiHzreSzNTczkc9d"?>',
+    '<x:xmpmeta xmlns:x="adobe:ns:meta/">',
+    '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">',
+    description,
+    "</rdf:RDF>",
+    "</x:xmpmeta>",
+    '<?xpacket end="w"?>'
+  ].join("\n");
+}
+function buildDescription(m) {
+  const attributes = [
+    ["rdf:about", ""],
+    ["xmlns:Iptc4xmpExt", "http://iptc.org/std/Iptc4xmpExt/2008-02-29/"],
+    ["xmlns:xmp", "http://ns.adobe.com/xap/1.0/"],
+    ["xmlns:dc", "http://purl.org/dc/elements/1.1/"],
+    ["xmlns:witness", WITNESS_NS],
+    ["witness:marker", "1"],
+    ["witness:kind", m.kind],
+    ["Iptc4xmpExt:DigitalSourceType", iptcSourceType(m.sourceType)],
+    ["xmp:CreateDate", m.createdAt]
+  ];
+  if (m.generator) {
+    attributes.push(["Iptc4xmpExt:AISystemUsed", m.generator]);
+    attributes.push(["xmp:CreatorTool", generatorName(m)]);
+  }
+  if (m.generatorVersion) attributes.push(["Iptc4xmpExt:AISystemVersionUsed", m.generatorVersion]);
+  if (m.provider) attributes.push(["witness:provider", m.provider]);
+  if (m.disclosureUrl) attributes.push(["witness:disclosureUrl", m.disclosureUrl]);
+  if (m.humanReviewed) attributes.push(["witness:humanReviewed", "True"]);
+  const attrs = attributes.map(([name, value]) => `
+  ${name}="${escapeXml(value)}"`).join("");
+  const description = m.description ? `
+  <dc:description><rdf:Alt><rdf:li xml:lang="x-default">${escapeXml(m.description)}</rdf:li></rdf:Alt></dc:description>
+` : "";
+  return description ? `<rdf:Description${attrs}>${description}</rdf:Description>` : `<rdf:Description${attrs}/>`;
+}
+function writePng(bytes, xmp) {
+  const chunks = pngChunks(bytes).filter((chunk) => !isPngXmp(bytes, chunk));
+  const itxt = pngChunk(
+    "iTXt",
+    concat(latin1("XML:com.adobe.xmp"), new Uint8Array([0, 0, 0, 0, 0]), utf8(xmp))
+  );
+  const parts = [bytes.subarray(0, 8)];
+  for (const chunk of chunks) {
+    parts.push(bytes.subarray(chunk.offset, chunk.end));
+    if (chunk.type === "IHDR") parts.push(itxt);
+  }
+  return concat(...parts);
+}
+function pngChunks(bytes) {
+  const chunks = [];
+  let offset = 8;
+  while (offset + 12 <= bytes.length) {
+    const length = readU32BE(bytes, offset);
+    const type = ascii(bytes, offset + 4, 4);
+    const dataStart = offset + 8;
+    const dataEnd = dataStart + length;
+    const end = dataEnd + 4;
+    if (end > bytes.length) throw new Error("Witness: truncated PNG chunk");
+    chunks.push({ type, offset, dataStart, dataEnd, end });
+    offset = end;
+    if (type === "IEND") break;
+  }
+  return chunks;
+}
+function isPngXmp(bytes, chunk) {
+  return (chunk.type === "iTXt" || chunk.type === "zTXt") && ascii(bytes, chunk.dataStart, 18) === "XML:com.adobe.xmp\0";
+}
+function readPngXmp(bytes) {
+  for (const chunk of pngChunks(bytes)) {
+    if (!isPngXmp(bytes, chunk)) continue;
+    let p = chunk.dataStart + 18;
+    let compressed;
+    if (chunk.type === "zTXt") {
+      compressed = true;
+      p += 1;
+    } else {
+      compressed = bytes[p] === 1;
+      p += 2;
+      while (p < chunk.dataEnd && bytes[p] !== 0) p++;
+      p++;
+      while (p < chunk.dataEnd && bytes[p] !== 0) p++;
+      p++;
+    }
+    const data = bytes.subarray(p, chunk.dataEnd);
+    try {
+      return new TextDecoder().decode(compressed ? inflateZlib(data) : data);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function pngChunk(type, data) {
+  const out = new Uint8Array(12 + data.length);
+  writeU32BE(out, 0, data.length);
+  out.set(latin1(type), 4);
+  out.set(data, 8);
+  writeU32BE(out, 8 + data.length, crc32(out.subarray(4, 8 + data.length)));
+  return out;
+}
+function jpegSegments(bytes) {
+  const segments = [];
+  let offset = 2;
+  while (offset + 4 <= bytes.length) {
+    if (bytes[offset] !== 255) throw new Error("Witness: invalid JPEG marker");
+    let markerOffset = offset;
+    while (bytes[markerOffset + 1] === 255) markerOffset++;
+    const marker = bytes[markerOffset + 1] ?? 0;
+    if (marker === 218 || marker === 217) return { segments, scanStart: offset };
+    const length = readU16BE(bytes, markerOffset + 2);
+    const end = markerOffset + 2 + length;
+    if (end > bytes.length) throw new Error("Witness: truncated JPEG segment");
+    segments.push({ marker, offset, dataStart: markerOffset + 4, end });
+    offset = end;
+  }
+  return { segments, scanStart: offset };
+}
+function isJpegXmp(bytes, segment) {
+  return segment.marker === 225 && ascii(bytes, segment.dataStart, XMP_NS.length) === XMP_NS;
+}
+function writeJpeg(bytes, xmp) {
+  const { segments, scanStart } = jpegSegments(bytes);
+  const payload = concat(latin1(XMP_NS), utf8(xmp));
+  if (payload.length + 2 > 65535) throw new Error("Witness: XMP packet too large for JPEG");
+  const app1 = new Uint8Array(4 + payload.length);
+  app1[0] = 255;
+  app1[1] = 225;
+  app1[2] = payload.length + 2 >> 8 & 255;
+  app1[3] = payload.length + 2 & 255;
+  app1.set(payload, 4);
+  const kept = segments.filter((segment) => !isJpegXmp(bytes, segment));
+  let insertAt = 0;
+  while (insertAt < kept.length) {
+    const segment = kept[insertAt];
+    if (!segment) break;
+    const isJfif = segment.marker === 224;
+    const isExif = segment.marker === 225 && ascii(bytes, segment.dataStart, 4) === "Exif";
+    if (!isJfif && !isExif) break;
+    insertAt++;
+  }
+  const parts = [bytes.subarray(0, 2)];
+  kept.forEach((segment, index) => {
+    if (index === insertAt) parts.push(app1);
+    parts.push(bytes.subarray(segment.offset, segment.end));
+  });
+  if (insertAt >= kept.length) parts.push(app1);
+  parts.push(bytes.subarray(scanStart));
+  return concat(...parts);
+}
+function readJpegXmp(bytes) {
+  for (const segment of jpegSegments(bytes).segments) {
+    if (isJpegXmp(bytes, segment)) {
+      return new TextDecoder().decode(
+        bytes.subarray(segment.dataStart + XMP_NS.length, segment.end)
+      );
+    }
+  }
+  return null;
+}
+function webpChunks(bytes) {
+  const chunks = [];
+  const riffEnd = Math.min(bytes.length, 8 + readU32LE(bytes, 4));
+  let offset = 12;
+  while (offset + 8 <= riffEnd) {
+    const fourcc = ascii(bytes, offset, 4);
+    const size = readU32LE(bytes, offset + 4);
+    const dataStart = offset + 8;
+    const end = dataStart + size + size % 2;
+    if (dataStart + size > bytes.length) throw new Error("Witness: truncated WebP chunk");
+    chunks.push({ fourcc, offset, dataStart, size, end: Math.min(end, bytes.length) });
+    offset = end;
+  }
+  return chunks;
+}
+function writeWebp(bytes, xmp) {
+  const chunks = webpChunks(bytes).filter((chunk) => chunk.fourcc !== "XMP ");
+  const first = chunks[0];
+  if (!first) throw new Error("Witness: empty WebP file");
+  const parts = [];
+  if (first.fourcc === "VP8X") {
+    const vp8x = bytes.slice(first.offset, first.end);
+    vp8x[8] = (vp8x[8] ?? 0) | 4;
+    parts.push(vp8x);
+    for (const chunk of chunks.slice(1)) parts.push(bytes.subarray(chunk.offset, chunk.end));
+  } else {
+    const { width, height, alpha } = webpCanvas(bytes, first);
+    const data = new Uint8Array(10);
+    data[0] = 4 | (alpha ? 16 : 0);
+    writeU24LE(data, 4, width - 1);
+    writeU24LE(data, 7, height - 1);
+    parts.push(riffChunk("VP8X", data));
+    for (const chunk of chunks) parts.push(bytes.subarray(chunk.offset, chunk.end));
+  }
+  parts.push(riffChunk("XMP ", utf8(xmp)));
+  const body = concat(...parts);
+  const out = new Uint8Array(12 + body.length);
+  out.set(latin1("RIFF"), 0);
+  writeU32LE(out, 4, 4 + body.length);
+  out.set(latin1("WEBP"), 8);
+  out.set(body, 12);
+  return out;
+}
+function webpCanvas(bytes, chunk) {
+  const d = chunk.dataStart;
+  if (chunk.fourcc === "VP8 ") {
+    if (bytes[d + 3] !== 157 || bytes[d + 4] !== 1 || bytes[d + 5] !== 42) {
+      throw new Error("Witness: invalid VP8 frame");
+    }
+    return {
+      width: readU16LE(bytes, d + 6) & 16383,
+      height: readU16LE(bytes, d + 8) & 16383,
+      alpha: false
+    };
+  }
+  if (chunk.fourcc === "VP8L") {
+    if (bytes[d] !== 47) throw new Error("Witness: invalid VP8L frame");
+    const bits = readU32LE(bytes, d + 1);
+    return {
+      width: (bits & 16383) + 1,
+      height: (bits >>> 14 & 16383) + 1,
+      alpha: (bits >>> 28 & 1) === 1
+    };
+  }
+  throw new Error(`Witness: unexpected WebP chunk ${chunk.fourcc}`);
+}
+function readWebpXmp(bytes) {
+  const chunk = webpChunks(bytes).find((c) => c.fourcc === "XMP ");
+  return chunk ? new TextDecoder().decode(bytes.subarray(chunk.dataStart, chunk.dataStart + chunk.size)) : null;
+}
+function riffChunk(fourcc, data) {
+  const out = new Uint8Array(8 + data.length + data.length % 2);
+  out.set(latin1(fourcc), 0);
+  writeU32LE(out, 4, data.length);
+  out.set(data, 8);
+  return out;
+}
+function readXmp(bytes, format) {
+  if (format === "png") return readPngXmp(bytes);
+  if (format === "jpeg") return readJpegXmp(bytes);
+  return readWebpXmp(bytes);
+}
+function hasC2pa(bytes, format) {
+  if (format === "png") return pngChunks(bytes).some((chunk) => chunk.type === "caBX");
+  if (format === "webp") return webpChunks(bytes).some((chunk) => chunk.fourcc === "C2PA");
+  return jpegSegments(bytes).segments.some(
+    (segment) => segment.marker === 235 && ascii(bytes, segment.dataStart, Math.min(64, segment.end - segment.dataStart)).includes(
+      "c2pa"
+    )
+  );
+}
+function ascii(bytes, offset, length) {
+  let out = "";
+  for (let i = offset; i < offset + length && i < bytes.length; i++) {
+    out += String.fromCharCode(bytes[i] ?? 0);
+  }
+  return out;
+}
+function latin1(text) {
+  const out = new Uint8Array(text.length);
+  for (let i = 0; i < text.length; i++) out[i] = text.charCodeAt(i) & 255;
+  return out;
+}
+function utf8(text) {
+  return new TextEncoder().encode(text);
+}
+function concat(...parts) {
+  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function readU16BE(b, o) {
+  return (b[o] ?? 0) << 8 | (b[o + 1] ?? 0);
+}
+function readU16LE(b, o) {
+  return (b[o] ?? 0) | (b[o + 1] ?? 0) << 8;
+}
+function readU32BE(b, o) {
+  return ((b[o] ?? 0) << 24 | (b[o + 1] ?? 0) << 16 | (b[o + 2] ?? 0) << 8 | (b[o + 3] ?? 0)) >>> 0;
+}
+function readU32LE(b, o) {
+  return ((b[o] ?? 0) | (b[o + 1] ?? 0) << 8 | (b[o + 2] ?? 0) << 16 | (b[o + 3] ?? 0) << 24) >>> 0;
+}
+function writeU32BE(b, o, v) {
+  b[o] = v >>> 24 & 255;
+  b[o + 1] = v >>> 16 & 255;
+  b[o + 2] = v >>> 8 & 255;
+  b[o + 3] = v & 255;
+}
+function writeU32LE(b, o, v) {
+  b[o] = v & 255;
+  b[o + 1] = v >>> 8 & 255;
+  b[o + 2] = v >>> 16 & 255;
+  b[o + 3] = v >>> 24 & 255;
+}
+function writeU24LE(b, o, v) {
+  b[o] = v & 255;
+  b[o + 1] = v >>> 8 & 255;
+  b[o + 2] = v >>> 16 & 255;
+}
+var crcTable = null;
+function crc32(data) {
+  if (!crcTable) {
+    crcTable = 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;
+      crcTable[n] = c >>> 0;
+    }
+  }
+  let crc = 4294967295;
+  for (const byte of data) crc = (crcTable[(crc ^ byte) & 255] ?? 0) ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/watermark.ts
+var MAGIC = [87, 49];
+var MAX_PAYLOAD = 255;
+function watermarkText(text, mark = {}) {
+  if (text.length === 0) return text;
+  return stripTextWatermark(text) + watermarkSuffix(mark);
+}
+function watermarkSuffix(mark = {}) {
+  const payload = encodePayload(mark);
+  return [...MAGIC, payload.length, ...payload].map(byteToSelector).join("");
+}
+function stripTextWatermark(text) {
+  const chars = [...text];
+  const remove = /* @__PURE__ */ new Set();
+  for (const run of selectorRuns(text)) {
+    let offset = 0;
+    while (offset < run.bytes.length) {
+      const found = findInRun(run.bytes.slice(offset));
+      if (!found) break;
+      const start = offset + found.start;
+      const end = offset + found.end;
+      for (let i = start; i < end; i++) remove.add(run.start + i);
+      offset = end;
+    }
+  }
+  if (remove.size === 0) return text;
+  return chars.filter((_, index) => !remove.has(index)).join("");
+}
+function encodePayload(mark) {
+  const fields = [];
+  if (mark.generator) fields.push(`g=${encodeURIComponent(mark.generator)}`);
+  if (mark.createdAt) fields.push(`t=${encodeURIComponent(mark.createdAt)}`);
+  if (mark.id) fields.push(`i=${encodeURIComponent(mark.id)}`);
+  let bytes = [...new TextEncoder().encode(fields.join(";"))];
+  if (bytes.length > MAX_PAYLOAD) {
+    while (fields.length > 0 && bytes.length > MAX_PAYLOAD) {
+      fields.pop();
+      bytes = [...new TextEncoder().encode(fields.join(";"))];
+    }
+  }
+  return bytes;
+}
+function byteToSelector(byte) {
+  return byte < 16 ? String.fromCodePoint(65024 + byte) : String.fromCodePoint(917760 + (byte - 16));
+}
+function selectorToByte(codePoint) {
+  if (codePoint >= 65024 && codePoint <= 65039) return codePoint - 65024;
+  if (codePoint >= 917760 && codePoint <= 917999) return codePoint - 917760 + 16;
+  return null;
+}
+function selectorRuns(text) {
+  const runs = [];
+  let current = null;
+  let index = 0;
+  for (const char of text) {
+    const byte = selectorToByte(char.codePointAt(0) ?? 0);
+    if (byte === null) {
+      current = null;
+    } else {
+      if (!current) {
+        current = { start: index, bytes: [] };
+        runs.push(current);
+      }
+      current.bytes.push(byte);
+    }
+    index++;
+  }
+  return runs;
+}
+function findInRun(bytes) {
+  for (let i = 0; i + MAGIC.length < bytes.length; i++) {
+    if (bytes[i] !== MAGIC[0] || bytes[i + 1] !== MAGIC[1]) continue;
+    const length = bytes[i + 2];
+    if (length === void 0) continue;
+    const start = i + 3;
+    const end = start + length;
+    if (end > bytes.length) continue;
+    return { start: i, end, payload: bytes.slice(start, end) };
+  }
+  return null;
+}
+
+// src/ai-sdk.ts
+function witnessProviderMetadata(marking) {
+  return {
+    aiGenerated: true,
+    kind: marking.kind,
+    sourceType: iptcSourceType(marking.sourceType),
+    createdAt: marking.createdAt,
+    ...marking.generator ? { generator: marking.generator } : {},
+    ...marking.provider ? { provider: marking.provider } : {}
+  };
+}
+function witnessMiddleware(options = {}) {
+  const watermark = options.watermark ?? true;
+  const markingFor = (model) => createMarking({
+    kind: options.kind ?? "generated",
+    generator: generatorFor(options.generator, model),
+    ...options.provider ? { provider: options.provider } : {}
+  });
+  const watermarkFor = (marking) => ({
+    ...marking.generator ? { generator: marking.generator } : {},
+    createdAt: marking.createdAt,
+    ...options.id ? { id: options.id() } : {}
+  });
+  return {
+    specificationVersion: options.specificationVersion ?? "v4",
+    async wrapGenerate({
+      doGenerate,
+      model
+    }) {
+      const result = await doGenerate();
+      const marking = markingFor(model);
+      const content = result.content.map((part) => {
+        if (part.type !== "text" || typeof part.text !== "string" || part.text.length === 0) {
+          return part;
+        }
+        options.onMarked?.({ type: "text", marking });
+        return watermark ? { ...part, text: watermarkText(part.text, watermarkFor(marking)) } : part;
+      });
+      return {
+        ...result,
+        content,
+        providerMetadata: { ...result.providerMetadata, witness: witnessProviderMetadata(marking) }
+      };
+    },
+    async wrapStream({
+      doStream,
+      model
+    }) {
+      const result = await doStream();
+      const marking = markingFor(model);
+      const withText = /* @__PURE__ */ new Set();
+      const transform = new TransformStream({
+        transform(part, controller) {
+          const id = part.id ?? "";
+          if (part.type === "text-delta" && typeof part.delta === "string" && part.delta.length > 0) {
+            withText.add(id);
+          }
+          if (part.type === "text-end" && withText.has(id)) {
+            withText.delete(id);
+            options.onMarked?.({ type: "text", marking, partId: id });
+            if (watermark) {
+              controller.enqueue({
+                type: "text-delta",
+                id,
+                delta: watermarkSuffix(watermarkFor(marking))
+              });
+            }
+          }
+          if (part.type === "finish") {
+            controller.enqueue({
+              ...part,
+              providerMetadata: {
+                ...part.providerMetadata,
+                witness: witnessProviderMetadata(marking)
+              }
+            });
+            return;
+          }
+          controller.enqueue(part);
+        }
+      });
+      return { ...result, stream: result.stream.pipeThrough(transform) };
+    }
+  };
+}
+function witnessImageMiddleware(options = {}) {
+  return {
+    specificationVersion: options.specificationVersion ?? "v4",
+    async wrapGenerate({
+      doGenerate,
+      model
+    }) {
+      const result = await doGenerate();
+      const marking = createMarking({
+        kind: options.kind ?? "generated",
+        generator: generatorFor(options.generator, model),
+        ...options.provider ? { provider: options.provider } : {}
+      });
+      const warnings = [...result.warnings];
+      const markOne = (bytes) => {
+        const marked = markImage(bytes, marking, options.c2pa ? { c2pa: options.c2pa } : {});
+        options.onMarked?.({ type: "image", marking, status: marked.status });
+        if (marked.status !== "marked") {
+          warnings.push({
+            type: "other",
+            message: marked.status === "skipped-c2pa" ? "Witness: image already carries a C2PA manifest and was left unchanged." : "Witness: image format not supported (PNG, JPEG, WebP); image is not marked."
+          });
+        }
+        return marked.bytes;
+      };
+      const images = result.images.map(
+        (image) => typeof image === "string" ? toBase64(markOne(fromBase64(image))) : markOne(image)
+      );
+      return { ...result, images, warnings };
+    }
+  };
+}
+function generatorFor(option, model) {
+  if (typeof option === "function") return option(model);
+  return option ?? `${model.provider}/${model.modelId}`;
+}
+function fromBase64(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function toBase64(bytes) {
+  let binary = "";
+  const step = 32768;
+  for (let i = 0; i < bytes.length; i += step) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + step));
+  }
+  return btoa(binary);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  witnessImageMiddleware,
+  witnessMiddleware,
+  witnessProviderMetadata
+});
+//# sourceMappingURL=ai-sdk.cjs.map