sigmap 1.5.0

package/src/extractors/html.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Extract signatures from HTML files.
+ * Focuses on id/class attributes, forms, and script tags.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Page title
+  const titleMatch = src.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  if (titleMatch) sigs.push(`title: ${titleMatch[1].trim()}`);
+
+  // Forms with id/action
+  for (const m of src.matchAll(/<form\s+([^>]*)>/gi)) {
+    const attrs = m[1];
+    const id = attrs.match(/id=["']?(\w+)/i);
+    const action = attrs.match(/action=["']?([^"'\s>]+)/i);
+    if (id) sigs.push(`form#${id[1]}${action ? ` action="${action[1]}"` : ''}`);
+  }
+
+  // Elements with id
+  for (const m of src.matchAll(/<(\w+)\s+[^>]*id=["'](\w+)["'][^>]*>/gi)) {
+    if (['html', 'head', 'body', 'script', 'style', 'link', 'meta'].includes(m[1].toLowerCase())) continue;
+    sigs.push(`${m[1]}#${m[2]}`);
+  }
+
+  // Data attributes (data-component, data-controller etc)
+  for (const m of src.matchAll(/data-(?:component|controller|view|page)=["'](\w[\w-]*)/gi)) {
+    sigs.push(`data-${m[0].match(/data-(\w[\w-]*)/i)[1]}: ${m[1]}`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+module.exports = { extract };

package/src/extractors/java.js

@@ -0,0 +1,49 @@
+'use strict';
+
+/**
+ * Extract signatures from Java source code.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const stripped = src
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Classes and interfaces
+  const typeRegex = /^(?:public\s+|protected\s+)?(?:abstract\s+|final\s+)?(class|interface|enum)\s+(\w+)(?:\s+extends\s+[\w<>, .]+)?(?:\s+implements\s+[\w<>, .]+)?\s*\{/gm;
+  for (const m of stripped.matchAll(typeRegex)) {
+    sigs.push(`${m[1]} ${m[2]}`);
+    const block = extractBlock(stripped, m.index + m[0].length);
+    for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function extractBlock(src, startIndex) {
+  let depth = 1;
+  let i = startIndex;
+  const end = Math.min(src.length, startIndex + 5000);
+  while (i < end && depth > 0) {
+    if (src[i] === '{') depth++;
+    else if (src[i] === '}') depth--;
+    i++;
+  }
+  return src.slice(startIndex, i - 1);
+}
+
+function extractMembers(block) {
+  const members = [];
+  const methodRe = /^\s+(?:public|protected)\s+(?:static\s+)?(?:final\s+)?(?:[\w<>\[\]]+\s+)+(\w+)\s*\(([^)]*)\)/gm;
+  for (const m of block.matchAll(methodRe)) {
+    const sig = m[0].trim().split('{')[0].trim();
+    members.push(sig);
+  }
+  return members.slice(0, 8);
+}
+
+module.exports = { extract };

package/src/extractors/javascript.js

@@ -0,0 +1,82 @@
+'use strict';
+
+/**
+ * Extract signatures from JavaScript source code.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const stripped = src
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Classes
+  const classRegex = /^(export\s+(?:default\s+)?)?class\s+(\w+)(?:\s+extends\s+[\w.]+)?\s*\{/gm;
+  for (const m of stripped.matchAll(classRegex)) {
+    const prefix = m[1] ? m[1].trim() + ' ' : '';
+    sigs.push(`${prefix}class ${m[2]}`);
+    const block = extractBlock(stripped, m.index + m[0].length);
+    for (const meth of extractClassMembers(block)) sigs.push(`  ${meth}`);
+  }
+
+  // Exported named functions
+  for (const m of stripped.matchAll(/^export\s+(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+    const asyncKw = /export\s+async/.test(m[0]) ? 'async ' : '';
+    sigs.push(`export ${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+  }
+
+  // Exported arrow functions
+  for (const m of stripped.matchAll(/^export\s+const\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*=>/gm)) {
+    const asyncKw = m[0].includes('async') ? 'async ' : '';
+    sigs.push(`export const ${m[1]} = ${asyncKw}(${normalizeParams(m[2])}) =>`);
+  }
+
+  // module.exports = { ... }
+  const moduleExports = stripped.match(/^module\.exports\s*=\s*\{([^}]+)\}/m);
+  if (moduleExports) {
+    const names = moduleExports[1].split(',').map((s) => s.trim()).filter(Boolean);
+    if (names.length > 0) sigs.push(`module.exports = { ${names.join(', ')} }`);
+  }
+
+  // Top-level named functions (non-exported)
+  for (const m of stripped.matchAll(/^(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+    const asyncKw = m[0].startsWith('async') ? 'async ' : '';
+    sigs.push(`${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function extractBlock(src, startIndex) {
+  let depth = 1;
+  let i = startIndex;
+  const end = Math.min(src.length, startIndex + 4000);
+  while (i < end && depth > 0) {
+    if (src[i] === '{') depth++;
+    else if (src[i] === '}') depth--;
+    i++;
+  }
+  return src.slice(startIndex, i - 1);
+}
+
+function extractClassMembers(block) {
+  const members = [];
+  for (const m of block.matchAll(/^\s+(?:static\s+|async\s+|get\s+|set\s+)*(\w+)\s*\(([^)]*)\)\s*\{/gm)) {
+    if (/^_/.test(m[1])) continue;
+    if (m[1] === 'constructor') { members.push(`constructor(${normalizeParams(m[2])})`); continue; }
+    const isAsync = m[0].includes('async ') ? 'async ' : '';
+    const isStatic = m[0].includes('static ') ? 'static ' : '';
+    members.push(`${isStatic}${isAsync}${m[1]}(${normalizeParams(m[2])})`);
+  }
+  return members.slice(0, 8);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim().replace(/\s+/g, ' ');
+}
+
+module.exports = { extract };

package/src/extractors/kotlin.js

@@ -0,0 +1,62 @@
+'use strict';
+
+/**
+ * Extract signatures from Kotlin source code.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const stripped = src
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Classes, objects, interfaces
+  for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:data\s+|sealed\s+|abstract\s+|open\s+)?(class|object|interface)\s+(\w+)(?:[^{]*)\{/gm)) {
+    sigs.push(`${m[1]} ${m[2]}`);
+    const block = extractBlock(stripped, m.index + m[0].length);
+    for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+  }
+
+  // Top-level functions
+  for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:suspend\s+)?fun\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    const suspend = m[0].includes('suspend') ? 'suspend ' : '';
+    sigs.push(`${suspend}fun ${m[1]}(${normalizeParams(m[2])})`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function extractBlock(src, startIndex) {
+  let depth = 1, i = startIndex;
+  const end = Math.min(src.length, startIndex + 4000);
+  while (i < end && depth > 0) {
+    if (src[i] === '{') depth++;
+    else if (src[i] === '}') depth--;
+    i++;
+  }
+  return src.slice(startIndex, i - 1);
+}
+
+function extractMembers(block) {
+  const members = [];
+  for (const m of block.matchAll(/^\s+(?:public\s+|internal\s+|override\s+)?(?:suspend\s+)?fun\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    if (m[1].startsWith('_')) continue;
+    const suspend = m[0].includes('suspend') ? 'suspend ' : '';
+    members.push(`${suspend}fun ${m[1]}(${normalizeParams(m[2])})`);
+  }
+  return members.slice(0, 8);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim()
+    .split(',')
+    .map((p) => p.trim().split(':')[0].trim())
+    .filter(Boolean)
+    .join(', ');
+}
+
+module.exports = { extract };

package/src/extractors/php.js

@@ -0,0 +1,62 @@
+'use strict';
+
+/**
+ * Extract signatures from PHP source code.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const stripped = src
+    .replace(/\/\/.*$/gm, '')
+    .replace(/#.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Classes and interfaces
+  const typeRe = /^(?:abstract\s+)?(?:class|interface|trait)\s+(\w+)(?:\s+extends\s+\w+)?(?:\s+implements\s+[\w, ]+)?\s*\{/gm;
+  for (const m of stripped.matchAll(typeRe)) {
+    const kind = m[0].trimStart().startsWith('interface') ? 'interface' :
+      m[0].trimStart().startsWith('trait') ? 'trait' : 'class';
+    sigs.push(`${kind} ${m[1]}`);
+    const block = extractBlock(stripped, m.index + m[0].length);
+    for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+  }
+
+  // Top-level functions
+  for (const m of stripped.matchAll(/^function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+    sigs.push(`function ${m[1]}(${normalizeParams(m[2])})`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function extractBlock(src, startIndex) {
+  let depth = 1, i = startIndex;
+  const end = Math.min(src.length, startIndex + 4000);
+  while (i < end && depth > 0) {
+    if (src[i] === '{') depth++;
+    else if (src[i] === '}') depth--;
+    i++;
+  }
+  return src.slice(startIndex, i - 1);
+}
+
+function extractMembers(block) {
+  const members = [];
+  const methodRe = /^\s+(?:public|protected)\s+(?:static\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm;
+  for (const m of block.matchAll(methodRe)) {
+    if (m[1].startsWith('_')) continue;
+    const isStatic = m[0].includes('static ') ? 'static ' : '';
+    members.push(`${isStatic}function ${m[1]}(${normalizeParams(m[2])})`);
+  }
+  return members.slice(0, 8);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim().replace(/\s+/g, ' ');
+}
+
+module.exports = { extract };

package/src/extractors/python.js

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * Extract signatures from Python source code.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Strip comments and docstrings (simple approach)
+  const stripped = src
+    .replace(/#.*$/gm, '')
+    .replace(/"""[\s\S]*?"""/g, '')
+    .replace(/'''[\s\S]*?'''/g, '');
+
+  // Classes
+  for (const m of stripped.matchAll(/^class\s+(\w+)(?:\s*\(([^)]*)\))?\s*:/gm)) {
+    const base = m[2] ? `(${m[2].trim()})` : '';
+    sigs.push(`class ${m[1]}${base}`);
+    // Get class body methods
+    const bodyStart = m.index + m[0].length;
+    const methods = extractClassMethods(stripped, bodyStart);
+    for (const meth of methods) sigs.push(`  ${meth}`);
+  }
+
+  // Top-level functions
+  for (const m of stripped.matchAll(/^(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)/gm)) {
+    if (/^_/.test(m[1])) continue; // skip private
+    const asyncKw = m[0].trimStart().startsWith('async') ? 'async ' : '';
+    const params = normalizeParams(m[2]);
+    sigs.push(`${asyncKw}def ${m[1]}(${params})`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function extractClassMethods(src, startIndex) {
+  const methods = [];
+  // Extract indented block
+  const lines = src.slice(startIndex).split('\n');
+  for (const line of lines) {
+    if (line.trim() === '') continue;
+    // End of class body: line with no leading indent that is not blank
+    const indent = line.match(/^(\s+)/);
+    if (!indent) break;
+    const m = line.match(/^\s+(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)/);
+    if (m) {
+      if (m[1].startsWith('__') && m[1] !== '__init__') continue;
+      if (m[1].startsWith('_') && !m[1].startsWith('__')) continue;
+      const asyncKw = line.trimStart().startsWith('async') ? 'async ' : '';
+      const params = normalizeParams(m[2]).replace(/^self,?\s*/, '');
+      methods.push(`${asyncKw}def ${m[1]}(${params})`);
+    }
+  }
+  return methods.slice(0, 8);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim()
+    .split(',')
+    .map((p) => p.trim().split(':')[0].split('=')[0].trim())
+    .filter(Boolean)
+    .join(', ');
+}
+
+module.exports = { extract };

package/src/extractors/ruby.js

@@ -0,0 +1,43 @@
+'use strict';
+
+/**
+ * Extract signatures from Ruby source code.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const stripped = src.replace(/#.*$/gm, '');
+
+  // Modules and classes
+  for (const m of stripped.matchAll(/^(?:module|class)\s+([\w:]+)(?:\s*<\s*[\w:]+)?\s*$/gm)) {
+    const kind = m[0].trimStart().startsWith('module') ? 'module' : 'class';
+    sigs.push(`${kind} ${m[1]}`);
+  }
+
+  // Public methods (not private/protected)
+  for (const m of stripped.matchAll(/^\s+def\s+(?:self\.)?(\w+)(?:\s*\(([^)]*)\))?/gm)) {
+    if (m[1].startsWith('_')) continue;
+    const params = m[2] ? `(${normalizeParams(m[2])})` : '';
+    const selfPrefix = m[0].includes('self.') ? 'self.' : '';
+    sigs.push(`  def ${selfPrefix}${m[1]}${params}`);
+  }
+
+  // Top-level def
+  for (const m of stripped.matchAll(/^def\s+(\w+)(?:\s*\(([^)]*)\))?/gm)) {
+    if (m[1].startsWith('_')) continue;
+    const params = m[2] ? `(${normalizeParams(m[2])})` : '';
+    sigs.push(`def ${m[1]}${params}`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim().replace(/\s+/g, ' ');
+}
+
+module.exports = { extract };

package/src/extractors/rust.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * Extract signatures from Rust source code.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const stripped = src
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Structs
+  for (const m of stripped.matchAll(/^pub\s+struct\s+(\w+)(?:<[^{]*>)?/gm)) {
+    sigs.push(`pub struct ${m[1]}`);
+  }
+
+  // Enums
+  for (const m of stripped.matchAll(/^pub\s+enum\s+(\w+)(?:<[^{]*>)?/gm)) {
+    sigs.push(`pub enum ${m[1]}`);
+  }
+
+  // Traits
+  for (const m of stripped.matchAll(/^pub\s+trait\s+(\w+)(?:<[^{]*>)?/gm)) {
+    sigs.push(`pub trait ${m[1]}`);
+  }
+
+  // impl blocks
+  for (const m of stripped.matchAll(/^impl(?:<[^>]*>)?\s+(?:[\w:]+\s+for\s+)?(\w+)(?:<[^{]*>)?\s*\{/gm)) {
+    sigs.push(`impl ${m[1]}`);
+    const block = extractBlock(stripped, m.index + m[0].length);
+    for (const fn of extractMethods(block)) sigs.push(`  ${fn}`);
+  }
+
+  // Top-level pub fns
+  for (const m of stripped.matchAll(/^pub(?:\s+async)?\s+fn\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    const asyncKw = m[0].includes('async') ? 'async ' : '';
+    sigs.push(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function extractBlock(src, startIndex) {
+  let depth = 1, i = startIndex;
+  const end = Math.min(src.length, startIndex + 5000);
+  while (i < end && depth > 0) {
+    if (src[i] === '{') depth++;
+    else if (src[i] === '}') depth--;
+    i++;
+  }
+  return src.slice(startIndex, i - 1);
+}
+
+function extractMethods(block) {
+  const methods = [];
+  for (const m of block.matchAll(/^\s+pub(?:\s+async)?\s+fn\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    const asyncKw = m[0].includes('async') ? 'async ' : '';
+    methods.push(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})`);
+  }
+  return methods.slice(0, 8);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim().replace(/\s+/g, ' ');
+}
+
+module.exports = { extract };

package/src/extractors/scala.js

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * Extract signatures from Scala source code.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const stripped = src
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Classes, traits, objects
+  const typeRe = /^(?:case\s+)?(?:class|trait|object)\s+(\w+)(?:\[[\w, ]+\])?(?:[^{]*)\{/gm;
+  for (const m of stripped.matchAll(typeRe)) {
+    const kind = m[0].trimStart().startsWith('case class') ? 'case class' :
+      m[0].trimStart().startsWith('trait') ? 'trait' :
+      m[0].trimStart().startsWith('object') ? 'object' : 'class';
+    sigs.push(`${kind} ${m[1]}`);
+    const block = extractBlock(stripped, m.index + m[0].length);
+    for (const fn of extractMembers(block)) sigs.push(`  ${fn}`);
+  }
+
+  // Top-level defs
+  for (const m of stripped.matchAll(/^def\s+(\w+)(?:\[[\w, ]+\])?\s*(?:\(([^)]*)\))?/gm)) {
+    if (m[1].startsWith('_')) continue;
+    const params = m[2] ? `(${normalizeParams(m[2])})` : '';
+    sigs.push(`def ${m[1]}${params}`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function extractBlock(src, startIndex) {
+  let depth = 1, i = startIndex;
+  const end = Math.min(src.length, startIndex + 4000);
+  while (i < end && depth > 0) {
+    if (src[i] === '{') depth++;
+    else if (src[i] === '}') depth--;
+    i++;
+  }
+  return src.slice(startIndex, i - 1);
+}
+
+function extractMembers(block) {
+  const members = [];
+  for (const m of block.matchAll(/^\s+def\s+(\w+)(?:\[[\w, ]+\])?\s*(?:\(([^)]*)\))?/gm)) {
+    if (m[1].startsWith('_')) continue;
+    const params = m[2] ? `(${normalizeParams(m[2])})` : '';
+    members.push(`def ${m[1]}${params}`);
+  }
+  return members.slice(0, 8);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim()
+    .split(',')
+    .map((p) => p.trim().split(':')[0].trim())
+    .filter(Boolean)
+    .join(', ');
+}
+
+module.exports = { extract };

package/src/extractors/shell.js

@@ -0,0 +1,43 @@
+'use strict';
+
+/**
+ * Extract signatures from shell scripts (bash, zsh, fish).
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const stripped = src.replace(/#.*$/gm, '');
+
+  // Function definitions (bash: name() { and function name {)
+  for (const m of stripped.matchAll(/^(?:function\s+)?([\w:-]+)\s*\(\s*\)\s*\{/gm)) {
+    if (m[1].startsWith('_')) continue;
+    sigs.push(`function ${m[1]}()`);
+  }
+
+  // Main entry point patterns
+  if (/^\s*main\s*\(/m.test(src) || /^\s*main\s+"?\$@/m.test(src)) {
+    sigs.push('main "$@"');
+  }
+
+  // Exported variables
+  for (const m of stripped.matchAll(/^export\s+([\w]+)=/gm)) {
+    sigs.push(`export ${m[1]}`);
+  }
+
+  // Script description (first non-comment line after shebang)
+  const lines = src.split('\n');
+  for (const line of lines.slice(0, 5)) {
+    if (line.startsWith('#!')) continue;
+    if (line.startsWith('#')) {
+      const desc = line.replace(/^#+\s*/, '').trim();
+      if (desc) { sigs.unshift(`# ${desc}`); break; }
+    }
+  }
+
+  return sigs.slice(0, 25);
+}
+
+module.exports = { extract };

package/src/extractors/svelte.js

@@ -0,0 +1,51 @@
+'use strict';
+
+/**
+ * Extract signatures from Svelte components.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Extract <script> block
+  const scriptMatch = src.match(/<script(?:\s[^>]*)?>(?:\s*)([\s\S]*?)<\/script>/i);
+  if (!scriptMatch) return sigs;
+
+  const script = scriptMatch[1]
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Exported props (writable)
+  for (const m of script.matchAll(/^\s+export\s+let\s+(\w+)(?:\s*=\s*[^;]+)?;/gm)) {
+    sigs.push(`export let ${m[1]}`);
+  }
+
+  // Exported functions
+  for (const m of script.matchAll(/^export\s+(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+    const asyncKw = m[0].includes('async') ? 'async ' : '';
+    sigs.push(`export ${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+  }
+
+  // Top-level functions
+  for (const m of script.matchAll(/^(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+    if (m[1].startsWith('_')) continue;
+    const asyncKw = m[0].startsWith('async') ? 'async ' : '';
+    sigs.push(`${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+  }
+
+  // Reactive declarations $:
+  for (const m of script.matchAll(/^\s+\$:\s+(\w+)\s*=/gm)) {
+    sigs.push(`$: ${m[1]}`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim().replace(/\s+/g, ' ');
+}
+
+module.exports = { extract };