@swarmvaultai/engine 0.6.8 → 0.7.1

package/dist/index.js

@@ -1434,6 +1434,7 @@ import path5 from "path";
 var require2 = createRequire(import.meta.url);
 var TREE_SITTER_RUNTIME_PACKAGE = "@vscode/tree-sitter-wasm";
 var TREE_SITTER_EXTRA_GRAMMARS_PACKAGE = "tree-sitter-wasms";
+var SWIFT_TREE_SITTER_OPT_IN_ENV = "SWARMVAULT_ENABLE_SWIFT_TREE_SITTER";
 var packageRootCache = /* @__PURE__ */ new Map();
 var RATIONALE_MARKERS = ["NOTE:", "IMPORTANT:", "HACK:", "WHY:", "RATIONALE:"];
 function stripKnownCommentPrefix(line) {
@@ -1464,7 +1465,16 @@ var grammarAssetByLanguage = {
   cpp: { packageName: TREE_SITTER_RUNTIME_PACKAGE, relativePath: "wasm/tree-sitter-cpp.wasm" },
   php: { packageName: TREE_SITTER_RUNTIME_PACKAGE, relativePath: "wasm/tree-sitter-php.wasm" },
   ruby: { packageName: TREE_SITTER_RUNTIME_PACKAGE, relativePath: "wasm/tree-sitter-ruby.wasm" },
-  powershell: { packageName: TREE_SITTER_RUNTIME_PACKAGE, relativePath: "wasm/tree-sitter-powershell.wasm" }
+  powershell: { packageName: TREE_SITTER_RUNTIME_PACKAGE, relativePath: "wasm/tree-sitter-powershell.wasm" },
+  swift: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-swift.wasm" },
+  elixir: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-elixir.wasm" },
+  ocaml: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-ocaml.wasm" },
+  objc: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-objc.wasm" },
+  rescript: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-rescript.wasm" },
+  solidity: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-solidity.wasm" },
+  html: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-html.wasm" },
+  css: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-css.wasm" },
+  vue: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-vue.wasm" }
 };
 function resolvePackageRoot(packageName) {
   const cached = packageRootCache.get(packageName);
@@ -1524,7 +1534,7 @@ function normalizeSymbolReference(value) {
 }
 function stripCodeExtension(filePath) {
   return filePath.replace(
-    /\.(?:[cm]?jsx?|tsx?|mts|cts|sh|bash|zsh|py|go|rs|java|kt|kts|scala|sc|dart|lua|zig|cs|php|c|cc|cpp|cxx|h|hh|hpp|hxx)$/i,
+    /\.(?:[cm]?jsx?|tsx?|mts|cts|sh|bash|zsh|py|go|rs|java|kt|kts|scala|sc|dart|lua|zig|cs|php|c|cc|cpp|cxx|h|hh|hpp|hxx|swift|exs?|mli?|mm|resi?|sol|html?|css|vue)$/i,
     ""
   );
 }
@@ -1812,6 +1822,72 @@ function descendantTypeNames(node) {
 function quotedPath(value) {
   return value.replace(/^['"<]+|['">]+$/g, "").trim();
 }
+function neutralizePreprocessorDirectives(content) {
+  const lines = content.split("\n");
+  const active = [];
+  const isActive = () => active.every(Boolean);
+  const directiveHead = (line) => {
+    const trimmed = line.trimStart();
+    if (trimmed[0] !== "#") {
+      return void 0;
+    }
+    const rest = trimmed.slice(1).trimStart();
+    const match = rest.match(/^([A-Za-z]+)/);
+    return match?.[1]?.toLowerCase();
+  };
+  const out = [];
+  for (const line of lines) {
+    const head = directiveHead(line);
+    if (head === "if" || head === "ifdef" || head === "ifndef") {
+      active.push(isActive());
+      out.push("");
+      continue;
+    }
+    if (head === "elif") {
+      if (active.length > 0) {
+        active[active.length - 1] = false;
+      }
+      out.push("");
+      continue;
+    }
+    if (head === "else") {
+      if (active.length > 0) {
+        active[active.length - 1] = false;
+      }
+      out.push("");
+      continue;
+    }
+    if (head === "endif") {
+      if (active.length > 0) {
+        active.pop();
+      }
+      out.push("");
+      continue;
+    }
+    if (!isActive()) {
+      out.push("");
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+function detectShellDialect(content) {
+  const prefix = content.slice(0, 4096);
+  if (/^#!\s*(?:\/usr\/bin\/env\s+)?zsh\b/m.test(prefix)) {
+    return "zsh";
+  }
+  if (/^\s*#compdef\b/m.test(prefix)) {
+    return "zsh";
+  }
+  if (/\$\{\([fFsq@%]/.test(prefix)) {
+    return "zsh";
+  }
+  if (/\b(?:setopt|unsetopt|zmodload|compinit|autoload\s+-Uz)\b/.test(prefix)) {
+    return "zsh";
+  }
+  return "bash";
+}
 function diagnosticsFromTree(rootNode) {
   if (!rootNode.hasError) {
     return [];
@@ -1861,6 +1937,18 @@ function treeSitterCompatibilityDiagnostic(language, error) {
     column: 1
   };
 }
+function swiftTreeSitterEnabled() {
+  return process.env[SWIFT_TREE_SITTER_OPT_IN_ENV] === "1";
+}
+function swiftTreeSitterDisabledDiagnostic() {
+  return {
+    code: 9012,
+    category: "warning",
+    message: `Swift parser-backed analysis is disabled by default because the packaged tree-sitter grammar can trigger Node/V8 out-of-memory crashes during WASM compilation. Set ${SWIFT_TREE_SITTER_OPT_IN_ENV}=1 to opt in anyway.`,
+    line: 1,
+    column: 1
+  };
+}
 function flattenPythonDottedName(node) {
   if (!node) {
     return "";
@@ -2691,24 +2779,20 @@ function zigDeclarationKind(node) {
   }
   return void 0;
 }
-function bashCodeAnalysis(manifest, rootNode, diagnostics) {
+function bashCodeAnalysis(manifest, rootNode, diagnostics, rawContent) {
   const imports = [];
   const draftSymbols = [];
   const exportLabels = [];
-  for (const child of rootNode.namedChildren) {
-    if (!child) {
-      continue;
-    }
-    if (child.type === "command") {
-      const parsed = parseBashImport(child);
-      if (parsed) {
-        imports.push(parsed);
-      }
-      continue;
-    }
-    if (child.type !== "function_definition") {
-      continue;
+  const commandNodes = rootNode.descendantsOfType("command").filter((node) => node !== null);
+  for (const command of commandNodes) {
+    const parsed = parseBashImport(command);
+    if (parsed) {
+      imports.push(parsed);
     }
+  }
+  const functionNodes = rootNode.descendantsOfType("function_definition").filter((node) => node !== null);
+  const functionByName = /* @__PURE__ */ new Map();
+  for (const child of functionNodes) {
     const name = nodeText(child.childForFieldName("name") ?? child.namedChildren.at(0) ?? null).trim();
     if (!name) {
       continue;
@@ -2724,16 +2808,44 @@ function bashCodeAnalysis(manifest, rootNode, diagnostics) {
       bodyText: nodeText(child.childForFieldName("body") ?? findNamedChild(child, "compound_statement"))
     });
     exportLabels.push(name);
+    if (!functionByName.has(name)) {
+      functionByName.set(name, child);
+    }
   }
   for (let index = 0; index < draftSymbols.length; index += 1) {
-    const functionNode = rootNode.namedChildren.find(
-      (child) => child?.type === "function_definition" && nodeText(child.childForFieldName("name") ?? child.namedChildren.at(0) ?? null).trim() === draftSymbols[index]?.name
-    );
-    draftSymbols[index].callNames = bashCallNamesFromBody(
+    const symbol = draftSymbols[index];
+    const functionNode = functionByName.get(symbol.name);
+    symbol.callNames = bashCallNamesFromBody(
       functionNode?.childForFieldName("body") ?? findNamedChild(functionNode, "compound_statement"),
-      draftSymbols[index].name
+      symbol.name
     );
   }
+  if (draftSymbols.length === 0 && rawContent) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const line of rawContent.split("\n")) {
+      const trimmed = line.trimStart();
+      let match = trimmed.match(/^function\s+([A-Za-z_][\w-]*)\s*(?:\(\))?/);
+      if (!match) {
+        match = trimmed.match(/^([A-Za-z_][\w-]*)\s*\(\)/);
+      }
+      const name = match?.[1];
+      if (!name || seen.has(name)) {
+        continue;
+      }
+      seen.add(name);
+      draftSymbols.push({
+        name,
+        kind: "function",
+        signature: singleLineSignature(trimmed),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: ""
+      });
+      exportLabels.push(name);
+    }
+  }
   return finalizeCodeAnalysis(manifest, "bash", imports, draftSymbols, exportLabels, diagnostics);
 }
 function dartCodeAnalysis(manifest, rootNode, diagnostics) {
@@ -3518,7 +3630,23 @@ function csharpCodeAnalysis(manifest, rootNode, diagnostics) {
     if (child.type === "file_scoped_namespace_declaration" || child.type === "namespace_declaration") {
       namespaceName = nodeText(child.childForFieldName("name")) || namespaceName;
       if (child.type === "namespace_declaration") {
-        for (const nested of child.namedChildren) {
+        const nameNode = child.childForFieldName("name");
+        const namespaceMembers = [];
+        for (const directChild of child.namedChildren) {
+          if (!directChild || directChild === nameNode) {
+            continue;
+          }
+          if (directChild.type === "declaration_list") {
+            for (const inner of directChild.namedChildren) {
+              if (inner) {
+                namespaceMembers.push(inner);
+              }
+            }
+            continue;
+          }
+          namespaceMembers.push(directChild);
+        }
+        for (const nested of namespaceMembers) {
           if (nested && nested !== child.childForFieldName("name")) {
             if (["class_declaration", "interface_declaration", "enum_declaration", "struct_declaration", "record_declaration"].includes(
               nested.type
@@ -3806,64 +3934,174 @@ function powershellCodeAnalysis(manifest, rootNode, diagnostics) {
   }
   return finalizeCodeAnalysis(manifest, "powershell", imports, draftSymbols, exportLabels, diagnostics);
 }
-function cFamilyCodeAnalysis(manifest, language, rootNode, diagnostics) {
+function parseSwiftImport(node) {
+  const identifierNode = findNamedChild(node, "identifier");
+  if (!identifierNode) {
+    return void 0;
+  }
+  const specifier = identifierNode.text.trim();
+  if (!specifier) {
+    return void 0;
+  }
+  return {
+    specifier,
+    importedSymbols: [],
+    // Swift does not have file-local relative imports; every `import` references
+    // an external module (Foundation, UIKit, a SwiftPM package product, or the
+    // current target's own module). Mark them all as external so the dependency
+    // aggregator groups them with other package-level graph edges.
+    isExternal: true,
+    reExport: false
+  };
+}
+function swiftDeclarationKindFromKeyword(node) {
+  for (const child of node.children) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "struct") {
+      return "struct";
+    }
+    if (child.type === "enum") {
+      return "enum";
+    }
+    if (child.type === "class") {
+      return "class";
+    }
+  }
+  return "class";
+}
+function swiftVisibilityKeyword(node) {
+  const modifiers = findNamedChild(node, "modifiers");
+  if (!modifiers) {
+    return void 0;
+  }
+  const visibility = findNamedChild(modifiers, "visibility_modifier");
+  if (!visibility) {
+    return void 0;
+  }
+  for (const kw of visibility.children) {
+    if (!kw) {
+      continue;
+    }
+    if (kw.type === "public" || kw.type === "private" || kw.type === "fileprivate" || kw.type === "internal" || kw.type === "open") {
+      return kw.type;
+    }
+  }
+  return void 0;
+}
+function swiftExported(node) {
+  const visibility = swiftVisibilityKeyword(node);
+  return visibility !== "private" && visibility !== "fileprivate";
+}
+function swiftCodeAnalysis(manifest, rootNode, diagnostics) {
   const imports = [];
   const draftSymbols = [];
   const exportLabels = [];
-  const functionNameFromDeclarator = (node) => {
-    if (!node) {
-      return void 0;
+  const recordParentTypes = (declaration) => {
+    const specifiers = declaration.namedChildren.filter((item) => item?.type === "inheritance_specifier");
+    if (specifiers.length === 0) {
+      return [];
     }
-    const declarator = node.childForFieldName("declarator");
-    if (declarator) {
-      return functionNameFromDeclarator(declarator);
+    const ordered = [];
+    for (const specifier of specifiers) {
+      const primary = findNamedChild(specifier, "user_type") ?? findNamedChild(specifier, "type_identifier") ?? specifier.namedChildren.find((item) => item !== null) ?? null;
+      if (!primary) {
+        continue;
+      }
+      const name = normalizeSymbolReference(primary.text);
+      if (name) {
+        ordered.push(name);
+      }
     }
-    return extractIdentifier(node);
+    return uniqueBy(ordered, (item) => item);
   };
   for (const child of rootNode.namedChildren) {
     if (!child) {
       continue;
     }
-    if (child.type === "preproc_include") {
-      const parsed = parseCppInclude(child);
+    if (child.type === "import_declaration") {
+      const parsed = parseSwiftImport(child);
       if (parsed) {
         imports.push(parsed);
       }
       continue;
     }
-    if (["class_specifier", "struct_specifier", "enum_specifier"].includes(child.type)) {
-      const name = extractIdentifier(child.childForFieldName("name"));
+    if (child.type === "protocol_declaration") {
+      const name = extractIdentifier(findNamedChild(child, "type_identifier"));
       if (!name) {
         continue;
       }
-      const kind = child.type === "enum_specifier" ? "enum" : child.type === "struct_specifier" ? "struct" : "class";
-      const baseClassClause = findNamedChild(child, "base_class_clause") ?? child.childForFieldName("base_class_clause");
-      const bases = baseClassClause ? uniqueBy(
-        baseClassClause.namedChildren.filter((item) => item !== null && item.type !== "access_specifier").map((item) => normalizeSymbolReference(item.text.replace(/\b(public|private|protected|virtual)\b/g, "").trim())).filter(Boolean),
-        (item) => item
-      ) : [];
-      const exported = !/\bstatic\b/.test(child.text);
+      const parents = recordParentTypes(child);
+      const exported = swiftExported(child);
+      draftSymbols.push({
+        name,
+        kind: "interface",
+        signature: singleLineSignature(child.text),
+        exported,
+        callNames: [],
+        extendsNames: parents,
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(child, "protocol_body")) || child.text
+      });
+      if (exported) {
+        exportLabels.push(name);
+      }
+      continue;
+    }
+    if (child.type === "class_declaration") {
+      const name = extractIdentifier(findNamedChild(child, "type_identifier"));
+      if (!name) {
+        continue;
+      }
+      const kind = swiftDeclarationKindFromKeyword(child);
+      const parentTypes = recordParentTypes(child);
+      const extendsNames = kind === "class" && parentTypes.length > 0 ? [parentTypes[0]] : [];
+      const implementsNames = kind === "class" ? parentTypes.slice(1) : parentTypes;
+      const exported = swiftExported(child);
+      const body = findNamedChild(child, "class_body") ?? findNamedChild(child, "enum_class_body");
       draftSymbols.push({
         name,
         kind,
         signature: singleLineSignature(child.text),
         exported,
         callNames: [],
-        extendsNames: bases,
+        extendsNames,
+        implementsNames,
+        bodyText: nodeText(body) || child.text
+      });
+      if (exported) {
+        exportLabels.push(name);
+      }
+      continue;
+    }
+    if (child.type === "typealias_declaration") {
+      const name = extractIdentifier(findNamedChild(child, "type_identifier"));
+      if (!name) {
+        continue;
+      }
+      const exported = swiftExported(child);
+      draftSymbols.push({
+        name,
+        kind: "type_alias",
+        signature: singleLineSignature(child.text),
+        exported,
+        callNames: [],
+        extendsNames: [],
         implementsNames: [],
-        bodyText: nodeText(child.childForFieldName("body")) || child.text
+        bodyText: child.text
       });
       if (exported) {
         exportLabels.push(name);
       }
       continue;
     }
-    if (child.type === "function_definition") {
-      const name = functionNameFromDeclarator(child.childForFieldName("declarator"));
+    if (child.type === "function_declaration") {
+      const name = extractIdentifier(findNamedChild(child, "simple_identifier") ?? findNamedChild(child, "identifier"));
       if (!name) {
         continue;
       }
-      const exported = !/\bstatic\b/.test(child.text);
+      const exported = swiftExported(child);
       draftSymbols.push({
         name,
         kind: "function",
@@ -3872,87 +4110,1163 @@ function cFamilyCodeAnalysis(manifest, language, rootNode, diagnostics) {
         callNames: [],
         extendsNames: [],
         implementsNames: [],
-        bodyText: nodeText(child.childForFieldName("body")) || child.text
+        bodyText: nodeText(findNamedChild(child, "function_body")) || child.text
       });
       if (exported) {
         exportLabels.push(name);
       }
+      continue;
+    }
+    if (child.type === "property_declaration") {
+      const exported = swiftExported(child);
+      const patterns = child.namedChildren.filter((item) => item?.type === "pattern");
+      for (const pattern of patterns) {
+        const name = extractIdentifier(findNamedChild(pattern, "simple_identifier") ?? pattern.namedChildren[0] ?? null);
+        if (!name) {
+          continue;
+        }
+        draftSymbols.push({
+          name,
+          kind: "variable",
+          signature: singleLineSignature(child.text),
+          exported,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: [],
+          bodyText: child.text
+        });
+        if (exported) {
+          exportLabels.push(name);
+        }
+      }
     }
   }
-  return finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportLabels, diagnostics);
+  return finalizeCodeAnalysis(manifest, "swift", imports, draftSymbols, exportLabels, diagnostics);
 }
-async function analyzeTreeSitterCode(manifest, content, language) {
-  let tree = null;
-  try {
-    const module = await getTreeSitterModule();
-    await ensureTreeSitterInit(module);
-    const parser = new module.Parser();
-    parser.setLanguage(await loadLanguage(language));
-    tree = parser.parse(content);
-  } catch (error) {
-    return {
-      code: finalizeCodeAnalysis(manifest, language, [], [], [], [treeSitterCompatibilityDiagnostic(language, error)]),
-      rationales: []
-    };
+function elixirCallIdentifier(callNode) {
+  return findNamedChild(callNode, "identifier")?.text.trim() || void 0;
+}
+function elixirFirstModulePath(argumentsNode) {
+  if (!argumentsNode) {
+    return void 0;
   }
-  if (!tree) {
-    return {
-      code: finalizeCodeAnalysis(
-        manifest,
-        language,
-        [],
-        [],
-        [],
-        [
-          {
-            code: 9e3,
-            category: "error",
-            message: `Failed to parse ${language} source.`,
-            line: 1,
-            column: 1
-          }
-        ]
-      ),
-      rationales: []
-    };
+  for (const child of argumentsNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "alias" || child.type === "identifier") {
+      const text = child.text.trim();
+      if (text) {
+        return text;
+      }
+    }
   }
-  try {
-    const diagnostics = language === "lua" ? [] : diagnosticsFromTree(tree.rootNode);
-    const rationales = extractTreeSitterRationales(manifest, language, tree.rootNode);
-    switch (language) {
-      case "bash":
-        return { code: bashCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "python":
-        return { code: pythonCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "go":
-        return { code: goCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "rust":
-        return { code: rustCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "java":
-        return { code: javaCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "kotlin":
-        return { code: kotlinCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "scala":
-        return { code: scalaCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "dart":
-        return { code: dartCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "lua":
-        return { code: luaCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "zig":
-        return { code: zigCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "csharp":
-        return { code: csharpCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "php":
-        return { code: phpCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "ruby":
-        return { code: rubyCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "powershell":
-        return { code: powershellCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
-      case "c":
-      case "cpp":
-        return { code: cFamilyCodeAnalysis(manifest, language, tree.rootNode, diagnostics), rationales };
-      default:
-        return {
+  return void 0;
+}
+function elixirFunctionNameFromArguments(argumentsNode) {
+  if (!argumentsNode) {
+    return void 0;
+  }
+  const first = argumentsNode.namedChildren.find((item) => item !== null);
+  if (!first) {
+    return void 0;
+  }
+  if (first.type === "call") {
+    const inner = findNamedChild(first, "identifier");
+    return inner?.text.trim() || void 0;
+  }
+  if (first.type === "identifier") {
+    return first.text.trim() || void 0;
+  }
+  return void 0;
+}
+var ELIXIR_IMPORT_MACROS = /* @__PURE__ */ new Set(["alias", "import", "require", "use"]);
+var ELIXIR_PUBLIC_DEF_MACROS = /* @__PURE__ */ new Set(["def", "defmacro"]);
+var ELIXIR_PRIVATE_DEF_MACROS = /* @__PURE__ */ new Set(["defp", "defmacrop"]);
+function elixirCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  let primaryModuleName;
+  for (const topCall of rootNode.namedChildren) {
+    if (!topCall || topCall.type !== "call") {
+      continue;
+    }
+    const macroName = elixirCallIdentifier(topCall);
+    if (macroName !== "defmodule" && macroName !== "defprotocol") {
+      continue;
+    }
+    const moduleArgs = findNamedChild(topCall, "arguments");
+    const moduleName = elixirFirstModulePath(moduleArgs);
+    if (!moduleName) {
+      continue;
+    }
+    const moduleKind = macroName === "defprotocol" ? "interface" : "class";
+    const moduleHeaderLine = topCall.text.split("\n")[0] ?? topCall.text;
+    if (primaryModuleName === void 0) {
+      primaryModuleName = moduleName;
+    }
+    draftSymbols.push({
+      name: moduleName,
+      kind: moduleKind,
+      signature: singleLineSignature(moduleHeaderLine),
+      // Modules and protocols are always module-level public in Elixir.
+      exported: true,
+      callNames: [],
+      extendsNames: [],
+      implementsNames: [],
+      bodyText: topCall.text
+    });
+    exportLabels.push(moduleName);
+    const doBlock = findNamedChild(topCall, "do_block");
+    if (!doBlock) {
+      continue;
+    }
+    for (const innerNode of doBlock.namedChildren) {
+      if (!innerNode || innerNode.type !== "call") {
+        continue;
+      }
+      const innerMacro = elixirCallIdentifier(innerNode);
+      if (!innerMacro) {
+        continue;
+      }
+      if (ELIXIR_IMPORT_MACROS.has(innerMacro)) {
+        const importArgs = findNamedChild(innerNode, "arguments");
+        const modulePath = elixirFirstModulePath(importArgs);
+        if (!modulePath) {
+          continue;
+        }
+        imports.push({
+          specifier: modulePath,
+          importedSymbols: [],
+          // Elixir imports always target a compiled BEAM module; there is no
+          // notion of "file-local" relative imports the way Python or JS use them.
+          // Treat every entry as external.
+          isExternal: true,
+          reExport: false
+        });
+        continue;
+      }
+      if (ELIXIR_PUBLIC_DEF_MACROS.has(innerMacro) || ELIXIR_PRIVATE_DEF_MACROS.has(innerMacro)) {
+        const innerArgs = findNamedChild(innerNode, "arguments");
+        const fnName = elixirFunctionNameFromArguments(innerArgs);
+        if (!fnName) {
+          continue;
+        }
+        const qualifiedName = `${moduleName}.${fnName}`;
+        const exported = ELIXIR_PUBLIC_DEF_MACROS.has(innerMacro);
+        const headerLine = innerNode.text.split("\n")[0] ?? innerNode.text;
+        draftSymbols.push({
+          name: qualifiedName,
+          kind: "function",
+          signature: singleLineSignature(headerLine),
+          exported,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: [],
+          bodyText: nodeText(findNamedChild(innerNode, "do_block")) || innerNode.text
+        });
+        if (exported) {
+          exportLabels.push(qualifiedName);
+        }
+      }
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "elixir", imports, draftSymbols, exportLabels, diagnostics, {
+    moduleName: primaryModuleName
+  });
+}
+function parseOCamlOpen(node) {
+  const modulePath = findNamedChild(node, "module_path");
+  if (!modulePath) {
+    return void 0;
+  }
+  const specifier = modulePath.text.trim();
+  if (!specifier) {
+    return void 0;
+  }
+  return {
+    specifier,
+    importedSymbols: [],
+    // Every OCaml `open` references a compiled module; there is no file-local
+    // "./sibling" form. Classify as external and let resolveCodeImport's single-
+    // candidate short-circuit promote it to local when an alias matches.
+    isExternal: true,
+    reExport: false
+  };
+}
+function ocamlValueBindingKind(letBinding) {
+  if (!letBinding) {
+    return void 0;
+  }
+  const hasParameter = letBinding.namedChildren.some((child) => child?.type === "parameter");
+  return hasParameter ? "function" : "variable";
+}
+function ocamlTypeKind(typeBinding) {
+  if (!typeBinding) {
+    return "type_alias";
+  }
+  for (const child of typeBinding.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "record_declaration") {
+      return "struct";
+    }
+    if (child.type === "variant_declaration") {
+      return "enum";
+    }
+  }
+  return "type_alias";
+}
+function ocamlCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "open_module") {
+      const parsed = parseOCamlOpen(child);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (child.type === "module_definition") {
+      const binding = findNamedChild(child, "module_binding");
+      const moduleNameNode = binding ? findNamedChild(binding, "module_name") : null;
+      const name = moduleNameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "class",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        // OCaml's `let`/`module` bindings are exported from the containing
+        // compilation unit unless an explicit `.mli` interface hides them.
+        // Treat everything defined in a `.ml` file as exported; consumers who
+        // want hiding should rely on the downstream interface-file merge.
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(binding, "structure")) || child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "module_type_definition") {
+      const nameNode = findNamedChild(child, "module_type_name");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "interface",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(child, "signature")) || child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "type_definition") {
+      const binding = findNamedChild(child, "type_binding");
+      const typeConstructorNode = binding ? findNamedChild(binding, "type_constructor") : null;
+      const name = typeConstructorNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const kind = ocamlTypeKind(binding);
+      draftSymbols.push({
+        name,
+        kind,
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "value_definition") {
+      const binding = findNamedChild(child, "let_binding");
+      if (!binding) {
+        continue;
+      }
+      const valueNameNode = findNamedChild(binding, "value_name");
+      const name = valueNameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const kind = ocamlValueBindingKind(binding) ?? "function";
+      draftSymbols.push({
+        name,
+        kind,
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "ocaml", imports, draftSymbols, exportLabels, diagnostics);
+}
+function objcCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const declaredClassNames = /* @__PURE__ */ new Set();
+  const functionNameFromDeclarator = (node) => {
+    if (!node) {
+      return void 0;
+    }
+    const declarator = node.childForFieldName("declarator");
+    if (declarator) {
+      return functionNameFromDeclarator(declarator);
+    }
+    return extractIdentifier(node);
+  };
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "preproc_include") {
+      const parsed = parseCppInclude(child);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (child.type === "protocol_declaration") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const refList = findNamedChild(child, "protocol_reference_list");
+      const parents = refList ? uniqueBy(
+        refList.namedChildren.filter((item) => item?.type === "identifier").map((item) => item.text.trim()).filter(Boolean),
+        (item) => item
+      ) : [];
+      draftSymbols.push({
+        name,
+        kind: "interface",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: parents,
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "class_interface") {
+      const identifierChildren = child.namedChildren.filter((item) => item?.type === "identifier");
+      const name = identifierChildren[0]?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const superclass = identifierChildren[1]?.text.trim();
+      const parameterized = findNamedChild(child, "parameterized_arguments");
+      const protocols = parameterized ? uniqueBy(
+        parameterized.namedChildren.filter((item) => item?.type === "type_name" || item?.type === "identifier").map((item) => item.text.trim()).filter(Boolean),
+        (item) => item
+      ) : [];
+      declaredClassNames.add(name);
+      draftSymbols.push({
+        name,
+        kind: "class",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: superclass ? [superclass] : [],
+        implementsNames: protocols,
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "class_implementation") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      if (declaredClassNames.has(name)) {
+        continue;
+      }
+      declaredClassNames.add(name);
+      draftSymbols.push({
+        name,
+        kind: "class",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "function_definition") {
+      const name = functionNameFromDeclarator(child.childForFieldName("declarator"));
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "function",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(child.childForFieldName("body")) || child.text
+      });
+      exportLabels.push(name);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "objc", imports, draftSymbols, exportLabels, diagnostics);
+}
+function rescriptCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const rescriptTypeKind = (typeBinding) => {
+    if (!typeBinding) {
+      return "type_alias";
+    }
+    for (const child of typeBinding.namedChildren) {
+      if (!child) {
+        continue;
+      }
+      if (child.type === "variant_type") {
+        return "enum";
+      }
+      if (child.type === "record_type") {
+        return "struct";
+      }
+    }
+    return "type_alias";
+  };
+  const rescriptLetBindingKind = (letBinding) => {
+    if (!letBinding) {
+      return "variable";
+    }
+    for (const child of letBinding.namedChildren) {
+      if (child?.type === "function") {
+        return "function";
+      }
+    }
+    return "variable";
+  };
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "open_statement") {
+      const identNode = findNamedChild(child, "module_identifier");
+      const specifier = identNode?.text.trim();
+      if (!specifier) {
+        continue;
+      }
+      imports.push({
+        specifier,
+        importedSymbols: [],
+        // ReScript modules resolve through the build system's own module graph;
+        // they are never file-local in the Python "./relative" sense.
+        isExternal: true,
+        reExport: false
+      });
+      continue;
+    }
+    if (child.type === "module_declaration") {
+      const binding = findNamedChild(child, "module_binding");
+      const nameNode = binding ? findNamedChild(binding, "module_identifier") : null;
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "class",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(binding, "block")) || child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "type_declaration") {
+      const binding = findNamedChild(child, "type_binding");
+      const nameNode = binding ? findNamedChild(binding, "type_identifier") : null;
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const kind = rescriptTypeKind(binding);
+      draftSymbols.push({
+        name,
+        kind,
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "let_declaration") {
+      const binding = findNamedChild(child, "let_binding");
+      const nameNode = binding ? findNamedChild(binding, "value_identifier") : null;
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const kind = rescriptLetBindingKind(binding);
+      draftSymbols.push({
+        name,
+        kind,
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "rescript", imports, draftSymbols, exportLabels, diagnostics);
+}
+function parseSolidityImport(node) {
+  const stringNode = node.namedChildren.find((item) => item?.type === "string");
+  if (!stringNode) {
+    return [];
+  }
+  const specifier = quotedPath(stringNode.text);
+  if (!specifier) {
+    return [];
+  }
+  const importedSymbols = uniqueBy(
+    node.namedChildren.filter((item) => item?.type === "identifier").map((item) => item.text.trim()).filter(Boolean),
+    (item) => item
+  );
+  const isLocal = specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/");
+  return [
+    {
+      specifier,
+      importedSymbols,
+      isExternal: !isLocal,
+      reExport: false
+    }
+  ];
+}
+function solidityCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const collectParents = (declaration) => {
+    const specifiers = declaration.namedChildren.filter((item) => item?.type === "inheritance_specifier");
+    const names = [];
+    for (const specifier of specifiers) {
+      for (const node of specifier.namedChildren) {
+        if (node && (node.type === "user_defined_type" || node.type === "identifier")) {
+          const text = normalizeSymbolReference(node.text);
+          if (text) {
+            names.push(text);
+          }
+        }
+      }
+    }
+    return uniqueBy(names, (item) => item);
+  };
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "import_directive") {
+      for (const parsed of parseSolidityImport(child)) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (child.type === "interface_declaration") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const parents = collectParents(child);
+      draftSymbols.push({
+        name,
+        kind: "interface",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: parents,
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(child, "contract_body")) || child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "library_declaration" || child.type === "contract_declaration") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const parents = child.type === "contract_declaration" ? collectParents(child) : [];
+      draftSymbols.push({
+        name,
+        kind: "class",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        // Solidity supports multiple inheritance; list every parent contract
+        // as a `implements` edge rather than arbitrarily promoting one to
+        // `extends`.
+        implementsNames: parents,
+        bodyText: nodeText(findNamedChild(child, "contract_body")) || child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "struct_declaration") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "struct",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "enum_declaration") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "enum",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "function_definition") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "function",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(child, "function_body")) || child.text
+      });
+      exportLabels.push(name);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "solidity", imports, draftSymbols, exportLabels, diagnostics);
+}
+function htmlAttributeValue(attribute) {
+  const quoted = attribute.namedChildren.find((c) => c?.type === "quoted_attribute_value");
+  if (quoted) {
+    const inner = quoted.namedChildren.find((c) => c?.type === "attribute_value");
+    if (inner) {
+      return inner.text.trim();
+    }
+    const raw = quoted.text;
+    if (raw.length >= 2 && (raw[0] === '"' || raw[0] === "'")) {
+      return raw.slice(1, -1).trim();
+    }
+    return raw.trim();
+  }
+  const bare = attribute.namedChildren.find((c) => c?.type === "attribute_value");
+  return bare?.text.trim();
+}
+function htmlAttributesOf(element) {
+  const out = /* @__PURE__ */ new Map();
+  const startTag = findNamedChild(element, "start_tag") ?? findNamedChild(element, "self_closing_tag");
+  if (!startTag) {
+    return out;
+  }
+  for (const child of startTag.namedChildren) {
+    if (!child || child.type !== "attribute") {
+      continue;
+    }
+    const nameNode = findNamedChild(child, "attribute_name");
+    const name = nameNode?.text.trim().toLowerCase();
+    if (!name) {
+      continue;
+    }
+    const value = htmlAttributeValue(child);
+    if (value !== void 0) {
+      out.set(name, value);
+    }
+  }
+  return out;
+}
+function htmlTagName(element) {
+  const startTag = findNamedChild(element, "start_tag") ?? findNamedChild(element, "self_closing_tag") ?? null;
+  if (!startTag) {
+    return void 0;
+  }
+  return findNamedChild(startTag, "tag_name")?.text.trim().toLowerCase();
+}
+function htmlCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const seenSymbolNames = /* @__PURE__ */ new Set();
+  const isLocalAssetSpecifier = (specifier) => {
+    if (!specifier) {
+      return false;
+    }
+    if (specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/")) {
+      return true;
+    }
+    if (specifier.startsWith("http://") || specifier.startsWith("https://") || specifier.startsWith("//")) {
+      return false;
+    }
+    return !specifier.includes(":");
+  };
+  const elements = rootNode.descendantsOfType(["element", "script_element", "style_element"]).filter((item) => item !== null);
+  for (const element of elements) {
+    const attrs = htmlAttributesOf(element);
+    const tagName = htmlTagName(element);
+    if (tagName === "link") {
+      const rel = attrs.get("rel");
+      const href = attrs.get("href");
+      if (rel === "stylesheet" && href) {
+        imports.push({
+          specifier: href,
+          importedSymbols: [],
+          isExternal: !isLocalAssetSpecifier(href),
+          reExport: false
+        });
+      }
+      continue;
+    }
+    if (element.type === "script_element") {
+      const src = attrs.get("src");
+      if (src) {
+        imports.push({
+          specifier: src,
+          importedSymbols: [],
+          isExternal: !isLocalAssetSpecifier(src),
+          reExport: false
+        });
+      }
+      continue;
+    }
+    if (tagName && tagName.includes("-")) {
+      if (!seenSymbolNames.has(tagName)) {
+        seenSymbolNames.add(tagName);
+        draftSymbols.push({
+          name: tagName,
+          kind: "class",
+          signature: singleLineSignature(element.text.split("\n")[0] ?? element.text),
+          exported: true,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: [],
+          bodyText: element.text
+        });
+        exportLabels.push(tagName);
+      }
+    }
+    const id = attrs.get("id");
+    if (id && !seenSymbolNames.has(id)) {
+      seenSymbolNames.add(id);
+      draftSymbols.push({
+        name: id,
+        kind: "variable",
+        signature: singleLineSignature(element.text.split("\n")[0] ?? element.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: element.text
+      });
+      exportLabels.push(id);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "html", imports, draftSymbols, exportLabels, diagnostics);
+}
+function parseCssImport(node) {
+  const directString = node.namedChildren.find((c) => c?.type === "string_value");
+  if (directString) {
+    const specifier = quotedPath(directString.text);
+    if (!specifier) {
+      return void 0;
+    }
+    return {
+      specifier,
+      importedSymbols: [],
+      isExternal: !(specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/")),
+      reExport: false
+    };
+  }
+  const call = node.namedChildren.find((c) => c?.type === "call_expression");
+  if (call) {
+    const args = findNamedChild(call, "arguments");
+    const stringNode = args?.namedChildren.find((c) => c?.type === "string_value");
+    if (stringNode) {
+      const specifier = quotedPath(stringNode.text);
+      if (!specifier) {
+        return void 0;
+      }
+      return {
+        specifier,
+        importedSymbols: [],
+        isExternal: !(specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/")),
+        reExport: false
+      };
+    }
+  }
+  return void 0;
+}
+function cssCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const seenSymbols = /* @__PURE__ */ new Set();
+  const addSelectorSymbol = (name, ruleText) => {
+    const trimmed = name.trim();
+    if (!trimmed || seenSymbols.has(trimmed)) {
+      return;
+    }
+    seenSymbols.add(trimmed);
+    draftSymbols.push({
+      name: trimmed,
+      kind: "class",
+      signature: singleLineSignature(ruleText.split("\n")[0] ?? ruleText),
+      exported: true,
+      callNames: [],
+      extendsNames: [],
+      implementsNames: [],
+      bodyText: ruleText
+    });
+    exportLabels.push(trimmed);
+  };
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "import_statement") {
+      const parsed = parseCssImport(child);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (child.type === "rule_set") {
+      const selectors = findNamedChild(child, "selectors");
+      if (!selectors) {
+        continue;
+      }
+      const selectorText = normalizeWhitespace(selectors.text);
+      addSelectorSymbol(selectorText, child.text);
+      continue;
+    }
+    if (child.type === "keyframes_statement") {
+      const nameNode = child.namedChildren.find((c) => c?.type === "keyframes_name" || c?.type === "plain_value");
+      const name = nameNode?.text.trim();
+      if (name) {
+        addSelectorSymbol(`@keyframes ${name}`, child.text);
+      }
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "css", imports, draftSymbols, exportLabels, diagnostics);
+}
+function vueCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const seenSymbols = /* @__PURE__ */ new Set();
+  const repoPath = manifest.repoRelativePath ?? path5.basename(manifest.originalPath ?? manifest.storedPath);
+  const basename = path5.posix.basename(stripCodeExtension(toPosix(repoPath)));
+  if (basename) {
+    seenSymbols.add(basename);
+    draftSymbols.push({
+      name: basename,
+      kind: "class",
+      signature: `vue component ${basename}`,
+      exported: true,
+      callNames: [],
+      extendsNames: [],
+      implementsNames: [],
+      bodyText: rootNode.text
+    });
+    exportLabels.push(basename);
+  }
+  const templateElement = rootNode.namedChildren.find((c) => c?.type === "template_element");
+  if (templateElement) {
+    const elements = templateElement.descendantsOfType(["element"]).filter((item) => item !== null);
+    for (const element of elements) {
+      const tagName = htmlTagName(element);
+      const attrs = htmlAttributesOf(element);
+      const startTag = findNamedChild(element, "start_tag") ?? findNamedChild(element, "self_closing_tag") ?? null;
+      const rawTagName = startTag ? findNamedChild(startTag, "tag_name")?.text.trim() : void 0;
+      if (rawTagName && /^[A-Z]/.test(rawTagName) && !seenSymbols.has(rawTagName)) {
+        seenSymbols.add(rawTagName);
+        draftSymbols.push({
+          name: rawTagName,
+          kind: "class",
+          signature: singleLineSignature(element.text.split("\n")[0] ?? element.text),
+          exported: true,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: [],
+          bodyText: element.text
+        });
+        exportLabels.push(rawTagName);
+      }
+      if (tagName && !tagName.includes("-") && !(rawTagName && /^[A-Z]/.test(rawTagName))) {
+        const id = attrs.get("id");
+        if (id && !seenSymbols.has(id)) {
+          seenSymbols.add(id);
+          draftSymbols.push({
+            name: id,
+            kind: "variable",
+            signature: singleLineSignature(element.text.split("\n")[0] ?? element.text),
+            exported: true,
+            callNames: [],
+            extendsNames: [],
+            implementsNames: [],
+            bodyText: element.text
+          });
+          exportLabels.push(id);
+        }
+      }
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "vue", imports, draftSymbols, exportLabels, diagnostics);
+}
+function cFamilyCodeAnalysis(manifest, language, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const functionNameFromDeclarator = (node) => {
+    if (!node) {
+      return void 0;
+    }
+    const declarator = node.childForFieldName("declarator");
+    if (declarator) {
+      return functionNameFromDeclarator(declarator);
+    }
+    return extractIdentifier(node);
+  };
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "preproc_include") {
+      const parsed = parseCppInclude(child);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (["class_specifier", "struct_specifier", "enum_specifier"].includes(child.type)) {
+      const name = extractIdentifier(child.childForFieldName("name"));
+      if (!name) {
+        continue;
+      }
+      const kind = child.type === "enum_specifier" ? "enum" : child.type === "struct_specifier" ? "struct" : "class";
+      const baseClassClause = findNamedChild(child, "base_class_clause") ?? child.childForFieldName("base_class_clause");
+      const bases = baseClassClause ? uniqueBy(
+        baseClassClause.namedChildren.filter((item) => item !== null && item.type !== "access_specifier").map((item) => normalizeSymbolReference(item.text.replace(/\b(public|private|protected|virtual)\b/g, "").trim())).filter(Boolean),
+        (item) => item
+      ) : [];
+      const exported = !/\bstatic\b/.test(child.text);
+      draftSymbols.push({
+        name,
+        kind,
+        signature: singleLineSignature(child.text),
+        exported,
+        callNames: [],
+        extendsNames: bases,
+        implementsNames: [],
+        bodyText: nodeText(child.childForFieldName("body")) || child.text
+      });
+      if (exported) {
+        exportLabels.push(name);
+      }
+      continue;
+    }
+    if (child.type === "function_definition") {
+      const name = functionNameFromDeclarator(child.childForFieldName("declarator"));
+      if (!name) {
+        continue;
+      }
+      const exported = !/\bstatic\b/.test(child.text);
+      draftSymbols.push({
+        name,
+        kind: "function",
+        signature: singleLineSignature(child.text),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(child.childForFieldName("body")) || child.text
+      });
+      if (exported) {
+        exportLabels.push(name);
+      }
+    }
+  }
+  return finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportLabels, diagnostics);
+}
+async function analyzeTreeSitterCode(manifest, content, language) {
+  if (language === "swift" && !swiftTreeSitterEnabled()) {
+    return {
+      code: finalizeCodeAnalysis(manifest, language, [], [], [], [swiftTreeSitterDisabledDiagnostic()]),
+      rationales: []
+    };
+  }
+  const parseInput = language === "c" || language === "cpp" || language === "csharp" ? neutralizePreprocessorDirectives(content) : content;
+  let tree = null;
+  try {
+    const module = await getTreeSitterModule();
+    await ensureTreeSitterInit(module);
+    const parser = new module.Parser();
+    parser.setLanguage(await loadLanguage(language));
+    tree = parser.parse(parseInput);
+  } catch (error) {
+    const diagnostic = treeSitterCompatibilityDiagnostic(language, error);
+    if (language === "bash" && typeof diagnostic.message === "string" && diagnostic.message.includes("resolved is not a function")) {
+      diagnostic.category = "warning";
+    }
+    return {
+      code: finalizeCodeAnalysis(manifest, language, [], [], [], [diagnostic]),
+      rationales: []
+    };
+  }
+  if (!tree) {
+    return {
+      code: finalizeCodeAnalysis(
+        manifest,
+        language,
+        [],
+        [],
+        [],
+        [
+          {
+            code: 9e3,
+            category: "error",
+            message: `Failed to parse ${language} source.`,
+            line: 1,
+            column: 1
+          }
+        ]
+      ),
+      rationales: []
+    };
+  }
+  try {
+    const suppressDiagnostics = language === "lua" || language === "bash" && detectShellDialect(content) === "zsh";
+    const rawDiagnostics = suppressDiagnostics ? [] : diagnosticsFromTree(tree.rootNode);
+    const grammarGappedLanguages = /* @__PURE__ */ new Set(["c", "cpp", "csharp", "bash"]);
+    const diagnostics = grammarGappedLanguages.has(language) ? rawDiagnostics.map((d) => d.category === "error" ? { ...d, category: "warning" } : d) : rawDiagnostics;
+    const rationales = extractTreeSitterRationales(manifest, language, tree.rootNode);
+    switch (language) {
+      case "bash":
+        return { code: bashCodeAnalysis(manifest, tree.rootNode, diagnostics, content), rationales };
+      case "python":
+        return { code: pythonCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "go":
+        return { code: goCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "rust":
+        return { code: rustCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "java":
+        return { code: javaCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "kotlin":
+        return { code: kotlinCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "scala":
+        return { code: scalaCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "dart":
+        return { code: dartCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "lua":
+        return { code: luaCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "zig":
+        return { code: zigCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "csharp":
+        return { code: csharpCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "php":
+        return { code: phpCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "ruby":
+        return { code: rubyCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "powershell":
+        return { code: powershellCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "swift":
+        return { code: swiftCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "elixir":
+        return { code: elixirCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "ocaml":
+        return { code: ocamlCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "objc":
+        return { code: objcCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "rescript":
+        return { code: rescriptCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "solidity":
+        return { code: solidityCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "html":
+        return { code: htmlCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "css":
+        return { code: cssCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "vue":
+        return { code: vueCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "c":
+      case "cpp":
+        return { code: cFamilyCodeAnalysis(manifest, language, tree.rootNode, diagnostics), rationales };
+      default:
+        return {
           code: finalizeCodeAnalysis(
             manifest,
             language,
@@ -4641,6 +5955,33 @@ function inferCodeLanguage(filePath, mimeType = "", options = {}) {
   if (extension === ".ps1" || extension === ".psm1" || extension === ".psd1") {
     return "powershell";
   }
+  if (extension === ".swift") {
+    return "swift";
+  }
+  if (extension === ".ex" || extension === ".exs") {
+    return "elixir";
+  }
+  if (extension === ".ml" || extension === ".mli") {
+    return "ocaml";
+  }
+  if (extension === ".m" || extension === ".mm") {
+    return "objc";
+  }
+  if (extension === ".res" || extension === ".resi") {
+    return "rescript";
+  }
+  if (extension === ".sol") {
+    return "solidity";
+  }
+  if (extension === ".html" || extension === ".htm") {
+    return "html";
+  }
+  if (extension === ".css") {
+    return "css";
+  }
+  if (extension === ".vue") {
+    return "vue";
+  }
   if (extension === ".c") {
     return "c";
   }
@@ -4829,6 +6170,24 @@ function candidateExtensionsFor(language) {
       return [".c", ".h"];
     case "cpp":
       return [".cc", ".cpp", ".cxx", ".h", ".hh", ".hpp", ".hxx"];
+    case "swift":
+      return [".swift"];
+    case "elixir":
+      return [".ex", ".exs"];
+    case "ocaml":
+      return [".ml", ".mli"];
+    case "objc":
+      return [".m", ".mm", ".h"];
+    case "rescript":
+      return [".res", ".resi"];
+    case "solidity":
+      return [".sol"];
+    case "html":
+      return [".css", ".js", ".mjs", ".cjs", ".html", ".htm"];
+    case "css":
+      return [".css"];
+    default:
+      return [];
   }
 }
 async function buildCodeIndex(rootDir, manifests, analyses) {
@@ -4932,6 +6291,39 @@ async function buildCodeIndex(rootDir, manifests, analyses) {
       case "powershell":
         recordAlias(aliases, basename);
         break;
+      case "elixir":
+        for (const symbol of analysis.code.symbols) {
+          if (symbol.kind === "class" || symbol.kind === "interface") {
+            recordAlias(aliases, symbol.name);
+          }
+        }
+        break;
+      case "ocaml": {
+        if (basename) {
+          const capitalized = basename.charAt(0).toUpperCase() + basename.slice(1);
+          recordAlias(aliases, capitalized);
+          recordAlias(aliases, basename);
+        }
+        for (const symbol of analysis.code.symbols) {
+          if (symbol.kind === "class" || symbol.kind === "interface") {
+            recordAlias(aliases, symbol.name);
+          }
+        }
+        break;
+      }
+      case "rescript": {
+        if (basename) {
+          const capitalized = basename.charAt(0).toUpperCase() + basename.slice(1);
+          recordAlias(aliases, capitalized);
+          recordAlias(aliases, basename);
+        }
+        for (const symbol of analysis.code.symbols) {
+          if (symbol.kind === "class") {
+            recordAlias(aliases, symbol.name);
+          }
+        }
+        break;
+      }
       default:
         break;
     }
@@ -5133,6 +6525,9 @@ function findImportCandidates(manifest, codeImport, lookup) {
     case "kotlin":
     case "scala":
     case "csharp":
+    case "elixir":
+    case "ocaml":
+    case "rescript":
       return aliasMatches(lookup, codeImport.specifier);
     case "dart":
       return repoRelativePath && dartSpecifierLooksLocal2(codeImport.specifier) ? repoPathMatches(lookup, ...importResolutionCandidates(repoRelativePath, codeImport.specifier, candidateExtensionsFor(language))) : aliasMatches(lookup, codeImport.specifier);
@@ -5167,6 +6562,10 @@ function findImportCandidates(manifest, codeImport, lookup) {
     }
     case "c":
     case "cpp":
+    case "objc":
+    case "solidity":
+    case "html":
+    case "css":
       return repoRelativePath && !codeImport.isExternal ? repoPathMatches(lookup, ...importResolutionCandidates(repoRelativePath, codeImport.specifier, candidateExtensionsFor(language))) : aliasMatches(lookup, codeImport.specifier);
     default:
       return [];
@@ -5192,8 +6591,10 @@ function importLooksLocal(manifest, codeImport, candidates) {
     case "powershell":
     case "c":
     case "cpp":
+    case "objc":
     case "kotlin":
     case "scala":
+    case "solidity":
       return !codeImport.isExternal;
     case "bash":
       return bashSpecifierLooksLocal2(codeImport.specifier);
@@ -5271,6 +6672,43 @@ import { strFromU8, unzipSync } from "fflate";
 import { JSDOM } from "jsdom";
 import TurndownService from "turndown";
 import { z } from "zod";
+
+// src/markdown-ast.ts
+import { fromMarkdown } from "mdast-util-from-markdown";
+function parseMarkdownNodes(text) {
+  try {
+    const root = fromMarkdown(text);
+    return Array.isArray(root.children) ? root.children : [];
+  } catch {
+    return [];
+  }
+}
+function markdownNodeText(node) {
+  if (node.type === "text" || node.type === "inlineCode" || node.type === "code") {
+    return normalizeWhitespace(node.value ?? "");
+  }
+  if (node.type === "image") {
+    return normalizeWhitespace(node.alt ?? "");
+  }
+  if (node.type === "break" || node.type === "thematicBreak") {
+    return " ";
+  }
+  return normalizeWhitespace((node.children ?? []).map((child) => markdownNodeText(child)).join(" "));
+}
+function firstMarkdownHeading(text) {
+  const nodes = parseMarkdownNodes(text);
+  for (const node of nodes) {
+    if (node.type === "heading") {
+      const title = markdownNodeText(node).trim();
+      if (title) {
+        return title;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/extraction.ts
 var imageVisionExtractionSchema = z.object({
   title: z.string().min(1).nullable().optional(),
   summary: z.string().min(1),
@@ -5665,18 +7103,158 @@ async function extractDocxText(input) {
       metadata: parseOfficeCoreMetadata(input.bytes),
       warnings: warnings.length ? warnings : void 0
     };
-    if (!extractedText) {
-      artifact.warnings = [...artifact.warnings ?? [], "DOCX text extraction completed but produced no extractable text."];
+    if (!extractedText) {
+      artifact.warnings = [...artifact.warnings ?? [], "DOCX text extraction completed but produced no extractable text."];
+    }
+    return {
+      extractedText: extractedText || void 0,
+      artifact
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("docx", input.mimeType, "docx_text"),
+        warnings: [`DOCX text extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+function jupyterCellSource(cell) {
+  const source = cell.source;
+  if (Array.isArray(source)) {
+    return source.join("");
+  }
+  if (typeof source === "string") {
+    return source;
+  }
+  return "";
+}
+function jupyterOutputSummary(outputs) {
+  if (!Array.isArray(outputs) || outputs.length === 0) {
+    return null;
+  }
+  const parts = [];
+  for (const output of outputs) {
+    const data = output.data;
+    if (data && typeof data === "object") {
+      const text = data["text/plain"] ?? data["text/markdown"];
+      if (typeof text === "string") {
+        parts.push(text.trim());
+        continue;
+      }
+      if (Array.isArray(text)) {
+        parts.push(text.join("").trim());
+        continue;
+      }
+    }
+    const textField = output.text;
+    if (typeof textField === "string") {
+      parts.push(textField.trim());
+      continue;
+    }
+    if (Array.isArray(textField)) {
+      parts.push(textField.join("").trim());
+    }
+  }
+  const joined = parts.filter(Boolean).join("\n").trim();
+  if (!joined) {
+    return `[${outputs.length} non-text output${outputs.length === 1 ? "" : "s"}]`;
+  }
+  return joined.length > 1200 ? `${joined.slice(0, 1200)}
+[output truncated]` : joined;
+}
+async function extractJupyterNotebook(input) {
+  try {
+    const text = decodeTextBytes(input.bytes);
+    const notebook = JSON.parse(text);
+    const cells = Array.isArray(notebook.cells) ? notebook.cells : [];
+    const kernelLanguage = notebook.metadata?.language_info?.name?.trim() || notebook.metadata?.kernelspec?.language?.trim() || "";
+    const kernelDisplay = notebook.metadata?.kernelspec?.display_name?.trim() || "";
+    let notebookTitle = typeof notebook.metadata?.title === "string" ? notebook.metadata.title.trim() : "";
+    if (!notebookTitle) {
+      for (const cell of cells) {
+        if (cell.cell_type === "markdown") {
+          const heading2 = firstMarkdownHeading(jupyterCellSource(cell));
+          if (heading2) {
+            notebookTitle = heading2;
+            break;
+          }
+        }
+      }
+    }
+    if (!notebookTitle && input.fileName) {
+      notebookTitle = path7.basename(input.fileName, path7.extname(input.fileName));
+    }
+    const sections = [];
+    let markdownCellCount = 0;
+    let codeCellCount = 0;
+    let outputCount = 0;
+    for (const cell of cells) {
+      const source = jupyterCellSource(cell).trim();
+      if (!source) {
+        continue;
+      }
+      if (cell.cell_type === "markdown") {
+        markdownCellCount += 1;
+        sections.push(source);
+        sections.push("");
+        continue;
+      }
+      if (cell.cell_type === "code") {
+        codeCellCount += 1;
+        const fence = kernelLanguage || "";
+        sections.push(`\`\`\`${fence}`);
+        sections.push(source);
+        sections.push("```");
+        const outputSummary = jupyterOutputSummary(cell.outputs);
+        if (outputSummary) {
+          outputCount += Array.isArray(cell.outputs) ? cell.outputs.length : 0;
+          sections.push("");
+          sections.push("_Output:_");
+          sections.push("");
+          sections.push(outputSummary);
+        }
+        sections.push("");
+        continue;
+      }
+      sections.push(source);
+      sections.push("");
+    }
+    const heading = notebookTitle ? [`# ${notebookTitle}`, ""] : [];
+    const extractedText = [
+      ...heading,
+      `Jupyter Notebook (${cells.length} cell${cells.length === 1 ? "" : "s"}, kernel: ${kernelDisplay || kernelLanguage || "unknown"})`,
+      "",
+      ...sections
+    ].join("\n").trim();
+    const metadata = {
+      cell_count: String(cells.length),
+      markdown_cells: String(markdownCellCount),
+      code_cells: String(codeCellCount),
+      output_count: String(outputCount)
+    };
+    if (kernelLanguage) {
+      metadata.kernel_language = kernelLanguage;
+    }
+    if (kernelDisplay) {
+      metadata.kernel_display_name = kernelDisplay;
+    }
+    if (notebook.nbformat !== void 0) {
+      metadata.nbformat = `${notebook.nbformat}${notebook.nbformat_minor !== void 0 ? `.${notebook.nbformat_minor}` : ""}`;
     }
     return {
+      title: notebookTitle || void 0,
       extractedText: extractedText || void 0,
-      artifact
+      artifact: {
+        ...extractionMetadata("jupyter", input.mimeType, "jupyter_text"),
+        metadata
+      }
     };
   } catch (error) {
     return {
       artifact: {
-        ...extractionMetadata("docx", input.mimeType, "docx_text"),
-        warnings: [`DOCX text extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+        ...extractionMetadata("jupyter", input.mimeType, "jupyter_text"),
+        warnings: [`Jupyter notebook extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
       }
     };
   }
@@ -5731,7 +7309,7 @@ async function extractCsvText(input) {
     };
   }
 }
-async function extractXlsxText(input) {
+async function extractSpreadsheetWorkbook(input, sourceKind, extractor) {
   try {
     const XLSX = await import("xlsx");
     const workbook = XLSX.read(input.bytes, { type: "buffer", cellFormula: false, cellHTML: false, cellStyles: false });
@@ -5772,7 +7350,7 @@ async function extractXlsxText(input) {
       title,
       extractedText,
       artifact: {
-        ...extractionMetadata("xlsx", input.mimeType, "xlsx_text"),
+        ...extractionMetadata(sourceKind, input.mimeType, extractor),
         metadata,
         warnings
       }
@@ -5780,12 +7358,20 @@ async function extractXlsxText(input) {
   } catch (error) {
     return {
       artifact: {
-        ...extractionMetadata("xlsx", input.mimeType, "xlsx_text"),
-        warnings: [`XLSX extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+        ...extractionMetadata(sourceKind, input.mimeType, extractor),
+        warnings: [
+          `${sourceKind.toUpperCase()} extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`
+        ]
       }
     };
   }
 }
+async function extractXlsxText(input) {
+  return extractSpreadsheetWorkbook(input, "xlsx", "xlsx_text");
+}
+async function extractOdsText(input) {
+  return extractSpreadsheetWorkbook(input, "ods", "ods_text");
+}
 async function extractPptxText(input) {
   try {
     const archive = unzipSync(new Uint8Array(input.bytes));
@@ -6038,66 +7624,707 @@ function calendarAttendees(value) {
     return name || address;
   }).filter(Boolean);
 }
-function slackFormatSpeakerId(input, usersById) {
-  return usersById.get(input) ?? input;
+function slackFormatSpeakerId(input, usersById) {
+  return usersById.get(input) ?? input;
+}
+function slackNormalizeText(text, usersById) {
+  return normalizeWhitespace(
+    text.replace(/<@([A-Z0-9]+)>/g, (_, userId) => `@${slackFormatSpeakerId(userId, usersById)}`).replace(/<#[A-Z0-9]+\|([^>]+)>/g, "#$1").replace(/<(https?:\/\/[^>|]+)\|([^>]+)>/g, "$2 ($1)").replace(/<(https?:\/\/[^>]+)>/g, "$1")
+  );
+}
+function slackMessageTimestamp(ts2, fallbackDate) {
+  const numeric = Number(ts2);
+  if (Number.isFinite(numeric) && numeric > 0) {
+    return new Date(numeric * 1e3).toISOString();
+  }
+  return (/* @__PURE__ */ new Date(`${fallbackDate}T00:00:00.000Z`)).toISOString();
+}
+async function loadZipMessageBuffers(bytes) {
+  const { MboxStream } = await import("node-mbox");
+  const stream = MboxStream(Readable.from([bytes]));
+  return await new Promise((resolve, reject) => {
+    const messages = [];
+    stream.on("data", (message) => {
+      messages.push(Buffer.isBuffer(message) ? message : Buffer.from(message));
+    });
+    stream.on("error", reject);
+    stream.on("finish", () => resolve(messages));
+    stream.on("end", () => resolve(messages));
+  });
+}
+function archiveEntriesAsText(archive) {
+  return new Map(
+    Object.entries(archive).filter(([, value]) => value).map(([entryPath, value]) => [entryPath, strFromU8(value)])
+  );
+}
+function looksLikeSlackEntries(entries) {
+  const all = [...entries];
+  const hasChannelsIndex = all.some(
+    (entry) => entry === "channels.json" || entry === "groups.json" || entry === "dms.json" || entry === "mpims.json"
+  );
+  const hasChannelDayFiles = all.some((entry) => /^[^/]+\/\d{4}-\d{2}-\d{2}\.json$/i.test(entry));
+  return hasChannelsIndex && hasChannelDayFiles;
+}
+function slackEntriesFromChannelIndex(raw, usersById) {
+  const entries = /* @__PURE__ */ new Map();
+  if (!Array.isArray(raw)) {
+    return entries;
+  }
+  for (const item of raw) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const value = item;
+    const id = normalizeWhitespace(value.id ?? "");
+    const title = normalizeWhitespace(value.name ?? "");
+    if (!title) {
+      continue;
+    }
+    const members = (Array.isArray(value.members) ? value.members : value.user ? [value.user] : []).map((member) => slackFormatSpeakerId(member, usersById)).filter(Boolean);
+    entries.set(title, { id, title, members });
+  }
+  return entries;
+}
+function parseOdfMetadata(bytes) {
+  try {
+    const archive = unzipSync(new Uint8Array(bytes));
+    const metaXml = zipEntryText(archive, "meta.xml");
+    if (!metaXml) {
+      return void 0;
+    }
+    const document = parseXmlDocument(metaXml);
+    const valuesByLocalName = /* @__PURE__ */ new Map();
+    for (const node of Array.from(document.getElementsByTagName("*"))) {
+      const localName = node.localName?.trim().toLowerCase();
+      const text = normalizeWhitespace(node.textContent ?? "");
+      if (!localName || !text || valuesByLocalName.has(localName)) {
+        continue;
+      }
+      valuesByLocalName.set(localName, text);
+    }
+    const metadata = {};
+    const mappings = [
+      ["title", "title"],
+      ["author", "creator"],
+      ["subject", "subject"],
+      ["description", "description"],
+      ["keywords", "keyword"],
+      ["initial_creator", "initial-creator"],
+      ["created", "creation-date"],
+      ["modified", "date"]
+    ];
+    for (const [targetKey, sourceKey] of mappings) {
+      const value = valuesByLocalName.get(sourceKey);
+      if (value) {
+        metadata[targetKey] = value;
+      }
+    }
+    return Object.keys(metadata).length ? metadata : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function collectOdfTextNodes(contentXml) {
+  const document = parseXmlDocument(contentXml);
+  const nodes = [];
+  for (const node of Array.from(document.getElementsByTagName("*"))) {
+    const localName = node.localName ?? "";
+    if (localName === "h") {
+      const level = Number.parseInt(node.getAttribute("text:outline-level") ?? "1", 10);
+      const text = normalizeWhitespace(node.textContent ?? "");
+      if (text) {
+        nodes.push({ heading: Number.isFinite(level) && level > 0 ? level : 1, text });
+      }
+      continue;
+    }
+    if (localName === "p" || localName === "list-item") {
+      if (node.closest?.("h")) {
+        continue;
+      }
+      const text = normalizeWhitespace(node.textContent ?? "");
+      if (text) {
+        nodes.push({ text });
+      }
+    }
+  }
+  return nodes;
+}
+function renderOdfTextNodes(nodes) {
+  const lines = [];
+  for (const node of nodes) {
+    if (node.heading) {
+      lines.push("");
+      lines.push(`${"#".repeat(Math.min(node.heading, 6))} ${node.text}`);
+      lines.push("");
+      continue;
+    }
+    lines.push(node.text);
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+async function extractOdtText(input) {
+  try {
+    const archive = unzipSync(new Uint8Array(input.bytes));
+    const contentXml = zipEntryText(archive, "content.xml");
+    if (!contentXml) {
+      throw new Error("Missing content.xml");
+    }
+    const metadata = parseOdfMetadata(input.bytes);
+    const textNodes = collectOdfTextNodes(contentXml);
+    const headingCount = textNodes.filter((node) => node.heading).length;
+    const paragraphCount = textNodes.filter((node) => !node.heading).length;
+    const title = metadata?.title || textNodes.find((node) => node.heading === 1)?.text || (input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0);
+    const body = renderOdfTextNodes(textNodes);
+    const extractedText = [title ? `# ${title}` : null, "", body].filter((item) => item !== null).join("\n").trim();
+    return {
+      title,
+      extractedText: extractedText || void 0,
+      artifact: {
+        ...extractionMetadata("odt", input.mimeType, "odt_text"),
+        metadata: {
+          ...metadata ?? {},
+          heading_count: String(headingCount),
+          paragraph_count: String(paragraphCount)
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("odt", input.mimeType, "odt_text"),
+        warnings: [`ODT extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractOdpText(input) {
+  try {
+    const archive = unzipSync(new Uint8Array(input.bytes));
+    const contentXml = zipEntryText(archive, "content.xml");
+    if (!contentXml) {
+      throw new Error("Missing content.xml");
+    }
+    const metadata = parseOdfMetadata(input.bytes);
+    const document = parseXmlDocument(contentXml);
+    const pages = Array.from(document.getElementsByTagName("*")).filter((node) => node.localName === "page");
+    const slideSections = [];
+    pages.slice(0, 60).forEach((page, index) => {
+      const slideName = page.getAttribute("draw:name") ?? `Slide ${index + 1}`;
+      const text = normalizeWhitespace(page.textContent ?? "");
+      slideSections.push(`## Slide ${index + 1}: ${slideName}`);
+      if (text) {
+        slideSections.push(text);
+      }
+      slideSections.push("");
+    });
+    const title = metadata?.title || (input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0);
+    const extractedText = [title ? `# ${title}` : null, `Slides: ${pages.length}`, "", ...slideSections].filter((item) => Boolean(item)).join("\n").trim();
+    const warnings = pages.length > 60 ? ["ODP extraction truncated to the first 60 slides."] : void 0;
+    return {
+      title,
+      extractedText: extractedText || void 0,
+      artifact: {
+        ...extractionMetadata("odp", input.mimeType, "odp_text"),
+        metadata: {
+          ...metadata ?? {},
+          slide_count: String(pages.length)
+        },
+        warnings
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("odp", input.mimeType, "odp_text"),
+        warnings: [`ODP extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+function inferStructuredFormat(mimeType, fileName) {
+  const lower = (fileName ?? "").toLowerCase();
+  if (lower.endsWith(".jsonc") || lower.endsWith(".json") || lower.endsWith(".json5") || mimeType === "application/json" || mimeType === "application/json5") {
+    return "json";
+  }
+  if (lower.endsWith(".yaml") || lower.endsWith(".yml") || mimeType === "application/yaml" || mimeType === "application/x-yaml") {
+    return "yaml";
+  }
+  if (lower.endsWith(".toml") || mimeType === "application/toml") {
+    return "toml";
+  }
+  if (lower.endsWith(".xml") || mimeType === "application/xml" || mimeType === "text/xml") {
+    return "xml";
+  }
+  if (lower.endsWith(".ini") || lower.endsWith(".conf") || lower.endsWith(".cfg")) {
+    return "ini";
+  }
+  if (lower.endsWith(".env")) {
+    return "env";
+  }
+  if (lower.endsWith(".properties")) {
+    return "properties";
+  }
+  return null;
+}
+function parseEnvFile(text) {
+  const result = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const eqIndex = line.indexOf("=");
+    if (eqIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, eqIndex).trim();
+    let value = line.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function parsePropertiesFile(text) {
+  const result = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#") || line.startsWith("!")) {
+      continue;
+    }
+    let sep = line.indexOf("=");
+    if (sep < 0) {
+      sep = line.indexOf(":");
+    }
+    if (sep <= 0) {
+      continue;
+    }
+    const key = line.slice(0, sep).trim();
+    const value = line.slice(sep + 1).trim();
+    result[key] = value;
+  }
+  return result;
+}
+function parseXmlToSchema(text) {
+  const document = parseXmlDocument(text);
+  const root = document.documentElement;
+  if (!root) {
+    return {};
+  }
+  const childCounts = /* @__PURE__ */ new Map();
+  for (const child of Array.from(root.children)) {
+    const name = child.tagName || child.localName || "";
+    if (!name) {
+      continue;
+    }
+    childCounts.set(name, (childCounts.get(name) ?? 0) + 1);
+  }
+  const result = {};
+  for (const [name, count] of childCounts.entries()) {
+    result[name] = { count };
+  }
+  return { [root.tagName || "root"]: result };
+}
+function describeJsonShape(value) {
+  if (value === null) {
+    return { type: "null", size: 0, depth: 0 };
+  }
+  if (Array.isArray(value)) {
+    const depths = value.map((entry) => describeJsonShape(entry).depth);
+    return { type: "array", size: value.length, depth: 1 + (depths.length ? Math.max(...depths) : 0) };
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    const depths = entries.map(([, v]) => describeJsonShape(v).depth);
+    return { type: "object", size: entries.length, depth: 1 + (depths.length ? Math.max(...depths) : 0) };
+  }
+  return { type: typeof value, size: 0, depth: 0 };
+}
+function describeTopLevelSchema(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    const shape = describeJsonShape(value);
+    return [`(root) ${shape.type}${shape.size ? ` (${shape.size})` : ""}`];
+  }
+  const entries = Object.entries(value);
+  return entries.slice(0, 20).map(([key, child]) => {
+    const shape = describeJsonShape(child);
+    const sizeHint = shape.type === "array" ? ` (${shape.size} items)` : shape.type === "object" ? ` (${shape.size} keys)` : "";
+    return `${key}: ${shape.type}${sizeHint}`;
+  });
+}
+async function parseStructuredPayload(bytes, format) {
+  const text = decodeTextBytes(bytes);
+  if (format === "json") {
+    const cleaned = text.replace(/^\uFEFF/, "");
+    return { format, value: JSON.parse(cleaned) };
+  }
+  if (format === "yaml") {
+    const yamlModule = await import("yaml");
+    return { format, value: yamlModule.parse(text) };
+  }
+  if (format === "toml") {
+    const tomlModule = await import("smol-toml");
+    return { format, value: tomlModule.parse(text) };
+  }
+  if (format === "xml") {
+    return { format, value: parseXmlToSchema(text) };
+  }
+  if (format === "ini") {
+    try {
+      const tomlModule = await import("smol-toml");
+      return { format, value: tomlModule.parse(text) };
+    } catch {
+      return { format, value: parsePropertiesFile(text) };
+    }
+  }
+  if (format === "env") {
+    return { format, value: parseEnvFile(text) };
+  }
+  return { format, value: parsePropertiesFile(text) };
+}
+async function extractStructuredData(input) {
+  const format = inferStructuredFormat(input.mimeType, input.fileName);
+  if (!format) {
+    return {
+      artifact: {
+        ...extractionMetadata("data", input.mimeType, "structured_data"),
+        warnings: ["Structured data extraction skipped: format not recognized."]
+      }
+    };
+  }
+  try {
+    const { value } = await parseStructuredPayload(input.bytes, format);
+    const shape = describeJsonShape(value);
+    const schemaLines = describeTopLevelSchema(value);
+    const previewText = decodeTextBytes(input.bytes);
+    const previewLines = previewText.split(/\r?\n/).slice(0, 40);
+    const truncated = previewText.split(/\r?\n/).length > previewLines.length;
+    const title = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0;
+    const extractedText = [
+      title ? `# ${title}` : null,
+      `Format: ${format.toUpperCase()}`,
+      `Top-level: ${shape.type}`,
+      shape.type === "object" || shape.type === "array" ? `Size: ${shape.size}` : null,
+      `Nested depth: ${shape.depth}`,
+      "",
+      "## Schema",
+      "",
+      ...schemaLines.map((entry) => `- ${entry}`),
+      "",
+      "## Preview",
+      "",
+      `\`\`\`${format}`,
+      ...previewLines,
+      truncated ? "\u2026" : null,
+      "```"
+    ].filter((item) => item !== null).join("\n").trim();
+    return {
+      title,
+      extractedText,
+      artifact: {
+        ...extractionMetadata("data", input.mimeType, "structured_data"),
+        metadata: {
+          format,
+          top_level_type: shape.type,
+          top_level_size: String(shape.size),
+          nested_depth: String(shape.depth)
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("data", input.mimeType, "structured_data"),
+        warnings: [`Structured data extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+function formatBibCreator(creator) {
+  if (creator.name) {
+    return creator.name;
+  }
+  const parts = [creator.prefix, creator.firstName, creator.lastName, creator.suffix].filter(Boolean);
+  return parts.join(" ");
 }
-function slackNormalizeText(text, usersById) {
-  return normalizeWhitespace(
-    text.replace(/<@([A-Z0-9]+)>/g, (_, userId) => `@${slackFormatSpeakerId(userId, usersById)}`).replace(/<#[A-Z0-9]+\|([^>]+)>/g, "#$1").replace(/<(https?:\/\/[^>|]+)\|([^>]+)>/g, "$2 ($1)").replace(/<(https?:\/\/[^>]+)>/g, "$1")
-  );
+function bibFieldString(value) {
+  if (value == null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => bibFieldString(item)).filter(Boolean).join(", ");
+  }
+  if (typeof value === "object") {
+    return bibFieldString(value.name ?? "");
+  }
+  return String(value);
 }
-function slackMessageTimestamp(ts2, fallbackDate) {
-  const numeric = Number(ts2);
-  if (Number.isFinite(numeric) && numeric > 0) {
-    return new Date(numeric * 1e3).toISOString();
+async function extractBibTeXText(input) {
+  try {
+    const bibtex = await import("@retorquere/bibtex-parser");
+    const text = decodeTextBytes(input.bytes);
+    const library = bibtex.parse(text);
+    const entries = Array.isArray(library.entries) ? library.entries : [];
+    const citationTypes = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const type = (entry.type ?? "misc").toLowerCase();
+      citationTypes.set(type, (citationTypes.get(type) ?? 0) + 1);
+    }
+    const entrySections = [];
+    for (const entry of entries.slice(0, 200)) {
+      const fields = entry.fields ?? {};
+      const title2 = bibFieldString(fields.title);
+      const authorList = Array.isArray(fields.author) ? fields.author.map((creator) => formatBibCreator(creator)).filter(Boolean) : bibFieldString(fields.author).split(/\s+and\s+/i).filter(Boolean);
+      const editorList = Array.isArray(fields.editor) ? fields.editor.map((creator) => formatBibCreator(creator)).filter(Boolean) : [];
+      const year = bibFieldString(fields.year ?? fields.date ?? "");
+      const journal = bibFieldString(fields.journal ?? fields.booktitle ?? fields.publisher ?? "");
+      const doi = bibFieldString(fields.doi);
+      const url = bibFieldString(fields.url);
+      const credit = authorList.length ? authorList.join(", ") : editorList.length ? `${editorList.join(", ")} (eds.)` : "Unknown";
+      const descriptorParts = [credit];
+      if (year) {
+        descriptorParts.push(year);
+      }
+      const descriptor = descriptorParts.join(", ");
+      const trailing = [];
+      if (journal) {
+        trailing.push(journal);
+      }
+      if (doi) {
+        trailing.push(`doi:${doi}`);
+      }
+      if (url) {
+        trailing.push(url);
+      }
+      const trailingText = trailing.length ? ` \u2014 ${trailing.join(", ")}` : "";
+      entrySections.push(`- [${entry.key}] ${title2 || "(untitled)"} (${descriptor})${trailingText}`);
+    }
+    const totalEntries = entries.length;
+    const truncated = entries.length > 200;
+    const typeSummary = [...citationTypes.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])).map(([type, count]) => `${type} (${count})`).join(", ");
+    const title = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : "BibTeX library";
+    const extractedText = [
+      `# ${title}`,
+      "",
+      `BibTeX library with ${totalEntries} entr${totalEntries === 1 ? "y" : "ies"}.`,
+      typeSummary ? `Citation types: ${typeSummary}.` : null,
+      "",
+      "## Entries",
+      "",
+      ...entrySections,
+      truncated ? `
+_Preview truncated to the first 200 entries._` : null
+    ].filter((item) => item !== null).join("\n").trim();
+    const warnings = library.errors?.length ? [`BibTeX parser reported ${library.errors.length} parse error(s).`] : void 0;
+    return {
+      title,
+      extractedText,
+      artifact: {
+        ...extractionMetadata("bibtex", input.mimeType, "bibtex_text"),
+        metadata: {
+          entry_count: String(totalEntries),
+          citation_types: [...citationTypes.keys()].sort().join(",")
+        },
+        warnings
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("bibtex", input.mimeType, "bibtex_text"),
+        warnings: [`BibTeX extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
   }
-  return (/* @__PURE__ */ new Date(`${fallbackDate}T00:00:00.000Z`)).toISOString();
 }
-async function loadZipMessageBuffers(bytes) {
-  const { MboxStream } = await import("node-mbox");
-  const stream = MboxStream(Readable.from([bytes]));
-  return await new Promise((resolve, reject) => {
-    const messages = [];
-    stream.on("data", (message) => {
-      messages.push(Buffer.isBuffer(message) ? message : Buffer.from(message));
+async function extractRtfText(input) {
+  try {
+    const rtfParser = await import("rtf-parser");
+    const parseString = rtfParser.string ?? rtfParser.default?.string;
+    if (typeof parseString !== "function") {
+      throw new Error("rtf-parser did not expose a string parser.");
+    }
+    const rtfText = decodeTextBytes(input.bytes);
+    const document = await new Promise((resolve, reject) => {
+      parseString(rtfText, (err, doc) => {
+        if (err || !doc) {
+          reject(err ?? new Error("RTF parse returned no document"));
+          return;
+        }
+        resolve(doc);
+      });
     });
-    stream.on("error", reject);
-    stream.on("finish", () => resolve(messages));
-    stream.on("end", () => resolve(messages));
-  });
-}
-function archiveEntriesAsText(archive) {
-  return new Map(
-    Object.entries(archive).filter(([, value]) => value).map(([entryPath, value]) => [entryPath, strFromU8(value)])
-  );
+    const paragraphs = [];
+    for (const paragraph of document.content ?? []) {
+      const spans = paragraph.content ?? [];
+      const text = normalizeWhitespace(spans.map((span) => span.value ?? "").join(""));
+      if (text) {
+        paragraphs.push(text);
+      }
+    }
+    const title = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0;
+    const extractedText = [title ? `# ${title}` : null, "", ...paragraphs].filter((item) => item !== null).join("\n\n").trim();
+    return {
+      title,
+      extractedText: extractedText || void 0,
+      artifact: {
+        ...extractionMetadata("rtf", input.mimeType, "rtf_text"),
+        metadata: {
+          paragraph_count: String(paragraphs.length)
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("rtf", input.mimeType, "rtf_text"),
+        warnings: [`RTF extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
 }
-function looksLikeSlackEntries(entries) {
-  const all = [...entries];
-  const hasChannelsIndex = all.some(
-    (entry) => entry === "channels.json" || entry === "groups.json" || entry === "dms.json" || entry === "mpims.json"
-  );
-  const hasChannelDayFiles = all.some((entry) => /^[^/]+\/\d{4}-\d{2}-\d{2}\.json$/i.test(entry));
-  return hasChannelsIndex && hasChannelDayFiles;
+function collectOrgNodeText(node) {
+  if (typeof node.value === "string") {
+    return node.value;
+  }
+  if (!Array.isArray(node.children)) {
+    return "";
+  }
+  return node.children.map((child) => collectOrgNodeText(child)).join("");
 }
-function slackEntriesFromChannelIndex(raw, usersById) {
-  const entries = /* @__PURE__ */ new Map();
-  if (!Array.isArray(raw)) {
-    return entries;
+function renderOrgNode(node, lines) {
+  if (node.type === "headline") {
+    const depth = Math.min(Math.max(node.level ?? 1, 1), 6);
+    const keyword = node.keyword ? `${node.keyword} ` : "";
+    const tags = node.tags?.length ? `  \`${node.tags.join(":")}\`` : "";
+    const text = normalizeWhitespace(collectOrgNodeText(node));
+    lines.push("");
+    lines.push(`${"#".repeat(depth)} ${keyword}${text}${tags}`.trim());
+    lines.push("");
+    return;
   }
-  for (const item of raw) {
-    if (!item || typeof item !== "object") {
-      continue;
+  if (node.type === "paragraph") {
+    const text = normalizeWhitespace(collectOrgNodeText(node));
+    if (text) {
+      lines.push(text);
+      lines.push("");
     }
-    const value = item;
-    const id = normalizeWhitespace(value.id ?? "");
-    const title = normalizeWhitespace(value.name ?? "");
-    if (!title) {
-      continue;
+    return;
+  }
+  if (node.type === "list") {
+    for (const child of node.children ?? []) {
+      if (child.type === "list.item") {
+        const text = normalizeWhitespace(collectOrgNodeText(child));
+        if (text) {
+          lines.push(`- ${text}`);
+        }
+      }
     }
-    const members = (Array.isArray(value.members) ? value.members : value.user ? [value.user] : []).map((member) => slackFormatSpeakerId(member, usersById)).filter(Boolean);
-    entries.set(title, { id, title, members });
+    lines.push("");
+    return;
+  }
+  if (node.type === "block") {
+    const name = node.name ?? "";
+    const body = typeof node.value === "string" ? node.value.trimEnd() : "";
+    if (body) {
+      lines.push(`\`\`\`${name === "src" ? "" : name.toLowerCase()}`);
+      lines.push(body);
+      lines.push("```");
+      lines.push("");
+    }
+    return;
+  }
+  for (const child of node.children ?? []) {
+    renderOrgNode(child, lines);
+  }
+}
+async function extractOrgText(input) {
+  try {
+    const orga = await import("orga");
+    const text = decodeTextBytes(input.bytes);
+    const document = orga.parse(text);
+    const properties = document.properties ?? {};
+    const documentTitle = Array.isArray(properties.title) ? properties.title.join(" ") : typeof properties.title === "string" ? properties.title : "";
+    let headlineCount = 0;
+    let todoCount = 0;
+    const walk = (node) => {
+      if (node.type === "headline") {
+        headlineCount += 1;
+        if (node.keyword) {
+          todoCount += 1;
+        }
+      }
+      for (const child of node.children ?? []) {
+        walk(child);
+      }
+    };
+    walk(document);
+    const bodyLines = [];
+    for (const child of document.children ?? []) {
+      renderOrgNode(child, bodyLines);
+    }
+    const title = documentTitle.trim() || (input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0);
+    const extractedText = [title ? `# ${title}` : null, "", ...bodyLines].filter((item) => item !== null).join("\n").trim();
+    return {
+      title,
+      extractedText: extractedText || void 0,
+      artifact: {
+        ...extractionMetadata("org", input.mimeType, "org_text"),
+        metadata: {
+          headline_count: String(headlineCount),
+          todo_count: String(todoCount)
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("org", input.mimeType, "org_text"),
+        warnings: [`Org extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractAsciiDocText(input) {
+  try {
+    const asciidoctorModule = await import("@asciidoctor/core");
+    const factory = asciidoctorModule.default ?? asciidoctorModule;
+    const processor = factory();
+    const source = decodeTextBytes(input.bytes);
+    const loaded = processor.load(source, { safe: "safe" });
+    const html = processor.convert(source, { safe: "safe", standalone: false });
+    const markdown = htmlToMarkdown(html);
+    const docTitle = (typeof loaded.getTitle === "function" ? loaded.getTitle() : void 0) ?? void 0;
+    const fileTitle = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0;
+    const title = docTitle?.trim() || fileTitle;
+    const extractedText = [title ? `# ${title}` : null, "", markdown].filter((item) => item !== null).join("\n").trim();
+    return {
+      title,
+      extractedText: extractedText || void 0,
+      artifact: {
+        ...extractionMetadata("asciidoc", input.mimeType, "asciidoc_text"),
+        metadata: {
+          html_size: String(html.length),
+          markdown_size: String(markdown.length)
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("asciidoc", input.mimeType, "asciidoc_text"),
+        warnings: [`AsciiDoc extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
   }
-  return entries;
 }
 async function extractTranscriptText(input) {
   try {
@@ -6537,41 +8764,6 @@ async function appendWatchRun(rootDir, run) {
   await appendJsonLine(paths.jobsLogPath, run);
 }
 
-// src/markdown-ast.ts
-import { fromMarkdown } from "mdast-util-from-markdown";
-function parseMarkdownNodes(text) {
-  try {
-    const root = fromMarkdown(text);
-    return Array.isArray(root.children) ? root.children : [];
-  } catch {
-    return [];
-  }
-}
-function markdownNodeText(node) {
-  if (node.type === "text" || node.type === "inlineCode" || node.type === "code") {
-    return normalizeWhitespace(node.value ?? "");
-  }
-  if (node.type === "image") {
-    return normalizeWhitespace(node.alt ?? "");
-  }
-  if (node.type === "break" || node.type === "thematicBreak") {
-    return " ";
-  }
-  return normalizeWhitespace((node.children ?? []).map((child) => markdownNodeText(child)).join(" "));
-}
-function firstMarkdownHeading(text) {
-  const nodes = parseMarkdownNodes(text);
-  for (const node of nodes) {
-    if (node.type === "heading") {
-      const title = markdownNodeText(node).trim();
-      if (title) {
-        return title;
-      }
-    }
-  }
-  return void 0;
-}
-
 // src/source-classification.ts
 import path9 from "path";
 var ALL_SOURCE_CLASSES = ["first_party", "third_party", "resource", "generated"];
@@ -6902,7 +9094,7 @@ function inferKind(mimeType, filePath, detectionOptions = {}) {
   if (isTranscriptFilePath(filePath) || mimeType === "application/x-subrip" || mimeType === "text/vtt") {
     return "transcript";
   }
-  if (mimeType.includes("markdown")) {
+  if (mimeType.includes("markdown") || filePath.toLowerCase().endsWith(".mdx")) {
     return "markdown";
   }
   if (mimeType.includes("html")) {
@@ -6911,7 +9103,7 @@ function inferKind(mimeType, filePath, detectionOptions = {}) {
   if (mimeType === "application/pdf" || filePath.toLowerCase().endsWith(".pdf")) {
     return "pdf";
   }
-  if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || filePath.toLowerCase().endsWith(".docx")) {
+  if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || mimeType === "application/vnd.ms-word.document.macroenabled.12" || mimeType === "application/vnd.ms-word.template.macroenabled.12" || mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.template" || filePath.toLowerCase().endsWith(".docx") || filePath.toLowerCase().endsWith(".docm") || filePath.toLowerCase().endsWith(".dotx") || filePath.toLowerCase().endsWith(".dotm")) {
     return "docx";
   }
   if (isEmailFilePath(filePath) || mimeType === "message/rfc822" || mimeType === "application/mbox") {
@@ -6926,20 +9118,66 @@ function inferKind(mimeType, filePath, detectionOptions = {}) {
   if (mimeType === "text/csv" || mimeType === "text/tab-separated-values" || filePath.toLowerCase().endsWith(".csv") || filePath.toLowerCase().endsWith(".tsv")) {
     return "csv";
   }
+  if (mimeType === "application/x-ipynb+json" || filePath.toLowerCase().endsWith(".ipynb")) {
+    return "jupyter";
+  }
+  if (mimeType === "application/vnd.oasis.opendocument.text" || filePath.toLowerCase().endsWith(".odt")) {
+    return "odt";
+  }
+  if (mimeType === "application/vnd.oasis.opendocument.presentation" || filePath.toLowerCase().endsWith(".odp")) {
+    return "odp";
+  }
+  if (mimeType === "application/vnd.oasis.opendocument.spreadsheet" || filePath.toLowerCase().endsWith(".ods")) {
+    return "ods";
+  }
+  if (filePath.toLowerCase().endsWith(".bib") || mimeType === "application/x-bibtex") {
+    return "bibtex";
+  }
+  if (mimeType === "application/rtf" || mimeType === "text/rtf" || filePath.toLowerCase().endsWith(".rtf")) {
+    return "rtf";
+  }
+  if (filePath.toLowerCase().endsWith(".org") || mimeType === "text/x-org") {
+    return "org";
+  }
+  if (filePath.toLowerCase().endsWith(".adoc") || filePath.toLowerCase().endsWith(".asciidoc") || mimeType === "text/x-asciidoc") {
+    return "asciidoc";
+  }
+  if (isStructuredDataPath(filePath, mimeType)) {
+    return "data";
+  }
   if (mimeType.startsWith("text/") || isStructuredTextMime(mimeType)) {
     return "text";
   }
-  if (mimeType === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" || filePath.toLowerCase().endsWith(".xlsx")) {
+  if (mimeType === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" || mimeType === "application/vnd.ms-excel" || mimeType === "application/vnd.ms-excel.sheet.macroenabled.12" || mimeType === "application/vnd.ms-excel.template.macroenabled.12" || mimeType === "application/vnd.openxmlformats-officedocument.spreadsheetml.template" || filePath.toLowerCase().endsWith(".xlsx") || filePath.toLowerCase().endsWith(".xlsm") || filePath.toLowerCase().endsWith(".xltx") || filePath.toLowerCase().endsWith(".xltm") || filePath.toLowerCase().endsWith(".xls")) {
     return "xlsx";
   }
-  if (mimeType === "application/vnd.openxmlformats-officedocument.presentationml.presentation" || filePath.toLowerCase().endsWith(".pptx")) {
+  if (mimeType === "application/vnd.openxmlformats-officedocument.presentationml.presentation" || mimeType === "application/vnd.ms-powerpoint.presentation.macroenabled.12" || mimeType === "application/vnd.ms-powerpoint.template.macroenabled.12" || mimeType === "application/vnd.openxmlformats-officedocument.presentationml.template" || filePath.toLowerCase().endsWith(".pptx") || filePath.toLowerCase().endsWith(".pptm") || filePath.toLowerCase().endsWith(".potx") || filePath.toLowerCase().endsWith(".potm")) {
     return "pptx";
   }
-  if (mimeType.startsWith("image/")) {
+  if (mimeType.startsWith("image/") || isImagePath(filePath)) {
     return "image";
   }
   return "binary";
 }
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".webp",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".tiff",
+  ".tif",
+  ".heic",
+  ".heif",
+  ".avif",
+  ".jxl",
+  ".svg"
+]);
+function isImagePath(filePath) {
+  return IMAGE_EXTENSIONS.has(path12.extname(filePath).toLowerCase());
+}
 function isStructuredTextMime(mimeType) {
   switch (mimeType) {
     case "application/json":
@@ -6960,6 +9198,23 @@ function isStructuredTextMime(mimeType) {
       return false;
   }
 }
+function isStructuredDataPath(filePath, mimeType) {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".toml") || mimeType === "application/toml" || mimeType === "application/yaml" || mimeType === "application/x-yaml") {
+    return true;
+  }
+  if (lower.endsWith(".xml") || lower.endsWith(".ini") || lower.endsWith(".env") || lower.endsWith(".properties") || lower.endsWith(".conf") || lower.endsWith(".cfg") || mimeType === "application/xml" || mimeType === "text/xml") {
+    return true;
+  }
+  if (lower.endsWith(".json") || lower.endsWith(".jsonc") || lower.endsWith(".json5") || mimeType === "application/json" || mimeType === "application/json5") {
+    const base = path12.basename(lower);
+    if (base === "package.json" || base === "package-lock.json" || base === "tsconfig.json" || base === "pnpm-lock.yaml") {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
 async function localCodeDetectionOptions(absolutePath, payloadBytes) {
   if (path12.extname(absolutePath)) {
     return {};
@@ -8615,6 +10870,60 @@ async function prepareFileInputs(rootDir, absoluteInput, repoRoot, sourceClass)
     title = extracted.title?.trim() || title;
     extractedText = extracted.extractedText;
     extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "jupyter") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractJupyterNotebook({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "odt") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractOdtText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "odp") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractOdpText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "ods") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractOdsText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "data") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractStructuredData({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "bibtex") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractBibTeXText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "rtf") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractRtfText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "org") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractOrgText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "asciidoc") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractAsciiDocText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
   } else if (sourceKind === "epub") {
     title = path12.basename(absoluteInput, path12.extname(absoluteInput));
     const extracted = await extractEpubChapters({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
@@ -8941,7 +11250,11 @@ async function collectInboxAttachmentRefs(inputDir, files) {
   for (const absolutePath of files) {
     const mimeType = guessMimeType(absolutePath);
     const detectionOptions = await localCodeDetectionOptions(absolutePath);
-    const sourceKind = inferKind(mimeType, absolutePath, detectionOptions);
+    let sourceKind = inferKind(mimeType, absolutePath, detectionOptions);
+    const lowerExt = path12.extname(absolutePath).toLowerCase();
+    if ((lowerExt === ".html" || lowerExt === ".htm") && sourceKind === "code") {
+      sourceKind = "html";
+    }
     if (sourceKind !== "markdown" && sourceKind !== "html") {
       continue;
     }
@@ -9285,7 +11598,11 @@ async function importInbox(rootDir, inputDir) {
     const mimeType = guessMimeType(absolutePath);
     const detectionOptions = await localCodeDetectionOptions(absolutePath);
     let sourceKind = inferKind(mimeType, absolutePath, detectionOptions);
-    if (sourceKind === "binary" && path12.extname(absolutePath).toLowerCase() === ".zip") {
+    const lowerExt = path12.extname(absolutePath).toLowerCase();
+    if ((lowerExt === ".html" || lowerExt === ".htm") && sourceKind === "code") {
+      sourceKind = "html";
+    }
+    if (sourceKind === "binary" && lowerExt === ".zip") {
       const bytes = await fs11.readFile(absolutePath);
       if (isSlackExportArchive(bytes)) {
         sourceKind = "chat_export";
@@ -18270,7 +20587,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.6.8";
+var SERVER_VERSION = "0.7.1";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",