fconvert 0.1.2 → 0.1.4

package/README.md

@@ -2,6 +2,9 @@
 
 Fast local CLI conversion tool with graph-based anything-to-anything routing.
 
+The built-in registry includes 100+ file formats across image, audio, video, document,
+data, archive, code, and font categories.
+
 ## Quick start
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fconvert",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Fast local CLI conversion tool with graph-based anything-to-anything routing",
   "type": "module",
   "main": "src/cli/main.ts",

package/src/cli/output-picker.ts

@@ -9,6 +9,7 @@ import { FormatRegistry } from "../formats/registry.ts";
 interface PickerPayload {
   prompt: string;
   query: string;
+  preferred: string;
   options: Array<{
     id: string;
     name: string;
@@ -110,7 +111,8 @@ export async function pickOutputFormatInteractive(
 
   const payload: PickerPayload = {
     prompt: "output format",
-    query: extname(inputPath).replace(/^\./, ""),
+    query: "",
+    preferred: extname(inputPath).replace(/^\./, ""),
     options: registry.all().map((format) => ({
       id: format.id,
       name: format.name,

package/src/formats/aliases.ts

@@ -1,8 +1,24 @@
 export const FORMAT_ALIASES: Record<string, string> = {
   jpg: "jpeg",
   jpeg: "jpeg",
+  tif: "tiff",
+  tiff: "tiff",
+  htm: "html",
+  html: "html",
   markdown: "md",
+  md: "md",
   yml: "yaml",
+  yaml: "yaml",
+  oga: "ogg",
+  mpg: "mpeg",
+  m2ts: "ts",
+  mts: "ts",
+  f4v: "flv",
+  asciidoc: "adoc",
+  texi: "texinfo",
   text: "txt",
   binary: "bin",
+  midi: "mid",
+  jsonl: "json",
+  ndjson: "json",
 };

package/src/formats/common.ts

@@ -1,69 +1,139 @@
 import type { Category, FormatDefinition } from "../core/types.ts";
 
-function defineFormat(
-  id: string,
-  name: string,
-  extension: string,
-  mime: string[],
-  category: Category[],
-  aliases: string[] = [],
-): FormatDefinition {
+interface FormatSeed {
+  id: string;
+  name: string;
+  extension: string;
+  mime: string[];
+  category: Category[];
+  aliases?: string[];
+  extraExtensions?: string[];
+}
+
+function defineFormat(seed: FormatSeed): FormatDefinition {
+  const aliases = (seed.aliases ?? []).map((value) => value.toLowerCase());
+  const extensions = [seed.extension, ...(seed.extraExtensions ?? [])].map((value) => value.toLowerCase());
   return {
-    id,
-    name,
-    extension,
-    extensions: [extension],
-    mime,
-    category,
+    id: seed.id.toLowerCase(),
+    name: seed.name,
+    extension: seed.extension.toLowerCase(),
+    extensions,
+    mime: seed.mime,
+    category: seed.category,
     aliases,
   };
 }
 
 export const COMMON_FORMATS: FormatDefinition[] = [
-  defineFormat("png", "Portable Network Graphics", "png", ["image/png"], ["image"]),
-  defineFormat("jpeg", "JPEG Image", "jpg", ["image/jpeg"], ["image"], ["jpg"]),
-  defineFormat("webp", "WebP Image", "webp", ["image/webp"], ["image"]),
-  defineFormat("gif", "Graphics Interchange Format", "gif", ["image/gif"], ["image", "video"]),
-  defineFormat("bmp", "Bitmap Image", "bmp", ["image/bmp"], ["image"]),
-  defineFormat("tiff", "Tagged Image File Format", "tiff", ["image/tiff"], ["image"], ["tif"]),
-  defineFormat("svg", "Scalable Vector Graphics", "svg", ["image/svg+xml"], ["image", "vector", "document"]),
+  defineFormat({ id: "png", name: "Portable Network Graphics", extension: "png", mime: ["image/png"], category: ["image"] }),
+  defineFormat({ id: "jpeg", name: "JPEG Image", extension: "jpg", extraExtensions: ["jpeg", "jpe"], mime: ["image/jpeg"], category: ["image"], aliases: ["jpg", "jpeg"] }),
+  defineFormat({ id: "webp", name: "WebP Image", extension: "webp", mime: ["image/webp"], category: ["image"] }),
+  defineFormat({ id: "gif", name: "Graphics Interchange Format", extension: "gif", mime: ["image/gif"], category: ["image", "video"] }),
+  defineFormat({ id: "bmp", name: "Bitmap Image", extension: "bmp", mime: ["image/bmp"], category: ["image"] }),
+  defineFormat({ id: "tiff", name: "Tagged Image File Format", extension: "tiff", extraExtensions: ["tif"], mime: ["image/tiff"], category: ["image"], aliases: ["tif"] }),
+  defineFormat({ id: "svg", name: "Scalable Vector Graphics", extension: "svg", mime: ["image/svg+xml"], category: ["image", "vector", "document"] }),
+  defineFormat({ id: "avif", name: "AVIF Image", extension: "avif", mime: ["image/avif"], category: ["image"] }),
+  defineFormat({ id: "heic", name: "HEIC Image", extension: "heic", extraExtensions: ["heif"], mime: ["image/heic"], category: ["image"], aliases: ["heif"] }),
+  defineFormat({ id: "ico", name: "Icon Image", extension: "ico", mime: ["image/x-icon"], category: ["image"] }),
+  defineFormat({ id: "jp2", name: "JPEG 2000", extension: "jp2", extraExtensions: ["j2k"], mime: ["image/jp2"], category: ["image"], aliases: ["j2k"] }),
+  defineFormat({ id: "psd", name: "Photoshop Document", extension: "psd", mime: ["image/vnd.adobe.photoshop"], category: ["image", "document"] }),
+  defineFormat({ id: "tga", name: "Targa Image", extension: "tga", mime: ["image/x-tga"], category: ["image"] }),
+  defineFormat({ id: "dds", name: "DirectDraw Surface", extension: "dds", mime: ["image/vnd.ms-dds"], category: ["image"] }),
+  defineFormat({ id: "hdr", name: "Radiance HDR", extension: "hdr", mime: ["image/vnd.radiance"], category: ["image"] }),
+  defineFormat({ id: "exr", name: "OpenEXR", extension: "exr", mime: ["image/aces"], category: ["image"] }),
+  defineFormat({ id: "pnm", name: "Portable Anymap", extension: "pnm", mime: ["image/x-portable-anymap"], category: ["image"] }),
+  defineFormat({ id: "pbm", name: "Portable Bitmap", extension: "pbm", mime: ["image/x-portable-bitmap"], category: ["image"] }),
+  defineFormat({ id: "pgm", name: "Portable Graymap", extension: "pgm", mime: ["image/x-portable-graymap"], category: ["image"] }),
+  defineFormat({ id: "ppm", name: "Portable Pixmap", extension: "ppm", mime: ["image/x-portable-pixmap"], category: ["image"] }),
+  defineFormat({ id: "apng", name: "Animated PNG", extension: "apng", mime: ["image/apng"], category: ["image", "video"] }),
 
-  defineFormat("wav", "Waveform Audio", "wav", ["audio/wav"], ["audio"]),
-  defineFormat("mp3", "MP3 Audio", "mp3", ["audio/mpeg"], ["audio"]),
-  defineFormat("flac", "FLAC Audio", "flac", ["audio/flac"], ["audio"]),
-  defineFormat("ogg", "Ogg Audio", "ogg", ["audio/ogg"], ["audio"]),
+  defineFormat({ id: "wav", name: "Waveform Audio", extension: "wav", mime: ["audio/wav"], category: ["audio"] }),
+  defineFormat({ id: "mp3", name: "MP3 Audio", extension: "mp3", mime: ["audio/mpeg"], category: ["audio"] }),
+  defineFormat({ id: "flac", name: "FLAC Audio", extension: "flac", mime: ["audio/flac"], category: ["audio"] }),
+  defineFormat({ id: "ogg", name: "Ogg Audio", extension: "ogg", extraExtensions: ["oga"], mime: ["audio/ogg"], category: ["audio"], aliases: ["oga"] }),
+  defineFormat({ id: "aac", name: "AAC Audio", extension: "aac", mime: ["audio/aac"], category: ["audio"] }),
+  defineFormat({ id: "m4a", name: "MPEG-4 Audio", extension: "m4a", mime: ["audio/mp4"], category: ["audio"] }),
+  defineFormat({ id: "wma", name: "Windows Media Audio", extension: "wma", mime: ["audio/x-ms-wma"], category: ["audio"] }),
+  defineFormat({ id: "aiff", name: "Audio Interchange File Format", extension: "aiff", extraExtensions: ["aif"], mime: ["audio/aiff"], category: ["audio"], aliases: ["aif"] }),
+  defineFormat({ id: "opus", name: "Opus Audio", extension: "opus", mime: ["audio/opus"], category: ["audio"] }),
+  defineFormat({ id: "amr", name: "AMR Audio", extension: "amr", mime: ["audio/amr"], category: ["audio"] }),
+  defineFormat({ id: "ac3", name: "Dolby Digital AC-3", extension: "ac3", mime: ["audio/ac3"], category: ["audio"] }),
+  defineFormat({ id: "dts", name: "Digital Theater Systems Audio", extension: "dts", mime: ["audio/vnd.dts"], category: ["audio"] }),
+  defineFormat({ id: "mka", name: "Matroska Audio", extension: "mka", mime: ["audio/x-matroska"], category: ["audio"] }),
+  defineFormat({ id: "mid", name: "MIDI Sequence", extension: "mid", extraExtensions: ["midi"], mime: ["audio/midi"], category: ["audio"], aliases: ["midi"] }),
 
-  defineFormat("mp4", "MPEG-4 Video", "mp4", ["video/mp4"], ["video"]),
-  defineFormat("mov", "QuickTime MOV", "mov", ["video/quicktime"], ["video"]),
-  defineFormat("webm", "WebM Video", "webm", ["video/webm"], ["video"]),
-  defineFormat("wmv", "Windows Media Video", "wmv", ["video/x-ms-wmv"], ["video"]),
+  defineFormat({ id: "mp4", name: "MPEG-4 Video", extension: "mp4", mime: ["video/mp4"], category: ["video"] }),
+  defineFormat({ id: "m4v", name: "MPEG-4 Video", extension: "m4v", mime: ["video/x-m4v"], category: ["video"] }),
+  defineFormat({ id: "mov", name: "QuickTime MOV", extension: "mov", mime: ["video/quicktime"], category: ["video"] }),
+  defineFormat({ id: "webm", name: "WebM Video", extension: "webm", mime: ["video/webm"], category: ["video"] }),
+  defineFormat({ id: "wmv", name: "Windows Media Video", extension: "wmv", mime: ["video/x-ms-wmv"], category: ["video"] }),
+  defineFormat({ id: "mkv", name: "Matroska Video", extension: "mkv", mime: ["video/x-matroska"], category: ["video"] }),
+  defineFormat({ id: "avi", name: "Audio Video Interleave", extension: "avi", mime: ["video/x-msvideo"], category: ["video"] }),
+  defineFormat({ id: "mpeg", name: "MPEG Video", extension: "mpeg", extraExtensions: ["mpg"], mime: ["video/mpeg"], category: ["video"], aliases: ["mpg"] }),
+  defineFormat({ id: "3gp", name: "3GPP Video", extension: "3gp", mime: ["video/3gpp"], category: ["video"] }),
+  defineFormat({ id: "3g2", name: "3GPP2 Video", extension: "3g2", mime: ["video/3gpp2"], category: ["video"] }),
+  defineFormat({ id: "flv", name: "Flash Video", extension: "flv", extraExtensions: ["f4v"], mime: ["video/x-flv"], category: ["video"], aliases: ["f4v"] }),
+  defineFormat({ id: "ts", name: "MPEG Transport Stream", extension: "ts", extraExtensions: ["m2ts", "mts"], mime: ["video/mp2t"], category: ["video"], aliases: ["m2ts", "mts"] }),
+  defineFormat({ id: "vob", name: "DVD Video Object", extension: "vob", mime: ["video/dvd"], category: ["video"] }),
+  defineFormat({ id: "ogv", name: "Ogg Video", extension: "ogv", mime: ["video/ogg"], category: ["video"] }),
+  defineFormat({ id: "asf", name: "Advanced Systems Format", extension: "asf", mime: ["video/x-ms-asf"], category: ["video"] }),
 
-  defineFormat("txt", "Plain Text", "txt", ["text/plain"], ["text"]),
-  defineFormat("md", "Markdown", "md", ["text/markdown"], ["text", "document"], ["markdown"]),
-  defineFormat("html", "HyperText Markup Language", "html", ["text/html"], ["text", "document"]),
-  defineFormat("json", "JSON", "json", ["application/json"], ["data", "text"]),
-  defineFormat("xml", "XML", "xml", ["application/xml", "text/xml"], ["data", "text"]),
-  defineFormat("yaml", "YAML", "yml", ["application/yaml", "text/yaml"], ["data", "text"], ["yml"]),
-  defineFormat("csv", "Comma Separated Values", "csv", ["text/csv"], ["data", "text"]),
-  defineFormat("css", "Cascading Style Sheets", "css", ["text/css"], ["code", "text"]),
-  defineFormat("sh", "Shell Script", "sh", ["application/x-sh"], ["code", "text"]),
-  defineFormat("py", "Python Script", "py", ["text/x-python"], ["code", "text"]),
+  defineFormat({ id: "txt", name: "Plain Text", extension: "txt", mime: ["text/plain"], category: ["text"] }),
+  defineFormat({ id: "md", name: "Markdown", extension: "md", extraExtensions: ["markdown"], mime: ["text/markdown"], category: ["text", "document"], aliases: ["markdown"] }),
+  defineFormat({ id: "html", name: "HyperText Markup Language", extension: "html", extraExtensions: ["htm"], mime: ["text/html"], category: ["text", "document"], aliases: ["htm"] }),
+  defineFormat({ id: "xhtml", name: "XHTML", extension: "xhtml", mime: ["application/xhtml+xml"], category: ["text", "document"] }),
+  defineFormat({ id: "json", name: "JSON", extension: "json", extraExtensions: ["jsonl", "ndjson"], mime: ["application/json"], category: ["data", "text"], aliases: ["jsonl", "ndjson"] }),
+  defineFormat({ id: "xml", name: "XML", extension: "xml", mime: ["application/xml", "text/xml"], category: ["data", "text"] }),
+  defineFormat({ id: "yaml", name: "YAML", extension: "yml", extraExtensions: ["yaml"], mime: ["application/yaml", "text/yaml"], category: ["data", "text"], aliases: ["yaml"] }),
+  defineFormat({ id: "toml", name: "TOML", extension: "toml", mime: ["application/toml"], category: ["data", "text"] }),
+  defineFormat({ id: "ini", name: "INI Config", extension: "ini", mime: ["text/plain"], category: ["data", "text"] }),
+  defineFormat({ id: "csv", name: "Comma Separated Values", extension: "csv", mime: ["text/csv"], category: ["data", "text"] }),
+  defineFormat({ id: "tsv", name: "Tab Separated Values", extension: "tsv", mime: ["text/tab-separated-values"], category: ["data", "text"] }),
+  defineFormat({ id: "css", name: "Cascading Style Sheets", extension: "css", mime: ["text/css"], category: ["code", "text"] }),
+  defineFormat({ id: "js", name: "JavaScript", extension: "js", mime: ["text/javascript"], category: ["code", "text"] }),
+  defineFormat({ id: "py", name: "Python Script", extension: "py", mime: ["text/x-python"], category: ["code", "text"] }),
+  defineFormat({ id: "sh", name: "Shell Script", extension: "sh", mime: ["application/x-sh"], category: ["code", "text"] }),
+  defineFormat({ id: "bat", name: "Batch Script", extension: "bat", mime: ["application/x-bat"], category: ["code", "text"] }),
+  defineFormat({ id: "ps1", name: "PowerShell Script", extension: "ps1", mime: ["text/plain"], category: ["code", "text"] }),
+  defineFormat({ id: "rst", name: "reStructuredText", extension: "rst", mime: ["text/x-rst"], category: ["text", "document"] }),
+  defineFormat({ id: "tex", name: "LaTeX", extension: "tex", mime: ["application/x-tex"], category: ["text", "document"] }),
+  defineFormat({ id: "adoc", name: "AsciiDoc", extension: "adoc", extraExtensions: ["asciidoc"], mime: ["text/plain"], category: ["text", "document"], aliases: ["asciidoc"] }),
+  defineFormat({ id: "bbcode", name: "BBCode", extension: "bbcode", mime: ["text/plain"], category: ["text", "document"] }),
+  defineFormat({ id: "org", name: "Org Mode", extension: "org", mime: ["text/plain"], category: ["text", "document"] }),
 
-  defineFormat("pdf", "Portable Document Format", "pdf", ["application/pdf"], ["document"]),
-  defineFormat("docx", "Word Document", "docx", ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"], ["document"]),
-  defineFormat("xlsx", "Excel Workbook", "xlsx", ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"], ["spreadsheet", "document"]),
-  defineFormat("pptx", "PowerPoint Presentation", "pptx", ["application/vnd.openxmlformats-officedocument.presentationml.presentation"], ["presentation", "document"]),
+  defineFormat({ id: "pdf", name: "Portable Document Format", extension: "pdf", mime: ["application/pdf"], category: ["document"] }),
+  defineFormat({ id: "docx", name: "Word Document", extension: "docx", mime: ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"], category: ["document"] }),
+  defineFormat({ id: "odt", name: "OpenDocument Text", extension: "odt", mime: ["application/vnd.oasis.opendocument.text"], category: ["document"] }),
+  defineFormat({ id: "rtf", name: "Rich Text Format", extension: "rtf", mime: ["application/rtf"], category: ["document", "text"] }),
+  defineFormat({ id: "epub", name: "EPUB eBook", extension: "epub", mime: ["application/epub+zip"], category: ["document"] }),
+  defineFormat({ id: "fb2", name: "FictionBook", extension: "fb2", mime: ["application/x-fictionbook+xml"], category: ["document", "text"] }),
+  defineFormat({ id: "pptx", name: "PowerPoint Presentation", extension: "pptx", mime: ["application/vnd.openxmlformats-officedocument.presentationml.presentation"], category: ["presentation", "document"] }),
+  defineFormat({ id: "xlsx", name: "Excel Workbook", extension: "xlsx", mime: ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"], category: ["spreadsheet", "document"] }),
+  defineFormat({ id: "ods", name: "OpenDocument Spreadsheet", extension: "ods", mime: ["application/vnd.oasis.opendocument.spreadsheet"], category: ["spreadsheet", "document"] }),
+  defineFormat({ id: "odp", name: "OpenDocument Presentation", extension: "odp", mime: ["application/vnd.oasis.opendocument.presentation"], category: ["presentation", "document"] }),
+  defineFormat({ id: "docbook", name: "DocBook", extension: "docbook", mime: ["application/xml"], category: ["document", "text"] }),
+  defineFormat({ id: "jats", name: "JATS XML", extension: "jats", mime: ["application/xml"], category: ["document", "text"] }),
+  defineFormat({ id: "texinfo", name: "Texinfo", extension: "texi", extraExtensions: ["texinfo"], mime: ["text/plain"], category: ["document", "text"], aliases: ["texi"] }),
+  defineFormat({ id: "eps", name: "Encapsulated PostScript", extension: "eps", mime: ["application/postscript"], category: ["vector", "document"] }),
+  defineFormat({ id: "ps", name: "PostScript", extension: "ps", mime: ["application/postscript"], category: ["vector", "document"] }),
 
-  defineFormat("zip", "ZIP Archive", "zip", ["application/zip"], ["archive"]),
-  defineFormat("tar", "TAR Archive", "tar", ["application/x-tar"], ["archive"]),
-  defineFormat("7z", "7-Zip Archive", "7z", ["application/x-7z-compressed"], ["archive"]),
+  defineFormat({ id: "zip", name: "ZIP Archive", extension: "zip", mime: ["application/zip"], category: ["archive"] }),
+  defineFormat({ id: "tar", name: "TAR Archive", extension: "tar", mime: ["application/x-tar"], category: ["archive"] }),
+  defineFormat({ id: "7z", name: "7-Zip Archive", extension: "7z", mime: ["application/x-7z-compressed"], category: ["archive"] }),
+  defineFormat({ id: "gz", name: "Gzip Archive", extension: "gz", mime: ["application/gzip"], category: ["archive"] }),
+  defineFormat({ id: "bz2", name: "Bzip2 Archive", extension: "bz2", mime: ["application/x-bzip2"], category: ["archive"] }),
+  defineFormat({ id: "xz", name: "XZ Archive", extension: "xz", mime: ["application/x-xz"], category: ["archive"] }),
+  defineFormat({ id: "rar", name: "RAR Archive", extension: "rar", mime: ["application/vnd.rar"], category: ["archive"] }),
+  defineFormat({ id: "cab", name: "Cabinet Archive", extension: "cab", mime: ["application/vnd.ms-cab-compressed"], category: ["archive"] }),
+  defineFormat({ id: "iso", name: "ISO Disk Image", extension: "iso", mime: ["application/x-iso9660-image"], category: ["archive", "binary"] }),
 
-  defineFormat("ttf", "TrueType Font", "ttf", ["font/ttf"], ["font"]),
-  defineFormat("otf", "OpenType Font", "otf", ["font/otf"], ["font"]),
-  defineFormat("woff", "Web Open Font Format", "woff", ["font/woff"], ["font"]),
-  defineFormat("woff2", "Web Open Font Format 2", "woff2", ["font/woff2"], ["font"]),
+  defineFormat({ id: "ttf", name: "TrueType Font", extension: "ttf", mime: ["font/ttf"], category: ["font"] }),
+  defineFormat({ id: "otf", name: "OpenType Font", extension: "otf", mime: ["font/otf"], category: ["font"] }),
+  defineFormat({ id: "woff", name: "Web Open Font Format", extension: "woff", mime: ["font/woff"], category: ["font"] }),
+  defineFormat({ id: "woff2", name: "Web Open Font Format 2", extension: "woff2", mime: ["font/woff2"], category: ["font"] }),
+  defineFormat({ id: "eot", name: "Embedded OpenType", extension: "eot", mime: ["application/vnd.ms-fontobject"], category: ["font"] }),
 
-  defineFormat("base64", "Base64 Text", "b64", ["text/plain"], ["data", "text"]),
-  defineFormat("hex", "Hex Text", "hex", ["text/plain"], ["data", "text"]),
-  defineFormat("bin", "Binary Blob", "bin", ["application/octet-stream"], ["binary"]),
+  defineFormat({ id: "base64", name: "Base64 Text", extension: "b64", mime: ["text/plain"], category: ["data", "text"] }),
+  defineFormat({ id: "hex", name: "Hex Text", extension: "hex", mime: ["text/plain"], category: ["data", "text"] }),
+  defineFormat({ id: "bin", name: "Binary Blob", extension: "bin", mime: ["application/octet-stream"], category: ["binary"] }),
 ];

package/src/handlers/bridges/text.ts

@@ -3,7 +3,29 @@ import { dirname } from "node:path";
 import type { ConversionHandler, ConvertRequest, HandlerContext, HandlerResult, HandlerRule } from "../base.ts";
 import { toFileArtifact } from "../../artifacts/file.ts";
 
-const TEXTISH = ["txt", "md", "html", "json", "xml", "yaml", "csv", "base64", "hex", "bin"];
+const TEXTISH = [
+  "txt",
+  "md",
+  "html",
+  "xhtml",
+  "json",
+  "xml",
+  "yaml",
+  "toml",
+  "ini",
+  "csv",
+  "tsv",
+  "rst",
+  "adoc",
+  "bbcode",
+  "org",
+  "tex",
+  "docbook",
+  "jats",
+  "base64",
+  "hex",
+  "bin",
+];
 
 function textRules(): HandlerRule[] {
   const rules: HandlerRule[] = [];
@@ -66,7 +88,7 @@ function fromStructuredToText(inputFormat: string, text: string): string {
     }
   }
 
-  if (inputFormat === "html" || inputFormat === "xml") {
+  if (inputFormat === "html" || inputFormat === "xhtml" || inputFormat === "xml") {
     return text.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
   }
 

package/src/handlers/native/ffmpeg.ts

@@ -5,9 +5,43 @@ import { runCommand } from "../exec.ts";
 import { CliError, ExitCode } from "../../core/errors.ts";
 import { toFileArtifact } from "../../artifacts/file.ts";
 
-const AUDIO = ["wav", "mp3", "flac", "ogg"];
-const VIDEO = ["mp4", "mov", "webm", "wmv", "gif"];
-const IMAGE = ["png", "jpeg", "webp", "bmp", "tiff", "gif"];
+const AUDIO = [
+  "wav",
+  "mp3",
+  "flac",
+  "ogg",
+  "aac",
+  "m4a",
+  "wma",
+  "aiff",
+  "opus",
+  "amr",
+  "ac3",
+  "dts",
+  "mka",
+  "mid",
+];
+
+const VIDEO = [
+  "mp4",
+  "m4v",
+  "mov",
+  "webm",
+  "wmv",
+  "mkv",
+  "avi",
+  "mpeg",
+  "3gp",
+  "3g2",
+  "flv",
+  "ts",
+  "vob",
+  "ogv",
+  "asf",
+  "gif",
+];
+
+const IMAGE = ["png", "jpeg", "webp", "bmp", "tiff", "gif", "avif", "jp2", "apng"];
 
 function pairRules(from: string[], to: string[], cost: number): HandlerRule[] {
   const rules: HandlerRule[] = [];

package/src/handlers/native/imagemagick.ts

@@ -5,7 +5,31 @@ import { runCommand } from "../exec.ts";
 import { CliError, ExitCode } from "../../core/errors.ts";
 import { toFileArtifact } from "../../artifacts/file.ts";
 
-const IMAGE_DOC = ["png", "jpeg", "webp", "bmp", "tiff", "gif", "svg", "pdf"];
+const IMAGE_DOC = [
+  "png",
+  "jpeg",
+  "webp",
+  "bmp",
+  "tiff",
+  "gif",
+  "svg",
+  "avif",
+  "heic",
+  "ico",
+  "jp2",
+  "psd",
+  "tga",
+  "dds",
+  "hdr",
+  "exr",
+  "pnm",
+  "pbm",
+  "pgm",
+  "ppm",
+  "pdf",
+  "eps",
+  "ps",
+];
 
 function imageRules(): HandlerRule[] {
   const rules: HandlerRule[] = [];

package/src/handlers/native/pandoc.ts

@@ -8,15 +8,32 @@ import { toFileArtifact } from "../../artifacts/file.ts";
 const DOC_TEXT_DATA = [
   "txt",
   "md",
+  "rst",
+  "adoc",
+  "bbcode",
+  "org",
+  "tex",
+  "texinfo",
   "html",
+  "xhtml",
   "json",
   "xml",
   "yaml",
+  "toml",
   "csv",
+  "tsv",
   "pdf",
   "docx",
+  "odt",
+  "rtf",
+  "epub",
+  "fb2",
   "pptx",
   "xlsx",
+  "ods",
+  "odp",
+  "docbook",
+  "jats",
 ];
 
 function pandocRules(): HandlerRule[] {

package/src/handlers/native/sevenzip.ts

@@ -5,7 +5,9 @@ import { runCommand } from "../exec.ts";
 import { CliError, ExitCode } from "../../core/errors.ts";
 import { toFileArtifact } from "../../artifacts/file.ts";
 
-const ARCHIVES = new Set(["zip", "tar", "7z"]);
+const ARCHIVES = new Set(["zip", "tar", "7z", "gz", "bz2", "xz", "rar", "cab", "iso"]);
+const WRITE_ARCHIVES = ["zip", "tar", "7z", "gz", "bz2", "xz", "rar", "cab", "iso"];
+const READ_ARCHIVES = ["zip", "tar", "7z", "gz", "bz2", "xz", "rar", "cab", "iso"];
 
 async function findFirstFile(root: string): Promise<string | undefined> {
   const entries = await readdir(root, { withFileTypes: true });
@@ -25,14 +27,14 @@ async function findFirstFile(root: string): Promise<string | undefined> {
 }
 
 function sevenZipRules(): HandlerRule[] {
-  return [
-    { from: "*", to: "zip", cost: 90, lossless: false },
-    { from: "*", to: "tar", cost: 90, lossless: false },
-    { from: "*", to: "7z", cost: 95, lossless: false },
-    { from: "zip", to: "*", cost: 140, lossless: false },
-    { from: "tar", to: "*", cost: 140, lossless: false },
-    { from: "7z", to: "*", cost: 145, lossless: false },
-  ];
+  const rules: HandlerRule[] = [];
+  for (const archive of WRITE_ARCHIVES) {
+    rules.push({ from: "*", to: archive, cost: 95, lossless: false });
+  }
+  for (const archive of READ_ARCHIVES) {
+    rules.push({ from: archive, to: "*", cost: 145, lossless: false });
+  }
+  return rules;
 }
 
 export class SevenZipHandler implements ConversionHandler {

package/test/unit/planner.test.ts

@@ -3,6 +3,7 @@ import { FormatRegistry } from "../../src/formats/registry.ts";
 import { ConversionGraph } from "../../src/planner/graph.ts";
 import { findRoutes } from "../../src/planner/search.ts";
 import type { ConversionHandler, ConvertRequest, HandlerContext, HandlerResult } from "../../src/handlers/base.ts";
+import type { FormatDefinition } from "../../src/core/types.ts";
 
 class MockHandler implements ConversionHandler {
   readonly name: string;
@@ -25,7 +26,37 @@ class MockHandler implements ConversionHandler {
 }
 
 test("planner prefers meaningful route over wildcard", () => {
-  const registry = new FormatRegistry();
+  const smallSet: FormatDefinition[] = [
+    {
+      id: "png",
+      name: "Portable Network Graphics",
+      extension: "png",
+      extensions: ["png"],
+      mime: ["image/png"],
+      category: ["image"],
+      aliases: [],
+    },
+    {
+      id: "wav",
+      name: "Waveform Audio",
+      extension: "wav",
+      extensions: ["wav"],
+      mime: ["audio/wav"],
+      category: ["audio"],
+      aliases: [],
+    },
+    {
+      id: "mp3",
+      name: "MP3 Audio",
+      extension: "mp3",
+      extensions: ["mp3"],
+      mime: ["audio/mpeg"],
+      category: ["audio"],
+      aliases: [],
+    },
+  ];
+
+  const registry = new FormatRegistry(smallSet);
 
   const handlers: ConversionHandler[] = [
     new MockHandler("image-audio-bridge", [{ from: "png", to: "wav", cost: 10 }]),

package/tools/format-picker/main.go

@@ -18,9 +18,10 @@ type option struct {
 }
 
 type payload struct {
-	Prompt  string   `json:"prompt"`
-	Query   string   `json:"query"`
-	Options []option `json:"options"`
+	Prompt    string   `json:"prompt"`
+	Query     string   `json:"query"`
+	Preferred string   `json:"preferred"`
+	Options   []option `json:"options"`
 }
 
 type scoredOption struct {
@@ -31,6 +32,7 @@ type scoredOption struct {
 type model struct {
 	prompt    string
 	query     string
+	preferred string
 	all       []option
 	filtered  []option
 	cursor    int
@@ -93,6 +95,9 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 func (m model) View() string {
 	var builder strings.Builder
 	builder.WriteString(fmt.Sprintf("%s > %s\n", m.prompt, m.query))
+	if m.query == "" && m.preferred != "" {
+		builder.WriteString(fmt.Sprintf("  hint: original extension '.%s' is ranked first\n", m.preferred))
+	}
 
 	if len(m.filtered) == 0 {
 		builder.WriteString("  no matches\n")
@@ -139,7 +144,7 @@ func (m *model) refilter() {
 	scored := make([]scoredOption, 0, len(m.all))
 
 	for _, item := range m.all {
-		score := fuzzyScore(query, item)
+		score := fuzzyScore(query, item, m.preferred)
 		if score < 0 {
 			continue
 		}
@@ -166,9 +171,19 @@ func (m *model) refilter() {
 	}
 }
 
-func fuzzyScore(query string, item option) int {
+func fuzzyScore(query string, item option, preferred string) int {
 	if query == "" {
-		return 1
+		score := 1
+		if preferred != "" {
+			normalizedPreferred := strings.ToLower(preferred)
+			if strings.EqualFold(item.Extension, normalizedPreferred) {
+				score += 25
+			}
+			if strings.EqualFold(item.ID, normalizedPreferred) {
+				score += 20
+			}
+		}
+		return score
 	}
 
 	candidate := strings.ToLower(item.ID + " " + item.Extension + " " + item.Name)
@@ -207,6 +222,16 @@ func fuzzyScore(query string, item option) int {
 	if strings.HasPrefix(strings.ToLower(item.ID), query) {
 		score += 15
 	}
+	if preferred != "" {
+		normalizedPreferred := strings.ToLower(preferred)
+		if strings.EqualFold(item.Extension, normalizedPreferred) {
+			score += 8
+		}
+		if strings.EqualFold(item.ID, normalizedPreferred) {
+			score += 6
+		}
+	}
+
 	return score
 }
 
@@ -244,9 +269,10 @@ func main() {
 	}
 
 	picker := model{
-		prompt: data.Prompt,
-		query:  data.Query,
-		all:    data.Options,
+		prompt:    data.Prompt,
+		query:     data.Query,
+		preferred: strings.TrimSpace(data.Preferred),
+		all:       data.Options,
 	}
 	picker.refilter()