vellum 0.2.13 → 0.3.2

package/src/tools/schedule/list.ts

@@ -1,69 +0,0 @@
-import type { ToolContext, ToolExecutionResult } from '../types.js';
-import { listSchedules, getSchedule, getScheduleRuns, formatLocalDate, describeCronExpression } from '../../schedule/schedule-store.js';
-import { hasSetConstructs } from '../../schedule/recurrence-engine.js';
-
-function describeSchedule(job: { syntax: string; expression: string; cronExpression: string }): string {
-  if (job.syntax === 'rrule') {
-    const label = hasSetConstructs(job.expression) ? '[RRULE set] ' : '';
-    return `${label}${job.expression}`;
-  }
-  return describeCronExpression(job.cronExpression);
-}
-
-export async function executeScheduleList(
-  input: Record<string, unknown>,
-  _context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const jobId = input.job_id as string | undefined;
-  const enabledOnly = (input.enabled_only as boolean) ?? false;
-
-  // Detail mode for a specific job
-  if (jobId) {
-    const job = getSchedule(jobId);
-    if (!job) {
-      return { content: `Error: Schedule not found: ${jobId}`, isError: true };
-    }
-
-    const runs = getScheduleRuns(jobId, 5);
-    const lines = [
-      `Schedule: ${job.name}`,
-      `  Syntax: ${job.syntax}`,
-      `  Expression: ${job.expression}`,
-      `  Schedule: ${describeSchedule(job)}${job.timezone ? ` (${job.timezone})` : ''}`,
-      `  Enabled: ${job.enabled}`,
-      `  Message: ${job.message}`,
-      `  Next run: ${formatLocalDate(job.nextRunAt)}`,
-      `  Last run: ${job.lastRunAt ? formatLocalDate(job.lastRunAt) : 'never'}`,
-      `  Last status: ${job.lastStatus ?? 'n/a'}`,
-      `  Retry count: ${job.retryCount}`,
-      `  Created: ${formatLocalDate(job.createdAt)}`,
-    ];
-
-    if (runs.length > 0) {
-      lines.push('', `Recent runs (${runs.length}):`);
-      for (const run of runs) {
-        const dur = run.durationMs != null ? `${run.durationMs}ms` : 'n/a';
-        lines.push(`  - ${run.status} at ${formatLocalDate(run.startedAt)} (${dur})${run.error ? ` error: ${run.error}` : ''}`);
-      }
-    } else {
-      lines.push('', 'No runs yet.');
-    }
-
-    return { content: lines.join('\n'), isError: false };
-  }
-
-  // List mode
-  const jobs = listSchedules({ enabledOnly });
-  if (jobs.length === 0) {
-    return { content: 'No schedules found.', isError: false };
-  }
-
-  const lines = [`Schedules (${jobs.length}):`];
-  for (const job of jobs) {
-    const status = job.enabled ? 'enabled' : 'disabled';
-    const next = job.enabled ? formatLocalDate(job.nextRunAt) : 'n/a';
-    lines.push(`  - [${status}] ${job.name} ([${job.syntax}] ${describeSchedule(job)}) — next: ${next}`);
-  }
-
-  return { content: lines.join('\n'), isError: false };
-}

package/src/tools/schedule/update.ts

@@ -1,90 +0,0 @@
-import type { ToolContext, ToolExecutionResult } from '../types.js';
-import { updateSchedule, formatLocalDate, describeCronExpression } from '../../schedule/schedule-store.js';
-import { normalizeScheduleSyntax, type ScheduleSyntax } from '../../schedule/recurrence-types.js';
-import { validateRruleSetLines } from '../../schedule/recurrence-engine.js';
-
-export async function executeScheduleUpdate(
-  input: Record<string, unknown>,
-  _context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const jobId = input.job_id as string;
-  if (!jobId || typeof jobId !== 'string') {
-    return { content: 'Error: job_id is required', isError: true };
-  }
-
-  const updates: Record<string, unknown> = {};
-  if (input.name !== undefined) updates.name = input.name;
-  if (input.timezone !== undefined) updates.timezone = input.timezone;
-  if (input.message !== undefined) updates.message = input.message;
-  if (input.enabled !== undefined) updates.enabled = input.enabled;
-
-  // Auto-detect syntax when expression changes without explicit syntax
-  const hasExpression = input.expression !== undefined || input.cron_expression !== undefined;
-  if (hasExpression || input.syntax !== undefined) {
-    const resolved = normalizeScheduleSyntax({
-      syntax: input.syntax as 'cron' | 'rrule' | undefined,
-      expression: input.expression as string | undefined,
-      legacyCronExpression: input.cron_expression as string | undefined,
-    });
-    if (resolved) {
-      updates.syntax = resolved.syntax;
-      updates.expression = resolved.expression;
-    } else if (input.expression !== undefined) {
-      updates.expression = input.expression;
-    } else if (input.cron_expression !== undefined) {
-      updates.cronExpression = input.cron_expression;
-    }
-  }
-
-  if (Object.keys(updates).length === 0) {
-    return { content: 'Error: No updates provided. Specify at least one field to update.', isError: true };
-  }
-
-  // Set-aware pre-validation for RRULE expressions
-  const effectiveSyntax = updates.syntax as string | undefined;
-  const effectiveExpr = (updates.expression as string | undefined) ?? (updates.cronExpression as string | undefined);
-  if (effectiveExpr && typeof effectiveExpr === 'string' && (effectiveSyntax === 'rrule' || /^(DTSTART|RRULE:)/m.test(effectiveExpr))) {
-    const setError = validateRruleSetLines(effectiveExpr);
-    if (setError) {
-      return {
-        content: `Error: ${setError}. Supported line types: DTSTART, RRULE, RDATE, EXDATE, EXRULE.`,
-        isError: true,
-      };
-    }
-  }
-
-  try {
-    const job = updateSchedule(jobId, updates as {
-      name?: string;
-      cronExpression?: string;
-      timezone?: string | null;
-      message?: string;
-      enabled?: boolean;
-      syntax?: ScheduleSyntax;
-      expression?: string;
-    });
-
-    if (!job) {
-      return { content: `Error: Schedule not found: ${jobId}`, isError: true };
-    }
-
-    const scheduleDescription = job.syntax === 'rrule'
-      ? job.expression
-      : describeCronExpression(job.cronExpression);
-
-    return {
-      content: [
-        `Schedule updated successfully.`,
-        `  Name: ${job.name}`,
-        `  Syntax: ${job.syntax}`,
-        `  Schedule: ${scheduleDescription}${job.timezone ? ` (${job.timezone})` : ''}`,
-        `  Enabled: ${job.enabled}`,
-        `  Next run: ${job.enabled ? formatLocalDate(job.nextRunAt) : 'n/a (disabled)'}`,
-      ].join('\n'),
-      isError: false,
-    };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { content: `Error updating schedule: ${msg}`, isError: true };
-  }
-}

package/src/tools/shared/filesystem/edit-engine.ts

@@ -1,56 +0,0 @@
-import { findAllMatches, adjustIndentation } from '../../filesystem/fuzzy-match.js';
-import type { MatchMethod } from '../../filesystem/fuzzy-match.js';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type EditEngineResult =
-  | { ok: true; updatedContent: string; matchCount: number; matchMethod: MatchMethod; similarity: number; actualOld: string; actualNew: string }
-  | { ok: false; reason: 'not_found' }
-  | { ok: false; reason: 'ambiguous'; matchCount: number };
-
-// ---------------------------------------------------------------------------
-// Engine
-// ---------------------------------------------------------------------------
-
-/**
- * Core match/replace logic shared by both sandbox and host edit tools,
- * and by the executor's preview-diff computation.
- *
- * This function is pure — it takes file content and edit parameters and
- * returns the result without performing any I/O.
- */
-export function applyEdit(
-  content: string,
-  oldString: string,
-  newString: string,
-  replaceAll: boolean,
-): EditEngineResult {
-  if (replaceAll) {
-    const firstIndex = content.indexOf(oldString);
-    if (firstIndex === -1) {
-      return { ok: false, reason: 'not_found' };
-    }
-    const count = content.split(oldString).length - 1;
-    const updatedContent = content.split(oldString).join(newString);
-    return { ok: true, updatedContent, matchCount: count, matchMethod: 'exact', similarity: 1, actualOld: oldString, actualNew: newString };
-  }
-
-  // Single-match path: cascading exact -> whitespace -> fuzzy
-  const matches = findAllMatches(content, oldString);
-  if (matches.length === 0) {
-    return { ok: false, reason: 'not_found' };
-  }
-  if (matches.length > 1) {
-    return { ok: false, reason: 'ambiguous', matchCount: matches.length };
-  }
-
-  const match = matches[0];
-  const adjustedNewString = match.method !== 'exact'
-    ? adjustIndentation(oldString, match.matched, newString)
-    : newString;
-
-  const updatedContent = content.slice(0, match.start) + adjustedNewString + content.slice(match.end);
-  return { ok: true, updatedContent, matchCount: 1, matchMethod: match.method, similarity: match.similarity, actualOld: match.matched, actualNew: adjustedNewString };
-}

package/src/tools/shared/filesystem/errors.ts

@@ -1,85 +0,0 @@
-// ---------------------------------------------------------------------------
-// Error codes
-// ---------------------------------------------------------------------------
-
-export type FsErrorCode =
-  | 'INVALID_PATH'
-  | 'PATH_OUT_OF_BOUNDS'
-  | 'PATH_NOT_ABSOLUTE'
-  | 'NOT_FOUND'
-  | 'NOT_A_FILE'
-  | 'SIZE_LIMIT_EXCEEDED'
-  | 'MATCH_NOT_FOUND'
-  | 'MATCH_AMBIGUOUS'
-  | 'IO_ERROR';
-
-// ---------------------------------------------------------------------------
-// Error type
-// ---------------------------------------------------------------------------
-
-export interface FsError {
-  code: FsErrorCode;
-  message: string;
-  /** The path that caused the error, when applicable. */
-  path?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Constructors
-// ---------------------------------------------------------------------------
-
-export function invalidPath(path: string, reason: string): FsError {
-  return { code: 'INVALID_PATH', message: reason, path };
-}
-
-export function pathOutOfBounds(path: string, boundary: string): FsError {
-  return {
-    code: 'PATH_OUT_OF_BOUNDS',
-    message: `Path "${path}" resolves outside the allowed boundary "${boundary}"`,
-    path,
-  };
-}
-
-export function pathNotAbsolute(path: string): FsError {
-  return {
-    code: 'PATH_NOT_ABSOLUTE',
-    message: `Path must be absolute: ${path}`,
-    path,
-  };
-}
-
-export function notFound(path: string): FsError {
-  return { code: 'NOT_FOUND', message: `File not found: ${path}`, path };
-}
-
-export function notAFile(path: string): FsError {
-  return { code: 'NOT_A_FILE', message: `Not a regular file: ${path}`, path };
-}
-
-export function sizeLimitExceeded(path: string, detail: string): FsError {
-  return {
-    code: 'SIZE_LIMIT_EXCEEDED',
-    message: detail,
-    path,
-  };
-}
-
-export function matchNotFound(path: string): FsError {
-  return {
-    code: 'MATCH_NOT_FOUND',
-    message: `old_string not found in ${path}`,
-    path,
-  };
-}
-
-export function matchAmbiguous(path: string, count: number): FsError {
-  return {
-    code: 'MATCH_AMBIGUOUS',
-    message: `old_string appears ${count} times in ${path}. Provide more surrounding context to make it unique, or set replace_all to true.`,
-    path,
-  };
-}
-
-export function ioError(path: string, detail: string): FsError {
-  return { code: 'IO_ERROR', message: detail, path };
-}

package/src/tools/shared/filesystem/file-ops-service.ts

@@ -1,215 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-
-import type { PathResult, PathFailureReason } from './path-policy.js';
-import { checkFileSizeOnDisk, checkContentSize } from './size-guard.js';
-import { applyEdit } from './edit-engine.js';
-import type {
-  ReadInput, ReadResult,
-  WriteInput, WriteResult,
-  EditInput, EditResult,
-} from './types.js';
-import * as Err from './errors.js';
-
-// ---------------------------------------------------------------------------
-// Path policy hook
-// ---------------------------------------------------------------------------
-
-/**
- * A function that validates a raw path and returns a resolved absolute path
- * or an error string. Both sandbox and host policies satisfy this shape.
- */
-export type PathPolicy = (
-  rawPath: string,
-  options?: { mustExist?: boolean },
-) => PathResult;
-
-// ---------------------------------------------------------------------------
-// Service
-// ---------------------------------------------------------------------------
-
-function pathError(path: string, reason: PathFailureReason, detail: string): Err.FsError {
-  switch (reason) {
-    case 'not_absolute': return Err.pathNotAbsolute(path);
-    case 'out_of_bounds': return { code: 'PATH_OUT_OF_BOUNDS', message: detail, path };
-  }
-}
-
-export class FileSystemOps {
-  private policy: PathPolicy;
-  private sizeLimit: number | undefined;
-
-  constructor(policy: PathPolicy, options?: { sizeLimit?: number }) {
-    this.policy = policy;
-    this.sizeLimit = options?.sizeLimit;
-  }
-
-  // -------------------------------------------------------------------------
-  // Read
-  // -------------------------------------------------------------------------
-
-  readFileSafe(input: ReadInput): ReadResult {
-    const pathCheck = this.policy(input.path, { mustExist: true });
-    if (!pathCheck.ok) {
-      return { ok: false, error: pathError(input.path, pathCheck.reason, pathCheck.error) };
-    }
-    const filePath = pathCheck.resolved;
-
-    if (!existsSync(filePath)) {
-      return { ok: false, error: Err.notFound(filePath) };
-    }
-
-    const stat = statSync(filePath);
-    if (!stat.isFile()) {
-      return { ok: false, error: Err.notAFile(filePath) };
-    }
-
-    const sizeErr = checkFileSizeOnDisk(filePath, this.sizeLimit);
-    if (sizeErr) {
-      return { ok: false, error: Err.sizeLimitExceeded(filePath, sizeErr) };
-    }
-
-    try {
-      const raw = readFileSync(filePath, 'utf-8');
-      const lines = raw.split('\n');
-
-      const offset = (input.offset ?? 1) - 1;
-      const limit = input.limit ?? lines.length;
-      const selected = lines.slice(Math.max(0, offset), offset + limit);
-
-      const numbered = selected
-        .map((line, i) => {
-          const lineNum = offset + i + 1;
-          return `${String(lineNum).padStart(6)}  ${line}`;
-        })
-        .join('\n');
-
-      return { ok: true, value: { content: numbered } };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { ok: false, error: Err.ioError(filePath, msg) };
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Write
-  // -------------------------------------------------------------------------
-
-  writeFileSafe(input: WriteInput): WriteResult {
-    const pathCheck = this.policy(input.path, { mustExist: false });
-    if (!pathCheck.ok) {
-      return { ok: false, error: pathError(input.path, pathCheck.reason, pathCheck.error) };
-    }
-    const filePath = pathCheck.resolved;
-
-    const sizeErr = checkContentSize(input.content, filePath, this.sizeLimit);
-    if (sizeErr) {
-      return { ok: false, error: Err.sizeLimitExceeded(filePath, sizeErr) };
-    }
-
-    try {
-      const dir = dirname(filePath);
-      if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-      }
-
-      let oldContent = '';
-      const isNewFile = !existsSync(filePath);
-      if (!isNewFile) {
-        try {
-          oldContent = readFileSync(filePath, 'utf-8');
-        } catch {
-          // Unreadable existing file — keep oldContent as empty string.
-        }
-      }
-
-      writeFileSync(filePath, input.content);
-
-      return {
-        ok: true,
-        value: {
-          filePath,
-          isNewFile,
-          oldContent,
-          newContent: input.content,
-        },
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { ok: false, error: Err.ioError(filePath, msg) };
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Edit
-  // -------------------------------------------------------------------------
-
-  editFileSafe(input: EditInput): EditResult {
-    const pathCheck = this.policy(input.path, { mustExist: true });
-    if (!pathCheck.ok) {
-      return { ok: false, error: pathError(input.path, pathCheck.reason, pathCheck.error) };
-    }
-    const filePath = pathCheck.resolved;
-
-    // Size-check the file on disk (swallow ENOENT — readFileSync gives a clearer error)
-    try {
-      const sizeErr = checkFileSizeOnDisk(filePath, this.sizeLimit);
-      if (sizeErr) {
-        return { ok: false, error: Err.sizeLimitExceeded(filePath, sizeErr) };
-      }
-    } catch {
-      // Fall through — the readFileSync below will surface NOT_FOUND.
-    }
-
-    let content: string;
-    try {
-      content = readFileSync(filePath, 'utf-8');
-    } catch (err) {
-      const code = err instanceof Error && 'code' in err
-        ? (err as NodeJS.ErrnoException).code
-        : undefined;
-      if (code === 'EISDIR') {
-        return { ok: false, error: Err.notAFile(filePath) };
-      }
-      if (code === 'ENOENT') {
-        return { ok: false, error: Err.notFound(filePath) };
-      }
-      const msg = err instanceof Error ? err.message : String(err);
-      return { ok: false, error: Err.ioError(filePath, msg) };
-    }
-
-    if (input.oldString.length === 0) {
-      return { ok: false, error: Err.matchNotFound(filePath) };
-    }
-
-    const result = applyEdit(content, input.oldString, input.newString, input.replaceAll);
-
-    if (!result.ok) {
-      if (result.reason === 'not_found') {
-        return { ok: false, error: Err.matchNotFound(filePath) };
-      }
-      return { ok: false, error: Err.matchAmbiguous(filePath, result.matchCount) };
-    }
-
-    try {
-      writeFileSync(filePath, result.updatedContent);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { ok: false, error: Err.ioError(filePath, msg) };
-    }
-
-    return {
-      ok: true,
-      value: {
-        filePath,
-        matchCount: result.matchCount,
-        oldContent: content,
-        newContent: result.updatedContent,
-        matchMethod: result.matchMethod,
-        similarity: result.similarity,
-        actualOld: result.actualOld,
-        actualNew: result.actualNew,
-      },
-    };
-  }
-}

package/src/tools/shared/filesystem/format-diff.ts

@@ -1,35 +0,0 @@
-const MAX_DIFF_LINES = 8;
-
-/**
- * Build a compact inline diff from an old→new string replacement.
- * Lines are prefixed with - / + and truncated if the change is large.
- */
-export function formatEditDiff(oldString: string, newString: string): string {
-  const removed = oldString.length > 0
-    ? truncateLines(oldString.split('\n'), MAX_DIFF_LINES).map(l => `- ${l}`)
-    : [];
-  const added = newString.length > 0
-    ? truncateLines(newString.split('\n'), MAX_DIFF_LINES).map(l => `+ ${l}`)
-    : [];
-
-  return [...removed, ...added].join('\n');
-}
-
-/**
- * Build a one-line summary for a file write.
- */
-export function formatWriteSummary(oldContent: string, newContent: string, isNewFile: boolean): string {
-  const newLineCount = newContent.split('\n').length;
-  if (isNewFile) {
-    return `(new file, ${newLineCount} line${newLineCount !== 1 ? 's' : ''})`;
-  }
-  const oldLineCount = oldContent.split('\n').length;
-  return `(${oldLineCount} → ${newLineCount} lines)`;
-}
-
-function truncateLines(lines: string[], max: number): string[] {
-  if (lines.length <= max) return lines;
-  const kept = lines.slice(0, max);
-  kept.push(`... (${lines.length - max} more lines)`);
-  return kept;
-}

package/src/tools/shared/filesystem/path-policy.ts

@@ -1,125 +0,0 @@
-import { resolve, relative, dirname, basename, join, isAbsolute } from 'node:path';
-import { realpathSync } from 'node:fs';
-
-/**
- * Result type shared by both sandbox and host path policies.
- */
-export type PathFailureReason = 'not_absolute' | 'out_of_bounds';
-
-export type PathResult =
-  | { ok: true; resolved: string }
-  | { ok: false; reason: PathFailureReason; error: string };
-
-// The Docker sandbox mounts the host workspace at /workspace inside the
-// container. The model generates container-scoped paths (e.g.
-// "/workspace/scratch/file.png") that need to be remapped to the host
-// boundary directory before validation.
-const CONTAINER_WORKSPACE_PREFIX = '/workspace/';
-const CONTAINER_WORKSPACE_EXACT = '/workspace';
-
-// ---------------------------------------------------------------------------
-// Sandbox policy
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve a user-supplied path against a boundary directory and verify
- * that the result stays within it.
- *
- * For existing paths, symlinks are resolved via realpathSync so a symlink
- * pointing outside the boundary is caught. For new paths (e.g. file_write),
- * pass `mustExist: false` — the nearest existing ancestor directory is
- * resolved via realpathSync to catch symlinks in parent dirs.
- *
- * Paths starting with `/workspace/` are treated as container-scoped and
- * remapped relative to the boundary directory (the Docker sandbox mounts
- * the host workspace at /workspace).
- */
-export function sandboxPolicy(
-  rawPath: string,
-  boundaryDir: string,
-  options?: { mustExist?: boolean },
-): PathResult {
-  const mustExist = options?.mustExist ?? true;
-
-  // Remap container-scoped /workspace paths to the host boundary dir.
-  // Skip remapping if the path already starts with boundaryDir to avoid
-  // double-nesting (e.g. /workspace/project/file.ts → /workspace/project/project/file.ts
-  // when boundaryDir is /workspace/project).
-  let effectivePath = rawPath;
-  if (
-    !rawPath.startsWith(boundaryDir + '/') &&
-    rawPath !== boundaryDir
-  ) {
-    if (rawPath.startsWith(CONTAINER_WORKSPACE_PREFIX)) {
-      effectivePath = rawPath.slice(CONTAINER_WORKSPACE_PREFIX.length);
-    } else if (rawPath === CONTAINER_WORKSPACE_EXACT) {
-      effectivePath = '.';
-    }
-  }
-
-  const resolved = resolve(boundaryDir, effectivePath);
-
-  // Resolve symlinks to catch symlink-based escapes.
-  // For mustExist=false, walk up to the nearest existing ancestor and
-  // resolve it, then re-append the trailing components.
-  let realResolved = resolved;
-  if (mustExist) {
-    try {
-      realResolved = realpathSync(resolved);
-    } catch {
-      // File doesn't exist — will be caught by the tool's own existence check
-      realResolved = resolved;
-    }
-  } else {
-    let current = resolved;
-    const trailing: string[] = [];
-    while (current !== dirname(current)) {
-      try {
-        const real = realpathSync(current);
-        realResolved = trailing.length > 0 ? join(real, ...trailing) : real;
-        break;
-      } catch {
-        trailing.unshift(basename(current));
-        current = dirname(current);
-      }
-    }
-  }
-
-  // Resolve the boundary directory's real path too (in case it's a symlink)
-  let realBoundary: string;
-  try {
-    realBoundary = realpathSync(boundaryDir);
-  } catch {
-    realBoundary = boundaryDir;
-  }
-
-  const rel = relative(realBoundary, realResolved);
-  if (rel.startsWith('..') || resolve(realBoundary, rel) !== realResolved) {
-    return {
-      ok: false,
-      reason: 'out_of_bounds',
-      error: `Path "${rawPath}" resolves to "${realResolved}" which is outside the working directory "${realBoundary}"`,
-    };
-  }
-
-  return { ok: true, resolved };
-}
-
-// ---------------------------------------------------------------------------
-// Host policy
-// ---------------------------------------------------------------------------
-
-/**
- * Validate a path for host filesystem access.
- * Only requirement: the path must be absolute. No sandbox boundary check.
- */
-export function hostPolicy(rawPath: string): PathResult {
-  if (!isAbsolute(rawPath)) {
-    return {
-      ok: false,
-      reason: 'not_absolute',
-      error: `path must be absolute for host file access: ${rawPath}`,
-    };
-  }
-  return { ok: true, resolved: rawPath };
-}