@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-ROMM6KMC.js

@@ -0,0 +1,433 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/brain/brain.sql.ts
+var brain_sql_exports = {};
+__export(brain_sql_exports, {
+  BrainAnalysisFindingTable: () => BrainAnalysisFindingTable,
+  BrainAnalysisOccurrenceTable: () => BrainAnalysisOccurrenceTable,
+  BrainAnalysisRunTable: () => BrainAnalysisRunTable,
+  BrainFileTable: () => BrainFileTable,
+  BrainImportTable: () => BrainImportTable,
+  BrainIndexStatusTable: () => BrainIndexStatusTable,
+  BrainProjectHealthTable: () => BrainProjectHealthTable,
+  BrainQueryCacheTable: () => BrainQueryCacheTable,
+  BrainRelationshipTable: () => BrainRelationshipTable,
+  BrainSemanticEmbeddingTable: () => BrainSemanticEmbeddingTable,
+  BrainSymbolTable: () => BrainSymbolTable,
+  BrainTaintFlowTable: () => BrainTaintFlowTable
+});
+import { sqliteTable as sqliteTable2, text as text2, integer as integer2, real, blob, index } from "drizzle-orm/sqlite-core";
+
+// src/project/project.sql.ts
+var project_sql_exports = {};
+__export(project_sql_exports, {
+  ProjectTable: () => ProjectTable
+});
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+var ProjectTable = sqliteTable("project", {
+  id: text("id").primaryKey(),
+  workspace_id: text("workspace_id").notNull(),
+  name: text("name"),
+  time_created: integer("time_created").notNull(),
+  time_updated: integer("time_updated").notNull()
+});
+
+// src/brain/brain.sql.ts
+var Timestamps = {
+  time_created: integer2("time_created").notNull(),
+  time_updated: integer2("time_updated").notNull()
+};
+var BrainFileTable = sqliteTable2(
+  "brain_file",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    path: text2().notNull(),
+    relative_path: text2().notNull(),
+    file_hash: text2().notNull(),
+    size_bytes: integer2(),
+    line_count: integer2(),
+    language: text2(),
+    last_modified: real(),
+    indexed_at: text2(),
+    layer: text2(),
+    // e.g., "ui", "business", "data", "infrastructure"
+    is_test_file: integer2({ mode: "boolean" }),
+    is_config_file: integer2({ mode: "boolean" }),
+    is_documentation: integer2({ mode: "boolean" }),
+    framework_type: text2(),
+    // e.g., "react", "flutter", "express", "django"
+    has_syntax_errors: integer2({ mode: "boolean" }).notNull().default(false),
+    error_report: text2({ mode: "json" }),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_file_project_idx").on(table.project_id),
+    index("brain_file_path_idx").on(table.path),
+    index("brain_file_language_idx").on(table.language),
+    index("brain_file_hash_idx").on(table.file_hash),
+    index("brain_file_syntax_errors_idx").on(table.has_syntax_errors),
+    // COMPOUND INDEXES for ultra-fast lookups
+    index("brain_file_proj_path_idx").on(table.project_id, table.path),
+    index("brain_file_proj_hash_idx").on(table.project_id, table.file_hash)
+  ]
+);
+var BrainSymbolTable = sqliteTable2(
+  "brain_symbol",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    file_id: text2().notNull().references(() => BrainFileTable.id, { onDelete: "cascade" }),
+    name: text2().notNull(),
+    qualified_name: text2(),
+    // Full namespace/module path
+    symbol_type: text2().notNull(),
+    // "function", "class", "variable", "interface", "enum", "type", etc.
+    line_start: integer2(),
+    line_end: integer2(),
+    byte_start: integer2(),
+    byte_end: integer2(),
+    return_type: text2(),
+    parameters: text2({ mode: "json" }),
+    docstring: text2(),
+    visibility: text2(),
+    // "public", "private", "protected", "internal"
+    is_async: integer2({ mode: "boolean" }),
+    is_static: integer2({ mode: "boolean" }),
+    is_abstract: integer2({ mode: "boolean" }),
+    is_override: integer2({ mode: "boolean" }),
+    is_getter: integer2({ mode: "boolean" }),
+    is_setter: integer2({ mode: "boolean" }),
+    complexity: integer2(),
+    owner_symbol_id: text2(),
+    // Parent class/namespace
+    scope_kind: text2(),
+    // "global", "class", "function", "module"
+    is_declaration: integer2({ mode: "boolean" }),
+    // #612: analyzer-published declaration (c prototype, cpp/rust/zig signature form); NULL/0 = definition
+    annotations: text2({ mode: "json" }),
+    // Language-specific annotations/decorators
+    generic_parameters: text2({ mode: "json" }),
+    qualified_calls: text2({ mode: "json" }),
+    // ProxiCall-style: JSON array of qualified call strings extracted as-is
+    gravity_score: real().default(0),
+    layer: text2().default("core"),
+    api_contract_path: text2(),
+    // Deterministic mapping: Exact Route URL or Fetch URL for 100% accurate cross-language links
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_symbol_project_idx").on(table.project_id),
+    index("brain_symbol_file_idx").on(table.file_id),
+    index("brain_symbol_name_idx").on(table.name),
+    index("brain_symbol_type_idx").on(table.symbol_type),
+    index("brain_symbol_qualified_idx").on(table.qualified_name),
+    index("brain_symbol_owner_idx").on(table.owner_symbol_id),
+    // COMPOUND INDEXES for ultra-fast lookups
+    index("brain_sym_proj_file_idx").on(table.project_id, table.file_id),
+    index("brain_sym_proj_name_idx").on(table.project_id, table.name),
+    index("brain_sym_proj_type_idx").on(table.project_id, table.symbol_type),
+    // Tool query: find symbol by project + name + type (callers/callees trace)
+    index("brain_sym_proj_name_type_idx").on(table.project_id, table.name, table.symbol_type)
+  ]
+);
+var BrainRelationshipTable = sqliteTable2(
+  "brain_relationship",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    source_symbol_id: text2().references(() => BrainSymbolTable.id, { onDelete: "cascade" }),
+    target_symbol_id: text2().references(() => BrainSymbolTable.id, { onDelete: "set null" }),
+    source_external: text2(),
+    // For unresolved / external sources (when source is a string but symbol not declared)
+    target_external: text2(),
+    // For external dependencies
+    relationship_type: text2().notNull(),
+    // "calls", "extends", "implements", "uses", "imports", "exports", etc.
+    confidence: real().notNull(),
+    // 0.0 to 1.0 - AI confidence in relationship
+    context: text2(),
+    // Additional context about the relationship
+    line_number: integer2(),
+    // Where relationship occurs
+    is_cross_language: integer2({ mode: "boolean" }),
+    // True for relationships across languages
+    bridge_mechanism: text2(),
+    // How cross-language bridge works (API, FFI, etc.)
+    is_cross_file: integer2({ mode: "boolean" }).notNull().default(false),
+    // Fast UI stat index
+    metadata: text2({ mode: "json" }),
+    // Flexible metadata storage
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_rel_project_idx").on(table.project_id),
+    index("brain_rel_source_idx").on(table.source_symbol_id),
+    index("brain_rel_target_idx").on(table.target_symbol_id),
+    // Enrichment in-degree: GROUP BY target_symbol_id WHERE project_id
+    index("brain_rel_proj_target_idx").on(table.project_id, table.target_symbol_id),
+    index("brain_rel_type_idx").on(table.relationship_type),
+    index("brain_rel_confidence_idx").on(table.confidence),
+    index("brain_rel_cross_lang_idx").on(table.is_cross_language),
+    index("brain_rel_cross_file_idx").on(table.is_cross_file),
+    // COMPOUND INDEXES for ultra-fast lookups
+    index("brain_rel_proj_source_idx").on(table.project_id, table.source_symbol_id),
+    index("brain_rel_proj_target_idx").on(table.project_id, table.target_symbol_id),
+    index("brain_rel_proj_type_idx").on(table.project_id, table.relationship_type),
+    // Tool query: find callers/callees by target symbol + relationship type
+    index("brain_rel_target_type_idx").on(table.target_symbol_id, table.relationship_type),
+    // M29.R3: hover's cross-language probes (is_cross_language = 1 AND
+    // target/source_symbol_id = ?) need the composite form — see schema-ddl.ts.
+    index("brain_rel_target_cross_idx").on(table.target_symbol_id, table.is_cross_language),
+    index("brain_rel_source_cross_idx").on(table.source_symbol_id, table.is_cross_language)
+  ]
+);
+var BrainImportTable = sqliteTable2(
+  "brain_import",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    file_id: text2().notNull().references(() => BrainFileTable.id, { onDelete: "cascade" }),
+    imported_name: text2().notNull(),
+    imported_as: text2(),
+    // Alias name
+    import_path: text2().notNull(),
+    import_type: text2().notNull(),
+    // "default", "named", "namespace", "side_effect"
+    is_external: integer2({ mode: "boolean" }),
+    // External package vs internal
+    package_name: text2(),
+    // For external imports
+    line_number: integer2(),
+    is_dynamic: integer2({ mode: "boolean" }),
+    // Dynamic imports
+    resolved_symbol_id: text2(),
+    // Link to actual symbol if internal
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_import_project_idx").on(table.project_id),
+    index("brain_import_file_idx").on(table.file_id),
+    index("brain_import_path_idx").on(table.import_path),
+    index("brain_import_name_idx").on(table.imported_name),
+    index("brain_import_external_idx").on(table.is_external)
+  ]
+);
+var BrainTaintFlowTable = sqliteTable2(
+  "brain_taint_flow",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    source_symbol_id: text2().references(() => BrainSymbolTable.id, { onDelete: "cascade" }),
+    sink_symbol_id: text2().references(() => BrainSymbolTable.id, { onDelete: "cascade" }),
+    source_type: text2().notNull(),
+    // "user_input", "database_read", "network_receive"
+    sink_type: text2().notNull(),
+    // "database_write", "log_output", "shell_execution", "http_response"
+    vulnerability_type: text2().notNull(),
+    // "sql_injection", "xss", "pii_leak", "command_injection"
+    severity: text2().notNull(),
+    // "critical", "high", "medium", "low"
+    is_mitigated: integer2({ mode: "boolean" }).notNull().default(false),
+    flow_path: text2({ mode: "json" }),
+    // Array of intermediate symbol IDs
+    cross_language_boundaries: integer2().notNull().default(0),
+    mitigation_steps: text2({ mode: "json" }),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_taint_project_idx").on(table.project_id),
+    index("brain_taint_source_idx").on(table.source_symbol_id),
+    index("brain_taint_sink_idx").on(table.sink_symbol_id),
+    index("brain_taint_vuln_idx").on(table.vulnerability_type),
+    index("brain_taint_severity_idx").on(table.severity)
+  ]
+);
+var BrainAnalysisRunTable = sqliteTable2(
+  "brain_analysis_run",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    kind: text2().notNull(),
+    status: text2().notNull(),
+    engine_version: text2().notNull(),
+    input_hash: text2().notNull(),
+    started_at: integer2().notNull(),
+    completed_at: integer2(),
+    finding_count: integer2().notNull().default(0),
+    error: text2(),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_analysis_run_project_idx").on(table.project_id),
+    index("brain_analysis_run_kind_idx").on(table.kind),
+    index("brain_analysis_run_started_idx").on(table.started_at)
+  ]
+);
+var BrainAnalysisFindingTable = sqliteTable2(
+  "brain_analysis_finding",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    kind: text2().notNull(),
+    fingerprint: text2().notNull(),
+    rule: text2().notNull(),
+    title: text2().notNull(),
+    severity: text2().notNull(),
+    state: text2().notNull(),
+    confidence: real(),
+    evidence: text2({ mode: "json" }),
+    first_seen_at: integer2().notNull(),
+    last_seen_at: integer2().notNull(),
+    resolved_at: integer2(),
+    suppressed_at: integer2(),
+    mitigated_at: integer2(),
+    occurrence_count: integer2().notNull().default(0),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_analysis_finding_project_idx").on(table.project_id),
+    index("brain_analysis_finding_fingerprint_idx").on(table.project_id, table.kind, table.fingerprint),
+    index("brain_analysis_finding_state_idx").on(table.project_id, table.state)
+  ]
+);
+var BrainAnalysisOccurrenceTable = sqliteTable2(
+  "brain_analysis_occurrence",
+  {
+    id: text2().primaryKey(),
+    finding_id: text2().notNull().references(() => BrainAnalysisFindingTable.id, { onDelete: "cascade" }),
+    run_id: text2().notNull().references(() => BrainAnalysisRunTable.id, { onDelete: "cascade" }),
+    state: text2().notNull(),
+    location: text2(),
+    evidence: text2({ mode: "json" }),
+    observed_at: integer2().notNull(),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_analysis_occurrence_finding_idx").on(table.finding_id),
+    index("brain_analysis_occurrence_run_idx").on(table.run_id)
+  ]
+);
+var BrainQueryCacheTable = sqliteTable2(
+  "brain_query_cache",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    query_type: text2().notNull(),
+    // "call_graph", "impact_analysis", "feature_map", etc.
+    query_hash: text2().notNull(),
+    query_params: text2({ mode: "json" }),
+    result_data: text2({ mode: "json" }),
+    confidence: real().notNull(),
+    computation_time_ms: integer2(),
+    cache_expires_at: integer2(),
+    hit_count: integer2().notNull().default(0),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_cache_project_idx").on(table.project_id),
+    index("brain_cache_query_type_idx").on(table.query_type),
+    index("brain_cache_hash_idx").on(table.query_hash),
+    index("brain_cache_expires_idx").on(table.cache_expires_at)
+  ]
+);
+var BrainProjectHealthTable = sqliteTable2("brain_project_health", {
+  project_id: text2().$type().primaryKey().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  complexity_score: integer2().notNull().default(0),
+  // 0-100
+  maintainability_score: integer2().notNull().default(0),
+  // 0-100
+  technical_debt_score: integer2().notNull().default(0),
+  // 0-100
+  code_quality_score: integer2().notNull().default(0),
+  // 0-100
+  language_distribution: text2({ mode: "json" }),
+  // LanguageMetric[]
+  service_metrics: text2({ mode: "json" }),
+  // ServiceMetric[]
+  dependency_metrics: text2({ mode: "json" }),
+  // DependencyMetric
+  circular_dependencies: text2({ mode: "json" }),
+  // string[][]
+  contract_drift: text2({ mode: "json" }),
+  // string[]
+  performance_bottlenecks: text2({ mode: "json" }),
+  // string[]
+  ...Timestamps
+});
+var BrainIndexStatusTable = sqliteTable2("brain_index_status", {
+  project_id: text2().$type().primaryKey().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  status: text2(),
+  // M21.I2: persisted complete/partial status (previously dropped)
+  last_full_index: integer2(),
+  // Timestamp
+  last_incremental_index: integer2(),
+  total_files: integer2().notNull().default(0),
+  indexed_files: integer2().notNull().default(0),
+  total_symbols: integer2().notNull().default(0),
+  total_relationships: integer2().notNull().default(0),
+  indexing_version: text2().notNull(),
+  // Schema version for migrations
+  languages_detected: text2({ mode: "json" }),
+  // Array of languages found
+  frameworks_detected: text2({ mode: "json" }),
+  // Array of frameworks detected
+  indexing_errors: text2({ mode: "json" }),
+  // Array of error messages
+  performance_stats: text2({ mode: "json" }),
+  // Indexing performance metrics
+  ...Timestamps
+});
+var BrainSemanticEmbeddingTable = sqliteTable2(
+  "brain_semantic_embedding",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    entity_id: text2().notNull(),
+    // Can be symbol_id, file_id, or pattern_id
+    entity_type: text2().notNull(),
+    // "symbol", "file", "pattern", "comment", "documentation"
+    embedding_model: text2().notNull(),
+    // "openai-ada-002", "sentence-transformers", etc.
+    embedding_vector: text2().notNull(),
+    // "" for dense rows (blob is authoritative); JSON for sparse/legacy rows
+    // Dense vectors are stored ONCE here as little-endian float32 (2026-11-01 contract);
+    // NULL on legacy rows (readers then scan embedding_vector). See vector-binary.ts.
+    embedding_blob: blob("embedding_blob", { mode: "buffer" }),
+    vector_dimension: integer2().notNull(),
+    content_hash: text2().notNull(),
+    // Hash of content that generated embedding
+    semantic_context: text2({ mode: "json" }),
+    // Additional context for better search
+    similarity_threshold: real().default(0.7),
+    // Minimum similarity for matches
+    last_updated: integer2().notNull(),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_embed_project_idx").on(table.project_id),
+    index("brain_embed_entity_idx").on(table.entity_id),
+    index("brain_embed_type_idx").on(table.entity_type),
+    index("brain_embed_model_idx").on(table.embedding_model),
+    index("brain_embed_hash_idx").on(table.content_hash)
+  ]
+);
+
+export {
+  project_sql_exports,
+  BrainFileTable,
+  BrainSymbolTable,
+  BrainRelationshipTable,
+  BrainImportTable,
+  BrainTaintFlowTable,
+  BrainAnalysisRunTable,
+  BrainAnalysisFindingTable,
+  BrainAnalysisOccurrenceTable,
+  BrainQueryCacheTable,
+  BrainProjectHealthTable,
+  BrainIndexStatusTable,
+  BrainSemanticEmbeddingTable,
+  brain_sql_exports
+};

package/dist/chunk-SK6YVHFZ.js

@@ -0,0 +1,211 @@
+import {
+  bbWasmCandidates,
+  bbWasmDirs
+} from "./chunk-2BSKD7O3.js";
+
+// src/util/wasm.ts
+import { createRequire } from "module";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var require2 = createRequire(import.meta.url);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var _wtsModule = null;
+var _wasmRegistry = {};
+var _wasiShimInstalled = false;
+function installWasiShim() {
+  if (_wasiShimInstalled) return;
+  _wasiShimInstalled = true;
+  let currentImports = null;
+  const memOf = () => currentImports?.env?.memory;
+  const view = () => {
+    const mem = memOf();
+    return mem ? new DataView(mem.buffer) : null;
+  };
+  const writeInt32 = (ptr, value) => {
+    const v = view();
+    if (v && Number.isFinite(ptr)) v.setInt32(ptr, value, true);
+  };
+  const writeBigInt = (ptr, value) => {
+    const v = view();
+    if (v && Number.isFinite(ptr)) v.setBigUint64(ptr, value, true);
+  };
+  const wasi = {
+    clock_time_get: (_clockId, _precisionPtr, timePtr) => {
+      writeBigInt(timePtr, BigInt(Date.now()) * 1000000n);
+      return 0;
+    },
+    proc_exit: () => {
+    },
+    fd_write: (_fd, _iov, _iovcnt, pnum) => {
+      writeInt32(pnum, 0);
+      return 0;
+    },
+    fd_read: () => -1,
+    fd_close: () => 0,
+    fd_seek: () => -1,
+    fd_fdstat_get: () => -1,
+    fd_fdstat_set_flags: () => -1,
+    fd_prestat_get: () => -1,
+    fd_prestat_dir_name: () => -1,
+    fd_sync: () => -1,
+    random_get: (buf, len) => {
+      const v = view();
+      if (v) for (let i = 0; i < len; i++) v.setUint8(buf + i, Math.floor(Math.random() * 256));
+      return 0;
+    },
+    environ_get: () => 0,
+    environ_sizes_get: (countPtr, sizePtr) => {
+      writeInt32(countPtr, 0);
+      writeInt32(sizePtr, 0);
+      return 0;
+    },
+    args_get: () => 0,
+    args_sizes_get: (countPtr, sizePtr) => {
+      writeInt32(countPtr, 0);
+      writeInt32(sizePtr, 0);
+      return 0;
+    },
+    sched_yield: () => 0,
+    poll_oneoff: () => 0,
+    path_open: () => -1,
+    path_filestat_get: () => -1,
+    path_filestat_set_times: () => -1,
+    path_create_directory: () => -1,
+    path_remove_directory: () => -1,
+    path_unlink_file: () => -1,
+    path_rename: () => -1,
+    path_link: () => -1,
+    path_symlink: () => -1,
+    path_readlink: () => -1,
+    path_filestat_set_size: () => -1,
+    clock_res_get: (_clockId, resPtr) => {
+      writeBigInt(resPtr, 1000000n);
+      return 0;
+    }
+  };
+  const patchImports = (imports) => {
+    if (!imports || typeof imports !== "object") return imports;
+    currentImports = imports;
+    if (imports.wasi_snapshot_preview1) {
+      imports.wasi_snapshot_preview1 = { ...imports.wasi_snapshot_preview1, ...wasi };
+    }
+    return imports;
+  };
+  const origInstantiate = WebAssembly.instantiate;
+  const origInstantiateStreaming = WebAssembly.instantiateStreaming;
+  WebAssembly.instantiate = async (bytes, imports) => {
+    if (imports) imports = patchImports(imports);
+    return origInstantiate.call(WebAssembly, bytes, imports);
+  };
+  WebAssembly.instantiateStreaming = async (resp, imports) => {
+    if (imports) imports = patchImports(imports);
+    return origInstantiateStreaming.call(WebAssembly, resp, imports);
+  };
+}
+function tryLoadWasm(name) {
+  if (_wasmRegistry[name]) return;
+  const paths = bbWasmCandidates(dirname(fileURLToPath(import.meta.url)), name);
+  for (const p of paths) {
+    if (existsSync(p)) {
+      try {
+        _wasmRegistry[name] = new Uint8Array(readFileSync(p));
+        return;
+      } catch {
+      }
+    }
+  }
+}
+async function ensureWasmRegistry() {
+  const dirs = bbWasmDirs(__dirname);
+  for (const wasmDir of dirs) {
+    if (existsSync(wasmDir)) {
+      try {
+        const files = (await import("fs")).readdirSync(wasmDir);
+        for (const f of files) {
+          if (f.endsWith(".wasm") && !_wasmRegistry[f]) {
+            try {
+              _wasmRegistry[f] = new Uint8Array(readFileSync(join(wasmDir, f)));
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function loadWebTreeSitter() {
+  if (!_wtsModule) {
+    installWasiShim();
+    _wtsModule = await import("web-tree-sitter");
+    const initFn = _wtsModule.default?.init || _wtsModule.init;
+    if (initFn) {
+      const coreName = "tree-sitter.wasm";
+      const coreBytes = hasWasmInRegistry(coreName);
+      const coreAbs = resolveWasmAsset(coreName);
+      const initOptions = {};
+      if (coreBytes) initOptions.wasmBinary = coreBytes;
+      if (coreAbs !== coreName) initOptions.locateFile = () => coreAbs;
+      await initFn(initOptions);
+    }
+  }
+  return _wtsModule;
+}
+function resolveWasmAsset(name) {
+  const wasmName = name.split("/").pop() || name;
+  const paths = bbWasmCandidates(dirname(fileURLToPath(import.meta.url)), wasmName);
+  for (const p of paths) {
+    if (existsSync(p)) return p;
+  }
+  return name;
+}
+function hasWasmInRegistry(name) {
+  const wasmName = name.split("/").pop() || name;
+  tryLoadWasm(wasmName);
+  if (_wasmRegistry[wasmName]) return _wasmRegistry[wasmName];
+  if (_wasmRegistry[name]) return _wasmRegistry[name];
+  const paths = bbWasmCandidates(dirname(fileURLToPath(import.meta.url)), wasmName);
+  for (const p of paths) {
+    if (existsSync(p)) {
+      try {
+        const data = new Uint8Array(readFileSync(p));
+        _wasmRegistry[wasmName] = data;
+        return data;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function isWasmRegistryLoaded() {
+  return false;
+}
+(function _autoLoadWasm() {
+  const dirs = bbWasmDirs(__dirname);
+  for (const wasmDir of dirs) {
+    if (existsSync(wasmDir)) {
+      try {
+        const files = readdirSync(wasmDir);
+        for (const f of files) {
+          if (f.endsWith(".wasm") && !_wasmRegistry[f]) {
+            try {
+              _wasmRegistry[f] = new Uint8Array(readFileSync(join(wasmDir, f)));
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+})();
+
+export {
+  ensureWasmRegistry,
+  loadWebTreeSitter,
+  resolveWasmAsset,
+  hasWasmInRegistry,
+  isWasmRegistryLoaded
+};