@camstack/addon-pipeline 0.1.20 → 0.2.1

package/dist/audio-codec-nodeav/index.js

@@ -1,467 +1,310 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const crypto = require("node:crypto");
-const index = require("../index-B36NMAdu.js");
-const nodeAv = require("node-av");
-const CODEC_ID_BY_NAME = {
-  aac: nodeAv.AV_CODEC_ID_AAC,
-  aac_latm: nodeAv.AV_CODEC_ID_AAC_LATM,
-  opus: nodeAv.AV_CODEC_ID_OPUS,
-  pcm_alaw: nodeAv.AV_CODEC_ID_PCM_ALAW,
-  pcm_mulaw: nodeAv.AV_CODEC_ID_PCM_MULAW
-};
-function resolveCodecId(codec) {
-  return CODEC_ID_BY_NAME[codec.toLowerCase()] ?? null;
-}
-function buildChannelLayout(channels) {
-  if (channels === 1) {
-    return { nbChannels: 1, order: nodeAv.AV_CHANNEL_ORDER_NATIVE, mask: nodeAv.AV_CH_LAYOUT_MONO };
-  }
-  if (channels === 2) {
-    return { nbChannels: 2, order: nodeAv.AV_CHANNEL_ORDER_NATIVE, mask: nodeAv.AV_CH_LAYOUT_STEREO };
-  }
-  return { nbChannels: channels, order: nodeAv.AV_CHANNEL_ORDER_NATIVE, mask: 0n };
-}
-function pcmFormatToAv(format) {
-  switch (format) {
-    case "f32le":
-      return nodeAv.AV_SAMPLE_FMT_FLT;
-    case "s16le":
-      return nodeAv.AV_SAMPLE_FMT_S16;
-  }
-}
-function bytesPerSample(format) {
-  switch (format) {
-    case "f32le":
-      return 4;
-    case "s16le":
-      return 2;
-  }
-}
-class DecodeRuntime {
-  ctx;
-  swr;
-  packet;
-  inFrame;
-  outFrame;
-  cfg;
-  inLayout;
-  outLayout;
-  inSampleFmt;
-  outSampleFmt;
-  outBytesPerSample;
-  nextPts = 0;
-  closed = false;
-  static create(cfg) {
-    const codecId = resolveCodecId(cfg.codec);
-    if (codecId === null) {
-      throw new Error(`audio-codec: unknown codec '${cfg.codec}' for decode runtime`);
-    }
-    const codec = nodeAv.Codec.findDecoder(codecId);
-    if (!codec) {
-      throw new Error(`audio-codec: decoder not registered for codec '${cfg.codec}'`);
-    }
-    const ctx = new nodeAv.CodecContext();
-    ctx.allocContext3(codec);
-    ctx.sampleRate = cfg.sourceSampleRate;
-    ctx.channels = cfg.sourceChannels;
-    const inLayout = buildChannelLayout(cfg.sourceChannels);
-    ctx.channelLayout = inLayout;
-    if (cfg.extraData && cfg.extraData.byteLength > 0) {
-      ctx.extraData = Buffer.from(cfg.extraData);
-    }
-    const ret = ctx.open2Sync(codec, null);
-    if (ret < 0) {
-      ctx.freeContext();
-      throw new Error(`audio-codec: open2 failed for '${cfg.codec}' (ret=${ret})`);
-    }
-    const inSampleFmt = ctx.sampleFormat ?? nodeAv.AV_SAMPLE_FMT_FLT;
-    const outSampleFmt = pcmFormatToAv(cfg.targetFormat);
-    const outLayout = buildChannelLayout(cfg.targetChannels);
-    const swr = new nodeAv.SoftwareResampleContext();
-    const allocRet = swr.allocSetOpts2(
-      outLayout,
-      outSampleFmt,
-      cfg.targetSampleRate,
-      inLayout,
-      inSampleFmt,
-      cfg.sourceSampleRate
-    );
-    if (allocRet < 0) {
-      ctx.freeContext();
-      throw new Error(`audio-codec: swr allocSetOpts2 failed (ret=${allocRet})`);
-    }
-    const initRet = swr.init();
-    if (initRet < 0) {
-      ctx.freeContext();
-      throw new Error(`audio-codec: swr init failed (ret=${initRet})`);
-    }
-    const packet = new nodeAv.Packet();
-    packet.alloc();
-    const inFrame = new nodeAv.Frame();
-    inFrame.alloc();
-    const outFrame = new nodeAv.Frame();
-    outFrame.alloc();
-    return new DecodeRuntime(ctx, swr, packet, inFrame, outFrame, cfg, inLayout, outLayout, inSampleFmt, outSampleFmt);
-  }
-  constructor(ctx, swr, packet, inFrame, outFrame, cfg, inLayout, outLayout, inSampleFmt, outSampleFmt) {
-    this.ctx = ctx;
-    this.swr = swr;
-    this.packet = packet;
-    this.inFrame = inFrame;
-    this.outFrame = outFrame;
-    this.cfg = cfg;
-    this.inLayout = inLayout;
-    this.outLayout = outLayout;
-    this.inSampleFmt = inSampleFmt;
-    this.outSampleFmt = outSampleFmt;
-    this.outBytesPerSample = bytesPerSample(cfg.targetFormat);
-  }
-  decode(buf, pts) {
-    if (this.closed) return [];
-    this.packet.data = Buffer.from(buf);
-    if (pts !== void 0) {
-      this.packet.pts = BigInt(Math.round(pts));
-      this.packet.dts = BigInt(Math.round(pts));
-    }
-    const sendRet = this.ctx.sendPacketSync(this.packet);
-    if (sendRet < 0 && sendRet !== nodeAv.AVERROR_EAGAIN) {
-      throw new Error(`audio-codec: sendPacket failed (ret=${sendRet})`);
-    }
-    const out = [];
-    while (true) {
-      const recvRet = this.ctx.receiveFrameSync(this.inFrame);
-      if (recvRet === nodeAv.AVERROR_EAGAIN || recvRet === nodeAv.AVERROR_EOF) break;
-      if (recvRet < 0) {
-        throw new Error(`audio-codec: receiveFrame failed (ret=${recvRet})`);
-      }
-      const pcm = this.resampleFrame(this.inFrame);
-      if (pcm) out.push(pcm);
-      this.inFrame.unref();
-    }
-    return out;
-  }
-  resampleFrame(inFrame) {
-    const inSamples = inFrame.nbSamples;
-    const outSamples = Math.ceil(inSamples * this.cfg.targetSampleRate / this.cfg.sourceSampleRate) + 32;
-    this.outFrame.unref();
-    this.outFrame.format = this.outSampleFmt;
-    this.outFrame.sampleRate = this.cfg.targetSampleRate;
-    this.outFrame.channelLayout = this.outLayout;
-    this.outFrame.nbSamples = outSamples;
-    const allocRet = this.outFrame.getBuffer(0);
-    if (allocRet < 0) {
-      throw new Error(`audio-codec: outFrame.getBuffer failed (ret=${allocRet})`);
-    }
-    const convRet = this.swr.convertFrame(this.outFrame, inFrame);
-    if (convRet < 0) {
-      throw new Error(`audio-codec: swr.convertFrame failed (ret=${convRet})`);
-    }
-    const producedSamples = this.outFrame.nbSamples;
-    if (producedSamples <= 0) return null;
-    const planes = this.outFrame.extendedData;
-    if (!planes || planes.length === 0 || !planes[0]) return null;
-    const bytes = producedSamples * this.cfg.targetChannels * this.outBytesPerSample;
-    const src = planes[0];
-    const out = new Uint8Array(new ArrayBuffer(bytes));
-    out.set(src.subarray(0, bytes));
-    const ptsMs = this.nextPts;
-    this.nextPts = ptsMs + Math.round(producedSamples * 1e3 / this.cfg.targetSampleRate);
-    return {
-      data: out,
-      sampleRate: this.cfg.targetSampleRate,
-      channels: this.cfg.targetChannels,
-      format: this.cfg.targetFormat,
-      pts: ptsMs
-    };
-  }
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    try {
-      this.outFrame.free();
-    } catch {
-    }
-    try {
-      this.inFrame.free();
-    } catch {
-    }
-    try {
-      this.packet.free();
-    } catch {
-    }
-    try {
-      this.swr.free();
-    } catch {
-    }
-    try {
-      this.ctx.freeContext();
-    } catch {
-    }
-  }
-  /** Surfaced for assertion-style tests to inspect computed layouts. */
-  describe() {
-    return {
-      inLayoutMask: this.inLayout.mask,
-      outLayoutMask: this.outLayout.mask,
-      inSampleFormat: this.inSampleFmt,
-      outSampleFormat: this.outSampleFmt
-    };
-  }
-}
-const CODEC_CATALOG = [
-  { codec: "pcm_mulaw", canDecode: true, canEncode: true, label: "PCM µ-law (G.711)" },
-  { codec: "pcm_alaw", canDecode: true, canEncode: true, label: "PCM A-law (G.711)" },
-  { codec: "aac", canDecode: true, canEncode: true, label: "AAC" },
-  { codec: "aac_latm", canDecode: true, canEncode: false, label: "AAC LATM" },
-  { codec: "mpeg4-generic", canDecode: true, canEncode: false, label: "AAC (MPEG4-GENERIC)" },
-  { codec: "opus", canDecode: true, canEncode: true, label: "Opus" }
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_dist = require("../dist-7ewQjTle.js");
+const require_codec_runtime = require("../codec-runtime-BOk-13PN.js");
+let node_crypto = require("node:crypto");
+//#region src/audio-codec-nodeav/addon/index.ts
+var CODEC_CATALOG = [
+	{
+		codec: "pcm_mulaw",
+		canDecode: true,
+		canEncode: true,
+		label: "PCM µ-law (G.711)"
+	},
+	{
+		codec: "pcm_alaw",
+		canDecode: true,
+		canEncode: true,
+		label: "PCM A-law (G.711)"
+	},
+	{
+		codec: "aac",
+		canDecode: true,
+		canEncode: true,
+		label: "AAC"
+	},
+	{
+		codec: "aac_latm",
+		canDecode: true,
+		canEncode: false,
+		label: "AAC LATM"
+	},
+	{
+		codec: "mpeg4-generic",
+		canDecode: true,
+		canEncode: false,
+		label: "AAC (MPEG4-GENERIC)"
+	},
+	{
+		codec: "opus",
+		canDecode: true,
+		canEncode: true,
+		label: "Opus"
+	}
 ];
 function resolveCodecAlias(codec) {
-  const c = codec.toLowerCase();
-  if (c === "mpeg4-generic") return "aac";
-  if (c === "l16") return "pcm_s16be";
-  return c;
+	const c = codec.toLowerCase();
+	if (c === "mpeg4-generic") return "aac";
+	if (c === "l16") return "pcm_s16be";
+	return c;
 }
-const DEFAULT_IDLE_MS = 3e4;
-const REAPER_INTERVAL_MS = 5e3;
-const DEFAULT_GLOBAL_CONFIG = {
-  defaultIdleMs: DEFAULT_IDLE_MS
+var DEFAULT_IDLE_MS = 3e4;
+var REAPER_INTERVAL_MS = 5e3;
+var DEFAULT_GLOBAL_CONFIG = { defaultIdleMs: DEFAULT_IDLE_MS };
+/**
+* Audio codec I/O box backed by node-av (libavcodec + libswresample).
+*
+* Each `createDecodeSession` / `createEncodeSession` allocates an
+* independent libav codec context + resampler so consumers don't share
+* resamplers — a 16kHz mono ASA subscriber and a 48kHz stereo WebRTC
+* subscriber on the same source codec each get their own session.
+*
+* Phase 1 scaffolds the cap surface + session bookkeeping. The actual
+* libav decode/encode wiring is filled in by follow-up commits — the
+* stub keeps the cap registered so wiring on the broker side can land
+* before the audio backend matures.
+*/
+var AudioCodecNodeAvAddon = class extends require_dist.BaseAddon {
+	sessions = /* @__PURE__ */ new Map();
+	reaperTimer = null;
+	logger = null;
+	constructor() {
+		super(DEFAULT_GLOBAL_CONFIG);
+	}
+	async onInitialize() {
+		this.logger = this.ctx.logger;
+		this.reaperTimer = setInterval(() => this.reapIdleSessions(), REAPER_INTERVAL_MS);
+		if (typeof this.reaperTimer.unref === "function") this.reaperTimer.unref();
+		return [{
+			capability: require_dist.audioCodecCapability,
+			provider: this
+		}];
+	}
+	async onShutdown() {
+		if (this.reaperTimer) {
+			clearInterval(this.reaperTimer);
+			this.reaperTimer = null;
+		}
+		for (const s of [...this.sessions.values()]) this.disposeSession(s);
+		this.sessions.clear();
+	}
+	async listSupportedCodecs() {
+		return CODEC_CATALOG.map((e) => ({
+			codec: e.codec,
+			canDecode: e.canDecode,
+			canEncode: e.canEncode,
+			...e.label ? { label: e.label } : {}
+		}));
+	}
+	async canHandle(input) {
+		const resolved = resolveCodecAlias(input.codec);
+		const entry = CODEC_CATALOG.find((e) => e.codec === resolved);
+		if (!entry) return false;
+		return input.kind === "decode" ? entry.canDecode : entry.canEncode;
+	}
+	async createDecodeSession(input) {
+		const codec = resolveCodecAlias(input.codec);
+		const entry = CODEC_CATALOG.find((e) => e.codec === codec);
+		if (!entry || !entry.canDecode) throw new Error(`audio-codec: decode unsupported for codec '${input.codec}'`);
+		const sessionId = `dec-${(0, node_crypto.randomUUID)()}`;
+		const state = {
+			sessionId,
+			kind: "decode",
+			config: {
+				...input,
+				codec
+			},
+			...input.tag ? { tag: input.tag } : {},
+			createdAtMs: Date.now(),
+			lastActivityMs: Date.now(),
+			framesIn: 0,
+			framesOut: 0,
+			pcmQueue: [],
+			runtime: null
+		};
+		this.sessions.set(sessionId, state);
+		this.logger?.info("audio-codec: decode session created", {
+			tags: { sessionId },
+			meta: {
+				codec,
+				target: `${input.targetSampleRate}Hz×${input.targetChannels}`
+			}
+		});
+		return {
+			sessionId,
+			nodeId: this.ctx.kernel.localNodeId ?? "local"
+		};
+	}
+	async createEncodeSession(input) {
+		const codec = resolveCodecAlias(input.codec);
+		const entry = CODEC_CATALOG.find((e) => e.codec === codec);
+		if (!entry || !entry.canEncode) throw new Error(`audio-codec: encode unsupported for codec '${input.codec}'`);
+		const sessionId = `enc-${(0, node_crypto.randomUUID)()}`;
+		const state = {
+			sessionId,
+			kind: "encode",
+			config: {
+				...input,
+				codec
+			},
+			...input.tag ? { tag: input.tag } : {},
+			createdAtMs: Date.now(),
+			lastActivityMs: Date.now(),
+			framesIn: 0,
+			framesOut: 0,
+			encodedQueue: []
+		};
+		this.sessions.set(sessionId, state);
+		this.logger?.info("audio-codec: encode session created", {
+			tags: { sessionId },
+			meta: {
+				codec,
+				target: `${input.targetSampleRate}Hz×${input.targetChannels}`
+			}
+		});
+		return {
+			sessionId,
+			nodeId: this.ctx.kernel.localNodeId ?? "local"
+		};
+	}
+	async closeSession(input) {
+		const s = this.sessions.get(input.sessionId);
+		if (!s) return;
+		this.disposeSession(s);
+		this.sessions.delete(input.sessionId);
+	}
+	async pushEncodedFrame(input) {
+		const s = this.sessions.get(input.sessionId);
+		if (!s || s.kind !== "decode") throw new Error(`audio-codec: decode session '${input.sessionId}' not found`);
+		s.lastActivityMs = Date.now();
+		s.framesIn++;
+		if (!s.runtime) try {
+			s.runtime = require_codec_runtime.DecodeRuntime.create({
+				codec: s.config.codec,
+				sourceSampleRate: s.config.sourceSampleRate,
+				sourceChannels: s.config.sourceChannels,
+				...s.config.extraData ? { extraData: s.config.extraData } : {},
+				targetSampleRate: s.config.targetSampleRate,
+				targetChannels: s.config.targetChannels,
+				targetFormat: s.config.targetFormat ?? "f32le"
+			});
+		} catch (err) {
+			this.logger?.error("audio-codec: decode runtime init failed", {
+				tags: { sessionId: input.sessionId },
+				meta: {
+					codec: s.config.codec,
+					error: require_dist.errMsg(err)
+				}
+			});
+			return;
+		}
+		try {
+			const pcms = s.runtime.decode(input.data, input.pts);
+			for (const pcm of pcms) s.pcmQueue.push(pcm);
+		} catch (err) {
+			this.logger?.warn("audio-codec: decode frame failed", {
+				tags: { sessionId: input.sessionId },
+				meta: {
+					codec: s.config.codec,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+	}
+	async pullPcm(input) {
+		const s = this.sessions.get(input.sessionId);
+		if (!s || s.kind !== "decode") throw new Error(`audio-codec: decode session '${input.sessionId}' not found`);
+		s.lastActivityMs = Date.now();
+		const out = s.pcmQueue.splice(0, input.maxCount);
+		s.framesOut += out.length;
+		return out;
+	}
+	async pushPcm(input) {
+		const s = this.sessions.get(input.sessionId);
+		if (!s || s.kind !== "encode") throw new Error(`audio-codec: encode session '${input.sessionId}' not found`);
+		s.lastActivityMs = Date.now();
+		s.framesIn++;
+		input.data;
+		input.pts;
+	}
+	async pullEncoded(input) {
+		const s = this.sessions.get(input.sessionId);
+		if (!s || s.kind !== "encode") throw new Error(`audio-codec: encode session '${input.sessionId}' not found`);
+		s.lastActivityMs = Date.now();
+		const out = s.encodedQueue.splice(0, input.maxCount);
+		s.framesOut += out.length;
+		return out;
+	}
+	async flushEncode(input) {
+		const s = this.sessions.get(input.sessionId);
+		if (!s || s.kind !== "encode") throw new Error(`audio-codec: encode session '${input.sessionId}' not found`);
+		s.lastActivityMs = Date.now();
+		const out = s.encodedQueue.splice(0);
+		s.framesOut += out.length;
+		return out;
+	}
+	async listActiveSessions() {
+		return [...this.sessions.values()].map((s) => ({
+			sessionId: s.sessionId,
+			kind: s.kind,
+			codec: s.config.codec,
+			sourceSampleRate: s.config.sourceSampleRate,
+			sourceChannels: s.config.sourceChannels,
+			targetSampleRate: s.config.targetSampleRate,
+			targetChannels: s.config.targetChannels,
+			format: this.resolveFormat(s),
+			...s.tag ? { tag: s.tag } : {},
+			createdAtMs: s.createdAtMs,
+			lastActivityMs: s.lastActivityMs,
+			framesIn: s.framesIn,
+			framesOut: s.framesOut
+		}));
+	}
+	resolveFormat(s) {
+		if (s.kind === "decode") return s.config.targetFormat ?? "f32le";
+		return s.config.sourceFormat ?? "f32le";
+	}
+	reapIdleSessions() {
+		const now = Date.now();
+		for (const [id, s] of this.sessions) {
+			const limit = s.config.idleMs ?? this.config.defaultIdleMs ?? DEFAULT_IDLE_MS;
+			if (now - s.lastActivityMs > limit) {
+				this.logger?.info("audio-codec: reaping idle session", {
+					tags: { sessionId: id },
+					meta: {
+						kind: s.kind,
+						idleMs: now - s.lastActivityMs,
+						limit
+					}
+				});
+				try {
+					this.disposeSession(s);
+				} catch (err) {
+					this.logger?.warn("audio-codec: dispose failed during reap", {
+						tags: { sessionId: id },
+						meta: { error: require_dist.errMsg(err) }
+					});
+				}
+				this.sessions.delete(id);
+			}
+		}
+	}
+	disposeSession(s) {
+		if (s.kind === "decode" && s.runtime) {
+			try {
+				s.runtime.close();
+			} catch (err) {
+				this.logger?.warn("audio-codec: decode runtime close failed", {
+					tags: { sessionId: s.sessionId },
+					meta: { error: require_dist.errMsg(err) }
+				});
+			}
+			s.runtime = null;
+		}
+	}
 };
-class AudioCodecNodeAvAddon extends index.BaseAddon {
-  sessions = /* @__PURE__ */ new Map();
-  reaperTimer = null;
-  logger = null;
-  constructor() {
-    super(DEFAULT_GLOBAL_CONFIG);
-  }
-  async onInitialize() {
-    this.logger = this.ctx.logger;
-    this.reaperTimer = setInterval(() => this.reapIdleSessions(), REAPER_INTERVAL_MS);
-    if (typeof this.reaperTimer.unref === "function") this.reaperTimer.unref();
-    return [{ capability: index.audioCodecCapability, provider: this }];
-  }
-  async onShutdown() {
-    if (this.reaperTimer) {
-      clearInterval(this.reaperTimer);
-      this.reaperTimer = null;
-    }
-    for (const s of [...this.sessions.values()]) {
-      this.disposeSession(s);
-    }
-    this.sessions.clear();
-  }
-  // ── Discovery ─────────────────────────────────────────────────────────────
-  async listSupportedCodecs() {
-    return CODEC_CATALOG.map((e) => ({
-      codec: e.codec,
-      canDecode: e.canDecode,
-      canEncode: e.canEncode,
-      ...e.label ? { label: e.label } : {}
-    }));
-  }
-  async canHandle(input) {
-    const resolved = resolveCodecAlias(input.codec);
-    const entry = CODEC_CATALOG.find((e) => e.codec === resolved);
-    if (!entry) return false;
-    return input.kind === "decode" ? entry.canDecode : entry.canEncode;
-  }
-  // ── Session lifecycle ─────────────────────────────────────────────────────
-  async createDecodeSession(input) {
-    const codec = resolveCodecAlias(input.codec);
-    const entry = CODEC_CATALOG.find((e) => e.codec === codec);
-    if (!entry || !entry.canDecode) {
-      throw new Error(`audio-codec: decode unsupported for codec '${input.codec}'`);
-    }
-    const sessionId = `dec-${crypto.randomUUID()}`;
-    const state = {
-      sessionId,
-      kind: "decode",
-      config: { ...input, codec },
-      ...input.tag ? { tag: input.tag } : {},
-      createdAtMs: Date.now(),
-      lastActivityMs: Date.now(),
-      framesIn: 0,
-      framesOut: 0,
-      pcmQueue: [],
-      runtime: null
-    };
-    this.sessions.set(sessionId, state);
-    this.logger?.info("audio-codec: decode session created", {
-      tags: { sessionId },
-      meta: { codec, target: `${input.targetSampleRate}Hz×${input.targetChannels}` }
-    });
-    return { sessionId, nodeId: this.ctx.kernel.localNodeId ?? "local" };
-  }
-  async createEncodeSession(input) {
-    const codec = resolveCodecAlias(input.codec);
-    const entry = CODEC_CATALOG.find((e) => e.codec === codec);
-    if (!entry || !entry.canEncode) {
-      throw new Error(`audio-codec: encode unsupported for codec '${input.codec}'`);
-    }
-    const sessionId = `enc-${crypto.randomUUID()}`;
-    const state = {
-      sessionId,
-      kind: "encode",
-      config: { ...input, codec },
-      ...input.tag ? { tag: input.tag } : {},
-      createdAtMs: Date.now(),
-      lastActivityMs: Date.now(),
-      framesIn: 0,
-      framesOut: 0,
-      encodedQueue: []
-    };
-    this.sessions.set(sessionId, state);
-    this.logger?.info("audio-codec: encode session created", {
-      tags: { sessionId },
-      meta: { codec, target: `${input.targetSampleRate}Hz×${input.targetChannels}` }
-    });
-    return { sessionId, nodeId: this.ctx.kernel.localNodeId ?? "local" };
-  }
-  async closeSession(input) {
-    const s = this.sessions.get(input.sessionId);
-    if (!s) return;
-    this.disposeSession(s);
-    this.sessions.delete(input.sessionId);
-  }
-  // ── Decode data plane ─────────────────────────────────────────────────────
-  async pushEncodedFrame(input) {
-    const s = this.sessions.get(input.sessionId);
-    if (!s || s.kind !== "decode") {
-      throw new Error(`audio-codec: decode session '${input.sessionId}' not found`);
-    }
-    s.lastActivityMs = Date.now();
-    s.framesIn++;
-    if (!s.runtime) {
-      try {
-        s.runtime = DecodeRuntime.create({
-          codec: s.config.codec,
-          sourceSampleRate: s.config.sourceSampleRate,
-          sourceChannels: s.config.sourceChannels,
-          ...s.config.extraData ? { extraData: s.config.extraData } : {},
-          targetSampleRate: s.config.targetSampleRate,
-          targetChannels: s.config.targetChannels,
-          targetFormat: s.config.targetFormat ?? "f32le"
-        });
-      } catch (err) {
-        this.logger?.error("audio-codec: decode runtime init failed", {
-          tags: { sessionId: input.sessionId },
-          meta: { codec: s.config.codec, error: index.errMsg(err) }
-        });
-        return;
-      }
-    }
-    try {
-      const pcms = s.runtime.decode(input.data, input.pts);
-      for (const pcm of pcms) {
-        s.pcmQueue.push(pcm);
-      }
-    } catch (err) {
-      this.logger?.warn("audio-codec: decode frame failed", {
-        tags: { sessionId: input.sessionId },
-        meta: { codec: s.config.codec, error: index.errMsg(err) }
-      });
-    }
-  }
-  async pullPcm(input) {
-    const s = this.sessions.get(input.sessionId);
-    if (!s || s.kind !== "decode") {
-      throw new Error(`audio-codec: decode session '${input.sessionId}' not found`);
-    }
-    s.lastActivityMs = Date.now();
-    const out = s.pcmQueue.splice(0, input.maxCount);
-    s.framesOut += out.length;
-    return out;
-  }
-  // ── Encode data plane ─────────────────────────────────────────────────────
-  async pushPcm(input) {
-    const s = this.sessions.get(input.sessionId);
-    if (!s || s.kind !== "encode") {
-      throw new Error(`audio-codec: encode session '${input.sessionId}' not found`);
-    }
-    s.lastActivityMs = Date.now();
-    s.framesIn++;
-    void input.data;
-    void input.pts;
-  }
-  async pullEncoded(input) {
-    const s = this.sessions.get(input.sessionId);
-    if (!s || s.kind !== "encode") {
-      throw new Error(`audio-codec: encode session '${input.sessionId}' not found`);
-    }
-    s.lastActivityMs = Date.now();
-    const out = s.encodedQueue.splice(0, input.maxCount);
-    s.framesOut += out.length;
-    return out;
-  }
-  async flushEncode(input) {
-    const s = this.sessions.get(input.sessionId);
-    if (!s || s.kind !== "encode") {
-      throw new Error(`audio-codec: encode session '${input.sessionId}' not found`);
-    }
-    s.lastActivityMs = Date.now();
-    const out = s.encodedQueue.splice(0);
-    s.framesOut += out.length;
-    return out;
-  }
-  // ── Inventory ─────────────────────────────────────────────────────────────
-  async listActiveSessions() {
-    return [...this.sessions.values()].map((s) => ({
-      sessionId: s.sessionId,
-      kind: s.kind,
-      codec: s.config.codec,
-      sourceSampleRate: s.config.sourceSampleRate,
-      sourceChannels: s.config.sourceChannels,
-      targetSampleRate: s.config.targetSampleRate,
-      targetChannels: s.config.targetChannels,
-      format: this.resolveFormat(s),
-      ...s.tag ? { tag: s.tag } : {},
-      createdAtMs: s.createdAtMs,
-      lastActivityMs: s.lastActivityMs,
-      framesIn: s.framesIn,
-      framesOut: s.framesOut
-    }));
-  }
-  // ── Internals ─────────────────────────────────────────────────────────────
-  resolveFormat(s) {
-    if (s.kind === "decode") return s.config.targetFormat ?? "f32le";
-    return s.config.sourceFormat ?? "f32le";
-  }
-  reapIdleSessions() {
-    const now = Date.now();
-    for (const [id, s] of this.sessions) {
-      const limit = s.config.idleMs ?? this.config.defaultIdleMs ?? DEFAULT_IDLE_MS;
-      if (now - s.lastActivityMs > limit) {
-        this.logger?.info("audio-codec: reaping idle session", {
-          tags: { sessionId: id },
-          meta: { kind: s.kind, idleMs: now - s.lastActivityMs, limit }
-        });
-        try {
-          this.disposeSession(s);
-        } catch (err) {
-          this.logger?.warn("audio-codec: dispose failed during reap", {
-            tags: { sessionId: id },
-            meta: { error: index.errMsg(err) }
-          });
-        }
-        this.sessions.delete(id);
-      }
-    }
-  }
-  disposeSession(s) {
-    if (s.kind === "decode" && s.runtime) {
-      try {
-        s.runtime.close();
-      } catch (err) {
-        this.logger?.warn("audio-codec: decode runtime close failed", {
-          tags: { sessionId: s.sessionId },
-          meta: { error: index.errMsg(err) }
-        });
-      }
-      s.runtime = null;
-    }
-  }
-}
+//#endregion
 exports.AudioCodecNodeAvAddon = AudioCodecNodeAvAddon;
 exports.default = AudioCodecNodeAvAddon;
-//# sourceMappingURL=index.js.map