sift-light 1.0.0

package/src/syntax-worker.mjs

@@ -0,0 +1,280 @@
+// src/syntax-worker.ts
+import { parse, registerDynamicLanguage } from "@ast-grep/napi";
+import go from "@ast-grep/lang-go";
+
+// src/analysis-limits.ts
+var MAX_STRUCTURE_BYTES = 32 * 1024 * 1024;
+var MAX_SYNTAX_NODES = 1e5;
+var MAX_ANALYSIS_STORAGE_BYTES = 32 * 1024 * 1024;
+var ANALYSIS_METADATA_RESERVE_BYTES = 64 * 1024;
+var MAX_ANALYSIS_REASON_BYTES = 4 * 1024;
+var ANALYSIS_TTL_MS = 10 * 60 * 1000;
+var MAX_SOURCE_CONTINUATION_BYTES = 1024 * 1024;
+
+// src/syntax-fields.ts
+var JAVASCRIPT_FIELDS = {
+  arrow_function: ["body", "parameter", "parameters", "return_type", "type_parameters"],
+  assignment_expression: ["left", "right"],
+  assignment_pattern: ["left", "right"],
+  augmented_assignment_expression: ["left", "operator", "right"],
+  binary_expression: ["left", "operator", "right"],
+  break_statement: ["label"],
+  call_expression: ["arguments", "function", "optional_chain", "type_arguments"],
+  catch_clause: ["body", "parameter", "type"],
+  class: ["body", "decorator", "name", "type_parameters"],
+  class_body: ["decorator", "member"],
+  class_declaration: ["body", "decorator", "name", "type_parameters"],
+  class_static_block: ["body"],
+  continue_statement: ["label"],
+  do_statement: ["body", "condition"],
+  export_specifier: ["alias", "name"],
+  export_statement: ["declaration", "decorator", "source", "value"],
+  field_definition: ["decorator", "property", "value"],
+  finally_clause: ["body"],
+  for_in_statement: ["body", "kind", "left", "operator", "right", "value"],
+  for_statement: ["body", "condition", "increment", "initializer"],
+  function_declaration: ["body", "name", "parameters", "return_type", "type_parameters"],
+  function_expression: ["body", "name", "parameters", "return_type", "type_parameters"],
+  generator_function: ["body", "name", "parameters", "return_type", "type_parameters"],
+  generator_function_declaration: ["body", "name", "parameters", "return_type", "type_parameters"],
+  if_statement: ["alternative", "condition", "consequence"],
+  import_specifier: ["alias", "name"],
+  import_statement: ["source"],
+  jsx_closing_element: ["name"],
+  jsx_element: ["close_tag", "open_tag"],
+  jsx_opening_element: ["attribute", "name", "type_arguments"],
+  jsx_self_closing_element: ["attribute", "name", "type_arguments"],
+  labeled_statement: ["body", "label"],
+  lexical_declaration: ["kind"],
+  member_expression: ["object", "optional_chain", "property"],
+  method_definition: ["body", "decorator", "name", "parameters", "return_type", "type_parameters"],
+  new_expression: ["arguments", "constructor", "type_arguments"],
+  object_assignment_pattern: ["left", "right"],
+  pair: ["key", "value"],
+  pair_pattern: ["key", "value"],
+  regex: ["flags", "pattern"],
+  subscript_expression: ["index", "object", "optional_chain"],
+  switch_case: ["body", "value"],
+  switch_default: ["body"],
+  switch_statement: ["body", "value"],
+  ternary_expression: ["alternative", "condition", "consequence"],
+  try_statement: ["body", "finalizer", "handler"],
+  unary_expression: ["argument", "operator"],
+  update_expression: ["argument", "operator"],
+  using_declaration: ["kind"],
+  variable_declarator: ["name", "type", "value"],
+  while_statement: ["body", "condition"],
+  with_statement: ["body", "object"],
+  abstract_class_declaration: ["body", "decorator", "name", "type_parameters"],
+  abstract_method_signature: ["name", "parameters", "return_type", "type_parameters"],
+  call_signature: ["parameters", "return_type", "type_parameters"],
+  conditional_type: ["alternative", "consequence", "left", "right"],
+  construct_signature: ["parameters", "type", "type_parameters"],
+  constructor_type: ["parameters", "type", "type_parameters"],
+  enum_assignment: ["name", "value"],
+  enum_body: ["name"],
+  enum_declaration: ["body", "name"],
+  extends_clause: ["type_arguments", "value"],
+  extends_type_clause: ["type"],
+  function_signature: ["name", "parameters", "return_type", "type_parameters"],
+  function_type: ["parameters", "return_type", "type_parameters"],
+  generic_type: ["name", "type_arguments"],
+  import_require_clause: ["source"],
+  index_signature: ["index_type", "name", "sign", "type"],
+  instantiation_expression: ["function", "type_arguments"],
+  interface_declaration: ["body", "name", "type_parameters"],
+  internal_module: ["body", "name"],
+  mapped_type_clause: ["alias", "name", "type"],
+  method_signature: ["name", "parameters", "return_type", "type_parameters"],
+  module: ["body", "name"],
+  nested_identifier: ["object", "property"],
+  nested_type_identifier: ["module", "name"],
+  optional_parameter: ["decorator", "name", "pattern", "type", "value"],
+  parenthesized_expression: ["type"],
+  property_signature: ["name", "type"],
+  public_field_definition: ["decorator", "name", "type", "value"],
+  required_parameter: ["decorator", "name", "pattern", "type", "value"],
+  type_alias_declaration: ["name", "type_parameters", "value"],
+  type_parameter: ["constraint", "name", "value"],
+  type_predicate: ["name", "type"]
+};
+var GO_FIELDS = {
+  array_type: ["element", "length"],
+  assignment_statement: ["left", "operator", "right"],
+  binary_expression: ["left", "operator", "right"],
+  call_expression: ["arguments", "function", "type_arguments"],
+  channel_type: ["value"],
+  communication_case: ["communication"],
+  composite_literal: ["body", "type"],
+  const_spec: ["name", "type", "value"],
+  expression_case: ["value"],
+  expression_switch_statement: ["initializer", "value"],
+  field_declaration: ["name", "tag", "type"],
+  for_clause: ["condition", "initializer", "update"],
+  for_statement: ["body"],
+  func_literal: ["body", "parameters", "result"],
+  function_declaration: ["body", "name", "parameters", "result", "type_parameters"],
+  function_type: ["parameters", "result"],
+  generic_type: ["type", "type_arguments"],
+  if_statement: ["alternative", "condition", "consequence", "initializer"],
+  implicit_length_array_type: ["element"],
+  import_spec: ["name", "path"],
+  index_expression: ["index", "operand"],
+  keyed_element: ["key", "value"],
+  labeled_statement: ["label"],
+  map_type: ["key", "value"],
+  method_declaration: ["body", "name", "parameters", "receiver", "result"],
+  method_elem: ["name", "parameters", "result"],
+  parameter_declaration: ["name", "type"],
+  qualified_type: ["name", "package"],
+  range_clause: ["left", "right"],
+  receive_statement: ["left", "right"],
+  selector_expression: ["field", "operand"],
+  send_statement: ["channel", "value"],
+  short_var_declaration: ["left", "right"],
+  slice_expression: ["capacity", "end", "operand", "start"],
+  slice_type: ["element"],
+  type_alias: ["name", "type", "type_parameters"],
+  type_assertion_expression: ["operand", "type"],
+  type_case: ["type"],
+  type_conversion_expression: ["operand", "type"],
+  type_instantiation_expression: ["type"],
+  type_parameter_declaration: ["name", "type"],
+  type_spec: ["name", "type", "type_parameters"],
+  type_switch_statement: ["alias", "initializer", "value"],
+  unary_expression: ["operand", "operator"],
+  var_spec: ["name", "type", "value"],
+  variadic_parameter_declaration: ["name", "type"]
+};
+
+// src/types.ts
+var MAX_SEARCH_STORAGE_BYTES = 32 * 1024 * 1024;
+var MAX_RESULT_BYTES = 16 * 1024;
+var MAX_PROTOCOL_LINE_BYTES = 16 * 1024 * 1024;
+var MAX_SOURCE_FILE_BYTES = 5 * 1024 * 1024;
+var MAX_PATTERN_CHARACTERS = 64 * 1024;
+
+// src/syntax-worker.ts
+function fieldsFor(node, language) {
+  const fields = new Map;
+  const names = (language === "go" ? GO_FIELDS : JAVASCRIPT_FIELDS)[node.kind()] ?? [];
+  for (const name of names) {
+    for (const child of node.fieldChildren(name))
+      fields.set(child.id(), name);
+  }
+  return fields;
+}
+function languageName(value) {
+  if (value === "javascript" || value === "typescript" || value === "tsx" || value === "go") {
+    return value;
+  }
+  throw new Error("Invalid syntax worker language");
+}
+function parseInput(input) {
+  if (!input || typeof input !== "object" || !("language" in input) || !("text" in input)) {
+    throw new Error("Invalid syntax worker input");
+  }
+  const language = languageName(input.language);
+  if (typeof input.text !== "string" || !input.text.isWellFormed()) {
+    throw new Error("Syntax worker input must be well-formed Unicode");
+  }
+  if (Buffer.byteLength(input.text) > MAX_SOURCE_FILE_BYTES) {
+    throw new Error("Syntax worker source exceeds the file limit");
+  }
+  if ("pattern" in input && (typeof input.pattern !== "string" || Buffer.byteLength(input.pattern) > 4096))
+    throw new Error("Invalid AST pattern");
+  return {
+    language,
+    text: input.text,
+    ..."pattern" in input && typeof input.pattern === "string" ? { pattern: input.pattern } : {}
+  };
+}
+function extract(language, text, pattern) {
+  if (language === "go")
+    registerDynamicLanguage({ go });
+  const names = { javascript: "JavaScript", typescript: "TypeScript", tsx: "Tsx", go: "go" };
+  if (pattern !== undefined) {
+    const prepared = language === "go" ? pattern.replaceAll("$", "µ") : pattern;
+    const templates = language === "go" ? [
+      prepared,
+      `package pattern
+${prepared}`,
+      `package pattern
+func pattern() {
+${prepared}
+}`
+    ] : [prepared];
+    const valid = templates.some((candidate) => {
+      const template = parse(names[language], candidate).root();
+      return template.kind() !== "ERROR" && !template.find({ rule: { kind: "ERROR" } });
+    });
+    if (!valid)
+      throw new Error("Malformed structural pattern for selected language");
+  }
+  const root = parse(names[language], text).root();
+  const rootRange = root.range();
+  const nodes = [
+    {
+      kind: String(root.kind()),
+      start: rootRange.start.index,
+      end: rootRange.end.index,
+      parent: null,
+      named: root.isNamed()
+    }
+  ];
+  const stack = [{ node: root, index: 0, next: 0, fields: fieldsFor(root, language) }];
+  let malformed = root.kind() === "ERROR";
+  while (stack.length > 0) {
+    const frame = stack.at(-1);
+    if (!frame)
+      break;
+    const child = frame.node.child(frame.next++);
+    if (!child) {
+      stack.pop();
+      continue;
+    }
+    if (nodes.length === MAX_SYNTAX_NODES)
+      return { status: "limit", nodes };
+    const range = child.range();
+    const kind = String(child.kind());
+    const field = frame.fields.get(child.id());
+    const node = {
+      kind,
+      start: range.start.index,
+      end: range.end.index,
+      parent: frame.index,
+      named: child.isNamed(),
+      ...field ? { field } : {}
+    };
+    if (kind === "ERROR" || node.start === node.end)
+      malformed = true;
+    const index = nodes.length;
+    nodes.push(node);
+    stack.push({ node: child, index, next: 0, fields: fieldsFor(child, language) });
+  }
+  const patternMatches = pattern === undefined || malformed ? undefined : root.findAll(pattern).map((node) => ({ start: node.range().start.index, end: node.range().end.index }));
+  return {
+    status: malformed ? "parse-error" : "ok",
+    nodes,
+    ...patternMatches ? { patternMatches } : {}
+  };
+}
+async function main() {
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of process.stdin) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.length;
+    if (bytes > MAX_STRUCTURE_BYTES)
+      throw new Error("Syntax worker input exceeds protocol limit");
+    chunks.push(buffer);
+  }
+  const input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  const { language, text, pattern } = parseInput(input);
+  const output = JSON.stringify(extract(language, text, pattern));
+  if (Buffer.byteLength(output) > MAX_STRUCTURE_BYTES) {
+    throw new Error("Syntax worker output exceeds protocol limit");
+  }
+  process.stdout.write(output);
+}
+await main();

package/src/syntax-worker.toml

@@ -0,0 +1,2 @@
+# Parser runtime configuration, not user/project configuration.
+preload = []

package/src/syntax-worker.ts

@@ -0,0 +1,143 @@
+import { parse, registerDynamicLanguage, type SgNode } from "@ast-grep/napi";
+import go from "@ast-grep/lang-go";
+import { MAX_STRUCTURE_BYTES, MAX_SYNTAX_NODES } from "./analysis-limits.ts";
+import { GO_FIELDS, JAVASCRIPT_FIELDS } from "./syntax-fields.ts";
+import type { SyntaxLanguage, SyntaxNode, SyntaxWorkerResult } from "./syntax-types.ts";
+import { MAX_SOURCE_FILE_BYTES } from "./types.ts";
+
+interface Frame {
+  node: SgNode;
+  index: number;
+  next: number;
+  fields: Map<number, string>;
+}
+
+function fieldsFor(node: SgNode, language: SyntaxLanguage): Map<number, string> {
+  const fields = new Map<number, string>();
+  const names = (language === "go" ? GO_FIELDS : JAVASCRIPT_FIELDS)[node.kind()] ?? [];
+  for (const name of names) {
+    for (const child of node.fieldChildren(name)) fields.set(child.id(), name);
+  }
+  return fields;
+}
+
+function languageName(value: unknown): SyntaxLanguage {
+  if (value === "javascript" || value === "typescript" || value === "tsx" || value === "go") {
+    return value;
+  }
+  throw new Error("Invalid syntax worker language");
+}
+
+function parseInput(input: unknown): { language: SyntaxLanguage; text: string; pattern?: string } {
+  if (!input || typeof input !== "object" || !("language" in input) || !("text" in input)) {
+    throw new Error("Invalid syntax worker input");
+  }
+  const language = languageName(input.language);
+  if (typeof input.text !== "string" || !input.text.isWellFormed()) {
+    throw new Error("Syntax worker input must be well-formed Unicode");
+  }
+  if (Buffer.byteLength(input.text) > MAX_SOURCE_FILE_BYTES) {
+    throw new Error("Syntax worker source exceeds the file limit");
+  }
+  if (
+    "pattern" in input &&
+    (typeof input.pattern !== "string" || Buffer.byteLength(input.pattern) > 4_096)
+  )
+    throw new Error("Invalid AST pattern");
+  return {
+    language,
+    text: input.text,
+    ...("pattern" in input && typeof input.pattern === "string" ? { pattern: input.pattern } : {}),
+  };
+}
+
+function extract(language: SyntaxLanguage, text: string, pattern?: string): SyntaxWorkerResult {
+  if (language === "go") registerDynamicLanguage({ go });
+  const names = { javascript: "JavaScript", typescript: "TypeScript", tsx: "Tsx", go: "go" };
+  if (pattern !== undefined) {
+    // Go's registered expando character makes metavariables legal identifiers during validation.
+    const prepared = language === "go" ? pattern.replaceAll("$", "µ") : pattern;
+    const templates =
+      language === "go"
+        ? [
+            prepared,
+            `package pattern\n${prepared}`,
+            `package pattern\nfunc pattern() {\n${prepared}\n}`,
+          ]
+        : [prepared];
+    const valid = templates.some((candidate) => {
+      const template = parse(names[language], candidate).root();
+      return template.kind() !== "ERROR" && !template.find({ rule: { kind: "ERROR" } });
+    });
+    if (!valid) throw new Error("Malformed structural pattern for selected language");
+  }
+  const root = parse(names[language], text).root();
+  const rootRange = root.range();
+  const nodes: SyntaxNode[] = [
+    {
+      kind: String(root.kind()),
+      start: rootRange.start.index,
+      end: rootRange.end.index,
+      parent: null,
+      named: root.isNamed(),
+    },
+  ];
+  const stack: Frame[] = [{ node: root, index: 0, next: 0, fields: fieldsFor(root, language) }];
+  let malformed = root.kind() === "ERROR";
+  while (stack.length > 0) {
+    const frame = stack.at(-1);
+    if (!frame) break;
+    const child = frame.node.child(frame.next++);
+    if (!child) {
+      stack.pop();
+      continue;
+    }
+    if (nodes.length === MAX_SYNTAX_NODES) return { status: "limit", nodes };
+    const range = child.range();
+    const kind = String(child.kind());
+    const field = frame.fields.get(child.id());
+    const node: SyntaxNode = {
+      kind,
+      start: range.start.index,
+      end: range.end.index,
+      parent: frame.index,
+      named: child.isNamed(),
+      ...(field ? { field } : {}),
+    };
+    if (kind === "ERROR" || node.start === node.end) malformed = true;
+    const index = nodes.length;
+    nodes.push(node);
+    stack.push({ node: child, index, next: 0, fields: fieldsFor(child, language) });
+  }
+  const patternMatches =
+    pattern === undefined || malformed
+      ? undefined
+      : root
+          .findAll(pattern)
+          .map((node) => ({ start: node.range().start.index, end: node.range().end.index }));
+  return {
+    status: malformed ? "parse-error" : "ok",
+    nodes,
+    ...(patternMatches ? { patternMatches } : {}),
+  };
+}
+
+async function main(): Promise<void> {
+  const chunks: Buffer[] = [];
+  let bytes = 0;
+  for await (const chunk of process.stdin) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.length;
+    if (bytes > MAX_STRUCTURE_BYTES) throw new Error("Syntax worker input exceeds protocol limit");
+    chunks.push(buffer);
+  }
+  const input: unknown = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  const { language, text, pattern } = parseInput(input);
+  const output = JSON.stringify(extract(language, text, pattern));
+  if (Buffer.byteLength(output) > MAX_STRUCTURE_BYTES) {
+    throw new Error("Syntax worker output exceeds protocol limit");
+  }
+  process.stdout.write(output);
+}
+
+await main();

package/src/syntax.ts

@@ -0,0 +1,259 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { MAX_PARSE_TIME_MS, MAX_STRUCTURE_BYTES, MAX_SYNTAX_NODES } from "./analysis-limits.js";
+import { abortError, SiftLightError } from "./errors.js";
+import { runOwnedProcess } from "./owned-process.js";
+import { scriptRuntimeEnvironment } from "./script-runtime.js";
+import { deriveSyntaxFacts } from "./syntax-facts.js";
+import { syntaxChildren } from "./syntax-tree.js";
+import type {
+  SyntaxAnalysis,
+  SyntaxLanguage,
+  SyntaxNode,
+  SyntaxStatus,
+  SyntaxWorkerResult,
+} from "./syntax-types.js";
+import { MAX_SOURCE_FILE_BYTES } from "./types.js";
+import {
+  DEFAULT_LANGUAGE_CAPABILITIES,
+  languageForPath,
+} from "./language-capability-definitions.js";
+
+export type {
+  SyntaxAnalysis,
+  SyntaxDiagnostic,
+  SyntaxLanguage,
+  SyntaxNode,
+  SyntaxRole,
+  SyntaxRoleName,
+  SyntaxStatus,
+  SyntaxSymbol,
+} from "./syntax-types.js";
+export { classifySyntaxRange } from "./syntax-facts.js";
+export { syntaxField, syntaxFields, syntaxText } from "./syntax-tree.js";
+
+export function syntaxLanguage(path: string): SyntaxLanguage | undefined {
+  switch (languageForPath(DEFAULT_LANGUAGE_CAPABILITIES, path)) {
+    case "javascript":
+      return "javascript";
+    case "typescript":
+      return "typescript";
+    case "tsx":
+      return "tsx";
+    case "go":
+      return "go";
+    default:
+      return undefined;
+  }
+}
+
+function emptyAnalysis(status: SyntaxStatus, language?: SyntaxLanguage): SyntaxAnalysis {
+  return {
+    status,
+    ...(language ? { language } : {}),
+    nodes: [],
+    children: [],
+    symbols: [],
+    roles: [],
+    diagnostics: [],
+    limited: status === "limit",
+  };
+}
+
+function invalidProtocol(): never {
+  throw new SiftLightError("Invalid syntax parser protocol");
+}
+
+function readNode(
+  value: unknown,
+  index: number,
+  nodes: readonly SyntaxNode[],
+  length: number,
+): SyntaxNode {
+  if (!value || typeof value !== "object") return invalidProtocol();
+  if (
+    !("kind" in value) ||
+    typeof value.kind !== "string" ||
+    value.kind.length === 0 ||
+    !("start" in value) ||
+    typeof value.start !== "number" ||
+    !Number.isSafeInteger(value.start) ||
+    !("end" in value) ||
+    typeof value.end !== "number" ||
+    !Number.isSafeInteger(value.end) ||
+    value.start < 0 ||
+    value.end < value.start ||
+    value.end > length ||
+    !("named" in value) ||
+    typeof value.named !== "boolean" ||
+    !("parent" in value)
+  )
+    return invalidProtocol();
+  const parent = value.parent;
+  if (
+    index === 0
+      ? parent !== null
+      : typeof parent !== "number" || !Number.isSafeInteger(parent) || parent < 0 || parent >= index
+  ) {
+    return invalidProtocol();
+  }
+  if (typeof parent === "number") {
+    const owner = nodes[parent];
+    if (!owner || owner.start > value.start || owner.end < value.end) return invalidProtocol();
+  }
+  if ("field" in value && typeof value.field !== "string") return invalidProtocol();
+  return {
+    kind: value.kind,
+    start: value.start,
+    end: value.end,
+    parent: typeof parent === "number" ? parent : null,
+    named: value.named,
+    ...("field" in value && typeof value.field === "string" ? { field: value.field } : {}),
+  };
+}
+
+function readResult(output: string, length: number): SyntaxWorkerResult {
+  let result: unknown;
+  try {
+    result = JSON.parse(output);
+  } catch {
+    return invalidProtocol();
+  }
+  if (
+    !result ||
+    typeof result !== "object" ||
+    !("status" in result) ||
+    !("nodes" in result) ||
+    !["ok", "parse-error", "limit"].includes(String(result.status)) ||
+    !Array.isArray(result.nodes) ||
+    result.nodes.length === 0 ||
+    result.nodes.length > MAX_SYNTAX_NODES
+  ) {
+    return invalidProtocol();
+  }
+  const nodes: SyntaxNode[] = [];
+  for (const value of result.nodes) nodes.push(readNode(value, nodes.length, nodes, length));
+  if (result.status !== "ok" && result.status !== "parse-error" && result.status !== "limit")
+    return invalidProtocol();
+  const patternMatches: { start: number; end: number }[] = [];
+  if ("patternMatches" in result) {
+    if (!Array.isArray(result.patternMatches) || result.patternMatches.length > MAX_SYNTAX_NODES)
+      return invalidProtocol();
+    for (const match of result.patternMatches) {
+      if (
+        !match ||
+        typeof match !== "object" ||
+        !("start" in match) ||
+        !("end" in match) ||
+        typeof match.start !== "number" ||
+        typeof match.end !== "number" ||
+        !Number.isSafeInteger(match.start) ||
+        !Number.isSafeInteger(match.end) ||
+        match.start < 0 ||
+        match.end < match.start ||
+        match.end > length
+      )
+        return invalidProtocol();
+      patternMatches.push({ start: match.start, end: match.end });
+    }
+  }
+  return { status: result.status, nodes, patternMatches };
+}
+
+/** The service serializes requests; this owns exactly one short-lived native parser. */
+export async function parseSyntax(
+  path: string,
+  text: string,
+  signal?: AbortSignal,
+  pattern?: string,
+): Promise<SyntaxAnalysis> {
+  if (signal?.aborted) throw abortError();
+  const language = syntaxLanguage(path);
+  if (!language) return emptyAnalysis("unsupported");
+  if (Buffer.byteLength(text) > MAX_SOURCE_FILE_BYTES) return emptyAnalysis("limit", language);
+  if (!text.isWellFormed()) {
+    return {
+      ...emptyAnalysis("parse-error", language),
+      diagnostics: [{ kind: "invalid-unicode", start: 0, end: text.length }],
+    };
+  }
+  const worker = fileURLToPath(new URL("./syntax-worker.mjs", import.meta.url));
+  const config = fileURLToPath(new URL("./syntax-worker.toml", import.meta.url));
+  const args = process.versions.bun
+    ? [`--config=${config}`, "--no-env-file", "--no-macros", "--no-install", worker]
+    : [worker];
+  const env = scriptRuntimeEnvironment();
+  const controller = new AbortController();
+  let timedOut = false;
+  const abort = () => controller.abort();
+  signal?.addEventListener("abort", abort, { once: true });
+  if (signal?.aborted) controller.abort();
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, MAX_PARSE_TIME_MS);
+  const chunks: Buffer[] = [];
+  let bytes = 0;
+  try {
+    const result = await runOwnedProcess(
+      {
+        executable: process.execPath,
+        args,
+        cwd: dirname(worker),
+        env,
+        signal: controller.signal,
+        input: Buffer.from(JSON.stringify({ language, text, pattern })),
+      },
+      async (stdout) => {
+        for await (const chunk of stdout) {
+          bytes += chunk.byteLength;
+          if (bytes > MAX_STRUCTURE_BYTES)
+            throw new SiftLightError("Syntax parser output exceeds protocol limit");
+          chunks.push(Buffer.from(chunk));
+        }
+      },
+    );
+    if (signal?.aborted) throw abortError();
+    if (result.code !== 0) {
+      throw new SiftLightError(
+        `Syntax parser process failed (${String(result.code)}): ${result.stderr.trim()}`,
+      );
+    }
+    const parsed = readResult(Buffer.concat(chunks).toString("utf8"), text.length);
+    const children = syntaxChildren(parsed.nodes);
+    const diagnostics = parsed.nodes.flatMap((node, index) =>
+      node.kind === "ERROR" || (index > 0 && node.start === node.end)
+        ? [
+            {
+              kind: node.kind === "ERROR" ? "syntax-error" : "missing-token",
+              start: node.start,
+              end: node.end,
+            },
+          ]
+        : [],
+    );
+    const facts =
+      parsed.status === "ok"
+        ? deriveSyntaxFacts({ nodes: parsed.nodes, children }, language, text)
+        : { symbols: [], roles: [] };
+    if (signal?.aborted) throw abortError();
+    return {
+      language,
+      status: parsed.status,
+      nodes: parsed.nodes,
+      children,
+      ...(parsed.patternMatches ? { patternMatches: parsed.patternMatches } : {}),
+      ...facts,
+      diagnostics,
+      limited: parsed.status === "limit",
+    };
+  } catch (error) {
+    const aborted = error instanceof Error && error.name === "AbortError";
+    if (aborted && signal?.aborted) throw abortError();
+    if (aborted && timedOut) return emptyAnalysis("timeout", language);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", abort);
+  }
+}