@affectively/synthetic-watermark 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.0.0] - 2026-01-25
+
+### Added
+
+- Initial release
+- PNG image watermarking using iTXt chunks
+- MP3 audio watermarking using ID3v2 COMM frames
+- Watermark detection for both formats
+- Convenience functions for common AI sources (DALL-E, Gemini, etc.)
+- Full TypeScript support
+- Zero external dependencies

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AFFECTIVELY
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,197 @@
+# @affectively/synthetic-watermark
+
+Invisible watermarking for AI-generated content. Embeds synthetic origin markers into PNG images and MP3 audio files for authenticity verification and AI safety compliance.
+
+## Features
+
+- **Image Watermarking** - Embeds invisible metadata into PNG files using iTXt chunks
+- **Audio Watermarking** - Embeds metadata into MP3 files using ID3v2 tags
+- **Detection** - Verify if content has synthetic origin markers
+- **Zero Dependencies** - Uses only Node.js Buffer API
+- **Non-Destructive** - Watermarks are stored in metadata, not visible/audible content
+- **AI Safety** - Helps identify AI-generated content for authenticity verification
+
+## Installation
+
+```bash
+npm install @affectively/synthetic-watermark
+# or
+bun add @affectively/synthetic-watermark
+# or
+yarn add @affectively/synthetic-watermark
+```
+
+## Quick Start
+
+### Image Watermarking
+
+```typescript
+import {
+  embedImageWatermark,
+  detectSyntheticImageWatermark,
+} from '@affectively/synthetic-watermark';
+
+// Watermark an AI-generated image
+const pngBuffer = await fs.readFile('ai-generated-image.png');
+const watermarkedImage = embedImageWatermark(pngBuffer, 'png', {
+  source: 'dalle',
+  model: 'dall-e-3',
+  platform: 'MyApp',
+});
+
+// Save the watermarked image
+await fs.writeFile('watermarked-image.png', watermarkedImage);
+
+// Detect watermark
+const detected = detectSyntheticImageWatermark(watermarkedImage);
+if (detected) {
+  console.log('Synthetic origin detected:', detected);
+  // { platform: 'MyApp', source: 'dalle', model: 'dall-e-3', timestamp: 1234567890 }
+}
+```
+
+### Audio Watermarking
+
+```typescript
+import {
+  embedAudioWatermark,
+  detectSyntheticWatermark,
+} from '@affectively/synthetic-watermark';
+
+// Watermark AI-generated audio
+const mp3Buffer = await fs.readFile('tts-audio.mp3');
+const watermarkedAudio = embedAudioWatermark(mp3Buffer, 'mp3', {
+  source: 'tts',
+  platform: 'MyApp',
+});
+
+// Save the watermarked audio
+await fs.writeFile('watermarked-audio.mp3', watermarkedAudio);
+
+// Detect watermark
+const detected = detectSyntheticWatermark(watermarkedAudio);
+if (detected) {
+  console.log('Synthetic audio detected:', detected);
+  // { platform: 'MyApp', source: 'tts', timestamp: 1234567890 }
+}
+```
+
+## Convenience Functions
+
+### For Images
+
+```typescript
+import {
+  watermarkDallEImage,
+  watermarkGeminiImage,
+  watermarkDigitalTwinImage,
+  watermarkCyranoImage,
+} from '@affectively/synthetic-watermark';
+
+// Pre-configured for specific AI image generators
+const watermarked = watermarkDallEImage(imageBuffer, 'png', optionalUserIdHash);
+```
+
+### For Audio
+
+```typescript
+import {
+  watermarkDigitalTwinAudio,
+  watermarkHologramAudio,
+  watermarkCyranoAudio,
+} from '@affectively/synthetic-watermark';
+
+// Pre-configured for specific TTS systems
+const watermarked = watermarkCyranoAudio(audioBuffer, 'mp3');
+```
+
+## Watermark Format
+
+### Image Watermark (PNG iTXt chunk)
+
+```
+SyntheticOrigin: SYNTHETIC_IMAGE|platform|source|timestamp|userIdHash|model
+```
+
+### Audio Watermark (ID3v2 COMM frame)
+
+```
+SYNTHETIC_ORIGIN: SYNTHETIC_AUDIO|platform|source|timestamp|userIdHash
+```
+
+## API Reference
+
+### Image Functions
+
+#### `embedImageWatermark(buffer, format, config?)`
+
+Embeds an invisible watermark into a PNG image.
+
+- `buffer` - Image data (Uint8Array)
+- `format` - Image format (currently only 'png' supported)
+- `config` - Optional configuration:
+  - `platform` - Platform identifier (default: 'SYNTHETIC')
+  - `source` - Source system (e.g., 'dalle', 'gemini')
+  - `model` - Model name (e.g., 'dall-e-3')
+  - `userIdHash` - Hashed user ID for audit trail
+
+Returns: Watermarked image buffer
+
+#### `detectSyntheticImageWatermark(buffer)`
+
+Detects and extracts watermark from PNG image.
+
+Returns: `ImageWatermarkConfig | null`
+
+### Audio Functions
+
+#### `embedAudioWatermark(buffer, format, config?)`
+
+Embeds an invisible watermark into MP3 audio.
+
+- `buffer` - Audio data (Buffer)
+- `format` - Audio format (currently only 'mp3' supported)
+- `config` - Optional configuration:
+  - `platform` - Platform identifier (default: 'SYNTHETIC')
+  - `source` - Source system (e.g., 'tts', 'hologram')
+  - `userIdHash` - Hashed user ID for audit trail
+
+Returns: Watermarked audio buffer
+
+#### `detectSyntheticWatermark(buffer)`
+
+Detects and extracts watermark from MP3 audio.
+
+Returns: `WatermarkConfig | null`
+
+## Use Cases
+
+1. **AI Safety Compliance** - Mark AI-generated content for authenticity verification
+2. **Content Authentication** - Verify the origin of synthetic media
+3. **Audit Trail** - Track when and by whom content was generated
+4. **Platform Trust** - Help users identify AI-generated content
+5. **Regulatory Compliance** - Support emerging AI content disclosure requirements
+
+## Technical Details
+
+### PNG Watermarking
+
+- Uses iTXt (International Text) chunk per PNG specification
+- Inserted before IEND chunk
+- Includes proper CRC32 checksum
+- Non-destructive to image data
+
+### MP3 Watermarking
+
+- Uses ID3v2.3 COMM (Comment) frame
+- Replaces existing ID3 tag if present
+- Syncsafe integer encoding for size
+- Compatible with standard ID3 readers
+
+## Browser Support
+
+Works in Node.js and browser environments (requires Buffer polyfill in browser).
+
+## License
+
+MIT © AFFECTIVELY

package/dist/index.d.mts

@@ -0,0 +1,130 @@
+import { Buffer } from 'buffer';
+
+/**
+ * Image Watermarking Service
+ *
+ * Embeds INVISIBLE metadata into generated images to indicate
+ * "Synthetic Origin" - marking AI-generated images for safety/authenticity.
+ *
+ * These watermarks are completely invisible to users.
+ * They are stored in the PNG file's metadata chunks (iTXt/tEXt),
+ * not rendered on the image itself. Similar to EXIF data in photos.
+ *
+ * For PNG format: Uses ancillary iTXt chunk (international text)
+ * For JPEG format: Could use EXIF/XMP metadata (future)
+ * For WebP format: Could use XMP metadata (future)
+ */
+
+/**
+ * Watermark configuration
+ */
+interface ImageWatermarkConfig {
+    /** Platform identifier */
+    platform: string;
+    /** Timestamp of generation */
+    timestamp: number;
+    /** Source system (e.g., 'dalle', 'imagen', 'gemini', 'digital_twin') */
+    source: string;
+    /** Optional user ID (hashed) for audit trail */
+    userIdHash?: string;
+    /** Optional model name */
+    model?: string;
+}
+/**
+ * Embed INVISIBLE watermark into image buffer
+ *
+ * For PNG: Inserts iTXt chunk before IEND
+ * For other formats: Passes through unchanged (future: EXIF/XMP)
+ *
+ * The watermark is stored in metadata, NOT visible on the image.
+ *
+ * @param imageBuffer - Raw image data
+ * @param format - Image format (png, jpeg, webp)
+ * @param config - Watermark configuration
+ * @returns Watermarked image buffer
+ */
+declare function embedImageWatermark(imageBuffer: Uint8Array, format?: string, config?: Partial<ImageWatermarkConfig>): Buffer;
+/**
+ * Detect synthetic origin watermark from image
+ *
+ * @param imageBuffer - Image data to check
+ * @returns Watermark info if found, null otherwise
+ */
+declare function detectSyntheticImageWatermark(imageBuffer: Buffer): ImageWatermarkConfig | null;
+/**
+ * Convenience function for DALL-E generated images
+ */
+declare function watermarkDallEImage(imageBuffer: Uint8Array, format?: string, userIdHash?: string): Buffer;
+/**
+ * Convenience function for Gemini Imagen images
+ */
+declare function watermarkGeminiImage(imageBuffer: Uint8Array, format?: string, userIdHash?: string): Buffer;
+/**
+ * Convenience function for Digital Twin generated images
+ */
+declare function watermarkDigitalTwinImage(imageBuffer: Uint8Array, format?: string, userIdHash?: string): Buffer;
+/**
+ * Convenience function for Cyrano-generated images
+ */
+declare function watermarkCyranoImage(imageBuffer: Uint8Array, format?: string, userIdHash?: string): Buffer;
+
+/**
+ * Audio Watermarking Service
+ *
+ * Embeds invisible/inaudible metadata into synthesized audio to indicate
+ * "Synthetic Origin" - marking AI-generated audio for safety and authenticity.
+ *
+ * Approach: Adds a metadata comment to the MP3 ID3 tag or embeds a
+ * high-frequency inaudible tone pattern (above 18kHz) that serves as
+ * a digital fingerprint.
+ *
+ * For MP3 format: Uses ID3 tag metadata injection
+ * For raw formats: Could use frequency-domain watermarking (future)
+ */
+
+/**
+ * Watermark configuration
+ */
+interface WatermarkConfig {
+    /** Platform identifier */
+    platform: string;
+    /** Timestamp of generation */
+    timestamp: number;
+    /** Source system (e.g., 'cyrano', 'hologram', 'twin') */
+    source: string;
+    /** Optional user ID (hashed) for audit trail */
+    userIdHash?: string;
+}
+/**
+ * Embed watermark into audio buffer
+ *
+ * For MP3: Prepends ID3v2 tag with synthetic origin metadata
+ * For other formats: Passes through unchanged (future: frequency watermarking)
+ *
+ * @param audioBuffer - Raw audio data
+ * @param format - Audio format (mp3, wav, etc.)
+ * @param config - Watermark configuration
+ * @returns Watermarked audio buffer
+ */
+declare function embedAudioWatermark(audioBuffer: Buffer, format?: string, config?: Partial<WatermarkConfig>): Buffer;
+/**
+ * Check if audio has synthetic origin watermark
+ *
+ * @param audioBuffer - Audio data to check
+ * @returns Watermark info if found, null otherwise
+ */
+declare function detectSyntheticWatermark(audioBuffer: Buffer): WatermarkConfig | null;
+/**
+ * Convenience function for Digital Twin audio
+ */
+declare function watermarkDigitalTwinAudio(audioBuffer: Buffer, format?: string, userIdHash?: string): Buffer;
+/**
+ * Convenience function for Hologram audio
+ */
+declare function watermarkHologramAudio(audioBuffer: Buffer, format?: string): Buffer;
+/**
+ * Convenience function for Cyrano TTS audio
+ */
+declare function watermarkCyranoAudio(audioBuffer: Buffer, format?: string): Buffer;
+
+export { type ImageWatermarkConfig, type WatermarkConfig, detectSyntheticImageWatermark, detectSyntheticWatermark, embedAudioWatermark, embedImageWatermark, watermarkCyranoAudio, watermarkCyranoImage, watermarkDallEImage, watermarkDigitalTwinAudio, watermarkDigitalTwinImage, watermarkGeminiImage, watermarkHologramAudio };

package/dist/index.d.ts

@@ -0,0 +1,130 @@
+import { Buffer } from 'buffer';
+
+/**
+ * Image Watermarking Service
+ *
+ * Embeds INVISIBLE metadata into generated images to indicate
+ * "Synthetic Origin" - marking AI-generated images for safety/authenticity.
+ *
+ * These watermarks are completely invisible to users.
+ * They are stored in the PNG file's metadata chunks (iTXt/tEXt),
+ * not rendered on the image itself. Similar to EXIF data in photos.
+ *
+ * For PNG format: Uses ancillary iTXt chunk (international text)
+ * For JPEG format: Could use EXIF/XMP metadata (future)
+ * For WebP format: Could use XMP metadata (future)
+ */
+
+/**
+ * Watermark configuration
+ */
+interface ImageWatermarkConfig {
+    /** Platform identifier */
+    platform: string;
+    /** Timestamp of generation */
+    timestamp: number;
+    /** Source system (e.g., 'dalle', 'imagen', 'gemini', 'digital_twin') */
+    source: string;
+    /** Optional user ID (hashed) for audit trail */
+    userIdHash?: string;
+    /** Optional model name */
+    model?: string;
+}
+/**
+ * Embed INVISIBLE watermark into image buffer
+ *
+ * For PNG: Inserts iTXt chunk before IEND
+ * For other formats: Passes through unchanged (future: EXIF/XMP)
+ *
+ * The watermark is stored in metadata, NOT visible on the image.
+ *
+ * @param imageBuffer - Raw image data
+ * @param format - Image format (png, jpeg, webp)
+ * @param config - Watermark configuration
+ * @returns Watermarked image buffer
+ */
+declare function embedImageWatermark(imageBuffer: Uint8Array, format?: string, config?: Partial<ImageWatermarkConfig>): Buffer;
+/**
+ * Detect synthetic origin watermark from image
+ *
+ * @param imageBuffer - Image data to check
+ * @returns Watermark info if found, null otherwise
+ */
+declare function detectSyntheticImageWatermark(imageBuffer: Buffer): ImageWatermarkConfig | null;
+/**
+ * Convenience function for DALL-E generated images
+ */
+declare function watermarkDallEImage(imageBuffer: Uint8Array, format?: string, userIdHash?: string): Buffer;
+/**
+ * Convenience function for Gemini Imagen images
+ */
+declare function watermarkGeminiImage(imageBuffer: Uint8Array, format?: string, userIdHash?: string): Buffer;
+/**
+ * Convenience function for Digital Twin generated images
+ */
+declare function watermarkDigitalTwinImage(imageBuffer: Uint8Array, format?: string, userIdHash?: string): Buffer;
+/**
+ * Convenience function for Cyrano-generated images
+ */
+declare function watermarkCyranoImage(imageBuffer: Uint8Array, format?: string, userIdHash?: string): Buffer;
+
+/**
+ * Audio Watermarking Service
+ *
+ * Embeds invisible/inaudible metadata into synthesized audio to indicate
+ * "Synthetic Origin" - marking AI-generated audio for safety and authenticity.
+ *
+ * Approach: Adds a metadata comment to the MP3 ID3 tag or embeds a
+ * high-frequency inaudible tone pattern (above 18kHz) that serves as
+ * a digital fingerprint.
+ *
+ * For MP3 format: Uses ID3 tag metadata injection
+ * For raw formats: Could use frequency-domain watermarking (future)
+ */
+
+/**
+ * Watermark configuration
+ */
+interface WatermarkConfig {
+    /** Platform identifier */
+    platform: string;
+    /** Timestamp of generation */
+    timestamp: number;
+    /** Source system (e.g., 'cyrano', 'hologram', 'twin') */
+    source: string;
+    /** Optional user ID (hashed) for audit trail */
+    userIdHash?: string;
+}
+/**
+ * Embed watermark into audio buffer
+ *
+ * For MP3: Prepends ID3v2 tag with synthetic origin metadata
+ * For other formats: Passes through unchanged (future: frequency watermarking)
+ *
+ * @param audioBuffer - Raw audio data
+ * @param format - Audio format (mp3, wav, etc.)
+ * @param config - Watermark configuration
+ * @returns Watermarked audio buffer
+ */
+declare function embedAudioWatermark(audioBuffer: Buffer, format?: string, config?: Partial<WatermarkConfig>): Buffer;
+/**
+ * Check if audio has synthetic origin watermark
+ *
+ * @param audioBuffer - Audio data to check
+ * @returns Watermark info if found, null otherwise
+ */
+declare function detectSyntheticWatermark(audioBuffer: Buffer): WatermarkConfig | null;
+/**
+ * Convenience function for Digital Twin audio
+ */
+declare function watermarkDigitalTwinAudio(audioBuffer: Buffer, format?: string, userIdHash?: string): Buffer;
+/**
+ * Convenience function for Hologram audio
+ */
+declare function watermarkHologramAudio(audioBuffer: Buffer, format?: string): Buffer;
+/**
+ * Convenience function for Cyrano TTS audio
+ */
+declare function watermarkCyranoAudio(audioBuffer: Buffer, format?: string): Buffer;
+
+export { type ImageWatermarkConfig, type WatermarkConfig, detectSyntheticImageWatermark, detectSyntheticWatermark, embedAudioWatermark, embedImageWatermark, watermarkCyranoAudio, watermarkCyranoImage, watermarkDallEImage, watermarkDigitalTwinAudio, watermarkDigitalTwinImage, watermarkGeminiImage, watermarkHologramAudio };

package/dist/index.js

@@ -0,0 +1,364 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  detectSyntheticImageWatermark: () => detectSyntheticImageWatermark,
+  detectSyntheticWatermark: () => detectSyntheticWatermark,
+  embedAudioWatermark: () => embedAudioWatermark,
+  embedImageWatermark: () => embedImageWatermark,
+  watermarkCyranoAudio: () => watermarkCyranoAudio,
+  watermarkCyranoImage: () => watermarkCyranoImage,
+  watermarkDallEImage: () => watermarkDallEImage,
+  watermarkDigitalTwinAudio: () => watermarkDigitalTwinAudio,
+  watermarkDigitalTwinImage: () => watermarkDigitalTwinImage,
+  watermarkGeminiImage: () => watermarkGeminiImage,
+  watermarkHologramAudio: () => watermarkHologramAudio
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/imageWatermark.ts
+var import_buffer = require("buffer");
+var DEFAULT_WATERMARK = {
+  platform: "SYNTHETIC",
+  source: "ai_generated"
+};
+var PNG_SIGNATURE = import_buffer.Buffer.from([
+  137,
+  80,
+  78,
+  71,
+  13,
+  10,
+  26,
+  10
+]);
+function isPNG(buffer) {
+  if (buffer.length < 8) return false;
+  for (let i = 0; i < 8; i++) {
+    if (buffer[i] !== PNG_SIGNATURE[i]) return false;
+  }
+  return true;
+}
+function crc32(data) {
+  const table = [];
+  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;
+    }
+    table[n] = c >>> 0;
+  }
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) {
+    crc = table[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function createiTXtChunk(config) {
+  const keyword = "SyntheticOrigin";
+  const text = `SYNTHETIC_IMAGE|${config.platform}|${config.source}|${config.timestamp}|${config.userIdHash || ""}|${config.model || ""}`;
+  const keywordBuf = import_buffer.Buffer.from(keyword + "\0");
+  const compressionFlag = import_buffer.Buffer.from([0]);
+  const compressionMethod = import_buffer.Buffer.from([0]);
+  const languageTag = import_buffer.Buffer.from("en\0");
+  const translatedKeyword = import_buffer.Buffer.from("\0");
+  const textBuf = import_buffer.Buffer.from(text);
+  const chunkData = import_buffer.Buffer.concat([
+    keywordBuf,
+    compressionFlag,
+    compressionMethod,
+    languageTag,
+    translatedKeyword,
+    textBuf
+  ]);
+  const chunkType = import_buffer.Buffer.from("iTXt");
+  const typeAndData = import_buffer.Buffer.concat([
+    chunkType,
+    chunkData
+  ]);
+  const crcValue = crc32(new Uint8Array(typeAndData));
+  const crcBuf = import_buffer.Buffer.alloc(4);
+  crcBuf.writeUInt32BE(crcValue, 0);
+  const lengthBuf = import_buffer.Buffer.alloc(4);
+  lengthBuf.writeUInt32BE(chunkData.length, 0);
+  const parts = [
+    lengthBuf,
+    chunkType,
+    chunkData,
+    crcBuf
+  ];
+  return import_buffer.Buffer.concat(parts);
+}
+function findIENDPosition(buffer) {
+  const iendMarker = import_buffer.Buffer.from("IEND");
+  for (let i = 8; i < buffer.length - 8; i++) {
+    const slice = buffer.subarray(i + 4, i + 8);
+    if (import_buffer.Buffer.from(slice).equals(iendMarker)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function embedImageWatermark(imageBuffer, format = "png", config = {}) {
+  const fullConfig = {
+    ...DEFAULT_WATERMARK,
+    timestamp: Date.now(),
+    ...config
+  };
+  const normalizedFormat = format.toLowerCase().replace("image/", "");
+  if (normalizedFormat !== "png") {
+    return import_buffer.Buffer.from(imageBuffer);
+  }
+  if (!isPNG(imageBuffer)) {
+    return import_buffer.Buffer.from(imageBuffer);
+  }
+  try {
+    const iendPos = findIENDPosition(imageBuffer);
+    if (iendPos === -1) {
+      return import_buffer.Buffer.from(imageBuffer);
+    }
+    const watermarkChunk = createiTXtChunk(fullConfig);
+    const beforeIEND = imageBuffer.subarray(0, iendPos);
+    const iendAndAfter = imageBuffer.subarray(iendPos);
+    const parts = [
+      import_buffer.Buffer.from(beforeIEND),
+      watermarkChunk,
+      import_buffer.Buffer.from(iendAndAfter)
+    ];
+    return import_buffer.Buffer.concat(parts);
+  } catch {
+    return import_buffer.Buffer.from(imageBuffer);
+  }
+}
+function detectSyntheticImageWatermark(imageBuffer) {
+  const bufferArray = new Uint8Array(imageBuffer);
+  if (!isPNG(bufferArray) || imageBuffer.length < 20) {
+    return null;
+  }
+  try {
+    const itxtMarker = import_buffer.Buffer.from("iTXt");
+    let pos = 8;
+    while (pos < imageBuffer.length - 12) {
+      const chunkLength = imageBuffer.readUInt32BE(pos);
+      const chunkType = imageBuffer.subarray(pos + 4, pos + 8).toString();
+      if (chunkType === "iTXt") {
+        const chunkData = imageBuffer.subarray(pos + 8, pos + 8 + chunkLength);
+        const chunkStr = chunkData.toString();
+        if (chunkStr.includes("SyntheticOrigin") && chunkStr.includes("SYNTHETIC_IMAGE|")) {
+          const markerIdx = chunkStr.indexOf("SYNTHETIC_IMAGE|");
+          const text = chunkStr.substring(markerIdx);
+          const parts = text.split("|");
+          if (parts.length >= 4) {
+            return {
+              platform: parts[1],
+              source: parts[2],
+              timestamp: parseInt(parts[3], 10),
+              userIdHash: parts[4] || void 0,
+              model: parts[5] || void 0
+            };
+          }
+        }
+      }
+      pos += 4 + 4 + chunkLength + 4;
+      if (chunkType === "IEND") break;
+    }
+  } catch {
+  }
+  return null;
+}
+function watermarkDallEImage(imageBuffer, format = "png", userIdHash) {
+  return embedImageWatermark(imageBuffer, format, {
+    source: "dalle",
+    model: "dall-e",
+    userIdHash
+  });
+}
+function watermarkGeminiImage(imageBuffer, format = "png", userIdHash) {
+  return embedImageWatermark(imageBuffer, format, {
+    source: "gemini",
+    model: "imagen",
+    userIdHash
+  });
+}
+function watermarkDigitalTwinImage(imageBuffer, format = "png", userIdHash) {
+  return embedImageWatermark(imageBuffer, format, {
+    source: "digital_twin",
+    userIdHash
+  });
+}
+function watermarkCyranoImage(imageBuffer, format = "png", userIdHash) {
+  return embedImageWatermark(imageBuffer, format, {
+    source: "cyrano",
+    userIdHash
+  });
+}
+
+// src/audioWatermark.ts
+var import_buffer2 = require("buffer");
+var DEFAULT_WATERMARK2 = {
+  platform: "SYNTHETIC",
+  source: "tts"
+};
+function createID3WatermarkTag(config) {
+  const comment = `SYNTHETIC_AUDIO|${config.platform}|${config.source}|${config.timestamp}${config.userIdHash ? `|${config.userIdHash}` : ""}`;
+  const encoding = import_buffer2.Buffer.from([0]);
+  const language = import_buffer2.Buffer.from("eng");
+  const shortDesc = import_buffer2.Buffer.from("SYNTHETIC_ORIGIN\0", "binary");
+  const text = import_buffer2.Buffer.concat([
+    import_buffer2.Buffer.from(comment, "utf-8"),
+    import_buffer2.Buffer.from([0])
+  ]);
+  const frameContent = import_buffer2.Buffer.concat([
+    encoding,
+    language,
+    shortDesc,
+    text
+  ]);
+  const frameId = import_buffer2.Buffer.from("COMM");
+  const frameSize = import_buffer2.Buffer.alloc(4);
+  frameSize.writeUInt32BE(frameContent.length, 0);
+  const frameFlags = import_buffer2.Buffer.from([0, 0]);
+  const frame = import_buffer2.Buffer.concat([
+    frameId,
+    frameSize,
+    frameFlags,
+    frameContent
+  ]);
+  const id3Header = import_buffer2.Buffer.from([
+    73,
+    68,
+    51,
+    // "ID3"
+    3,
+    0,
+    // Version 2.3
+    0
+    // Flags
+  ]);
+  const size = frame.length;
+  const syncsafeSize = import_buffer2.Buffer.alloc(4);
+  syncsafeSize[0] = size >> 21 & 127;
+  syncsafeSize[1] = size >> 14 & 127;
+  syncsafeSize[2] = size >> 7 & 127;
+  syncsafeSize[3] = size & 127;
+  return import_buffer2.Buffer.concat([
+    id3Header,
+    syncsafeSize,
+    frame
+  ]);
+}
+function hasID3Tag(audioBuffer) {
+  if (audioBuffer.length < 10) return false;
+  return audioBuffer[0] === 73 && // 'I'
+  audioBuffer[1] === 68 && // 'D'
+  audioBuffer[2] === 51;
+}
+function getID3TagSize(audioBuffer) {
+  if (!hasID3Tag(audioBuffer)) return 0;
+  const size = (audioBuffer[6] & 127) << 21 | (audioBuffer[7] & 127) << 14 | (audioBuffer[8] & 127) << 7 | audioBuffer[9] & 127;
+  return size + 10;
+}
+function embedAudioWatermark(audioBuffer, format = "mp3", config = {}) {
+  const fullConfig = {
+    ...DEFAULT_WATERMARK2,
+    timestamp: Date.now(),
+    ...config
+  };
+  const normalizedFormat = format.toLowerCase();
+  if (normalizedFormat !== "mp3") {
+    return audioBuffer;
+  }
+  try {
+    let audioData = audioBuffer;
+    const bufferArray = new Uint8Array(audioBuffer);
+    if (hasID3Tag(bufferArray)) {
+      const existingTagSize = getID3TagSize(bufferArray);
+      if (existingTagSize <= audioBuffer.length) {
+        audioData = audioBuffer.subarray(existingTagSize);
+      }
+    }
+    const watermarkTag = createID3WatermarkTag(fullConfig);
+    return import_buffer2.Buffer.concat([watermarkTag, audioData]);
+  } catch {
+    return audioBuffer;
+  }
+}
+function detectSyntheticWatermark(audioBuffer) {
+  const bufferArray = new Uint8Array(audioBuffer);
+  if (!hasID3Tag(bufferArray)) {
+    return null;
+  }
+  try {
+    const searchStr = "SYNTHETIC_ORIGIN";
+    const idx = audioBuffer.indexOf(searchStr);
+    if (idx === -1) return null;
+    const markerEnd = idx + searchStr.length + 1;
+    if (markerEnd >= audioBuffer.length) return null;
+    const markerStart = audioBuffer.indexOf("SYNTHETIC_AUDIO|", markerEnd);
+    if (markerStart === -1) return null;
+    let end = markerStart;
+    while (end < audioBuffer.length && audioBuffer[end] !== 0) {
+      end++;
+    }
+    const comment = audioBuffer.subarray(markerStart, end).toString("utf-8");
+    const parts = comment.split("|");
+    if (parts.length >= 4) {
+      return {
+        platform: parts[1] || "",
+        source: parts[2] || "",
+        timestamp: parseInt(parts[3] || "0", 10),
+        userIdHash: parts[4]
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function watermarkDigitalTwinAudio(audioBuffer, format = "mp3", userIdHash) {
+  return embedAudioWatermark(audioBuffer, format, {
+    source: "digital_twin",
+    userIdHash
+  });
+}
+function watermarkHologramAudio(audioBuffer, format = "mp3") {
+  return embedAudioWatermark(audioBuffer, format, {
+    source: "hologram"
+  });
+}
+function watermarkCyranoAudio(audioBuffer, format = "mp3") {
+  return embedAudioWatermark(audioBuffer, format, {
+    source: "cyrano"
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectSyntheticImageWatermark,
+  detectSyntheticWatermark,
+  embedAudioWatermark,
+  embedImageWatermark,
+  watermarkCyranoAudio,
+  watermarkCyranoImage,
+  watermarkDallEImage,
+  watermarkDigitalTwinAudio,
+  watermarkDigitalTwinImage,
+  watermarkGeminiImage,
+  watermarkHologramAudio
+});

package/dist/index.mjs

@@ -0,0 +1,327 @@
+// src/imageWatermark.ts
+import { Buffer } from "buffer";
+var DEFAULT_WATERMARK = {
+  platform: "SYNTHETIC",
+  source: "ai_generated"
+};
+var PNG_SIGNATURE = Buffer.from([
+  137,
+  80,
+  78,
+  71,
+  13,
+  10,
+  26,
+  10
+]);
+function isPNG(buffer) {
+  if (buffer.length < 8) return false;
+  for (let i = 0; i < 8; i++) {
+    if (buffer[i] !== PNG_SIGNATURE[i]) return false;
+  }
+  return true;
+}
+function crc32(data) {
+  const table = [];
+  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;
+    }
+    table[n] = c >>> 0;
+  }
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) {
+    crc = table[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function createiTXtChunk(config) {
+  const keyword = "SyntheticOrigin";
+  const text = `SYNTHETIC_IMAGE|${config.platform}|${config.source}|${config.timestamp}|${config.userIdHash || ""}|${config.model || ""}`;
+  const keywordBuf = Buffer.from(keyword + "\0");
+  const compressionFlag = Buffer.from([0]);
+  const compressionMethod = Buffer.from([0]);
+  const languageTag = Buffer.from("en\0");
+  const translatedKeyword = Buffer.from("\0");
+  const textBuf = Buffer.from(text);
+  const chunkData = Buffer.concat([
+    keywordBuf,
+    compressionFlag,
+    compressionMethod,
+    languageTag,
+    translatedKeyword,
+    textBuf
+  ]);
+  const chunkType = Buffer.from("iTXt");
+  const typeAndData = Buffer.concat([
+    chunkType,
+    chunkData
+  ]);
+  const crcValue = crc32(new Uint8Array(typeAndData));
+  const crcBuf = Buffer.alloc(4);
+  crcBuf.writeUInt32BE(crcValue, 0);
+  const lengthBuf = Buffer.alloc(4);
+  lengthBuf.writeUInt32BE(chunkData.length, 0);
+  const parts = [
+    lengthBuf,
+    chunkType,
+    chunkData,
+    crcBuf
+  ];
+  return Buffer.concat(parts);
+}
+function findIENDPosition(buffer) {
+  const iendMarker = Buffer.from("IEND");
+  for (let i = 8; i < buffer.length - 8; i++) {
+    const slice = buffer.subarray(i + 4, i + 8);
+    if (Buffer.from(slice).equals(iendMarker)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function embedImageWatermark(imageBuffer, format = "png", config = {}) {
+  const fullConfig = {
+    ...DEFAULT_WATERMARK,
+    timestamp: Date.now(),
+    ...config
+  };
+  const normalizedFormat = format.toLowerCase().replace("image/", "");
+  if (normalizedFormat !== "png") {
+    return Buffer.from(imageBuffer);
+  }
+  if (!isPNG(imageBuffer)) {
+    return Buffer.from(imageBuffer);
+  }
+  try {
+    const iendPos = findIENDPosition(imageBuffer);
+    if (iendPos === -1) {
+      return Buffer.from(imageBuffer);
+    }
+    const watermarkChunk = createiTXtChunk(fullConfig);
+    const beforeIEND = imageBuffer.subarray(0, iendPos);
+    const iendAndAfter = imageBuffer.subarray(iendPos);
+    const parts = [
+      Buffer.from(beforeIEND),
+      watermarkChunk,
+      Buffer.from(iendAndAfter)
+    ];
+    return Buffer.concat(parts);
+  } catch {
+    return Buffer.from(imageBuffer);
+  }
+}
+function detectSyntheticImageWatermark(imageBuffer) {
+  const bufferArray = new Uint8Array(imageBuffer);
+  if (!isPNG(bufferArray) || imageBuffer.length < 20) {
+    return null;
+  }
+  try {
+    const itxtMarker = Buffer.from("iTXt");
+    let pos = 8;
+    while (pos < imageBuffer.length - 12) {
+      const chunkLength = imageBuffer.readUInt32BE(pos);
+      const chunkType = imageBuffer.subarray(pos + 4, pos + 8).toString();
+      if (chunkType === "iTXt") {
+        const chunkData = imageBuffer.subarray(pos + 8, pos + 8 + chunkLength);
+        const chunkStr = chunkData.toString();
+        if (chunkStr.includes("SyntheticOrigin") && chunkStr.includes("SYNTHETIC_IMAGE|")) {
+          const markerIdx = chunkStr.indexOf("SYNTHETIC_IMAGE|");
+          const text = chunkStr.substring(markerIdx);
+          const parts = text.split("|");
+          if (parts.length >= 4) {
+            return {
+              platform: parts[1],
+              source: parts[2],
+              timestamp: parseInt(parts[3], 10),
+              userIdHash: parts[4] || void 0,
+              model: parts[5] || void 0
+            };
+          }
+        }
+      }
+      pos += 4 + 4 + chunkLength + 4;
+      if (chunkType === "IEND") break;
+    }
+  } catch {
+  }
+  return null;
+}
+function watermarkDallEImage(imageBuffer, format = "png", userIdHash) {
+  return embedImageWatermark(imageBuffer, format, {
+    source: "dalle",
+    model: "dall-e",
+    userIdHash
+  });
+}
+function watermarkGeminiImage(imageBuffer, format = "png", userIdHash) {
+  return embedImageWatermark(imageBuffer, format, {
+    source: "gemini",
+    model: "imagen",
+    userIdHash
+  });
+}
+function watermarkDigitalTwinImage(imageBuffer, format = "png", userIdHash) {
+  return embedImageWatermark(imageBuffer, format, {
+    source: "digital_twin",
+    userIdHash
+  });
+}
+function watermarkCyranoImage(imageBuffer, format = "png", userIdHash) {
+  return embedImageWatermark(imageBuffer, format, {
+    source: "cyrano",
+    userIdHash
+  });
+}
+
+// src/audioWatermark.ts
+import { Buffer as Buffer2 } from "buffer";
+var DEFAULT_WATERMARK2 = {
+  platform: "SYNTHETIC",
+  source: "tts"
+};
+function createID3WatermarkTag(config) {
+  const comment = `SYNTHETIC_AUDIO|${config.platform}|${config.source}|${config.timestamp}${config.userIdHash ? `|${config.userIdHash}` : ""}`;
+  const encoding = Buffer2.from([0]);
+  const language = Buffer2.from("eng");
+  const shortDesc = Buffer2.from("SYNTHETIC_ORIGIN\0", "binary");
+  const text = Buffer2.concat([
+    Buffer2.from(comment, "utf-8"),
+    Buffer2.from([0])
+  ]);
+  const frameContent = Buffer2.concat([
+    encoding,
+    language,
+    shortDesc,
+    text
+  ]);
+  const frameId = Buffer2.from("COMM");
+  const frameSize = Buffer2.alloc(4);
+  frameSize.writeUInt32BE(frameContent.length, 0);
+  const frameFlags = Buffer2.from([0, 0]);
+  const frame = Buffer2.concat([
+    frameId,
+    frameSize,
+    frameFlags,
+    frameContent
+  ]);
+  const id3Header = Buffer2.from([
+    73,
+    68,
+    51,
+    // "ID3"
+    3,
+    0,
+    // Version 2.3
+    0
+    // Flags
+  ]);
+  const size = frame.length;
+  const syncsafeSize = Buffer2.alloc(4);
+  syncsafeSize[0] = size >> 21 & 127;
+  syncsafeSize[1] = size >> 14 & 127;
+  syncsafeSize[2] = size >> 7 & 127;
+  syncsafeSize[3] = size & 127;
+  return Buffer2.concat([
+    id3Header,
+    syncsafeSize,
+    frame
+  ]);
+}
+function hasID3Tag(audioBuffer) {
+  if (audioBuffer.length < 10) return false;
+  return audioBuffer[0] === 73 && // 'I'
+  audioBuffer[1] === 68 && // 'D'
+  audioBuffer[2] === 51;
+}
+function getID3TagSize(audioBuffer) {
+  if (!hasID3Tag(audioBuffer)) return 0;
+  const size = (audioBuffer[6] & 127) << 21 | (audioBuffer[7] & 127) << 14 | (audioBuffer[8] & 127) << 7 | audioBuffer[9] & 127;
+  return size + 10;
+}
+function embedAudioWatermark(audioBuffer, format = "mp3", config = {}) {
+  const fullConfig = {
+    ...DEFAULT_WATERMARK2,
+    timestamp: Date.now(),
+    ...config
+  };
+  const normalizedFormat = format.toLowerCase();
+  if (normalizedFormat !== "mp3") {
+    return audioBuffer;
+  }
+  try {
+    let audioData = audioBuffer;
+    const bufferArray = new Uint8Array(audioBuffer);
+    if (hasID3Tag(bufferArray)) {
+      const existingTagSize = getID3TagSize(bufferArray);
+      if (existingTagSize <= audioBuffer.length) {
+        audioData = audioBuffer.subarray(existingTagSize);
+      }
+    }
+    const watermarkTag = createID3WatermarkTag(fullConfig);
+    return Buffer2.concat([watermarkTag, audioData]);
+  } catch {
+    return audioBuffer;
+  }
+}
+function detectSyntheticWatermark(audioBuffer) {
+  const bufferArray = new Uint8Array(audioBuffer);
+  if (!hasID3Tag(bufferArray)) {
+    return null;
+  }
+  try {
+    const searchStr = "SYNTHETIC_ORIGIN";
+    const idx = audioBuffer.indexOf(searchStr);
+    if (idx === -1) return null;
+    const markerEnd = idx + searchStr.length + 1;
+    if (markerEnd >= audioBuffer.length) return null;
+    const markerStart = audioBuffer.indexOf("SYNTHETIC_AUDIO|", markerEnd);
+    if (markerStart === -1) return null;
+    let end = markerStart;
+    while (end < audioBuffer.length && audioBuffer[end] !== 0) {
+      end++;
+    }
+    const comment = audioBuffer.subarray(markerStart, end).toString("utf-8");
+    const parts = comment.split("|");
+    if (parts.length >= 4) {
+      return {
+        platform: parts[1] || "",
+        source: parts[2] || "",
+        timestamp: parseInt(parts[3] || "0", 10),
+        userIdHash: parts[4]
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function watermarkDigitalTwinAudio(audioBuffer, format = "mp3", userIdHash) {
+  return embedAudioWatermark(audioBuffer, format, {
+    source: "digital_twin",
+    userIdHash
+  });
+}
+function watermarkHologramAudio(audioBuffer, format = "mp3") {
+  return embedAudioWatermark(audioBuffer, format, {
+    source: "hologram"
+  });
+}
+function watermarkCyranoAudio(audioBuffer, format = "mp3") {
+  return embedAudioWatermark(audioBuffer, format, {
+    source: "cyrano"
+  });
+}
+export {
+  detectSyntheticImageWatermark,
+  detectSyntheticWatermark,
+  embedAudioWatermark,
+  embedImageWatermark,
+  watermarkCyranoAudio,
+  watermarkCyranoImage,
+  watermarkDallEImage,
+  watermarkDigitalTwinAudio,
+  watermarkDigitalTwinImage,
+  watermarkGeminiImage,
+  watermarkHologramAudio
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@affectively/synthetic-watermark",
+  "version": "1.0.0",
+  "description": "Invisible watermarking for AI-generated content. Embeds synthetic origin markers into PNG images (iTXt chunks) and MP3 audio (ID3v2 tags) for authenticity verification.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "prepublishOnly": "npm run build",
+    "test": "bun test"
+  },
+  "keywords": [
+    "watermark",
+    "ai-generated",
+    "synthetic",
+    "authenticity",
+    "png",
+    "mp3",
+    "id3",
+    "metadata",
+    "ai-safety",
+    "content-authenticity",
+    "digital-watermark",
+    "steganography"
+  ],
+  "author": "AFFECTIVELY <opensource@affectively.ai>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/affectively-ai/synthetic-watermark.git"
+  },
+  "bugs": {
+    "url": "https://github.com/affectively-ai/synthetic-watermark/issues"
+  },
+  "homepage": "https://github.com/affectively-ai/synthetic-watermark#readme",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}