@standardagents/sip

import { sip, probe } from "@standardagents/sip"
import { readFile, writeFile } from "fs/promises"

// Read an image file
const imageBuffer = await readFile("my-image.jpg")

// Get image info without decoding
const info = probe(imageBuffer)
console.log(info)
// { format: 'jpeg', width: 4000, height: 3000, hasAlpha: false }

// Process image: resize and convert to JPEG
const result = await sip.process(imageBuffer, {
  maxWidth: 2048,
  maxHeight: 2048,
  quality: 85,
})

console.log(result)
// {
//   data: ArrayBuffer,
//   width: 2048,
//   height: 1536,
//   mimeType: 'image/jpeg',
//   originalFormat: 'jpeg'
// }

// Save the resized image
await writeFile("my-image-resized.jpg", Buffer.from(result.data))

import { probe } from "@standardagents/sip"

const info = probe(imageBuffer)
// { format: 'jpeg', width: 4000, height: 3000, hasAlpha: false }

interface ProbeResult {
  format: "jpeg" | "png" | "webp" | "avif" | "unknown"
  width: number   // 0 if unknown
  height: number  // 0 if unknown
  hasAlpha: boolean
}

import { sip } from "@standardagents/sip"

const result = await sip.process(imageBuffer, {
  maxWidth: 2048,
  maxHeight: 2048,
  maxBytes: 1.5 * 1024 * 1024,
  quality: 85,
})

interface ProcessResult {
  data: ArrayBuffer        // Output JPEG data
  width: number            // Output width
  height: number           // Output height
  mimeType: "image/jpeg"   // Always JPEG
  originalFormat: ImageFormat  // Input format detected
}

import { initStreaming } from "@standardagents/sip"

// Call early in your application startup
const available = await initStreaming()
console.log(`WASM available: ${available}`)

Input Image (any size)
        ↓
Decode Row 0 → Resize → Encode  ← Only these rows in memory
Decode Row 1 → Resize → Encode
        ↓
Output JPEG (streamed)

# Clone emsdk
git clone https://github.com/emscripten-core/emsdk.git
cd emsdk

# Install and activate latest version
./emsdk install latest
./emsdk activate latest

# Add to current shell
source ./emsdk_env.sh

git clone git@github.com:standardagents/sip.git
cd sip
pnpm install
pnpm build:wasm

import { sip } from "@standardagents/sip"

async function createThumbnail(buffer: ArrayBuffer): Promise<ArrayBuffer> {
  const result = await sip.process(buffer, {
    maxWidth: 200,
    maxHeight: 200,
    maxBytes: 30 * 1024, // 30KB max
    quality: 80,
  })
  return result.data
}

import { sip, probe } from "@standardagents/sip"

const ALLOWED_FORMATS = ["jpeg", "png", "webp", "avif"]
const MAX_INPUT_SIZE = 50 * 1024 * 1024 // 50MB

async function handleImageUpload(buffer: ArrayBuffer) {
  // Validate input size
  if (buffer.byteLength > MAX_INPUT_SIZE) {
    throw new Error(`Image too large: ${buffer.byteLength} bytes`)
  }

  // Validate format
  const info = probe(buffer)
  if (!ALLOWED_FORMATS.includes(info.format)) {
    throw new Error(`Unsupported format: ${info.format}`)
  }

  // Process
  return await sip.process(buffer, {
    maxWidth: 4096,
    maxHeight: 4096,
    maxBytes: 2 * 1024 * 1024,
    quality: 85,
  })
}

import { sip, probe, initStreaming } from "@standardagents/sip"

// Warm up WASM on startup
let wasmReady = initStreaming()

export default {
  async fetch(request: Request): Promise<Response> {
    await wasmReady

    if (request.method !== "POST") {
      return new Response("Method not allowed", { status: 405 })
    }

    try {
      const buffer = await request.arrayBuffer()
      const result = await sip.process(buffer, {
        maxWidth: 2048,
        maxHeight: 2048,
        quality: 85,
      })

      return new Response(result.data, {
        headers: {
          "Content-Type": "image/jpeg",
          "Content-Length": String(result.data.byteLength),
        },
      })
    } catch (error) {
      return new Response(`Processing failed: ${error.message}`, { status: 500 })
    }
  },
}

import { sip } from "@standardagents/sip"

async function generateSizes(buffer: ArrayBuffer) {
  const [thumbnail, preview, full] = await Promise.all([
    sip.process(buffer, { maxWidth: 150, maxHeight: 150, quality: 80 }),
    sip.process(buffer, { maxWidth: 800, maxHeight: 800, quality: 82 }),
    sip.process(buffer, { maxWidth: 2048, maxHeight: 2048, quality: 85 }),
  ])

  return {
    thumbnail: thumbnail.data,
    preview: preview.data,
    full: full.data,
  }
}

import type {
  ProbeResult,
  ProcessOptions,
  ProcessResult,
  ImageFormat,
} from "@standardagents/sip"

try {
  const result = await sip.process(imageBuffer, options)
} catch (error) {
  if (error.message.includes("WASM module not available")) {
    // WASM not built - run `pnpm build:wasm`
    console.error("Run: pnpm build:wasm")
  } else if (error.message.includes("Unknown image format")) {
    // Unsupported format
    console.error("Unsupported image format")
  } else {
    // Other error (corrupt image, etc.)
    console.error("Processing failed:", error.message)
  }
}