aivee 0.1.0-alpha.0 → 0.1.0-dev.d34a6ba

package/src/media/analysis-provider.mjs

@@ -1,75 +1,75 @@
-import { probeMedia } from './probe.mjs';
-
-/** Run a pluggable media analyzer and normalize its time-coded findings. */
-export async function analyzeMediaWithProvider(mediaPath, provider, options = {}) {
-  const media = probeMedia(mediaPath, { requireVideo: false });
-  if (!provider || typeof provider !== 'object'
-      || !/^[a-z][a-z0-9-]*$/.test(provider.id ?? '')
-      || typeof provider.analyze !== 'function') {
-    throw new TypeError('Provider must define a kebab-case id and async analyze function.');
-  }
-  const findings = await provider.analyze({
-    mediaPath: media.path,
-    durationSeconds: media.durationSeconds,
-    media: structuredClone(media),
-    options: structuredClone(options.providerOptions ?? {}),
-  });
-  return {
-    providerId: provider.id,
-    analysis: normalizeMediaFindings(findings, media.durationSeconds),
-  };
-}
-
-export function normalizeMediaFindings(input, durationSeconds) {
-  if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) {
-    throw new TypeError('Media analysis durationSeconds must be positive.');
-  }
-  if (!input || typeof input !== 'object' || Array.isArray(input) || !Array.isArray(input.findings)) {
-    throw new TypeError('Media analysis result must contain a findings array.');
-  }
-
-  const findings = input.findings.map((finding, index) => {
-    const label = `Media analysis finding ${index + 1}`;
-    if (!finding || typeof finding !== 'object' || Array.isArray(finding)
-        || typeof finding.type !== 'string' || !/^[a-z][a-z0-9-]*$/.test(finding.type)) {
-      throw new TypeError(`${label} must define a kebab-case type.`);
-    }
-    const { startSeconds, endSeconds, confidence, description } = finding;
-    if (!Number.isFinite(startSeconds) || startSeconds < 0 || startSeconds >= durationSeconds) {
-      throw new TypeError(`${label} startSeconds must be inside the media duration.`);
-    }
-    if (endSeconds !== undefined
-        && (!Number.isFinite(endSeconds) || endSeconds <= startSeconds || endSeconds > durationSeconds)) {
-      throw new TypeError(`${label} endSeconds must be after startSeconds and within the media duration.`);
-    }
-    if (confidence !== undefined && (!Number.isFinite(confidence) || confidence < 0 || confidence > 1)) {
-      throw new TypeError(`${label} confidence must be between 0 and 1.`);
-    }
-    if (description !== undefined && (typeof description !== 'string' || description.length > 1000)) {
-      throw new TypeError(`${label} description must be a string up to 1000 characters.`);
-    }
-    return {
-      id: `finding-${String(index + 1).padStart(3, '0')}`,
-      type: finding.type,
-      startSeconds,
-      ...(endSeconds !== undefined ? { endSeconds } : {}),
-      ...(confidence !== undefined ? { confidence } : {}),
-      ...(description !== undefined ? { description } : {}),
-      ...(finding.suggestion !== undefined ? { suggestion: normalizeSuggestedEdit(finding.suggestion, label, durationSeconds) } : {}),
-    };
-  }).sort((left, right) => left.startSeconds - right.startSeconds || left.id.localeCompare(right.id));
-
-  return { schemaVersion: 1, durationSeconds, findings };
-}
-
-function normalizeSuggestedEdit(suggestion, label, durationSeconds) {
-  if (!suggestion || typeof suggestion !== 'object' || Array.isArray(suggestion)
-      || Object.keys(suggestion).some((field) => !['type', 'sourceStart', 'sourceEnd', 'reason'].includes(field))
-      || suggestion.type !== 'remove-range'
-      || !Number.isFinite(suggestion.sourceStart) || suggestion.sourceStart < 0 || suggestion.sourceStart >= durationSeconds
-      || !Number.isFinite(suggestion.sourceEnd) || suggestion.sourceEnd <= suggestion.sourceStart || suggestion.sourceEnd > durationSeconds
-      || typeof suggestion.reason !== 'string' || !suggestion.reason.trim() || suggestion.reason.length > 500) {
-    throw new TypeError(`${label} suggestion must define a valid remove-range with source bounds and a reason.`);
-  }
-  return structuredClone(suggestion);
-}
+import { probeMedia } from './probe.mjs';
+
+/** Run a pluggable media analyzer and normalize its time-coded findings. */
+export async function analyzeMediaWithProvider(mediaPath, provider, options = {}) {
+  const media = probeMedia(mediaPath, { requireVideo: false });
+  if (!provider || typeof provider !== 'object'
+      || !/^[a-z][a-z0-9-]*$/.test(provider.id ?? '')
+      || typeof provider.analyze !== 'function') {
+    throw new TypeError('Provider must define a kebab-case id and async analyze function.');
+  }
+  const findings = await provider.analyze({
+    mediaPath: media.path,
+    durationSeconds: media.durationSeconds,
+    media: structuredClone(media),
+    options: structuredClone(options.providerOptions ?? {}),
+  });
+  return {
+    providerId: provider.id,
+    analysis: normalizeMediaFindings(findings, media.durationSeconds),
+  };
+}
+
+export function normalizeMediaFindings(input, durationSeconds) {
+  if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) {
+    throw new TypeError('Media analysis durationSeconds must be positive.');
+  }
+  if (!input || typeof input !== 'object' || Array.isArray(input) || !Array.isArray(input.findings)) {
+    throw new TypeError('Media analysis result must contain a findings array.');
+  }
+
+  const findings = input.findings.map((finding, index) => {
+    const label = `Media analysis finding ${index + 1}`;
+    if (!finding || typeof finding !== 'object' || Array.isArray(finding)
+        || typeof finding.type !== 'string' || !/^[a-z][a-z0-9-]*$/.test(finding.type)) {
+      throw new TypeError(`${label} must define a kebab-case type.`);
+    }
+    const { startSeconds, endSeconds, confidence, description } = finding;
+    if (!Number.isFinite(startSeconds) || startSeconds < 0 || startSeconds >= durationSeconds) {
+      throw new TypeError(`${label} startSeconds must be inside the media duration.`);
+    }
+    if (endSeconds !== undefined
+        && (!Number.isFinite(endSeconds) || endSeconds <= startSeconds || endSeconds > durationSeconds)) {
+      throw new TypeError(`${label} endSeconds must be after startSeconds and within the media duration.`);
+    }
+    if (confidence !== undefined && (!Number.isFinite(confidence) || confidence < 0 || confidence > 1)) {
+      throw new TypeError(`${label} confidence must be between 0 and 1.`);
+    }
+    if (description !== undefined && (typeof description !== 'string' || description.length > 1000)) {
+      throw new TypeError(`${label} description must be a string up to 1000 characters.`);
+    }
+    return {
+      id: `finding-${String(index + 1).padStart(3, '0')}`,
+      type: finding.type,
+      startSeconds,
+      ...(endSeconds !== undefined ? { endSeconds } : {}),
+      ...(confidence !== undefined ? { confidence } : {}),
+      ...(description !== undefined ? { description } : {}),
+      ...(finding.suggestion !== undefined ? { suggestion: normalizeSuggestedEdit(finding.suggestion, label, durationSeconds) } : {}),
+    };
+  }).sort((left, right) => left.startSeconds - right.startSeconds || left.id.localeCompare(right.id));
+
+  return { schemaVersion: 1, durationSeconds, findings };
+}
+
+function normalizeSuggestedEdit(suggestion, label, durationSeconds) {
+  if (!suggestion || typeof suggestion !== 'object' || Array.isArray(suggestion)
+      || Object.keys(suggestion).some((field) => !['type', 'sourceStart', 'sourceEnd', 'reason'].includes(field))
+      || suggestion.type !== 'remove-range'
+      || !Number.isFinite(suggestion.sourceStart) || suggestion.sourceStart < 0 || suggestion.sourceStart >= durationSeconds
+      || !Number.isFinite(suggestion.sourceEnd) || suggestion.sourceEnd <= suggestion.sourceStart || suggestion.sourceEnd > durationSeconds
+      || typeof suggestion.reason !== 'string' || !suggestion.reason.trim() || suggestion.reason.length > 500) {
+    throw new TypeError(`${label} suggestion must define a valid remove-range with source bounds and a reason.`);
+  }
+  return structuredClone(suggestion);
+}

package/src/media/compatibility.mjs

@@ -1,45 +1,45 @@
-import { probeMediaAsync } from './probe.mjs';
-import { listFfmpegDecoders, listFfmpegDemuxers } from './ffmpeg-capabilities.mjs';
-
-/** Probe a media file and report whether the local FFmpeg build has its demuxer and stream decoders. */
-export async function inspectMediaCompatibility(inputPath, options = {}) {
-  if (!options || typeof options !== 'object' || Array.isArray(options)) throw new TypeError('Media compatibility options must be an object.');
-  for (const field of Object.keys(options)) if (!['ffmpeg', 'signal'].includes(field)) throw new TypeError(`Unsupported media compatibility option: ${field}.`);
-  const ffmpeg = options.ffmpeg ?? 'ffmpeg';
-  if (typeof ffmpeg !== 'string' || !ffmpeg.trim()) throw new TypeError('ffmpeg must be a non-empty command path.');
-
-  const media = await probeMediaAsync(inputPath, { requireVideo: false, signal: options.signal });
-  const demuxers = listFfmpegDemuxers(ffmpeg);
-  const decoders = listFfmpegDecoders(ffmpeg);
-  const sourceFormats = typeof media.formatName === 'string'
-    ? media.formatName.split(',').map((name) => name.trim()).filter(Boolean)
-    : [];
-  const containerAvailable = sourceFormats.some((format) => demuxers.has(format));
-  const video = media.videoStreams.map((stream) => ({
-    index: stream.index,
-    streamIndex: stream.streamIndex,
-    codec: stream.codec,
-    available: typeof stream.codec === 'string' && decoders.has(stream.codec),
-  }));
-  const audio = media.audioStreams.map((stream) => ({
-    index: stream.index,
-    streamIndex: stream.streamIndex,
-    codec: stream.codec,
-    available: typeof stream.codec === 'string' && decoders.has(stream.codec),
-  }));
-  const unsupported = [];
-  if (!containerAvailable) unsupported.push({ kind: 'container', formats: sourceFormats });
-  for (const stream of [...video, ...audio]) {
-    if (!stream.available) unsupported.push({ kind: 'decoder', streamIndex: stream.streamIndex, codec: stream.codec });
-  }
-  return {
-    schemaVersion: 1,
-    path: media.path,
-    durationSeconds: media.durationSeconds,
-    sourceFormats,
-    containerAvailable,
-    streams: { video, audio },
-    compatible: unsupported.length === 0 && video.length + audio.length > 0,
-    unsupported,
-  };
-}
+import { probeMediaAsync } from './probe.mjs';
+import { listFfmpegDecoders, listFfmpegDemuxers } from './ffmpeg-capabilities.mjs';
+
+/** Probe a media file and report whether the local FFmpeg build has its demuxer and stream decoders. */
+export async function inspectMediaCompatibility(inputPath, options = {}) {
+  if (!options || typeof options !== 'object' || Array.isArray(options)) throw new TypeError('Media compatibility options must be an object.');
+  for (const field of Object.keys(options)) if (!['ffmpeg', 'signal'].includes(field)) throw new TypeError(`Unsupported media compatibility option: ${field}.`);
+  const ffmpeg = options.ffmpeg ?? 'ffmpeg';
+  if (typeof ffmpeg !== 'string' || !ffmpeg.trim()) throw new TypeError('ffmpeg must be a non-empty command path.');
+
+  const media = await probeMediaAsync(inputPath, { requireVideo: false, signal: options.signal });
+  const demuxers = listFfmpegDemuxers(ffmpeg);
+  const decoders = listFfmpegDecoders(ffmpeg);
+  const sourceFormats = typeof media.formatName === 'string'
+    ? media.formatName.split(',').map((name) => name.trim()).filter(Boolean)
+    : [];
+  const containerAvailable = sourceFormats.some((format) => demuxers.has(format));
+  const video = media.videoStreams.map((stream) => ({
+    index: stream.index,
+    streamIndex: stream.streamIndex,
+    codec: stream.codec,
+    available: typeof stream.codec === 'string' && decoders.has(stream.codec),
+  }));
+  const audio = media.audioStreams.map((stream) => ({
+    index: stream.index,
+    streamIndex: stream.streamIndex,
+    codec: stream.codec,
+    available: typeof stream.codec === 'string' && decoders.has(stream.codec),
+  }));
+  const unsupported = [];
+  if (!containerAvailable) unsupported.push({ kind: 'container', formats: sourceFormats });
+  for (const stream of [...video, ...audio]) {
+    if (!stream.available) unsupported.push({ kind: 'decoder', streamIndex: stream.streamIndex, codec: stream.codec });
+  }
+  return {
+    schemaVersion: 1,
+    path: media.path,
+    durationSeconds: media.durationSeconds,
+    sourceFormats,
+    containerAvailable,
+    streams: { video, audio },
+    compatible: unsupported.length === 0 && video.length + audio.length > 0,
+    unsupported,
+  };
+}

package/src/media/ffmpeg-capabilities.mjs

@@ -1,129 +1,129 @@
-import { spawnSync } from 'node:child_process';
-
-export function parseFfmpegFilters(output) {
-  if (typeof output !== 'string') throw new TypeError('FFmpeg filter output must be text.');
-  return new Set(output.split(/\r?\n/).flatMap((line) => {
-    const [flags, name, inputOutput] = line.trim().split(/\s+/, 3);
-    return flags && /^[TSC.]{2,3}$/.test(flags) && name && inputOutput?.includes('->') ? [name] : [];
-  }));
-}
-
-export function hasFfmpegFilter(filterName, ffmpeg = 'ffmpeg') {
-  if (typeof filterName !== 'string' || !/^[a-z0-9_]+$/.test(filterName)) throw new TypeError('FFmpeg filter name is invalid.');
-  return listFfmpegFilters(ffmpeg).has(filterName);
-}
-
-export function listFfmpegFilters(ffmpeg = 'ffmpeg') {
-  const result = spawnSync(ffmpeg, ['-hide_banner', '-filters'], {
-    encoding: 'utf8',
-    windowsHide: true,
-    maxBuffer: 4 * 1024 * 1024,
-  });
-  if (result.error || result.status !== 0) {
-    throw new Error(`Could not inspect FFmpeg filters: ${result.error?.message ?? result.stderr.trim()}`);
-  }
-  return parseFfmpegFilters(result.stdout);
-}
-
-export function parseFfmpegEncoders(output) {
-  if (typeof output !== 'string') throw new TypeError('FFmpeg encoder output must be text.');
-  return new Set(output.split(/\r?\n/).flatMap((line) => {
-    const match = line.trim().match(/^[A-Z.]{6}\s+([a-z0-9_-]+)\s+/i);
-    return match ? [match[1]] : [];
-  }));
-}
-
-export function parseFfmpegDecoders(output) {
-  if (typeof output !== 'string') throw new TypeError('FFmpeg decoder output must be text.');
-  return new Set(output.split(/\r?\n/).flatMap((line) => {
-    const match = line.trim().match(/^[A-Z.]{6}\s+([a-z0-9_-]+)\s+/i);
-    return match ? [match[1]] : [];
-  }));
-}
-
-export function parseFfmpegDemuxers(output) {
-  if (typeof output !== 'string') throw new TypeError('FFmpeg demuxer output must be text.');
-  return new Set(output.split(/\r?\n/).flatMap((line) => {
-    const match = line.trim().match(/^D\s+([a-z0-9_,]+)\s+/i);
-    return match ? match[1].split(',').map((name) => name.trim()).filter(Boolean) : [];
-  }));
-}
-
-export function assertFfmpegEncoder(encoderName, availableEncoders) {
-  if (typeof encoderName !== 'string' || !/^[a-z0-9_-]+$/i.test(encoderName)) throw new TypeError('FFmpeg encoder name is invalid.');
-  if (!(availableEncoders instanceof Set)) throw new TypeError('Available FFmpeg encoders must be a Set.');
-  if (!availableEncoders.has(encoderName)) {
-    throw new Error(`FFmpeg encoder "${encoderName}" is unavailable in this build. Install an FFmpeg build with this encoder or select another codec.`);
-  }
-  return encoderName;
-}
-
-export function assertFfmpegDecoder(decoderName, availableDecoders) {
-  if (typeof decoderName !== 'string' || !/^[a-z0-9_-]+$/i.test(decoderName)) throw new TypeError('FFmpeg decoder name is invalid.');
-  if (!(availableDecoders instanceof Set)) throw new TypeError('Available FFmpeg decoders must be a Set.');
-  if (!availableDecoders.has(decoderName)) {
-    throw new Error(`FFmpeg decoder "${decoderName}" is unavailable in this build. Install an FFmpeg build with this decoder or choose another input format.`);
-  }
-  return decoderName;
-}
-
-export function assertFfmpegDemuxer(demuxerName, availableDemuxers) {
-  if (typeof demuxerName !== 'string' || !/^[a-z0-9_]+$/i.test(demuxerName)) throw new TypeError('FFmpeg demuxer name is invalid.');
-  if (!(availableDemuxers instanceof Set)) throw new TypeError('Available FFmpeg demuxers must be a Set.');
-  if (!availableDemuxers.has(demuxerName)) {
-    throw new Error(`FFmpeg demuxer "${demuxerName}" is unavailable in this build. Install an FFmpeg build with this demuxer or choose another container.`);
-  }
-  return demuxerName;
-}
-
-export function hasFfmpegEncoder(encoderName, ffmpeg = 'ffmpeg') {
-  if (typeof encoderName !== 'string' || !/^[a-z0-9_-]+$/i.test(encoderName)) throw new TypeError('FFmpeg encoder name is invalid.');
-  assertFfmpegEncoder(encoderName, listFfmpegEncoders(ffmpeg));
-  return true;
-}
-
-export function hasFfmpegDecoder(decoderName, ffmpeg = 'ffmpeg') {
-  if (typeof decoderName !== 'string' || !/^[a-z0-9_-]+$/i.test(decoderName)) throw new TypeError('FFmpeg decoder name is invalid.');
-  return listFfmpegDecoders(ffmpeg).has(decoderName);
-}
-
-export function hasFfmpegDemuxer(demuxerName, ffmpeg = 'ffmpeg') {
-  if (typeof demuxerName !== 'string' || !/^[a-z0-9_]+$/i.test(demuxerName)) throw new TypeError('FFmpeg demuxer name is invalid.');
-  return listFfmpegDemuxers(ffmpeg).has(demuxerName);
-}
-
-export function listFfmpegEncoders(ffmpeg = 'ffmpeg') {
-  const result = spawnSync(ffmpeg, ['-hide_banner', '-encoders'], {
-    encoding: 'utf8',
-    windowsHide: true,
-    maxBuffer: 4 * 1024 * 1024,
-  });
-  if (result.error || result.status !== 0) {
-    throw new Error(`Could not inspect FFmpeg encoders: ${result.error?.message ?? result.stderr.trim()}`);
-  }
-  return parseFfmpegEncoders(result.stdout);
-}
-
-export function listFfmpegDecoders(ffmpeg = 'ffmpeg') {
-  const result = spawnSync(ffmpeg, ['-hide_banner', '-decoders'], {
-    encoding: 'utf8',
-    windowsHide: true,
-    maxBuffer: 4 * 1024 * 1024,
-  });
-  if (result.error || result.status !== 0) {
-    throw new Error(`Could not inspect FFmpeg decoders: ${result.error?.message ?? result.stderr.trim()}`);
-  }
-  return parseFfmpegDecoders(result.stdout);
-}
-
-export function listFfmpegDemuxers(ffmpeg = 'ffmpeg') {
-  const result = spawnSync(ffmpeg, ['-hide_banner', '-demuxers'], {
-    encoding: 'utf8',
-    windowsHide: true,
-    maxBuffer: 4 * 1024 * 1024,
-  });
-  if (result.error || result.status !== 0) {
-    throw new Error(`Could not inspect FFmpeg demuxers: ${result.error?.message ?? result.stderr.trim()}`);
-  }
-  return parseFfmpegDemuxers(result.stdout);
-}
+import { spawnSync } from 'node:child_process';
+
+export function parseFfmpegFilters(output) {
+  if (typeof output !== 'string') throw new TypeError('FFmpeg filter output must be text.');
+  return new Set(output.split(/\r?\n/).flatMap((line) => {
+    const [flags, name, inputOutput] = line.trim().split(/\s+/, 3);
+    return flags && /^[TSC.]{2,3}$/.test(flags) && name && inputOutput?.includes('->') ? [name] : [];
+  }));
+}
+
+export function hasFfmpegFilter(filterName, ffmpeg = 'ffmpeg') {
+  if (typeof filterName !== 'string' || !/^[a-z0-9_]+$/.test(filterName)) throw new TypeError('FFmpeg filter name is invalid.');
+  return listFfmpegFilters(ffmpeg).has(filterName);
+}
+
+export function listFfmpegFilters(ffmpeg = 'ffmpeg') {
+  const result = spawnSync(ffmpeg, ['-hide_banner', '-filters'], {
+    encoding: 'utf8',
+    windowsHide: true,
+    maxBuffer: 4 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(`Could not inspect FFmpeg filters: ${result.error?.message ?? result.stderr.trim()}`);
+  }
+  return parseFfmpegFilters(result.stdout);
+}
+
+export function parseFfmpegEncoders(output) {
+  if (typeof output !== 'string') throw new TypeError('FFmpeg encoder output must be text.');
+  return new Set(output.split(/\r?\n/).flatMap((line) => {
+    const match = line.trim().match(/^[A-Z.]{6}\s+([a-z0-9_-]+)\s+/i);
+    return match ? [match[1]] : [];
+  }));
+}
+
+export function parseFfmpegDecoders(output) {
+  if (typeof output !== 'string') throw new TypeError('FFmpeg decoder output must be text.');
+  return new Set(output.split(/\r?\n/).flatMap((line) => {
+    const match = line.trim().match(/^[A-Z.]{6}\s+([a-z0-9_-]+)\s+/i);
+    return match ? [match[1]] : [];
+  }));
+}
+
+export function parseFfmpegDemuxers(output) {
+  if (typeof output !== 'string') throw new TypeError('FFmpeg demuxer output must be text.');
+  return new Set(output.split(/\r?\n/).flatMap((line) => {
+    const match = line.trim().match(/^D\s+([a-z0-9_,]+)\s+/i);
+    return match ? match[1].split(',').map((name) => name.trim()).filter(Boolean) : [];
+  }));
+}
+
+export function assertFfmpegEncoder(encoderName, availableEncoders) {
+  if (typeof encoderName !== 'string' || !/^[a-z0-9_-]+$/i.test(encoderName)) throw new TypeError('FFmpeg encoder name is invalid.');
+  if (!(availableEncoders instanceof Set)) throw new TypeError('Available FFmpeg encoders must be a Set.');
+  if (!availableEncoders.has(encoderName)) {
+    throw new Error(`FFmpeg encoder "${encoderName}" is unavailable in this build. Install an FFmpeg build with this encoder or select another codec.`);
+  }
+  return encoderName;
+}
+
+export function assertFfmpegDecoder(decoderName, availableDecoders) {
+  if (typeof decoderName !== 'string' || !/^[a-z0-9_-]+$/i.test(decoderName)) throw new TypeError('FFmpeg decoder name is invalid.');
+  if (!(availableDecoders instanceof Set)) throw new TypeError('Available FFmpeg decoders must be a Set.');
+  if (!availableDecoders.has(decoderName)) {
+    throw new Error(`FFmpeg decoder "${decoderName}" is unavailable in this build. Install an FFmpeg build with this decoder or choose another input format.`);
+  }
+  return decoderName;
+}
+
+export function assertFfmpegDemuxer(demuxerName, availableDemuxers) {
+  if (typeof demuxerName !== 'string' || !/^[a-z0-9_]+$/i.test(demuxerName)) throw new TypeError('FFmpeg demuxer name is invalid.');
+  if (!(availableDemuxers instanceof Set)) throw new TypeError('Available FFmpeg demuxers must be a Set.');
+  if (!availableDemuxers.has(demuxerName)) {
+    throw new Error(`FFmpeg demuxer "${demuxerName}" is unavailable in this build. Install an FFmpeg build with this demuxer or choose another container.`);
+  }
+  return demuxerName;
+}
+
+export function hasFfmpegEncoder(encoderName, ffmpeg = 'ffmpeg') {
+  if (typeof encoderName !== 'string' || !/^[a-z0-9_-]+$/i.test(encoderName)) throw new TypeError('FFmpeg encoder name is invalid.');
+  assertFfmpegEncoder(encoderName, listFfmpegEncoders(ffmpeg));
+  return true;
+}
+
+export function hasFfmpegDecoder(decoderName, ffmpeg = 'ffmpeg') {
+  if (typeof decoderName !== 'string' || !/^[a-z0-9_-]+$/i.test(decoderName)) throw new TypeError('FFmpeg decoder name is invalid.');
+  return listFfmpegDecoders(ffmpeg).has(decoderName);
+}
+
+export function hasFfmpegDemuxer(demuxerName, ffmpeg = 'ffmpeg') {
+  if (typeof demuxerName !== 'string' || !/^[a-z0-9_]+$/i.test(demuxerName)) throw new TypeError('FFmpeg demuxer name is invalid.');
+  return listFfmpegDemuxers(ffmpeg).has(demuxerName);
+}
+
+export function listFfmpegEncoders(ffmpeg = 'ffmpeg') {
+  const result = spawnSync(ffmpeg, ['-hide_banner', '-encoders'], {
+    encoding: 'utf8',
+    windowsHide: true,
+    maxBuffer: 4 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(`Could not inspect FFmpeg encoders: ${result.error?.message ?? result.stderr.trim()}`);
+  }
+  return parseFfmpegEncoders(result.stdout);
+}
+
+export function listFfmpegDecoders(ffmpeg = 'ffmpeg') {
+  const result = spawnSync(ffmpeg, ['-hide_banner', '-decoders'], {
+    encoding: 'utf8',
+    windowsHide: true,
+    maxBuffer: 4 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(`Could not inspect FFmpeg decoders: ${result.error?.message ?? result.stderr.trim()}`);
+  }
+  return parseFfmpegDecoders(result.stdout);
+}
+
+export function listFfmpegDemuxers(ffmpeg = 'ffmpeg') {
+  const result = spawnSync(ffmpeg, ['-hide_banner', '-demuxers'], {
+    encoding: 'utf8',
+    windowsHide: true,
+    maxBuffer: 4 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(`Could not inspect FFmpeg demuxers: ${result.error?.message ?? result.stderr.trim()}`);
+  }
+  return parseFfmpegDemuxers(result.stdout);
+}

package/src/media/frame-rate.mjs

@@ -1,58 +1,58 @@
-const COMMON_RATES = [
-  [23.976, 24000, 1001],
-  [29.97, 30000, 1001],
-  [59.94, 60000, 1001],
-  [119.88, 120000, 1001],
-];
-
-export function normalizeFrameRate(value) {
-  if (typeof value === 'number') {
-    if (!Number.isFinite(value)) throw new TypeError('Frame rate must be finite.');
-    const common = COMMON_RATES.find(([rate]) => Math.abs(rate - value) < 0.0005);
-    if (common) return `${common[1]}/${common[2]}`;
-    return normalizeFrameRate(String(value));
-  }
-  if (typeof value !== 'string') throw new TypeError('Frame rate must be an integer, decimal, or rational string.');
-  const input = value.trim();
-  const rational = /^(\d+)\/(\d+)$/.exec(input);
-  if (rational) {
-    let numerator = Number(rational[1]);
-    let denominator = Number(rational[2]);
-    if (!Number.isSafeInteger(numerator) || !Number.isSafeInteger(denominator) || denominator <= 0) throw new TypeError('Frame rate rational must use positive safe integers.');
-    const divisor = gcd(numerator, denominator);
-    numerator /= divisor;
-    denominator /= divisor;
-    const rate = numerator / denominator;
-    validateRate(rate);
-    return denominator === 1 ? numerator : `${numerator}/${denominator}`;
-  }
-  if (!/^\d+(?:\.\d+)?$/.test(input)) throw new TypeError('Frame rate must be an integer, decimal, or numerator/denominator value.');
-  const decimal = Number(input);
-  if (!Number.isFinite(decimal)) throw new TypeError('Frame rate must be finite.');
-  const common = COMMON_RATES.find(([rate]) => Math.abs(rate - decimal) < 0.0005);
-  if (common) return `${common[1]}/${common[2]}`;
-  const [whole, fraction = ''] = input.split('.');
-  const denominator = 10 ** fraction.length;
-  const numerator = Number(whole) * denominator + Number(fraction || 0);
-  return normalizeFrameRate(`${numerator}/${denominator}`);
-}
-
-export function frameRateNumber(value) {
-  if (typeof value === 'number') {
-    validateRate(value);
-    return value;
-  }
-  const normalized = normalizeFrameRate(value);
-  if (typeof normalized === 'number') return normalized;
-  const [numerator, denominator] = normalized.split('/').map(Number);
-  return numerator / denominator;
-}
-
-function validateRate(rate) {
-  if (!Number.isFinite(rate) || rate < 1 || rate > 240) throw new TypeError('Frame rate must be between 1 and 240 fps.');
-}
-
-function gcd(a, b) {
-  while (b !== 0) [a, b] = [b, a % b];
-  return Math.abs(a);
-}
+const COMMON_RATES = [
+  [23.976, 24000, 1001],
+  [29.97, 30000, 1001],
+  [59.94, 60000, 1001],
+  [119.88, 120000, 1001],
+];
+
+export function normalizeFrameRate(value) {
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) throw new TypeError('Frame rate must be finite.');
+    const common = COMMON_RATES.find(([rate]) => Math.abs(rate - value) < 0.0005);
+    if (common) return `${common[1]}/${common[2]}`;
+    return normalizeFrameRate(String(value));
+  }
+  if (typeof value !== 'string') throw new TypeError('Frame rate must be an integer, decimal, or rational string.');
+  const input = value.trim();
+  const rational = /^(\d+)\/(\d+)$/.exec(input);
+  if (rational) {
+    let numerator = Number(rational[1]);
+    let denominator = Number(rational[2]);
+    if (!Number.isSafeInteger(numerator) || !Number.isSafeInteger(denominator) || denominator <= 0) throw new TypeError('Frame rate rational must use positive safe integers.');
+    const divisor = gcd(numerator, denominator);
+    numerator /= divisor;
+    denominator /= divisor;
+    const rate = numerator / denominator;
+    validateRate(rate);
+    return denominator === 1 ? numerator : `${numerator}/${denominator}`;
+  }
+  if (!/^\d+(?:\.\d+)?$/.test(input)) throw new TypeError('Frame rate must be an integer, decimal, or numerator/denominator value.');
+  const decimal = Number(input);
+  if (!Number.isFinite(decimal)) throw new TypeError('Frame rate must be finite.');
+  const common = COMMON_RATES.find(([rate]) => Math.abs(rate - decimal) < 0.0005);
+  if (common) return `${common[1]}/${common[2]}`;
+  const [whole, fraction = ''] = input.split('.');
+  const denominator = 10 ** fraction.length;
+  const numerator = Number(whole) * denominator + Number(fraction || 0);
+  return normalizeFrameRate(`${numerator}/${denominator}`);
+}
+
+export function frameRateNumber(value) {
+  if (typeof value === 'number') {
+    validateRate(value);
+    return value;
+  }
+  const normalized = normalizeFrameRate(value);
+  if (typeof normalized === 'number') return normalized;
+  const [numerator, denominator] = normalized.split('/').map(Number);
+  return numerator / denominator;
+}
+
+function validateRate(rate) {
+  if (!Number.isFinite(rate) || rate < 1 || rate > 240) throw new TypeError('Frame rate must be between 1 and 240 fps.');
+}
+
+function gcd(a, b) {
+  while (b !== 0) [a, b] = [b, a % b];
+  return Math.abs(a);
+}