@privacyscrubber/sdk 2.3.9 → 2.4.1

package/vercel-ai.cjs

@@ -0,0 +1,400 @@
+/**
+ * @privacyscrubber/sdk/vercel-ai
+ * Zero-Trust Data Sanitization (ZTDS) In-Memory Middleware for Vercel AI SDK
+ * Conforms to IETF Standards Track: draft-sibiryakov-ztds-protocol-01
+ *
+ * Core Protocol Invariants:
+ * 1. Zero External Egress Prior to Sanitization
+ * 2. Deterministic Reversible Tokenization
+ * 3. Sub-millisecond In-Memory Sliding-Window Streaming Detokenization
+ * 4. Zero Network Dependencies (100% Local RAM Execution)
+ *
+ * Compatible with Vercel AI SDK v3/v4: streamText, generateText, wrapLanguageModel.
+ *
+ * https://privacyscrubber.com/sdk/
+ */
+
+const {
+  PrivacyScrubberEngine,
+  StreamingDetokenizer,
+  buildStreamReplacer,
+  buildCisoAuditTelemetry
+} = require('./index.cjs');
+
+const TOKEN_MAP_SYMBOL = Symbol('ztds_token_map');
+const tokenMapsWeakMap = new WeakMap();
+
+/**
+ * Sanitizes Vercel AI SDK prompt structures (array of messages, string, or multipart parts)
+ * in local RAM before model invocation.
+ *
+ * @param {any} prompt - Array of LanguageModelV1Prompt messages or string.
+ * @param {PrivacyScrubberEngine} engine - Initialized PrivacyScrubberEngine instance.
+ * @param {Record<string, string>} sessionTokenMap - Volatile map populated with detected tokens.
+ * @returns {any} Sanitized prompt with tokens replacing authentic PII.
+ */
+function sanitizePromptParts(prompt, engine, sessionTokenMap) {
+  if (!prompt) return prompt;
+
+  if (typeof prompt === 'string') {
+    const res = engine.sanitize(prompt, { existingSessionMap: sessionTokenMap });
+    Object.assign(sessionTokenMap, res.tokenMap);
+    return res.scrubbedText;
+  }
+
+  if (!Array.isArray(prompt)) return prompt;
+
+  return prompt.map(msg => {
+    if (!msg || typeof msg !== 'object') return msg;
+
+    // Standard string content: { role: 'user', content: 'Contact john@example.com' }
+    if (typeof msg.content === 'string') {
+      const res = engine.sanitize(msg.content, { existingSessionMap: sessionTokenMap });
+      Object.assign(sessionTokenMap, res.tokenMap);
+      return { ...msg, content: res.scrubbedText };
+    }
+
+    // Multipart content: { role: 'user', content: [{ type: 'text', text: '...' }] }
+    if (Array.isArray(msg.content)) {
+      const newContent = msg.content.map(part => {
+        if (part && part.type === 'text' && typeof part.text === 'string') {
+          const res = engine.sanitize(part.text, { existingSessionMap: sessionTokenMap });
+          Object.assign(sessionTokenMap, res.tokenMap);
+          return { ...part, text: res.scrubbedText };
+        }
+        if (part && part.type === 'tool-result' && typeof part.result === 'string') {
+          const res = engine.sanitize(part.result, { existingSessionMap: sessionTokenMap });
+          Object.assign(sessionTokenMap, res.tokenMap);
+          return { ...part, result: res.scrubbedText };
+        }
+        return part;
+      });
+      return { ...msg, content: newContent };
+    }
+
+    return msg;
+  });
+}
+
+/**
+ * Creates a Vercel AI SDK LanguageModelV1Middleware instance.
+ * Intercepts outbound prompt parameters to sanitize PII in RAM, and transparently
+ * restores tokens in generated responses and streaming deltas.
+ *
+ * @param {object} [options={}] - PrivacyScrubber configuration options.
+ * @param {string} [options.profile='General'] - Detection profile ('General', 'Medical', 'Finance', 'Dev', etc.).
+ * @param {boolean} [options.detectSecrets=true] - Whether to detect API keys, tokens, and credentials.
+ * @param {string} [options.licenseKey] - PrivacyScrubber SDK license key.
+ * @param {boolean} [options.sanitizeInputs=true] - Whether to sanitize inbound prompt messages.
+ * @param {boolean} [options.sanitizeOutputs=true] - Whether to restore tokens in outbound responses/deltas.
+ * @param {Function} [options.onSanitized] - Optional telemetry callback on sanitization.
+ * @param {object} [options.streamingOptions] - Sliding window buffer tuning options for StreamingDetokenizer.
+ * @returns {object} LanguageModelV1Middleware compliant object.
+ */
+function createPrivacyMiddleware(options = {}) {
+  const sanitizeInputs = options.sanitizeInputs !== false;
+  const sanitizeOutputs = options.sanitizeOutputs !== false;
+
+  return {
+    async transformParams({ type, params }) {
+      if (!sanitizeInputs || !params) {
+        return params;
+      }
+
+      const engine = options.engine || new PrivacyScrubberEngine(options);
+      const sessionTokenMap = {};
+      const sanitizedPrompt = sanitizePromptParts(params.prompt, engine, sessionTokenMap);
+      const sanitizedParams = {
+        ...params,
+        prompt: sanitizedPrompt
+      };
+
+      tokenMapsWeakMap.set(sanitizedParams, sessionTokenMap);
+      tokenMapsWeakMap.set(params, sessionTokenMap);
+      try {
+        Object.defineProperty(sanitizedParams, TOKEN_MAP_SYMBOL, {
+          value: sessionTokenMap,
+          writable: true,
+          enumerable: false,
+          configurable: true
+        });
+      } catch (_) {}
+
+      if (typeof options.onSanitized === 'function') {
+        try {
+          options.onSanitized({
+            type,
+            prompt: sanitizedPrompt,
+            tokenMap: sessionTokenMap,
+            tokenCount: Object.keys(sessionTokenMap).length
+          });
+        } catch (_) {}
+      }
+
+      return sanitizedParams;
+    },
+
+    async wrapGenerate({ doGenerate, params, model }) {
+      const tokenMap = (params && (tokenMapsWeakMap.get(params) || params[TOKEN_MAP_SYMBOL])) || {};
+      const result = await doGenerate();
+
+      if (sanitizeOutputs && result && Object.keys(tokenMap).length > 0) {
+        if (typeof result.text === 'string') {
+          result.text = detokenizeText(result.text, tokenMap);
+        }
+        if (typeof result.reasoning === 'string') {
+          result.reasoning = detokenizeText(result.reasoning, tokenMap);
+        }
+      }
+
+      return result;
+    },
+
+    async wrapStream({ doStream, params, model }) {
+      const tokenMap = (params && (tokenMapsWeakMap.get(params) || params[TOKEN_MAP_SYMBOL])) || {};
+      const result = await doStream();
+
+      if (sanitizeOutputs && result && result.stream && Object.keys(tokenMap).length > 0) {
+        const detok = new StreamingDetokenizer(tokenMap, options.streamingOptions);
+        const originalStream = result.stream;
+
+        if (typeof originalStream.pipeThrough === 'function' && typeof TransformStream !== 'undefined') {
+          result.stream = originalStream.pipeThrough(new TransformStream({
+            transform(chunk, controller) {
+              if (chunk && chunk.type === 'text-delta' && typeof chunk.textDelta === 'string') {
+                const restored = detok.feed(chunk.textDelta);
+                if (restored) controller.enqueue({ ...chunk, textDelta: restored });
+              } else if (chunk && chunk.type === 'reasoning' && typeof chunk.textDelta === 'string') {
+                const restored = detok.feed(chunk.textDelta);
+                if (restored) controller.enqueue({ ...chunk, textDelta: restored });
+              } else {
+                controller.enqueue(chunk);
+              }
+            },
+            flush(controller) {
+              const rem = detok.flush();
+              if (rem) controller.enqueue({ type: 'text-delta', textDelta: rem });
+            }
+          }));
+        } else if (typeof originalStream[Symbol.asyncIterator] === 'function') {
+          async function* wrappedAsync() {
+            for await (const chunk of originalStream) {
+              if (chunk && chunk.type === 'text-delta' && typeof chunk.textDelta === 'string') {
+                const restored = detok.feed(chunk.textDelta);
+                if (restored) yield { ...chunk, textDelta: restored };
+              } else if (chunk && chunk.type === 'reasoning' && typeof chunk.textDelta === 'string') {
+                const restored = detok.feed(chunk.textDelta);
+                if (restored) yield { ...chunk, textDelta: restored };
+              } else {
+                yield chunk;
+              }
+            }
+            const rem = detok.flush();
+            if (rem) yield { type: 'text-delta', textDelta: rem };
+          }
+          result.stream = wrappedAsync();
+        }
+      }
+
+      return result;
+    }
+  };
+}
+
+/**
+ * Wraps a Vercel AI SDK LanguageModel instance with the specified middleware.
+ * Fully compatible with Vercel AI SDK's experimental_wrapLanguageModel / wrapLanguageModel.
+ *
+ * @param {object} params - Parameters object.
+ * @param {object} params.model - The LanguageModel instance to wrap.
+ * @param {object} params.middleware - LanguageModelV1Middleware instance.
+ * @returns {object} Wrapped LanguageModel instance.
+ */
+function wrapLanguageModel({ model, middleware }) {
+  if (!model || typeof model !== 'object') {
+    throw new Error('[PrivacyScrubber] wrapLanguageModel requires a valid LanguageModel instance.');
+  }
+  if (!middleware || typeof middleware !== 'object') {
+    return model;
+  }
+
+  const wrapped = Object.create(model);
+
+  if (typeof model.doGenerate === 'function') {
+    wrapped.doGenerate = async function(params) {
+      let callParams = params;
+      if (typeof middleware.transformParams === 'function') {
+        callParams = await middleware.transformParams({ type: 'generate', params: callParams });
+      }
+      if (typeof middleware.wrapGenerate === 'function') {
+        return middleware.wrapGenerate({
+          doGenerate: () => model.doGenerate(callParams),
+          params: callParams,
+          model
+        });
+      }
+      return model.doGenerate(callParams);
+    };
+  }
+
+  if (typeof model.doStream === 'function') {
+    wrapped.doStream = async function(params) {
+      let callParams = params;
+      if (typeof middleware.transformParams === 'function') {
+        callParams = await middleware.transformParams({ type: 'stream', params: callParams });
+      }
+      if (typeof middleware.wrapStream === 'function') {
+        return middleware.wrapStream({
+          doStream: () => model.doStream(callParams),
+          params: callParams,
+          model
+        });
+      }
+      return model.doStream(callParams);
+    };
+  }
+
+  return wrapped;
+}
+
+/**
+ * Universal wrapper for Vercel AI SDK.
+ *
+ * When passed a LanguageModel instance:
+ *   const safeModel = withPrivacyScrubber(openai('gpt-4o'), { profile: 'General' });
+ * Returns the privacy-shielded model directly.
+ *
+ * When passed options (or 0 arguments):
+ *   const middleware = withPrivacyScrubber({ profile: 'General' });
+ * Returns the LanguageModelV1Middleware object for wrapLanguageModel.
+ *
+ * @param {any} [modelOrOptions] - LanguageModel instance OR options object.
+ * @param {object} [maybeOptions] - Options if model was passed as first argument.
+ * @returns {any} Shielded model OR middleware object.
+ */
+function withPrivacyScrubber(modelOrOptions, maybeOptions) {
+  if (modelOrOptions && (typeof modelOrOptions.doGenerate === 'function' || typeof modelOrOptions.doStream === 'function' || modelOrOptions.specificationVersion)) {
+    const middleware = createPrivacyMiddleware(maybeOptions || {});
+    const wrapped = wrapLanguageModel({ model: modelOrOptions, middleware });
+    wrapped.middleware = middleware;
+    return wrapped;
+  }
+
+  return createPrivacyMiddleware(modelOrOptions || {});
+}
+
+/**
+ * Creates a standard Web API TransformStream for piping text or deltas through the StreamingDetokenizer.
+ * Compatible with Next.js Route Handlers and Web Streams:
+ *   response.pipeThrough(createDetokenizerTransformStream(tokenMap));
+ *
+ * @param {Record<string, string>} [tokenMap={}] - Volatile session token map.
+ * @param {object} [options={}] - Detokenizer tuning options.
+ * @returns {TransformStream}
+ */
+function createDetokenizerTransformStream(tokenMap = {}, options = {}) {
+  const detok = new StreamingDetokenizer(tokenMap, options);
+  if (typeof TransformStream === 'undefined') {
+    throw new Error('[PrivacyScrubber] TransformStream is not supported in this runtime.');
+  }
+  let isObjectStream = false;
+  return new TransformStream({
+    transform(chunk, controller) {
+      if (typeof chunk === 'string') {
+        const out = detok.feed(chunk);
+        if (out) controller.enqueue(out);
+      } else if (chunk && typeof chunk === 'object' && typeof chunk.textDelta === 'string') {
+        isObjectStream = true;
+        const out = detok.feed(chunk.textDelta);
+        if (out) controller.enqueue({ ...chunk, textDelta: out });
+      } else {
+        controller.enqueue(chunk);
+      }
+    },
+    flush(controller) {
+      const rem = detok.flush();
+      if (rem) {
+        if (isObjectStream) {
+          controller.enqueue({ type: 'text-delta', textDelta: rem });
+        } else {
+          controller.enqueue(rem);
+        }
+      }
+    }
+  });
+}
+
+/**
+ * Wraps an async iterable stream (e.g. result.textStream from streamText) and transparently
+ * de-tokenizes split tokens on the fly.
+ *
+ * @param {AsyncIterable<string|object>} stream - The incoming stream.
+ * @param {Record<string, string>} [tokenMap={}] - Volatile session token map.
+ * @param {object} [options={}] - Detokenizer tuning options.
+ * @returns {AsyncGenerator<any>}
+ */
+async function* detokenizeStream(stream, tokenMap = {}, options = {}) {
+  const detok = new StreamingDetokenizer(tokenMap, options);
+  for await (const chunk of stream) {
+    if (typeof chunk === 'string') {
+      const out = detok.feed(chunk);
+      if (out) yield out;
+    } else if (chunk && typeof chunk === 'object' && typeof chunk.textDelta === 'string') {
+      const out = detok.feed(chunk.textDelta);
+      if (out) yield { ...chunk, textDelta: out };
+    } else {
+      yield chunk;
+    }
+  }
+  const rem = detok.flush();
+  if (rem) {
+    yield rem;
+  }
+}
+
+/**
+ * Replaces tokens in text with authentic values in local RAM.
+ *
+ * @param {string} text - Text containing tokens.
+ * @param {Record<string, string>} [tokenMap={}] - Volatile session token map.
+ * @returns {string} Restored text.
+ */
+function detokenizeText(text, tokenMap = {}) {
+  if (typeof text !== 'string') return text;
+  const replacer = buildStreamReplacer(tokenMap);
+  return replacer(text);
+}
+
+/**
+ * Direct prompt sanitization helper for Vercel AI SDK prompts.
+ *
+ * @param {any} prompt - Array of messages or raw string prompt.
+ * @param {object} [options={}] - Sanitization options.
+ * @returns {{ sanitizedPrompt: any, tokenMap: Record<string, string>, tokenCount: number, telemetry: object }}
+ */
+function sanitizePrompt(prompt, options = {}) {
+  const engine = new PrivacyScrubberEngine(options);
+  const tokenMap = {};
+  const sanitizedPrompt = sanitizePromptParts(prompt, engine, tokenMap);
+  const telemetry = buildCisoAuditTelemetry(tokenMap, {
+    frameworks: ['GDPR', 'HIPAA', 'SOC2', 'PCI-DSS', 'NIST-AI-RMF']
+  });
+  return {
+    sanitizedPrompt,
+    tokenMap,
+    tokenCount: Object.keys(tokenMap).length,
+    telemetry
+  };
+}
+
+module.exports = {
+  createPrivacyMiddleware,
+  wrapLanguageModel,
+  withPrivacyScrubber,
+  createDetokenizerTransformStream,
+  detokenizeStream,
+  detokenizeText,
+  sanitizePrompt,
+  StreamingDetokenizer
+};
+module.exports.default = module.exports;

package/vercel-ai.d.ts

@@ -0,0 +1,156 @@
+/**
+ * @privacyscrubber/sdk/vercel-ai
+ * TypeScript Definitions for Vercel AI SDK Zero-Trust Middleware
+ */
+
+export interface PrivacyMiddlewareOptions {
+  /**
+   * Detection profile to apply.
+   * Universal profiles: 'General' (universal consumer PII).
+   * 30 Specialized Industry Profiles: 'Medical' (HIPAA), 'Finance' (GLBA/PCI-DSS), 'Dev' (API Keys/Secrets), 'Legal', etc.
+   * Default: 'General'
+   */
+  profile?: string;
+
+  /**
+   * Whether to scan for DevOps secrets (OpenAI, AWS, GitHub tokens, private keys).
+   * Default: true
+   */
+  detectSecrets?: boolean;
+
+  /**
+   * Commercial Developer SDK or Enterprise license key.
+   */
+  licenseKey?: string;
+
+  /**
+   * Whether to sanitize inbound prompt messages before LLM model invocation.
+   * Default: true
+   */
+  sanitizeInputs?: boolean;
+
+  /**
+   * Whether to de-tokenize outbound generated text and real-time streaming deltas.
+   * Default: true
+   */
+  sanitizeOutputs?: boolean;
+
+  /**
+   * Optional telemetry callback invoked upon inbound prompt sanitization.
+   */
+  onSanitized?: (telemetry: {
+    type: 'generate' | 'stream';
+    prompt: any;
+    tokenMap: Record<string, string>;
+    tokenCount: number;
+  }) => void;
+
+  /**
+   * Optional sliding window buffer options for StreamingDetokenizer.
+   */
+  streamingOptions?: {
+    tailWindow?: number;
+    maxSessionTokens?: number;
+  };
+
+  /**
+   * Custom user-defined regex rules to run in addition to the selected profile.
+   */
+  customRules?: Array<{ name: string; pattern: RegExp; tokenType: string }>;
+}
+
+export interface PrivacyMiddleware {
+  transformParams: (options: {
+    type: 'generate' | 'stream';
+    params: any;
+  }) => Promise<any>;
+
+  wrapGenerate: (options: {
+    doGenerate: () => Promise<any>;
+    params: any;
+    model: any;
+  }) => Promise<any>;
+
+  wrapStream: (options: {
+    doStream: () => Promise<any>;
+    params: any;
+    model: any;
+  }) => Promise<any>;
+}
+
+export interface SanitizePromptResult {
+  sanitizedPrompt: any;
+  tokenMap: Record<string, string>;
+  tokenCount: number;
+  telemetry: any;
+}
+
+/**
+ * Creates a Vercel AI SDK LanguageModelV1Middleware instance.
+ */
+export declare function createPrivacyMiddleware(options?: PrivacyMiddlewareOptions): PrivacyMiddleware;
+
+/**
+ * Universal wrapper for Vercel AI SDK models or middleware creator.
+ *
+ * When passed a model:
+ *   const safeModel = withPrivacyScrubber(openai('gpt-4o'), { profile: 'General' });
+ * Returns the shielded model directly.
+ *
+ * When passed options:
+ *   const middleware = withPrivacyScrubber({ profile: 'General' });
+ * Returns the middleware for wrapLanguageModel.
+ */
+export declare function withPrivacyScrubber<TModel = any>(model: TModel, options?: PrivacyMiddlewareOptions): TModel;
+export declare function withPrivacyScrubber(options?: PrivacyMiddlewareOptions): PrivacyMiddleware;
+
+/**
+ * Wraps a Vercel AI SDK LanguageModel with the specified middleware.
+ */
+export declare function wrapLanguageModel<TModel = any>(params: { model: TModel; middleware: any }): TModel;
+
+/**
+ * Creates a standard Web API TransformStream for piping text or deltas through the StreamingDetokenizer.
+ */
+export declare function createDetokenizerTransformStream(
+  tokenMap?: Record<string, string>,
+  options?: any
+): TransformStream;
+
+/**
+ * Wraps an async iterable stream (e.g. result.textStream from streamText) and transparently
+ * de-tokenizes split tokens on the fly.
+ */
+export declare function detokenizeStream<T = any>(
+  stream: AsyncIterable<T>,
+  tokenMap?: Record<string, string>,
+  options?: any
+): AsyncGenerator<T>;
+
+/**
+ * Replaces tokens in text with authentic values in local RAM.
+ */
+export declare function detokenizeText(text: string, tokenMap?: Record<string, string>): string;
+
+/**
+ * Direct prompt sanitization helper for Vercel AI SDK prompts.
+ */
+export declare function sanitizePrompt(prompt: any, options?: PrivacyMiddlewareOptions): SanitizePromptResult;
+
+/**
+ * Streaming Token Detokenizer with sliding window buffer for LLM chunk boundary splits.
+ */
+export { StreamingDetokenizer } from './index';
+
+declare const _default: {
+  createPrivacyMiddleware: typeof createPrivacyMiddleware;
+  withPrivacyScrubber: typeof withPrivacyScrubber;
+  wrapLanguageModel: typeof wrapLanguageModel;
+  createDetokenizerTransformStream: typeof createDetokenizerTransformStream;
+  detokenizeStream: typeof detokenizeStream;
+  detokenizeText: typeof detokenizeText;
+  sanitizePrompt: typeof sanitizePrompt;
+  StreamingDetokenizer: any;
+};
+
+export default _default;

package/vercel-ai.js

@@ -0,0 +1,36 @@
+/**
+ * @privacyscrubber/sdk/vercel-ai
+ * Zero-Trust Data Sanitization (ZTDS) In-Memory Middleware for Vercel AI SDK
+ * Conforms to IETF Standards Track: draft-sibiryakov-ztds-protocol-01
+ *
+ * Sub-millisecond in-memory prompt sanitization and real-time streaming de-tokenization.
+ * Compatible with Vercel AI SDK v3/v4: streamText, generateText, wrapLanguageModel.
+ * Zero external dependencies. Zero network calls. 100% local RAM execution.
+ *
+ * https://privacyscrubber.com/sdk/
+ */
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const vercelAi = require('./vercel-ai.cjs');
+
+export const createPrivacyMiddleware = vercelAi.createPrivacyMiddleware;
+export const withPrivacyScrubber = vercelAi.withPrivacyScrubber;
+export const wrapLanguageModel = vercelAi.wrapLanguageModel;
+export const createDetokenizerTransformStream = vercelAi.createDetokenizerTransformStream;
+export const detokenizeStream = vercelAi.detokenizeStream;
+export const detokenizeText = vercelAi.detokenizeText;
+export const sanitizePrompt = vercelAi.sanitizePrompt;
+export const StreamingDetokenizer = vercelAi.StreamingDetokenizer;
+
+export default {
+  createPrivacyMiddleware,
+  withPrivacyScrubber,
+  wrapLanguageModel,
+  createDetokenizerTransformStream,
+  detokenizeStream,
+  detokenizeText,
+  sanitizePrompt,
+  StreamingDetokenizer
+};

package/vision.cjs

@@ -71,15 +71,23 @@ function stripExifMetadata(inputBuffer) {
 
       // Markers to strip:
       // 0xE1 = APP1 (EXIF, XMP)
+      // 0xE2 = APP2 (ICC Profile, FlashPix, MPF)
+      // 0xEC = APP12 (Picture Info, Ducky)
       // 0xED = APP13 (Photoshop IRB, IPTC)
       // 0xFE = COM (Comment)
       const isExif = marker === 0xE1;
+      const isApp2 = marker === 0xE2;
+      const isApp12 = marker === 0xEC;
       const isIptc = marker === 0xED;
       const isComment = marker === 0xFE;
 
-      if (isExif || isIptc || isComment) {
+      if (isExif || isApp2 || isApp12 || isIptc || isComment) {
         stripped = true;
-        const segmentName = isExif ? 'APP1 (Exif/XMP)' : isIptc ? 'APP13 (IPTC)' : 'COM (Comment)';
+        const segmentName = isExif ? 'APP1 (Exif/XMP)'
+          : isApp2 ? 'APP2 (ICC/MPF)'
+          : isApp12 ? 'APP12 (PictureInfo/Ducky)'
+          : isIptc ? 'APP13 (IPTC)'
+          : 'COM (Comment)';
         removedSegments.push(segmentName);
         offset = segmentEnd;
       } else if (marker === 0xDA) { // SOS (Start of Scan) - compressed bitstream follows until EOI
@@ -128,8 +136,8 @@ function stripExifMetadata(inputBuffer) {
     let offset = 8;
     let stripped = false;
 
-    // Ancillary chunk types to strip: eXIf, tEXt, zTXt, iTXt, tIME, pHYs
-    const ANCILLARY_TYPES = new Set(['eXIf', 'tEXt', 'zTXt', 'iTXt', 'tIME', 'pHYs']);
+    // Ancillary chunk types to strip: eXIf, tEXt, zTXt, iTXt, tIME, pHYs, iCCP
+    const ANCILLARY_TYPES = new Set(['eXIf', 'tEXt', 'zTXt', 'iTXt', 'tIME', 'pHYs', 'iCCP']);
 
     while (offset + 8 <= u8.length) {
       const length = (u8[offset] << 24) | (u8[offset + 1] << 16) | (u8[offset + 2] << 8) | u8[offset + 3];
@@ -199,7 +207,7 @@ function stripExifMetadata(inputBuffer) {
         break;
       }
 
-      if (fourCC === 'EXIF' || fourCC === 'XMP ') {
+      if (fourCC === 'EXIF' || fourCC === 'XMP ' || fourCC === 'ICCP') {
         stripped = true;
         removedSegments.push(`WEBP_${fourCC.trim()}`);
         offset += totalChunkSize;

package/vision.js

@@ -71,15 +71,23 @@ export function stripExifMetadata(inputBuffer) {
 
       // Markers to strip:
       // 0xE1 = APP1 (EXIF, XMP)
+      // 0xE2 = APP2 (ICC Profile, FlashPix, MPF)
+      // 0xEC = APP12 (Picture Info, Ducky)
       // 0xED = APP13 (Photoshop IRB, IPTC)
       // 0xFE = COM (Comment)
       const isExif = marker === 0xE1;
+      const isApp2 = marker === 0xE2;
+      const isApp12 = marker === 0xEC;
       const isIptc = marker === 0xED;
       const isComment = marker === 0xFE;
 
-      if (isExif || isIptc || isComment) {
+      if (isExif || isApp2 || isApp12 || isIptc || isComment) {
         stripped = true;
-        const segmentName = isExif ? 'APP1 (Exif/XMP)' : isIptc ? 'APP13 (IPTC)' : 'COM (Comment)';
+        const segmentName = isExif ? 'APP1 (Exif/XMP)'
+          : isApp2 ? 'APP2 (ICC/MPF)'
+          : isApp12 ? 'APP12 (PictureInfo/Ducky)'
+          : isIptc ? 'APP13 (IPTC)'
+          : 'COM (Comment)';
         removedSegments.push(segmentName);
         offset = segmentEnd;
       } else if (marker === 0xDA) { // SOS (Start of Scan) - compressed bitstream follows until EOI
@@ -128,8 +136,8 @@ export function stripExifMetadata(inputBuffer) {
     let offset = 8;
     let stripped = false;
 
-    // Ancillary chunk types to strip: eXIf, tEXt, zTXt, iTXt, tIME, pHYs
-    const ANCILLARY_TYPES = new Set(['eXIf', 'tEXt', 'zTXt', 'iTXt', 'tIME', 'pHYs']);
+    // Ancillary chunk types to strip: eXIf, tEXt, zTXt, iTXt, tIME, pHYs, iCCP
+    const ANCILLARY_TYPES = new Set(['eXIf', 'tEXt', 'zTXt', 'iTXt', 'tIME', 'pHYs', 'iCCP']);
 
     while (offset + 8 <= u8.length) {
       const length = (u8[offset] << 24) | (u8[offset + 1] << 16) | (u8[offset + 2] << 8) | u8[offset + 3];
@@ -199,7 +207,7 @@ export function stripExifMetadata(inputBuffer) {
         break;
       }
 
-      if (fourCC === 'EXIF' || fourCC === 'XMP ') {
+      if (fourCC === 'EXIF' || fourCC === 'XMP ' || fourCC === 'ICCP') {
         stripped = true;
         removedSegments.push(`WEBP_${fourCC.trim()}`);
         offset += totalChunkSize;