vellum 0.2.13 → 0.3.2

package/src/tools/terminal/evaluate-typescript.ts

@@ -1,275 +0,0 @@
-import { spawn } from 'node:child_process';
-import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { join, basename } from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
-import { getConfig } from '../../config/loader.js';
-import { getLogger } from '../../util/logger.js';
-import { wrapCommand } from './sandbox.js';
-import { buildSanitizedEnv } from './safe-env.js';
-
-const log = getLogger('evaluate-typescript');
-
-const MAX_CODE_BYTES = 100_000;
-const MAX_MOCK_INPUT_BYTES = 100_000;
-const DEFAULT_MAX_OUTPUT_CHARS = 25_000;
-const DEFAULT_TIMEOUT_SEC = 10;
-const MIN_TIMEOUT_SEC = 1;
-const MAX_TIMEOUT_SEC = 20;
-
-interface EvalResult {
-  ok: boolean;
-  exitCode: number | null;
-  durationMs: number;
-  result?: unknown;
-  stdout: string;
-  stderr: string;
-  truncated: boolean;
-  timeout: boolean;
-}
-
-function sanitizeFilename(raw: string): string {
-  const base = basename(raw).replace(/[^a-zA-Z0-9._-]/g, '_');
-  if (!base || base.startsWith('.')) return 'snippet.ts';
-  if (base === '__runner.ts' || base === '__runner') return 'snippet.ts';
-  if (!base.endsWith('.ts')) return base + '.ts';
-  return base;
-}
-
-function buildWrapperSource(snippetFilename: string, entrypoint: string): string {
-  const exportName = entrypoint === 'run' ? 'run' : 'default';
-  return `
-import * as mod from './${snippetFilename}';
-
-const fn = (mod as any)['${exportName}'];
-if (typeof fn !== 'function') {
-  console.error(JSON.stringify({ __eval_error: 'Snippet must export a function named "${exportName}"' }));
-  process.exit(1);
-}
-
-const inputJson = process.env.__EVAL_INPUT_JSON ?? '{}';
-let input: unknown;
-try {
-  input = JSON.parse(inputJson);
-} catch {
-  console.error(JSON.stringify({ __eval_error: 'Invalid JSON in __EVAL_INPUT_JSON' }));
-  process.exit(1);
-}
-
-try {
-  const result = await fn(input);
-  console.log(JSON.stringify({ __eval_result: result }));
-} catch (err: unknown) {
-  console.error(err instanceof Error ? err.stack ?? String(err) : String(err));
-  process.exit(1);
-}
-`;
-}
-
-export class EvaluateTypescriptTool implements Tool {
-  name = 'evaluate_typescript_code';
-  description = 'Evaluate a TypeScript snippet in an isolated sandbox. Use this to test code before persisting it as a managed skill.';
-  category = 'terminal';
-  defaultRiskLevel = RiskLevel.High;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          code: {
-            type: 'string',
-            description: 'The TypeScript source code to evaluate. Must export a `default` or `run` function with signature `(input: unknown) => unknown | Promise<unknown>`.',
-          },
-          mock_input_json: {
-            type: 'string',
-            description: 'Optional JSON string to pass as the input argument to the exported function. Defaults to "{}".',
-          },
-          timeout_seconds: {
-            type: 'number',
-            description: `Optional timeout in seconds (${MIN_TIMEOUT_SEC}-${MAX_TIMEOUT_SEC}). Defaults to ${DEFAULT_TIMEOUT_SEC}.`,
-          },
-          filename: {
-            type: 'string',
-            description: 'Optional filename for the snippet (default: "snippet.ts"). Sanitized to basename only.',
-          },
-          entrypoint: {
-            type: 'string',
-            enum: ['default', 'run'],
-            description: 'Which export to call: "default" or "run". Defaults to "default".',
-          },
-          max_output_chars: {
-            type: 'number',
-            description: `Optional max output characters (1-${DEFAULT_MAX_OUTPUT_CHARS}). Defaults to ${DEFAULT_MAX_OUTPUT_CHARS}.`,
-          },
-        },
-        required: ['code'],
-      },
-    };
-  }
-
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
-    const code = input.code;
-    if (typeof code !== 'string' || !code.trim()) {
-      return { content: 'Error: code is required and must be a non-empty string', isError: true };
-    }
-    if (Buffer.byteLength(code) > MAX_CODE_BYTES) {
-      return { content: `Error: code exceeds maximum size of ${MAX_CODE_BYTES} bytes`, isError: true };
-    }
-
-    const mockInputJson = typeof input.mock_input_json === 'string' ? input.mock_input_json : '{}';
-    if (Buffer.byteLength(mockInputJson) > MAX_MOCK_INPUT_BYTES) {
-      return { content: `Error: mock_input_json exceeds maximum size of ${MAX_MOCK_INPUT_BYTES} bytes`, isError: true };
-    }
-    try {
-      JSON.parse(mockInputJson);
-    } catch {
-      return { content: 'Error: mock_input_json must be valid JSON', isError: true };
-    }
-
-    const rawTimeout = typeof input.timeout_seconds === 'number' ? input.timeout_seconds : DEFAULT_TIMEOUT_SEC;
-    const timeoutSec = Math.max(MIN_TIMEOUT_SEC, Math.min(MAX_TIMEOUT_SEC, Math.round(rawTimeout)));
-    const timeoutMs = timeoutSec * 1000;
-
-    const filename = sanitizeFilename(typeof input.filename === 'string' ? input.filename : 'snippet.ts');
-    const entrypoint = input.entrypoint === 'run' ? 'run' : 'default';
-    const maxOutputChars = typeof input.max_output_chars === 'number'
-      ? Math.max(1, Math.min(DEFAULT_MAX_OUTPUT_CHARS, Math.round(input.max_output_chars)))
-      : DEFAULT_MAX_OUTPUT_CHARS;
-
-    const evalDir = join(context.workingDir, '.vellum-eval', randomUUID());
-
-    try {
-      mkdirSync(evalDir, { recursive: true });
-      writeFileSync(join(evalDir, filename), code, 'utf-8');
-      writeFileSync(join(evalDir, '__runner.ts'), buildWrapperSource(filename, entrypoint), 'utf-8');
-
-      const result = await this.runSnippet(evalDir, mockInputJson, timeoutSec, timeoutMs, maxOutputChars, context);
-      return { content: JSON.stringify(result), isError: !result.ok };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      log.error({ err }, 'evaluate_typescript_code failed');
-      return { content: `Error: ${msg}`, isError: true };
-    } finally {
-      try {
-        rmSync(evalDir, { recursive: true, force: true });
-      } catch {
-        // best effort
-      }
-    }
-  }
-
-  private runSnippet(
-    evalDir: string,
-    mockInputJson: string,
-    timeoutSec: number,
-    timeoutMs: number,
-    maxOutputChars: number,
-    _context: ToolContext,
-  ): Promise<EvalResult> {
-    return new Promise<EvalResult>((resolve) => {
-      const startTime = Date.now();
-      const stdoutChunks: Buffer[] = [];
-      const stderrChunks: Buffer[] = [];
-      let timedOut = false;
-
-      const config = getConfig();
-      // Force sandbox on regardless of global config
-      const sandboxConfig = { ...config.sandbox, enabled: true };
-      const bunRunCmd = `bun run __runner.ts`;
-      const wrapped = wrapCommand(bunRunCmd, evalDir, sandboxConfig);
-
-      const env = buildSanitizedEnv();
-      env.__EVAL_INPUT_JSON = mockInputJson;
-
-      const child = spawn(wrapped.command, wrapped.args, {
-        cwd: evalDir,
-        env,
-        stdio: ['ignore', 'pipe', 'pipe'],
-      });
-
-      const timer = setTimeout(() => {
-        timedOut = true;
-        child.kill('SIGKILL');
-      }, timeoutMs);
-
-      child.stdout.on('data', (data: Buffer) => stdoutChunks.push(data));
-      child.stderr.on('data', (data: Buffer) => stderrChunks.push(data));
-
-      child.on('close', (code) => {
-        clearTimeout(timer);
-        const durationMs = Date.now() - startTime;
-
-        let stdout = Buffer.concat(stdoutChunks).toString();
-        let stderr = Buffer.concat(stderrChunks).toString();
-        let truncated = false;
-
-        // Extract structured result from raw stdout before truncation.
-        // Scan backward from the end for the marker; if the last occurrence
-        // is on a malformed line, keep searching earlier occurrences so a
-        // valid result is not missed due to trailing marker-like log output.
-        let result: unknown = undefined;
-        if (code === 0) {
-          let searchFrom = stdout.length;
-          while (searchFrom > 0) {
-            const markerIdx = stdout.lastIndexOf('__eval_result', searchFrom - 1);
-            if (markerIdx === -1) break;
-            const lineStart = stdout.lastIndexOf('\n', markerIdx) + 1;
-            const lineEnd = stdout.indexOf('\n', markerIdx);
-            const line = stdout.slice(lineStart, lineEnd === -1 ? undefined : lineEnd);
-            try {
-              const parsed = JSON.parse(line);
-              if (parsed && typeof parsed === 'object' && '__eval_result' in parsed) {
-                result = parsed.__eval_result;
-                break;
-              }
-            } catch {
-              // malformed line — continue scanning earlier occurrences
-            }
-            searchFrom = lineStart;
-          }
-        }
-
-        if (stdout.length + stderr.length > maxOutputChars) {
-          truncated = true;
-          const halfMax = Math.floor(maxOutputChars / 2);
-          if (stdout.length > halfMax) stdout = stdout.slice(0, halfMax) + '\n[stdout truncated]';
-          if (stderr.length > halfMax) stderr = stderr.slice(0, halfMax) + '\n[stderr truncated]';
-        }
-
-        resolve({
-          ok: code === 0 && !timedOut,
-          exitCode: code,
-          durationMs,
-          result,
-          stdout,
-          stderr,
-          truncated,
-          timeout: timedOut,
-        });
-      });
-
-      child.on('error', (err) => {
-        clearTimeout(timer);
-        const durationMs = Date.now() - startTime;
-        resolve({
-          ok: false,
-          exitCode: null,
-          durationMs,
-          stdout: '',
-          stderr: `Error spawning process: ${err.message}`,
-          truncated: false,
-          timeout: false,
-        });
-      });
-    });
-  }
-}
-
-export const evaluateTypescriptTool: Tool = new EvaluateTypescriptTool();
-registerTool(evaluateTypescriptTool);

package/src/tools/terminal/parser.ts

@@ -1,415 +0,0 @@
-import { join, dirname } from 'node:path';
-import { readFileSync, existsSync } from 'node:fs';
-import { createHash } from 'node:crypto';
-import { getLogger } from '../../util/logger.js';
-import { IntegrityError } from '../../util/errors.js';
-import { Parser, Language, type Node as TSNode } from 'web-tree-sitter';
-
-const log = getLogger('shell-parser');
-
-export type DangerousPatternType =
-  | 'pipe_to_shell'
-  | 'base64_execute'
-  | 'process_substitution'
-  | 'sensitive_redirect'
-  | 'dangerous_substitution'
-  | 'env_injection';
-
-export interface DangerousPattern {
-  type: DangerousPatternType;
-  description: string;
-  text: string;
-}
-
-export interface CommandSegment {
-  command: string;
-  program: string;
-  args: string[];
-  operator: '&&' | '||' | ';' | '|' | '';
-}
-
-export interface ParsedCommand {
-  segments: CommandSegment[];
-  dangerousPatterns: DangerousPattern[];
-  hasOpaqueConstructs: boolean;
-}
-
-const SHELL_PROGRAMS = new Set(['sh', 'bash', 'zsh', 'dash', 'ksh', 'fish']);
-const OPAQUE_PROGRAMS = new Set(['eval', 'source']);
-const DANGEROUS_ENV_VARS = new Set([
-  'LD_PRELOAD', 'LD_LIBRARY_PATH',
-  'DYLD_INSERT_LIBRARIES', 'DYLD_LIBRARY_PATH', 'DYLD_FRAMEWORK_PATH',
-  'NODE_OPTIONS', 'NODE_PATH',
-  'PATH', 'PYTHONPATH', 'RUBYLIB',
-]);
-const SENSITIVE_PATH_PREFIXES = [
-  '~/.zshrc', '~/.bashrc', '~/.bash_profile', '~/.profile',
-  '~/.ssh/', '~/.gnupg/', '~/.config/',
-  '/etc/', '/usr/lib/', '/usr/bin/',
-];
-
-// Expected SHA-256 checksums for WASM binaries.
-// Update these when intentionally upgrading web-tree-sitter or tree-sitter-bash.
-// Generate with: shasum -a 256 node_modules/web-tree-sitter/web-tree-sitter.wasm node_modules/tree-sitter-bash/tree-sitter-bash.wasm
-const EXPECTED_CHECKSUMS: Record<string, string> = {
-  'web-tree-sitter.wasm': '3d4c304cb7d59cfac4a2aa23c3408416cbfa2287fe17a9c975da46eb2ead8646',
-  'tree-sitter-bash.wasm': '8292919c88a0f7d3fb31d0cd0253ca5a9531bc1ede82b0537f2c63dd8abe6a7a',
-};
-
-function verifyWasmChecksum(filePath: string, label: string): void {
-  const data = readFileSync(filePath);
-  const hash = createHash('sha256').update(data).digest('hex');
-  const expected = EXPECTED_CHECKSUMS[label];
-  if (!expected) {
-    throw new IntegrityError(
-      `No expected checksum registered for ${label}`,
-    );
-  }
-  if (hash !== expected) {
-    throw new IntegrityError(
-      `WASM integrity check failed for ${label}: expected ${expected}, got ${hash}`,
-    );
-  }
-}
-
-let parserInstance: Parser | null = null;
-let initPromise: Promise<void> | null = null;
-
-/**
- * Locate a WASM file from a dependency package.
- *
- * In development / `bunx` the file lives under `node_modules/` relative
- * to the source tree.  In compiled Bun binaries `import.meta.dirname`
- * points into the virtual `/$bunfs/` filesystem where binary assets
- * don't exist — fall back to:
- *   1. `../Resources/<file>` (macOS .app bundle layout)
- *   2. Next to the compiled binary (process.execPath)
- * This matches the pattern used by docker.ts for Dockerfile.sandbox.
- */
-function findWasmPath(pkg: string, file: string): string {
-  const dir = import.meta.dirname ?? __dirname;
-  const sourcePath = join(dir, '..', '..', '..', 'node_modules', pkg, file);
-
-  if (!existsSync(sourcePath) && dir.startsWith('/$bunfs/')) {
-    const execDir = dirname(process.execPath);
-    // macOS .app bundle: binary is in Contents/MacOS/, resources in Contents/Resources/
-    const resourcesPath = join(execDir, '..', 'Resources', file);
-    if (existsSync(resourcesPath)) return resourcesPath;
-    // Fallback: next to the binary itself (non-app-bundle deployments)
-    return join(execDir, file);
-  }
-
-  return sourcePath;
-}
-
-async function ensureParser(): Promise<Parser> {
-  if (parserInstance) return parserInstance;
-
-  if (!initPromise) {
-    initPromise = (async () => {
-      const treeSitterWasm = findWasmPath('web-tree-sitter', 'web-tree-sitter.wasm');
-      const bashWasmPath = findWasmPath('tree-sitter-bash', 'tree-sitter-bash.wasm');
-
-      verifyWasmChecksum(treeSitterWasm, 'web-tree-sitter.wasm');
-      verifyWasmChecksum(bashWasmPath, 'tree-sitter-bash.wasm');
-
-      await Parser.init({
-        locateFile: () => treeSitterWasm,
-      });
-
-      const Bash = await Language.load(bashWasmPath);
-      const parser = new Parser();
-      parser.setLanguage(Bash);
-      parserInstance = parser;
-      log.info('Shell parser initialized (web-tree-sitter + bash, checksums verified)');
-    })();
-  }
-
-  await initPromise;
-  return parserInstance!;
-}
-
-function extractSegments(node: TSNode): CommandSegment[] {
-  const segments: CommandSegment[] = [];
-
-  function walkNode(n: TSNode, operator: CommandSegment['operator']): void {
-    switch (n.type) {
-      case 'program': {
-        for (const child of n.namedChildren) {
-          walkNode(child, '');
-        }
-        break;
-      }
-
-      case 'list': {
-        // list = command (operator command)*
-        for (let i = 0; i < n.childCount; i++) {
-          const child = n.child(i);
-          if (!child) continue;
-          if (child.type === '&&' || child.type === '||' || child.type === ';') {
-            operator = child.type as CommandSegment['operator'];
-          } else if (child.type !== 'comment') {
-            walkNode(child, operator);
-            operator = '';
-          }
-        }
-        break;
-      }
-
-      case 'pipeline': {
-        let first = true;
-        for (const child of n.namedChildren) {
-          walkNode(child, first ? operator : '|');
-          first = false;
-        }
-        break;
-      }
-
-      case 'command': {
-        const words: string[] = [];
-        for (const child of n.namedChildren) {
-          if (child.type === 'command_name' || child.type === 'word' ||
-              child.type === 'string' || child.type === 'raw_string' ||
-              child.type === 'simple_expansion' || child.type === 'expansion' ||
-              child.type === 'command_substitution' || child.type === 'concatenation' ||
-              child.type === 'number') {
-            words.push(child.text);
-          }
-        }
-        if (words.length > 0) {
-          segments.push({
-            command: n.text,
-            program: words[0],
-            args: words.slice(1),
-            operator,
-          });
-        }
-        break;
-      }
-
-      case 'redirected_statement': {
-        for (const child of n.namedChildren) {
-          if (child.type !== 'file_redirect' && child.type !== 'heredoc_redirect' &&
-              child.type !== 'herestring_redirect') {
-            walkNode(child, operator);
-          }
-        }
-        break;
-      }
-
-      case 'subshell':
-      case 'command_substitution':
-      case 'compound_statement':
-      case 'if_statement':
-      case 'while_statement':
-      case 'for_statement':
-      case 'case_statement':
-      case 'function_definition':
-      case 'negated_command': {
-        for (const child of n.namedChildren) {
-          walkNode(child, operator);
-        }
-        break;
-      }
-
-      default: {
-        for (const child of n.namedChildren) {
-          walkNode(child, operator);
-        }
-        break;
-      }
-    }
-  }
-
-  walkNode(node, '');
-  return segments;
-}
-
-function detectDangerousPatterns(node: TSNode, segments: CommandSegment[]): DangerousPattern[] {
-  const patterns: DangerousPattern[] = [];
-
-  for (let i = 1; i < segments.length; i++) {
-    if (segments[i].operator === '|') {
-      const prog = segments[i].program;
-      if (SHELL_PROGRAMS.has(prog) || prog === 'eval' || prog === 'xargs') {
-        patterns.push({
-          type: 'pipe_to_shell',
-          description: `Pipeline into ${prog}`,
-          text: segments[i].command,
-        });
-      }
-    }
-  }
-
-  for (let i = 0; i < segments.length - 1; i++) {
-    if (segments[i].program === 'base64' && segments[i].args.includes('-d')) {
-      if (i + 1 < segments.length && segments[i + 1].operator === '|') {
-        const nextProg = segments[i + 1].program;
-        if (SHELL_PROGRAMS.has(nextProg) || nextProg === 'eval') {
-          patterns.push({
-            type: 'base64_execute',
-            description: 'base64 decoded content piped to shell',
-            text: `${segments[i].command} | ${segments[i + 1].command}`,
-          });
-        }
-      }
-    }
-  }
-
-  function walkForPatterns(n: TSNode): void {
-    if (n.type === 'process_substitution') {
-      patterns.push({
-        type: 'process_substitution',
-        description: 'Process substitution detected',
-        text: n.text,
-      });
-    }
-
-    if (n.type === 'file_redirect') {
-      const dest = n.lastChild;
-      if (dest) {
-        const destText = dest.text;
-        for (const prefix of SENSITIVE_PATH_PREFIXES) {
-          if (destText.startsWith(prefix) || destText.startsWith(prefix.replace('~', '$HOME'))) {
-            patterns.push({
-              type: 'sensitive_redirect',
-              description: `Redirect to sensitive path: ${destText}`,
-              text: n.text,
-            });
-            break;
-          }
-        }
-      }
-    }
-
-    if (n.type === 'command_substitution' && n.parent) {
-      const parent = n.parent;
-      if (parent.type === 'command') {
-        const firstWord = parent.namedChild(0);
-        if (firstWord && (firstWord.text === 'rm' || firstWord.text === 'chmod' || firstWord.text === 'chown')) {
-          patterns.push({
-            type: 'dangerous_substitution',
-            description: `Command substitution as argument to ${firstWord.text}`,
-            text: parent.text,
-          });
-        }
-      }
-    }
-
-    if (n.type === 'variable_assignment') {
-      const varName = n.firstChild;
-      if (varName && varName.type === 'variable_name') {
-        if (DANGEROUS_ENV_VARS.has(varName.text)) {
-          patterns.push({
-            type: 'env_injection',
-            description: `Assignment to dangerous env var: ${varName.text}`,
-            text: n.text,
-          });
-        }
-      }
-    }
-
-    for (const child of n.children) {
-      walkForPatterns(child);
-    }
-  }
-
-  walkForPatterns(node);
-  return patterns;
-}
-
-function detectOpaqueConstructs(node: TSNode, segments: CommandSegment[]): boolean {
-  // Check segments for opaque programs
-  for (const seg of segments) {
-    if (OPAQUE_PROGRAMS.has(seg.program) || seg.program === '.') {
-      return true;
-    }
-    if (SHELL_PROGRAMS.has(seg.program) && (seg.args.includes('-c') || seg.args.includes('-ec'))) {
-      return true;
-    }
-  }
-
-  function walkForOpacity(n: TSNode): boolean {
-    // Heredocs / herestrings
-    if (n.type === 'heredoc_redirect' || n.type === 'heredoc_body' ||
-        n.type === 'herestring_redirect') {
-      return true;
-    }
-
-    // Variable expansion used as command name
-    if (n.type === 'command') {
-      const firstChild = n.namedChild(0);
-      if (firstChild) {
-        // Direct expansion as command (e.g. in some grammars)
-        if (
-          firstChild.type === 'simple_expansion' ||
-          firstChild.type === 'expansion' ||
-          firstChild.type === 'command_substitution'
-        ) {
-          return true;
-        }
-        // tree-sitter-bash wraps the command name in a command_name node,
-        // so check inside it for variable/command substitution
-        if (firstChild.type === 'command_name') {
-          const inner = firstChild.namedChild(0);
-          if (inner && (
-            inner.type === 'simple_expansion' ||
-            inner.type === 'expansion' ||
-            inner.type === 'command_substitution' ||
-            inner.type === 'concatenation'
-          )) {
-            return true;
-          }
-        }
-      }
-    }
-
-    // Hex/octal escape sequences in command position
-    if (n.type === 'ansi_c_string' || n.type === 'ansii_c_string') {
-      if (n.parent?.type === 'command') {
-        const first = n.parent.namedChild(0);
-        if (first && first.equals(n)) {
-          return true;
-        }
-      }
-      if (/\\x[0-9a-fA-F]{2}|\\[0-7]{3}/.test(n.text)) {
-        return true;
-      }
-    }
-
-    // Array expansion as command
-    if (n.type === 'expansion' && n.text.includes('[@]') && n.parent?.type === 'command') {
-      const first = n.parent.namedChild(0);
-      if (first && first.equals(n)) {
-        return true;
-      }
-    }
-
-    for (const child of n.children) {
-      if (walkForOpacity(child)) return true;
-    }
-    return false;
-  }
-
-  return walkForOpacity(node);
-}
-
-export async function parse(command: string): Promise<ParsedCommand> {
-  const parser = await ensureParser();
-  const tree = parser.parse(command);
-  if (!tree) {
-    // Parser couldn't parse — treat as opaque
-    return { segments: [], dangerousPatterns: [], hasOpaqueConstructs: true };
-  }
-  const rootNode = tree.rootNode;
-
-  const segments = extractSegments(rootNode);
-  const dangerousPatterns = detectDangerousPatterns(rootNode, segments);
-  const hasOpaqueConstructs = detectOpaqueConstructs(rootNode, segments);
-
-  tree.delete();
-
-  return { segments, dangerousPatterns, hasOpaqueConstructs };
-}
-
-export { ensureParser };