@jbearak/sight 0.15.0 → 0.15.1

package/dist/sight-server.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@jbearak/sight",
-    version: "0.15.0",
+    version: "0.15.1",
     type: "module",
     workspaces: [
       "client"
@@ -2357,6 +2357,9 @@ function ascii_to_lower(c) {
     return String.fromCharCode(code + 32);
   return c;
 }
+function ascii_case_fold(text) {
+  return text.replace(ASCII_UPPERCASE_PATTERN, ascii_to_lower);
+}
 function ascii_ci_equal(a, b) {
   if (a.length !== b.length)
     return false;
@@ -2425,12 +2428,17 @@ function resolve_path_rich(resolved_fs_path, options) {
     return { kind: "exact", path: chosen_root };
   }
   const the_components = remainder.split(sep2);
-  let current_dir = chosen_root;
-  let had_case_mismatch = false;
   const join_path = (dir, name) => dir.endsWith(sep2) ? `${dir}${name}` : `${dir}${sep2}${name}`;
-  for (let comp_idx = 0;comp_idx < the_components.length; comp_idx++) {
+  let directory_reads_left = the_components.length + MAX_CASE_VARIANT_BACKTRACK_READS;
+  let budget_exhausted = false;
+  const walk = (current_dir, comp_idx, had_case_mismatch) => {
     const my_component = the_components[comp_idx];
     const my_is_final = comp_idx === the_components.length - 1;
+    if (directory_reads_left <= 0) {
+      budget_exhausted = true;
+      return { kind: "missing", requested: resolved_fs_path };
+    }
+    directory_reads_left--;
     let my_entries;
     try {
       my_entries = the_fs.readdirSync(current_dir, {
@@ -2442,20 +2450,43 @@ function resolve_path_rich(resolved_fs_path, options) {
     if (!my_is_final) {
       const my_exact = my_entries.find((e) => e.name === my_component && entry_is_dir(e, join_path(current_dir, e.name), the_fs));
       if (my_exact !== undefined) {
-        current_dir = join_path(current_dir, my_exact.name);
-        continue;
+        const my_outcome = walk(join_path(current_dir, my_exact.name), comp_idx + 1, had_case_mismatch);
+        if (my_outcome.kind !== "missing") {
+          return my_outcome;
+        }
       }
-      const the_ci_dirs = my_entries.filter((e) => ascii_ci_equal(e.name, my_component) && entry_is_dir(e, join_path(current_dir, e.name), the_fs));
-      if (the_ci_dirs.length === 1) {
-        had_case_mismatch = true;
-        current_dir = join_path(current_dir, the_ci_dirs[0].name);
-        continue;
+      const the_hits = [];
+      for (const my_entry of my_entries) {
+        if (my_entry.name === my_component || !ascii_ci_equal(my_entry.name, my_component) || !entry_is_dir(my_entry, join_path(current_dir, my_entry.name), the_fs)) {
+          continue;
+        }
+        const my_outcome = walk(join_path(current_dir, my_entry.name), comp_idx + 1, true);
+        if (my_outcome.kind === "ambiguous") {
+          the_hits.push(...my_outcome.matches);
+        } else if (my_outcome.kind !== "missing") {
+          the_hits.push(my_outcome.path);
+        }
+        if (the_hits.length > 1) {
+          return {
+            kind: "ambiguous",
+            requested: resolved_fs_path,
+            matches: the_hits
+          };
+        }
       }
-      if (the_ci_dirs.length > 1) {
+      if (budget_exhausted) {
         return {
           kind: "ambiguous",
           requested: resolved_fs_path,
-          matches: the_ci_dirs.map((e) => join_path(current_dir, e.name))
+          matches: the_hits,
+          truncated: true
+        };
+      }
+      if (the_hits.length === 1) {
+        return {
+          kind: "case_only",
+          path: the_hits[0],
+          requested: resolved_fs_path
         };
       }
       return { kind: "missing", requested: resolved_fs_path };
@@ -2504,8 +2535,8 @@ function resolve_path_rich(resolved_fs_path, options) {
       };
     }
     return { kind: "missing", requested: resolved_fs_path };
-  }
-  return { kind: "missing", requested: resolved_fs_path };
+  };
+  return walk(chosen_root, 0, false);
 }
 function host_is_case_sensitive(seed_existing_dir, fs3) {
   if (fs3 !== undefined) {
@@ -2575,6 +2606,31 @@ function is_resolvable_static_call(call) {
 function outcome_fs_path(outcome) {
   return outcome.kind === "exact" || outcome.kind === "case_only" ? outcome.path : outcome.requested;
 }
+function case_only_matched_directory(outcome) {
+  const dir_of = (fs_path) => node_path.posix.dirname(fs_path.replace(/\\/g, "/"));
+  return dir_of(outcome.path) !== dir_of(outcome.requested);
+}
+function case_mismatch_display_paths(raw_path, outcome, display_dir) {
+  const my_normalized_raw = raw_path.replace(/\\/g, "/");
+  const my_is_abs = node_path.isAbsolute(my_normalized_raw) || /^[a-zA-Z]:\//.test(my_normalized_raw);
+  const the_raw_parts = my_normalized_raw.split("/").filter((my_part) => my_part.length > 0);
+  const my_count = the_raw_parts.length;
+  const the_requested_parts = outcome.requested.replace(/\\/g, "/").split("/");
+  const the_real_parts = outcome.path.replace(/\\/g, "/").split("/");
+  const my_base_count = the_requested_parts.length - my_count;
+  const my_pairs = !my_is_abs && my_count > 0 && the_raw_parts.every((my_part) => my_part !== "." && my_part !== "..") && my_base_count >= 0 && the_real_parts.length === the_requested_parts.length && the_requested_parts.slice(my_base_count).join("/") === the_raw_parts.join("/") && the_requested_parts.slice(0, my_base_count).join("/") === the_real_parts.slice(0, my_base_count).join("/");
+  if (my_pairs) {
+    return {
+      requested: the_raw_parts.join("/"),
+      on_disk: the_real_parts.slice(-my_count).join("/")
+    };
+  }
+  const relative_to_display_dir = (fs_path) => node_path.relative(display_dir, fs_path).replace(/\\/g, "/") || fs_path;
+  return {
+    requested: relative_to_display_dir(outcome.requested),
+    on_disk: relative_to_display_dir(outcome.path)
+  };
+}
 function resolve_forward_call_rich(raw_path, caller_dir, working_directory, options) {
   const my_normalized_raw = raw_path.replace(/\\/g, "/");
   const my_is_abs = node_path.isAbsolute(my_normalized_raw) || /^[a-zA-Z]:\//.test(my_normalized_raw);
@@ -2657,6 +2713,7 @@ function build_cd_timeline(params) {
   const { starting_wd, caller_dir, cd_commands, workspace_roots, fs: fs3 } = params;
   const the_diagnostics = [];
   const the_entries = [];
+  let depends_on_directory_casing = false;
   const the_statics = (cd_commands ?? []).filter((c) => c.is_static && c.raw_path.length > 0).sort((a, b) => position_before(a.range.start, b.range.start) ? -1 : position_before(b.range.start, a.range.start) ? 1 : 0);
   let current_wd = starting_wd;
   for (const my_cd of the_statics) {
@@ -2672,6 +2729,7 @@ function build_cd_timeline(params) {
       current_wd = my_outcome.path;
     } else if (my_outcome.kind === "case_only") {
       current_wd = my_outcome.path;
+      depends_on_directory_casing = true;
       the_diagnostics.push(make_cd_case_mismatch_diagnostic(my_cd, my_outcome, caller_dir, workspace_roots));
     } else if (my_outcome.kind === "missing") {
       current_wd = my_outcome.requested;
@@ -2683,8 +2741,9 @@ function build_cd_timeline(params) {
         code: "CROSS_FILE_MISSING_FILE" /* CROSS_FILE_MISSING_FILE */
       });
     } else {
+      depends_on_directory_casing = true;
       the_diagnostics.push({
-        message: `Ambiguous directory for cd: "${my_cd.raw_path}" ` + `(multiple case-insensitive matches)`,
+        message: `Ambiguous directory for cd: "${my_cd.raw_path}" ` + (my_outcome.truncated ? `(too many case-variant directories to search)` : `(multiple case-insensitive matches)`),
         range: my_cd.range,
         severity: "warning",
         kind: "missing_directory",
@@ -2695,15 +2754,15 @@ function build_cd_timeline(params) {
   }
   return {
     timeline: { starting_wd, entries: the_entries },
-    diagnostics: the_diagnostics
+    diagnostics: the_diagnostics,
+    depends_on_directory_casing
   };
 }
 function make_cd_case_mismatch_diagnostic(cd, outcome, caller_dir, workspace_roots) {
-  const my_req_disp = node_path.relative(caller_dir, outcome.requested).replace(/\\/g, "/") || outcome.requested;
-  const my_real_disp = node_path.relative(caller_dir, outcome.path).replace(/\\/g, "/") || outcome.path;
+  const my_display = case_mismatch_display_paths(cd.raw_path, outcome, caller_dir);
   const my_seed = workspace_roots ? get_workspace_root_for_path(workspace_roots, outcome.path) ?? node_path.dirname(outcome.path) : node_path.dirname(outcome.path);
   return {
-    message: `Path "${my_req_disp}" does not match the directory on disk ` + `"${my_real_disp}"; Stata will not find it on case-sensitive ` + `filesystems (Linux). Update the path to match.`,
+    message: `Path "${my_display.requested}" does not match the directory ` + `on disk "${my_display.on_disk}"; Stata will not find it on ` + `case-sensitive filesystems (Linux). Update the path to match.`,
     range: cd.range,
     severity: "warning",
     kind: "path_case_mismatch",
@@ -2722,7 +2781,7 @@ function apply_cd_timeline(forward_calls, timeline) {
     };
   });
 }
-var FILE_COMMANDS, PATH_DIRECTIVES, STATA_FILE_EXTENSIONS, VCS_METADATA_DIRS, entry_is_dir, entry_is_file, case_sensitivity_cache;
+var FILE_COMMANDS, PATH_DIRECTIVES, STATA_FILE_EXTENSIONS, VCS_METADATA_DIRS, MAX_CASE_VARIANT_BACKTRACK_READS = 256, ASCII_UPPERCASE_PATTERN, entry_is_dir, entry_is_file, case_sensitivity_cache;
 var init_file_path_utils = __esm(() => {
   init_types();
   init_workspace_roots();
@@ -2755,6 +2814,7 @@ var init_file_path_utils = __esm(() => {
   ]);
   STATA_FILE_EXTENSIONS = [".do", ".ado", ".doh", ".mata"];
   VCS_METADATA_DIRS = new Set([".git", ".hg", ".svn"]);
+  ASCII_UPPERCASE_PATTERN = /[A-Z]/g;
   entry_is_dir = entry_is_directory_sync;
   entry_is_file = entry_is_file_sync;
   case_sensitivity_cache = new Map;
@@ -22010,6 +22070,11 @@ function build_forward_closure_key(inputs) {
     inputs.dep_graph_version
   ]);
 }
+function mark_directory_casing(collector) {
+  if (collector !== undefined) {
+    collector.depends_on_directory_casing = true;
+  }
+}
 
 class ForwardScopeResolver {
   scope_resolver;
@@ -22034,6 +22099,7 @@ class ForwardScopeResolver {
   };
   standalone_in_flight = new Set;
   active_probe_collectors = [];
+  collector_by_visited = new WeakMap;
   dependency_graph;
   constructor(scope_resolver, config = {}) {
     this.scope_resolver = scope_resolver;
@@ -22066,7 +22132,7 @@ class ForwardScopeResolver {
   }
   invalidate_forward_closure_for_uri(uri) {
     this.memo_invalidation_epoch++;
-    const the_keys = this.memo_uri_to_keys.get(uri);
+    const the_keys = this.memo_uri_to_keys.get(this.memo_index_key(uri));
     if (!the_keys) {
       return 0;
     }
@@ -22096,15 +22162,19 @@ class ForwardScopeResolver {
   }
   prune_memo_uri_to_keys_for_entry(key, entry) {
     for (const my_dep_uri of entry.dependent_uris) {
-      const my_key_set = this.memo_uri_to_keys.get(my_dep_uri);
+      const my_index_key = this.memo_index_key(my_dep_uri);
+      const my_key_set = this.memo_uri_to_keys.get(my_index_key);
       if (my_key_set) {
         my_key_set.delete(key);
         if (my_key_set.size === 0) {
-          this.memo_uri_to_keys.delete(my_dep_uri);
+          this.memo_uri_to_keys.delete(my_index_key);
         }
       }
     }
   }
+  memo_index_key(uri) {
+    return ascii_case_fold(uri);
+  }
   set_forward_closure_memo_capacity(max_entries) {
     this.forward_closure_memo.set_max_size(max_entries);
   }
@@ -22118,7 +22188,7 @@ class ForwardScopeResolver {
     for (const my_fs_path of fs_paths) {
       const my_probe_uri = URI.file(my_fs_path).toString();
       for (const my_collector of this.active_probe_collectors) {
-        my_collector.add(my_probe_uri);
+        my_collector.probes.add(my_probe_uri);
       }
     }
   }
@@ -22137,7 +22207,7 @@ class ForwardScopeResolver {
     const resolved = path5.resolve(fs_path);
     return this.workspace_roots.some((root) => resolved.startsWith(root + path5.sep) || resolved === root);
   }
-  resolve_call_path(raw_path, caller_uri, working_directory) {
+  resolve_call_path(raw_path, caller_uri, working_directory, casing_collector) {
     const my_caller_dir = path5.dirname(URI.parse(caller_uri).fsPath);
     const my_missed_candidates = this.active_probe_collectors.length > 0 ? [] : undefined;
     const my_outcome = resolve_forward_call_rich(raw_path, my_caller_dir, working_directory, {
@@ -22155,6 +22225,9 @@ class ForwardScopeResolver {
       };
     }
     if (my_outcome.kind === "case_only") {
+      if (case_only_matched_directory(my_outcome)) {
+        mark_directory_casing(casing_collector);
+      }
       const my_seed = this.find_seed_dir(my_outcome.path);
       return {
         resolved_path: my_outcome.path,
@@ -22171,13 +22244,16 @@ class ForwardScopeResolver {
   find_seed_dir(fs_path) {
     return get_workspace_root_for_path(this.workspace_roots, fs_path) ?? path5.dirname(fs_path);
   }
-  resolve_call_path_simple(raw_path, caller_uri, working_directory) {
+  resolve_call_path_simple(raw_path, caller_uri, working_directory, casing_collector) {
     const my_caller_dir = path5.dirname(URI.parse(caller_uri).fsPath);
     const my_outcome = resolve_forward_call_rich(raw_path, my_caller_dir, working_directory, {
       workspace_roots: this.workspace_roots.length > 0 ? this.workspace_roots : undefined,
       fs: this.resolve_fs
     });
     if (my_outcome.kind === "exact" || my_outcome.kind === "case_only") {
+      if (my_outcome.kind === "case_only" && case_only_matched_directory(my_outcome)) {
+        mark_directory_casing(casing_collector);
+      }
       return my_outcome.path;
     }
     return null;
@@ -22205,13 +22281,21 @@ class ForwardScopeResolver {
     const the_call_sites = [];
     let accumulated_symbols = create_empty_symbol_table();
     const my_caller_dir = path5.dirname(URI.parse(file_uri).fsPath);
-    const { timeline: cd_timeline, diagnostics: cd_diagnostics } = build_cd_timeline({
+    const my_casing_collector = this.collector_by_visited.get(my_context.visited);
+    const {
+      timeline: cd_timeline,
+      diagnostics: cd_diagnostics,
+      depends_on_directory_casing
+    } = build_cd_timeline({
       starting_wd: my_context.working_directory,
       caller_dir: my_caller_dir,
       cd_commands: my_context.cd_commands ?? [],
       workspace_roots: this.workspace_roots.length > 0 ? this.workspace_roots : undefined,
       fs: this.resolve_fs
     });
+    if (depends_on_directory_casing) {
+      mark_directory_casing(my_casing_collector);
+    }
     if (my_context.diagnostic_owner_uri !== undefined && file_uri === my_context.diagnostic_owner_uri && my_context.depth === 0) {
       const my_source_filename = path5.basename(URI.parse(file_uri).fsPath);
       for (const my_cd_diag of cd_diagnostics) {
@@ -22258,16 +22342,16 @@ class ForwardScopeResolver {
         break;
       }
       const my_effective_type = this.compute_effective_call_type(my_call.type, my_context.effective_call_type);
-      const my_path_result = this.resolve_call_path(my_call.raw_path, file_uri, effective_call_wd);
+      const my_path_result = this.resolve_call_path(my_call.raw_path, file_uri, effective_call_wd, my_casing_collector);
       const resolved_path = my_path_result.resolved_path;
       const callee_uri = URI.file(resolved_path).toString();
       if (my_path_result.outcome_kind === "case_only" && my_context.diagnostic_owner_uri !== undefined && file_uri === my_context.diagnostic_owner_uri && my_context.depth === 0) {
-        const my_requested = my_path_result.requested_path ?? my_call.raw_path;
-        const my_real = my_path_result.resolved_path;
-        const my_req_disp = path5.relative(path5.dirname(URI.parse(file_uri).fsPath), my_requested).replace(/\\/g, "/") || my_requested;
-        const my_real_disp = path5.relative(path5.dirname(URI.parse(file_uri).fsPath), my_real).replace(/\\/g, "/") || my_real;
+        const my_display = case_mismatch_display_paths(my_call.raw_path, {
+          path: my_path_result.resolved_path,
+          requested: my_path_result.requested_path ?? my_call.raw_path
+        }, path5.dirname(URI.parse(file_uri).fsPath));
         my_context.diagnostics.push({
-          message: `Path "${my_req_disp}" does not match the file ` + `on disk "${my_real_disp}"; Stata will not find ` + `it on case-sensitive filesystems (Linux). ` + `Update the path to match.`,
+          message: `Path "${my_display.requested}" does not match ` + `the file on disk "${my_display.on_disk}"; ` + `Stata will not find ` + `it on case-sensitive filesystems (Linux). ` + `Update the path to match.`,
           range: my_call.range,
           severity: "warning",
           kind: "path_case_mismatch",
@@ -22315,7 +22399,7 @@ class ForwardScopeResolver {
         if ("error" in callee_result) {
           continue;
         }
-        const effective_end_state = await this.compute_effective_end_state_locals(callee_uri, resolved_path, callee_result.working_directory ?? effective_call_wd, new Set(my_stack), my_context.depth + 1, resolved_config, token);
+        const effective_end_state = await this.compute_effective_end_state_locals(callee_uri, resolved_path, callee_result.working_directory ?? effective_call_wd, new Set(my_stack), my_context.depth + 1, resolved_config, token, my_casing_collector);
         const boundary_excluded = effective_end_state.size > 0 ? effective_end_state : undefined;
         the_call_sites.push({
           callee_uri,
@@ -22363,7 +22447,7 @@ class ForwardScopeResolver {
       }
       let excluded_locals;
       if (my_call.type !== "include" && my_effective_type === "do" && my_context.depth === 0) {
-        const effective_end_state = await this.compute_effective_end_state_locals(callee_uri, resolved_path, callee_result.working_directory ?? effective_call_wd, new Set(my_stack), my_context.depth + 1, resolved_config, token);
+        const effective_end_state = await this.compute_effective_end_state_locals(callee_uri, resolved_path, callee_result.working_directory ?? effective_call_wd, new Set(my_stack), my_context.depth + 1, resolved_config, token, my_casing_collector);
         if (effective_end_state.size > 0) {
           excluded_locals = effective_end_state;
         }
@@ -22465,8 +22549,12 @@ class ForwardScopeResolver {
     const fresh_diagnostics = [];
     this.memo_metrics.misses++;
     this.standalone_in_flight.add(callee_uri);
-    const my_probe_collector = new Set;
+    const my_probe_collector = {
+      probes: new Set,
+      depends_on_directory_casing: false
+    };
     this.active_probe_collectors.push(my_probe_collector);
+    this.collector_by_visited.set(fresh_visited, my_probe_collector);
     let standalone;
     try {
       standalone = await this.resolve(callee_uri, forward_calls, effective_call_type, {
@@ -22489,6 +22577,7 @@ class ForwardScopeResolver {
       if (my_collector_index >= 0) {
         this.active_probe_collectors.splice(my_collector_index, 1);
       }
+      this.collector_by_visited.delete(fresh_visited);
     }
     if (token?.isCancellationRequested) {
       return;
@@ -22502,9 +22591,9 @@ class ForwardScopeResolver {
     const dependent_uris = new Set([
       callee_uri,
       ...fresh_visited.keys(),
-      ...my_probe_collector
+      ...my_probe_collector.probes
     ]);
-    if (fresh_diagnostics.length > 0) {
+    if (fresh_diagnostics.length > 0 || my_probe_collector.depends_on_directory_casing) {
       return this.store_memo_entry(key, {
         kind: "unservable",
         dependent_uris
@@ -22525,10 +22614,11 @@ class ForwardScopeResolver {
     }
     this.forward_closure_memo.set(key, entry);
     for (const my_dep_uri of entry.dependent_uris) {
-      let my_key_set = this.memo_uri_to_keys.get(my_dep_uri);
+      const my_index_key = this.memo_index_key(my_dep_uri);
+      let my_key_set = this.memo_uri_to_keys.get(my_index_key);
       if (!my_key_set) {
         my_key_set = new Set;
-        this.memo_uri_to_keys.set(my_dep_uri, my_key_set);
+        this.memo_uri_to_keys.set(my_index_key, my_key_set);
       }
       my_key_set.add(key);
     }
@@ -22581,7 +22671,7 @@ class ForwardScopeResolver {
     }
     return result;
   }
-  async compute_effective_end_state_locals(callee_uri, callee_fs_path, working_directory, stack, depth, resolved_config, token) {
+  async compute_effective_end_state_locals(callee_uri, callee_fs_path, working_directory, stack, depth, resolved_config, token, casing_collector) {
     if (token?.isCancellationRequested)
       return new Map;
     if (stack.has(callee_uri))
@@ -22633,13 +22723,19 @@ class ForwardScopeResolver {
       the_events.sort((a, b) => a.line - b.line || a.character - b.character);
       const the_effective = new Map;
       const nested_base_wd = callee_result.working_directory ?? working_directory;
-      const { timeline: nested_cd_timeline } = build_cd_timeline({
+      const {
+        timeline: nested_cd_timeline,
+        depends_on_directory_casing: nested_depends_on_casing
+      } = build_cd_timeline({
         starting_wd: nested_base_wd,
         caller_dir: path5.dirname(URI.parse(callee_uri).fsPath),
         cd_commands: callee_result.cd_commands,
         workspace_roots: this.workspace_roots.length > 0 ? this.workspace_roots : undefined,
         fs: this.resolve_fs
       });
+      if (nested_depends_on_casing) {
+        mark_directory_casing(casing_collector);
+      }
       for (const my_event of the_events) {
         if (token?.isCancellationRequested)
           break;
@@ -22647,12 +22743,12 @@ class ForwardScopeResolver {
           the_effective.set(my_event.name, my_event.symbol);
         } else {
           const event_wd = wd_for_position(nested_cd_timeline, my_event.call.range.start);
-          const nested_resolved = this.resolve_call_path_simple(my_event.call.raw_path, callee_uri, event_wd);
+          const nested_resolved = this.resolve_call_path_simple(my_event.call.raw_path, callee_uri, event_wd, casing_collector);
           if (nested_resolved === null) {
             continue;
           }
           const nested_uri = URI.file(nested_resolved).toString();
-          const nested_effective = await this.compute_effective_end_state_locals(nested_uri, nested_resolved, event_wd, stack, depth + 1, resolved_config, token);
+          const nested_effective = await this.compute_effective_end_state_locals(nested_uri, nested_resolved, event_wd, stack, depth + 1, resolved_config, token, casing_collector);
           for (const [my_name, my_symbol] of nested_effective) {
             the_effective.set(my_name, my_symbol);
           }
@@ -25487,8 +25583,8 @@ function is_missing(error) {
   return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
 }
 function contains_path(root, target) {
-  const relative6 = path10.relative(root, target);
-  return relative6 !== ".." && !relative6.startsWith(`..${path10.sep}`) && !path10.isAbsolute(relative6);
+  const relative5 = path10.relative(root, target);
+  return relative5 !== ".." && !relative5.startsWith(`..${path10.sep}`) && !path10.isAbsolute(relative5);
 }
 function create_gitignore_matcher(workspace_roots, respect_gitignore = true) {
   if (!respect_gitignore || workspace_roots.length === 0) {
@@ -25535,8 +25631,8 @@ function create_gitignore_matcher(workspace_roots, respect_gitignore = true) {
   function matches_rules(context, absolute_path, kind) {
     if (context.ignored)
       return true;
-    const relative6 = path10.relative(context.rule_root, absolute_path).split(path10.sep).join("/");
-    return context.rules.ignores(kind === "directory" ? `${relative6}/` : relative6);
+    const relative5 = path10.relative(context.rule_root, absolute_path).split(path10.sep).join("/");
+    return context.rules.ignores(kind === "directory" ? `${relative5}/` : relative5);
   }
   function directory_context(scope, directory) {
     const cached = scope.directories.get(directory);
@@ -26628,9 +26724,9 @@ var require_parse = __commonJS((exports, module) => {
               const idx = prev.value.lastIndexOf("[");
               const pre = prev.value.slice(0, idx);
               const rest2 = prev.value.slice(idx + 2);
-              const posix3 = POSIX_REGEX_SOURCE[rest2];
-              if (posix3) {
-                prev.value = pre + posix3;
+              const posix4 = POSIX_REGEX_SOURCE[rest2];
+              if (posix4) {
+                prev.value = pre + posix4;
                 state.backtrack = true;
                 advance();
                 if (!bos.output && tokens.indexOf(prev) === 1) {
@@ -27151,7 +27247,7 @@ var require_picomatch = __commonJS((exports, module) => {
       throw new TypeError("Expected pattern to be a non-empty string");
     }
     const opts = options || {};
-    const posix3 = opts.windows;
+    const posix4 = opts.windows;
     const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
     const state = regex.state;
     delete regex.state;
@@ -27161,8 +27257,8 @@ var require_picomatch = __commonJS((exports, module) => {
       isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
     }
     const matcher = (input, returnObject = false) => {
-      const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix: posix3 });
-      const result = { glob, state, regex, posix: posix3, input, output, match, isMatch };
+      const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix: posix4 });
+      const result = { glob, state, regex, posix: posix4, input, output, match, isMatch };
       if (typeof opts.onResult === "function") {
         opts.onResult(result);
       }
@@ -27187,7 +27283,7 @@ var require_picomatch = __commonJS((exports, module) => {
     }
     return matcher;
   };
-  picomatch.test = (input, regex, options, { glob, posix: posix3 } = {}) => {
+  picomatch.test = (input, regex, options, { glob, posix: posix4 } = {}) => {
     if (typeof input !== "string") {
       throw new TypeError("Expected input to be a string");
     }
@@ -27195,7 +27291,7 @@ var require_picomatch = __commonJS((exports, module) => {
       return { isMatch: false, output: "" };
     }
     const opts = options || {};
-    const format = opts.format || (posix3 ? utils.toPosixSlashes : null);
+    const format = opts.format || (posix4 ? utils.toPosixSlashes : null);
     let match = input === glob;
     let output = match && format ? format(input) : input;
     if (match === false) {
@@ -27204,7 +27300,7 @@ var require_picomatch = __commonJS((exports, module) => {
     }
     if (match === false || opts.capture === true) {
       if (opts.matchBase === true || opts.basename === true) {
-        match = picomatch.matchBase(input, regex, options, posix3);
+        match = picomatch.matchBase(input, regex, options, posix4);
       } else {
         match = regex.exec(output);
       }
@@ -27357,12 +27453,12 @@ function create_exclude_matcher(patterns) {
   return {
     is_empty: false,
     is_excluded_file(abs_path, workspace_roots) {
-      const relative6 = relative_to_containing_root(abs_path, workspace_roots);
-      if (relative6 === null || relative6 === "")
+      const relative5 = relative_to_containing_root(abs_path, workspace_roots);
+      if (relative5 === null || relative5 === "")
         return false;
       let excluded = false;
       for (const my_rule of compiled) {
-        if (my_rule.match(relative6)) {
+        if (my_rule.match(relative5)) {
           excluded = !my_rule.is_negated;
         }
       }
@@ -27371,8 +27467,8 @@ function create_exclude_matcher(patterns) {
     is_excluded_dir(abs_path, workspace_roots) {
       if (dir_match === null)
         return false;
-      const relative6 = relative_to_containing_root(abs_path, workspace_roots);
-      return relative6 !== null && relative6 !== "" && dir_match(relative6);
+      const relative5 = relative_to_containing_root(abs_path, workspace_roots);
+      return relative5 !== null && relative5 !== "" && dir_match(relative5);
     }
   };
 }
@@ -35121,20 +35217,20 @@ function canonicalize_existing_path(file_path) {
   return fs13.realpathSync.native(file_path);
 }
 function workspace_relative(workspace_root, file_path) {
-  const relative7 = path14.relative(workspace_root, file_path);
-  const inside = relative7 !== ".." && !relative7.startsWith(`..${path14.sep}`) && !path14.isAbsolute(relative7);
-  return { relative: relative7, inside };
+  const relative6 = path14.relative(workspace_root, file_path);
+  const inside = relative6 !== ".." && !relative6.startsWith(`..${path14.sep}`) && !path14.isAbsolute(relative6);
+  return { relative: relative6, inside };
 }
 function relative_path(workspace_root, file_path) {
-  const { relative: relative7 } = workspace_relative(workspace_root, file_path);
-  if (relative7 === "") {
+  const { relative: relative6 } = workspace_relative(workspace_root, file_path);
+  if (relative6 === "") {
     return ".";
   }
-  return path14.isAbsolute(relative7) ? file_path : relative7.split(path14.sep).join("/");
+  return path14.isAbsolute(relative6) ? file_path : relative6.split(path14.sep).join("/");
 }
 function is_within_workspace(workspace_root, file_path) {
-  const { relative: relative7, inside } = workspace_relative(workspace_root, file_path);
-  return relative7 === "" || relative7.length > 0 && inside;
+  const { relative: relative6, inside } = workspace_relative(workspace_root, file_path);
+  return relative6 === "" || relative6.length > 0 && inside;
 }
 function walk_sources(dir_path, out, operator_errors, workspace_roots, exclude_matcher, gitignore_matcher) {
   if (gitignore_matcher.is_ignored(dir_path, "directory"))
@@ -37418,11 +37514,11 @@ ${source_info}${footer}`
     if (workspace_fs_path === null) {
       return fs_path;
     }
-    const relative8 = path16.relative(workspace_fs_path, fs_path);
-    if (relative8.startsWith("..") || path16.isAbsolute(relative8)) {
+    const relative7 = path16.relative(workspace_fs_path, fs_path);
+    if (relative7.startsWith("..") || path16.isAbsolute(relative7)) {
       return fs_path;
     }
-    return relative8;
+    return relative7;
   }
   format_source_link(source_uri, current_uri, workspace_root) {
     const source_path = this.normalize_file_path(source_uri);
@@ -73502,8 +73598,8 @@ async function create_server(options) {
   function is_relevant_gitignore(uri) {
     const directory = path19.dirname(URI.parse(uri).fsPath);
     return gitignore_watch_directories.some((watch) => {
-      const relative9 = path19.relative(watch.directory, directory);
-      return relative9 === "" || watch.recursive && relative9 !== ".." && !relative9.startsWith(`..${path19.sep}`) && !path19.isAbsolute(relative9);
+      const relative8 = path19.relative(watch.directory, directory);
+      return relative8 === "" || watch.recursive && relative8 !== ".." && !relative8.startsWith(`..${path19.sep}`) && !path19.isAbsolute(relative8);
     });
   }
   function schedule_gitignore_refresh() {
@@ -74526,4 +74622,4 @@ export {
   is_cli_entry_point
 };
 
-//# debugId=47C20F7ACC43ED9664756E2164756E21
+//# debugId=7D74EF27B76852CD64756E2164756E21

package/dist/sight-server.js.sha256

@@ -1 +1 @@
-65f2c1d1eb4d0efd5e73e44566ce6a00345e4c8e38f623c055fabb4b1e954f0e  sight-server.js
+6cb7a3ff1e19375396733e1315ef0fc4c003f25802a8144cb68ff5ef92d8bdf9  sight-server.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbearak/sight",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "type": "module",
   "workspaces": [
     "client"