@camstack/addon-pipeline 0.1.8

package/swift/audio-analyzer/apple-sound-classifier.swift

@@ -0,0 +1,213 @@
+#!/usr/bin/env swift
+//
+// apple-sound-classifier.swift
+//
+// Lightweight Swift CLI that reads raw Float32 audio from stdin,
+// runs Apple SoundAnalysis (SNClassifySoundRequest), and writes
+// JSON classification results to stdout.
+//
+// Protocol (binary IPC, same as PythonInferenceEngine):
+//   stdin  → [4 bytes LE uint32 length][Float32 audio samples]
+//   stdout → [4 bytes LE uint32 length][JSON bytes]
+//
+// The analyzer persists across chunks, accumulating audio for the
+// SoundAnalysis time window (~1.5s). Results are emitted when
+// the analyzer has enough data to classify.
+//
+// Build:  swiftc -O -o apple-sound-classifier apple-sound-classifier.swift
+// Usage:  ./apple-sound-classifier --sample-rate=16000
+
+import Foundation
+import SoundAnalysis
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+var sampleRate: Double = 16000
+var topK: Int = 10
+var minScore: Double = 0.05
+
+for arg in CommandLine.arguments.dropFirst() {
+    if arg.hasPrefix("--sample-rate=") {
+        sampleRate = Double(arg.split(separator: "=").last ?? "16000") ?? 16000
+    } else if arg.hasPrefix("--top-k=") {
+        topK = Int(arg.split(separator: "=").last ?? "10") ?? 10
+    } else if arg.hasPrefix("--min-score=") {
+        minScore = Double(arg.split(separator: "=").last ?? "0.05") ?? 0.05
+    }
+}
+
+// ---------------------------------------------------------------------------
+// SoundAnalysis setup
+// ---------------------------------------------------------------------------
+
+class AudioClassifier: NSObject, SNResultsObserving {
+    private var results: [[String: Any]] = []
+    private var inferenceMs: Double = 0
+    private var gotResult = false
+    private var startTime: CFAbsoluteTime = 0
+
+    func startTiming() {
+        results = []
+        inferenceMs = 0
+        gotResult = false
+        startTime = CFAbsoluteTimeGetCurrent()
+    }
+
+    func request(_ request: SNRequest, didProduce result: SNResult) {
+        guard let classResult = result as? SNClassificationResult else { return }
+        for classification in classResult.classifications {
+            if classification.confidence >= minScore {
+                results.append([
+                    "className": classification.identifier,
+                    "score": round(classification.confidence * 1000) / 1000,
+                ])
+            }
+        }
+        gotResult = true
+        inferenceMs = (CFAbsoluteTimeGetCurrent() - startTime) * 1000
+    }
+
+    func request(_ request: SNRequest, didFailWithError error: Error) {
+        fputs("[apple-sound-classifier] Error: \(error.localizedDescription)\n", stderr)
+        gotResult = true
+    }
+
+    func requestDidComplete(_ request: SNRequest) {
+        // Not used for streaming — results come via didProduce
+    }
+
+    func consumeResult() -> (classifications: [[String: Any]], inferenceMs: Double)? {
+        guard gotResult else { return nil }
+        let sorted = results.sorted {
+            ($0["score"] as? Double ?? 0) > ($1["score"] as? Double ?? 0)
+        }
+        let out = (Array(sorted.prefix(topK)), inferenceMs)
+        results = []
+        gotResult = false
+        return out
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Binary IPC: read [4B length][payload] from stdin
+// ---------------------------------------------------------------------------
+
+func readFrame() -> Data? {
+    var lengthBytes = [UInt8](repeating: 0, count: 4)
+    let readCount = fread(&lengthBytes, 1, 4, stdin)
+    if readCount < 4 { return nil } // EOF
+
+    let length = UInt32(lengthBytes[0])
+        | (UInt32(lengthBytes[1]) << 8)
+        | (UInt32(lengthBytes[2]) << 16)
+        | (UInt32(lengthBytes[3]) << 24)
+
+    if length == 0 { return Data() }
+
+    var payload = [UInt8](repeating: 0, count: Int(length))
+    let payloadRead = fread(&payload, 1, Int(length), stdin)
+    if payloadRead < Int(length) { return nil }
+    return Data(payload)
+}
+
+func writeFrame(_ data: Data) {
+    var length = UInt32(data.count).littleEndian
+    _ = withUnsafeBytes(of: &length) { ptr in
+        fwrite(ptr.baseAddress!, 1, 4, stdout)
+    }
+    _ = data.withUnsafeBytes { ptr in
+        fwrite(ptr.baseAddress!, 1, data.count, stdout)
+    }
+    fflush(stdout)
+}
+
+// ---------------------------------------------------------------------------
+// Main loop — persistent analyzer
+// ---------------------------------------------------------------------------
+
+let classifier = AudioClassifier()
+let format = AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1)!
+
+// Create persistent analyzer + request
+let analyzer = SNAudioStreamAnalyzer(format: format)
+var framePosition: AVAudioFramePosition = 0
+
+do {
+    let request = try SNClassifySoundRequest(classifierIdentifier: .version1)
+    request.windowDuration = CMTimeMakeWithSeconds(1.5, preferredTimescale: 48000)
+    request.overlapFactor = 0.5
+    try analyzer.add(request, withObserver: classifier)
+} catch {
+    fputs("[apple-sound-classifier] Setup error: \(error.localizedDescription)\n", stderr)
+    exit(1)
+}
+
+// Signal ready
+let readyMsg = try! JSONSerialization.data(withJSONObject: [
+    "status": "ready",
+    "backend": "apple-soundanalysis",
+    "platform": "darwin",
+])
+writeFrame(readyMsg)
+
+while let frameData = readFrame() {
+    // Convert raw bytes to Float32 samples
+    let float32Count = frameData.count / MemoryLayout<Float32>.size
+    guard float32Count > 0 else {
+        let errorResult = try! JSONSerialization.data(withJSONObject: [
+            "classifications": [] as [Any],
+            "inferenceMs": 0,
+        ] as [String: Any])
+        writeFrame(errorResult)
+        continue
+    }
+
+    classifier.startTiming()
+
+    let samples: [Float] = frameData.withUnsafeBytes { ptr in
+        let floatPtr = ptr.bindMemory(to: Float32.self)
+        return Array(floatPtr)
+    }
+
+    // Create audio buffer and feed to persistent analyzer
+    let frameCount = AVAudioFrameCount(samples.count)
+    guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: frameCount) else {
+        fputs("[apple-sound-classifier] Failed to create audio buffer\n", stderr)
+        let errorResult = try! JSONSerialization.data(withJSONObject: [
+            "classifications": [] as [Any],
+            "inferenceMs": 0,
+        ] as [String: Any])
+        writeFrame(errorResult)
+        continue
+    }
+    buffer.frameLength = frameCount
+    let channelData = buffer.floatChannelData![0]
+    for i in 0..<Int(frameCount) {
+        channelData[i] = samples[i]
+    }
+
+    // Feed chunk to the persistent analyzer (accumulates audio over time)
+    analyzer.analyze(buffer, atAudioFramePosition: framePosition)
+    framePosition += AVAudioFramePosition(frameCount)
+
+    // Check if analyzer produced a result (it will once enough audio is accumulated)
+    // Give it a brief moment to process on the internal queue
+    Thread.sleep(forTimeInterval: 0.005)
+
+    if let (classifications, inferenceMs) = classifier.consumeResult() {
+        let result = try! JSONSerialization.data(withJSONObject: [
+            "classifications": classifications,
+            "inferenceMs": round(inferenceMs * 10) / 10,
+        ] as [String: Any])
+        writeFrame(result)
+    } else {
+        // Not enough audio accumulated yet — return empty
+        let result = try! JSONSerialization.data(withJSONObject: [
+            "classifications": [] as [Any],
+            "inferenceMs": 0,
+        ] as [String: Any])
+        writeFrame(result)
+    }
+}

package/swift/detection-pipeline/apple-sound-classifier.swift

@@ -0,0 +1,196 @@
+#!/usr/bin/env swift
+//
+// apple-sound-classifier.swift
+//
+// Lightweight Swift CLI that reads raw Float32 audio from stdin,
+// runs Apple SoundAnalysis (SNClassifySoundRequest), and writes
+// JSON classification results to stdout.
+//
+// Protocol (binary IPC, same as PythonInferenceEngine):
+//   stdin  → [4 bytes LE uint32 length][Float32 audio samples]
+//   stdout → [4 bytes LE uint32 length][JSON bytes]
+//
+// The process stays alive and handles multiple requests.
+// Send EOF on stdin to exit.
+//
+// Build:  swiftc -O -o apple-sound-classifier apple-sound-classifier.swift
+// Usage:  ./apple-sound-classifier --sample-rate=16000
+
+import Foundation
+import SoundAnalysis
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+var sampleRate: Double = 16000
+var topK: Int = 10
+var minScore: Double = 0.05
+
+for arg in CommandLine.arguments.dropFirst() {
+    if arg.hasPrefix("--sample-rate=") {
+        sampleRate = Double(arg.split(separator: "=").last ?? "16000") ?? 16000
+    } else if arg.hasPrefix("--top-k=") {
+        topK = Int(arg.split(separator: "=").last ?? "10") ?? 10
+    } else if arg.hasPrefix("--min-score=") {
+        minScore = Double(arg.split(separator: "=").last ?? "0.05") ?? 0.05
+    }
+}
+
+// ---------------------------------------------------------------------------
+// SoundAnalysis setup
+// ---------------------------------------------------------------------------
+
+class AudioClassifier: NSObject, SNResultsObserving {
+    private var results: [[String: Any]] = []
+    private var inferenceMs: Double = 0
+    private let semaphore = DispatchSemaphore(value: 0)
+    private var startTime: CFAbsoluteTime = 0
+
+    func startTiming() {
+        results = []
+        inferenceMs = 0
+        startTime = CFAbsoluteTimeGetCurrent()
+    }
+
+    func request(_ request: SNRequest, didProduce result: SNResult) {
+        guard let classResult = result as? SNClassificationResult else { return }
+        for classification in classResult.classifications {
+            if classification.confidence >= minScore {
+                results.append([
+                    "className": classification.identifier,
+                    "score": round(classification.confidence * 1000) / 1000,
+                ])
+            }
+        }
+    }
+
+    func request(_ request: SNRequest, didFailWithError error: Error) {
+        fputs("[apple-sound-classifier] Error: \(error.localizedDescription)\n", stderr)
+        semaphore.signal()
+    }
+
+    func requestDidComplete(_ request: SNRequest) {
+        inferenceMs = (CFAbsoluteTimeGetCurrent() - startTime) * 1000
+        semaphore.signal()
+    }
+
+    func waitForResult() -> (classifications: [[String: Any]], inferenceMs: Double) {
+        semaphore.wait()
+        // Sort by score descending, take top K
+        let sorted = results.sorted {
+            ($0["score"] as? Double ?? 0) > ($1["score"] as? Double ?? 0)
+        }
+        return (Array(sorted.prefix(topK)), inferenceMs)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Binary IPC: read [4B length][payload] from stdin
+// ---------------------------------------------------------------------------
+
+func readFrame() -> Data? {
+    var lengthBytes = [UInt8](repeating: 0, count: 4)
+    let readCount = fread(&lengthBytes, 1, 4, stdin)
+    if readCount < 4 { return nil } // EOF
+
+    let length = UInt32(lengthBytes[0])
+        | (UInt32(lengthBytes[1]) << 8)
+        | (UInt32(lengthBytes[2]) << 16)
+        | (UInt32(lengthBytes[3]) << 24)
+
+    if length == 0 { return Data() }
+
+    var payload = [UInt8](repeating: 0, count: Int(length))
+    let payloadRead = fread(&payload, 1, Int(length), stdin)
+    if payloadRead < Int(length) { return nil }
+    return Data(payload)
+}
+
+func writeFrame(_ data: Data) {
+    var length = UInt32(data.count).littleEndian
+    _ = withUnsafeBytes(of: &length) { ptr in
+        fwrite(ptr.baseAddress!, 1, 4, stdout)
+    }
+    _ = data.withUnsafeBytes { ptr in
+        fwrite(ptr.baseAddress!, 1, data.count, stdout)
+    }
+    fflush(stdout)
+}
+
+// ---------------------------------------------------------------------------
+// Main loop
+// ---------------------------------------------------------------------------
+
+let classifier = AudioClassifier()
+
+// Signal ready
+let readyMsg = try! JSONSerialization.data(withJSONObject: [
+    "status": "ready",
+    "backend": "apple-soundanalysis",
+    "platform": "darwin",
+])
+writeFrame(readyMsg)
+
+while let frameData = readFrame() {
+    classifier.startTiming()
+
+    // Convert raw bytes to Float32 samples
+    let float32Count = frameData.count / MemoryLayout<Float32>.size
+    guard float32Count > 0 else {
+        let errorResult = try! JSONSerialization.data(withJSONObject: [
+            "classifications": [] as [Any],
+            "inferenceMs": 0,
+        ] as [String: Any])
+        writeFrame(errorResult)
+        continue
+    }
+
+    let samples: [Float] = frameData.withUnsafeBytes { ptr in
+        let floatPtr = ptr.bindMemory(to: Float32.self)
+        return Array(floatPtr)
+    }
+
+    // Create an audio buffer in AVAudioPCMBuffer format
+    let format = AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1)!
+    let frameCount = AVAudioFrameCount(samples.count)
+    guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: frameCount) else {
+        fputs("[apple-sound-classifier] Failed to create audio buffer\n", stderr)
+        let errorResult = try! JSONSerialization.data(withJSONObject: [
+            "classifications": [] as [Any],
+            "inferenceMs": 0,
+        ] as [String: Any])
+        writeFrame(errorResult)
+        continue
+    }
+    buffer.frameLength = frameCount
+    let channelData = buffer.floatChannelData![0]
+    for i in 0..<Int(frameCount) {
+        channelData[i] = samples[i]
+    }
+
+    // Run SoundAnalysis
+    do {
+        let analyzer = SNAudioStreamAnalyzer(format: format)
+        let request = try SNClassifySoundRequest(classifierIdentifier: .version1)
+        try analyzer.add(request, withObserver: classifier)
+        analyzer.analyze(buffer, atAudioFramePosition: 0)
+        analyzer.completeAnalysis()
+
+        let (classifications, inferenceMs) = classifier.waitForResult()
+
+        let result = try! JSONSerialization.data(withJSONObject: [
+            "classifications": classifications,
+            "inferenceMs": round(inferenceMs * 10) / 10,
+        ] as [String: Any])
+        writeFrame(result)
+    } catch {
+        fputs("[apple-sound-classifier] Analysis error: \(error.localizedDescription)\n", stderr)
+        let errorResult = try! JSONSerialization.data(withJSONObject: [
+            "classifications": [] as [Any],
+            "inferenceMs": 0,
+            "error": error.localizedDescription,
+        ] as [String: Any])
+        writeFrame(errorResult)
+    }
+}

package/wasm/assembly/index.ts

@@ -0,0 +1,290 @@
+/**
+ * WASM Motion Detection — raw pointer approach (no managed arrays)
+ *
+ * All input/output via linear memory offsets. JS caller writes frames
+ * to known offsets, calls detectMotion, reads results from known offsets.
+ */
+
+// Layout in linear memory (set by init):
+// [0..SIZE)          = prev frame (gray8)
+// [SIZE..2*SIZE)     = curr frame (gray8)
+// [2*SIZE..3*SIZE)   = blur buffer A
+// [3*SIZE..4*SIZE)   = blur buffer B
+// [4*SIZE..5*SIZE)   = diff mask
+// [5*SIZE..5*SIZE+4*SIZE) = label map (i32)
+// [after labels]     = parent buf, remap buf, region output
+
+const MAX_REGIONS: i32 = 256
+const REGION_STRIDE: i32 = 5
+
+let W: i32 = 0
+let H: i32 = 0
+let SIZE: i32 = 0
+
+// Offsets into linear memory
+let prevOff: i32 = 0
+let currOff: i32 = 0
+let blurAOff: i32 = 0
+let blurBOff: i32 = 0
+let diffOff: i32 = 0
+let labelOff: i32 = 0
+let parentOff: i32 = 0
+let remapOff: i32 = 0
+let regionOff: i32 = 0
+
+/** Call once with frame dimensions. Returns offset for prev frame. */
+export function init(w: i32, h: i32): i32 {
+  W = w
+  H = h
+  SIZE = w * h
+  // All buffers in linear memory, sequentially
+  prevOff = 1024 // start after stack
+  currOff = prevOff + SIZE
+  blurAOff = currOff + SIZE
+  blurBOff = blurAOff + SIZE
+  diffOff = blurBOff + SIZE
+  labelOff = diffOff + SIZE
+  parentOff = labelOff + SIZE * 4 // i32 per pixel
+  remapOff = parentOff + (MAX_REGIONS + 1) * 4
+  regionOff = remapOff + (MAX_REGIONS + 1) * 4
+
+  // Ensure enough memory
+  const needed = regionOff + MAX_REGIONS * REGION_STRIDE * 4 + 1024
+  const pages = (needed + 65535) >> 16 // 64KB pages
+  const currentPages = memory.size()
+  if (pages > currentPages) {
+    memory.grow(pages - currentPages)
+  }
+
+  return prevOff
+}
+
+/** Get offset for writing current frame */
+export function getCurrOffset(): i32 { return currOff }
+/** Get offset for writing previous frame */
+export function getPrevOffset(): i32 { return prevOff }
+/** Get offset for reading region results */
+export function getRegionOffset(): i32 { return regionOff }
+
+// ── Box blur (separable) ──
+
+function boxBlurH(srcOff: i32, dstOff: i32, w: i32, h: i32, r: i32): void {
+  const inv: f32 = 1.0 / <f32>(r + r + 1)
+  for (let y: i32 = 0; y < h; y++) {
+    const row = y * w
+    let sum: i32 = 0
+    for (let k: i32 = -r; k <= r; k++) {
+      const cx = k < 0 ? 0 : (k >= w ? w - 1 : k)
+      sum += <i32>load<u8>(srcOff + row + cx)
+    }
+    store<u8>(dstOff + row, <u8>(<f32>sum * inv))
+    for (let x: i32 = 1; x < w; x++) {
+      const addX = x + r < w ? x + r : w - 1
+      const remX = x - r - 1 >= 0 ? x - r - 1 : 0
+      sum += <i32>load<u8>(srcOff + row + addX) - <i32>load<u8>(srcOff + row + remX)
+      store<u8>(dstOff + row + x, <u8>(<f32>sum * inv))
+    }
+  }
+}
+
+function boxBlurV(srcOff: i32, dstOff: i32, w: i32, h: i32, r: i32): void {
+  const inv: f32 = 1.0 / <f32>(r + r + 1)
+  for (let x: i32 = 0; x < w; x++) {
+    let sum: i32 = 0
+    for (let k: i32 = -r; k <= r; k++) {
+      const cy = k < 0 ? 0 : (k >= h ? h - 1 : k)
+      sum += <i32>load<u8>(srcOff + cy * w + x)
+    }
+    store<u8>(dstOff + x, <u8>(<f32>sum * inv))
+    for (let y: i32 = 1; y < h; y++) {
+      const addY = y + r < h ? y + r : h - 1
+      const remY = y - r - 1 >= 0 ? y - r - 1 : 0
+      sum += <i32>load<u8>(srcOff + addY * w + x) - <i32>load<u8>(srcOff + remY * w + x)
+      store<u8>(dstOff + y * w + x, <u8>(<f32>sum * inv))
+    }
+  }
+}
+
+function blur(srcOff: i32, dstOff: i32, tmpOff: i32, w: i32, h: i32, r: i32): void {
+  boxBlurH(srcOff, tmpOff, w, h, r)
+  boxBlurV(tmpOff, dstOff, w, h, r)
+}
+
+// ── Diff + threshold ──
+
+function diffThreshold(aOff: i32, bOff: i32, outOff: i32, size: i32, thresh: i32): i32 {
+  let count: i32 = 0
+  for (let i: i32 = 0; i < size; i++) {
+    const d = <i32>load<u8>(aOff + i) - <i32>load<u8>(bOff + i)
+    const ad = d < 0 ? -d : d
+    if (ad > thresh) {
+      store<u8>(outOff + i, 255)
+      count++
+    } else {
+      store<u8>(outOff + i, 0)
+    }
+  }
+  return count
+}
+
+// ── Dilate ──
+
+function dilate(off: i32, w: i32, h: i32, r: i32): void {
+  for (let y: i32 = 0; y < h; y++) {
+    let last: i32 = -r - 1
+    for (let x: i32 = 0; x < w; x++) {
+      const idx = off + y * w + x
+      if (load<u8>(idx)) { last = x }
+      else if (x - last <= r) { store<u8>(idx, 255) }
+    }
+    last = w + r + 1
+    for (let x: i32 = w - 1; x >= 0; x--) {
+      const idx = off + y * w + x
+      if (load<u8>(idx)) { last = x }
+      else if (last - x <= r) { store<u8>(idx, 255) }
+    }
+  }
+  for (let x: i32 = 0; x < w; x++) {
+    let last: i32 = -r - 1
+    for (let y: i32 = 0; y < h; y++) {
+      const idx = off + y * w + x
+      if (load<u8>(idx)) { last = y }
+      else if (y - last <= r) { store<u8>(idx, 255) }
+    }
+    last = h + r + 1
+    for (let y: i32 = h - 1; y >= 0; y--) {
+      const idx = off + y * w + x
+      if (load<u8>(idx)) { last = y }
+      else if (last - y <= r) { store<u8>(idx, 255) }
+    }
+  }
+}
+
+// ── Union-Find CCL ──
+
+function ufFind(x: i32): i32 {
+  let cur = x
+  while (load<i32>(parentOff + (cur << 2)) !== cur) {
+    const p = load<i32>(parentOff + (load<i32>(parentOff + (cur << 2)) << 2))
+    store<i32>(parentOff + (cur << 2), p)
+    cur = p
+  }
+  return cur
+}
+
+function ufUnion(a: i32, b: i32): void {
+  const ra = ufFind(a), rb = ufFind(b)
+  if (ra !== rb) store<i32>(parentOff + (rb << 2), ra)
+}
+
+function labelCCL(maskOff: i32, labelOff_: i32, w: i32, h: i32): i32 {
+  let nextLabel: i32 = 1
+  for (let i: i32 = 0; i <= MAX_REGIONS; i++) {
+    store<i32>(parentOff + (i << 2), i)
+  }
+
+  for (let y: i32 = 0; y < h; y++) {
+    for (let x: i32 = 0; x < w; x++) {
+      const idx = y * w + x
+      if (!load<u8>(maskOff + idx)) {
+        store<i32>(labelOff_ + (idx << 2), 0)
+        continue
+      }
+      const left: i32 = x > 0 ? load<i32>(labelOff_ + ((idx - 1) << 2)) : 0
+      const up: i32 = y > 0 ? load<i32>(labelOff_ + (((y - 1) * w + x) << 2)) : 0
+
+      if (left > 0 && up > 0) {
+        store<i32>(labelOff_ + (idx << 2), left)
+        if (left !== up) ufUnion(left, up)
+      } else if (left > 0) {
+        store<i32>(labelOff_ + (idx << 2), left)
+      } else if (up > 0) {
+        store<i32>(labelOff_ + (idx << 2), up)
+      } else if (nextLabel < MAX_REGIONS) {
+        store<i32>(labelOff_ + (idx << 2), nextLabel)
+        nextLabel++
+      } else {
+        store<i32>(labelOff_ + (idx << 2), MAX_REGIONS - 1)
+      }
+    }
+  }
+
+  // Flatten
+  let distinct: i32 = 0
+  for (let i: i32 = 0; i <= MAX_REGIONS; i++) store<i32>(remapOff + (i << 2), 0)
+  for (let i: i32 = 1; i < nextLabel; i++) {
+    const root = ufFind(i)
+    if (!load<i32>(remapOff + (root << 2))) {
+      distinct++
+      store<i32>(remapOff + (root << 2), distinct)
+    }
+    store<i32>(remapOff + (i << 2), load<i32>(remapOff + (root << 2)))
+  }
+
+  const size = w * h
+  for (let i: i32 = 0; i < size; i++) {
+    const l = load<i32>(labelOff_ + (i << 2))
+    if (l > 0) store<i32>(labelOff_ + (i << 2), load<i32>(remapOff + (l << 2)))
+  }
+  return distinct
+}
+
+// ── Main ──
+
+/**
+ * Detect motion between frames at prevOff and currOff.
+ * Caller must write gray pixels to getPrevOffset() and getCurrOffset() first.
+ * Returns number of regions. Read bboxes from getRegionOffset():
+ *   [x, y, w, h, pixelCount] × N as i32 array.
+ */
+export function detectMotion(
+  threshold: i32 = 25,
+  blurRadius: i32 = 1,
+  dilateRadius: i32 = 4,
+  minArea: i32 = 200,
+): i32 {
+  const w = W, h = H, size = SIZE
+
+  // Blur prev → blurA (using diffOff as temp — safe, will be overwritten by diffThreshold)
+  blur(prevOff, blurAOff, diffOff, w, h, blurRadius)
+  // Blur curr → blurB (using diffOff as temp — safe, will be overwritten by diffThreshold)
+  blur(currOff, blurBOff, diffOff, w, h, blurRadius)
+  // Now blurAOff = blurred prev, blurBOff = blurred curr (no buffer overlap)
+
+  // Diff
+  const changed = diffThreshold(blurAOff, blurBOff, diffOff, size, threshold)
+  if (changed < minArea) return 0
+
+  // Dilate
+  if (dilateRadius > 0) dilate(diffOff, w, h, dilateRadius)
+
+  // CCL
+  const numComp = labelCCL(diffOff, labelOff, w, h)
+
+  // Extract bboxes — return ALL regions (minArea filtering done in JS)
+  let regionCount: i32 = 0
+  for (let c: i32 = 1; c <= numComp && regionCount < MAX_REGIONS; c++) {
+    let minX: i32 = w, minY: i32 = h, maxX: i32 = 0, maxY: i32 = 0, px: i32 = 0
+    for (let y: i32 = 0; y < h; y++) {
+      for (let x: i32 = 0; x < w; x++) {
+        if (load<i32>(labelOff + ((y * w + x) << 2)) === c) {
+          if (x < minX) minX = x
+          if (x > maxX) maxX = x
+          if (y < minY) minY = y
+          if (y > maxY) maxY = y
+          px++
+        }
+      }
+    }
+    if (px > 0) {
+      const off = regionOff + regionCount * REGION_STRIDE * 4
+      store<i32>(off, minX)
+      store<i32>(off + 4, minY)
+      store<i32>(off + 8, maxX - minX + 1)
+      store<i32>(off + 12, maxY - minY + 1)
+      store<i32>(off + 16, px)
+      regionCount++
+    }
+  }
+  return regionCount
+}

package/wasm/assembly/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "assemblyscript/std/assembly.json",
+  "include": ["./**/*.ts"]
+}