apify-test-tools 0.10.1-beta.2 → 0.10.1-beta.4

package/bin/utils/config/actor-json.ts

@@ -0,0 +1,84 @@
+import z from 'zod';
+
+import { safeReadJsonObjectFile } from '../json-file.js';
+import { ExistingFile, type RelativeDir, type RelativeFile } from '../path/repo-relative.js';
+import type { ValidatedActorConfig } from './structures/base.js';
+
+const inlineOrPath = z.union([z.string(), z.record(z.string(), z.unknown())]).nullish();
+
+const ActorJsonFieldsSchema = z.object({
+    dockerContextDir: z.string().default('..'),
+    dockerfile: z.string().optional(),
+    readme: z.string().nullish(),
+    changelog: z.string().nullish(),
+    input: inlineOrPath,
+    inputSchema: inlineOrPath,
+    output: inlineOrPath,
+    outputSchema: inlineOrPath,
+    webServerSchema: inlineOrPath,
+});
+
+export interface ActorJsonPaths {
+    file: ExistingFile;
+    dockerContextDir: RelativeDir;
+    dockerfile?: RelativeFile;
+    readme?: RelativeFile;
+    changelog?: RelativeFile;
+    inputSchema?: RelativeFile;
+    outputSchema?: RelativeFile;
+    webServerSchema?: RelativeFile;
+}
+
+const resolveFile = (actorJsonFile: ExistingFile, field: string, value: unknown): RelativeFile | undefined => {
+    if (typeof value !== 'string') return undefined;
+    try {
+        return actorJsonFile.joinFile(value);
+    } catch (error) {
+        throw new Error(`Invalid "${field}" in "${actorJsonFile}": ${(error as Error).message}`);
+    }
+};
+
+export function readActorJson(config: ValidatedActorConfig): ActorJsonPaths {
+    const actorJsonPath = config.folder.joinFile('.actor/actor.json');
+    let actorJsonFile: ExistingFile;
+    try {
+        actorJsonFile = ExistingFile.initialize(actorJsonPath);
+    } catch {
+        throw new Error(
+            `Cannot read "${actorJsonPath}". Every actor entry must have a corresponding .actor/actor.json file.`,
+        );
+    }
+
+    const json = safeReadJsonObjectFile(actorJsonFile);
+    if (!json.success) throw new Error(`Cannot read "${actorJsonFile}". ${json.failure.message}`);
+
+    const parsed = ActorJsonFieldsSchema.safeParse(json.contents);
+    if (!parsed.success) throw new Error(`Invalid "${actorJsonFile}": ${z.prettifyError(parsed.error)}`);
+
+    const fields = parsed.data;
+    let dockerContextDir: RelativeDir;
+    try {
+        dockerContextDir = actorJsonFile.joinDir(fields.dockerContextDir);
+    } catch (error) {
+        throw new Error(`Invalid "dockerContextDir" in "${actorJsonFile}": ${(error as Error).message}`);
+    }
+
+    return {
+        file: actorJsonFile,
+        dockerContextDir,
+        dockerfile: resolveFile(actorJsonFile, 'dockerfile', fields.dockerfile),
+        readme: resolveFile(actorJsonFile, 'readme', fields.readme),
+        changelog: resolveFile(actorJsonFile, 'changelog', fields.changelog),
+        inputSchema: resolveFile(
+            actorJsonFile,
+            fields.input != null ? 'input' : 'inputSchema',
+            fields.input ?? fields.inputSchema,
+        ),
+        outputSchema: resolveFile(
+            actorJsonFile,
+            fields.output != null ? 'output' : 'outputSchema',
+            fields.output ?? fields.outputSchema,
+        ),
+        webServerSchema: resolveFile(actorJsonFile, 'webServerSchema', fields.webServerSchema),
+    };
+}

package/bin/utils/config/load-config.ts

@@ -1,30 +1,26 @@
-import path from 'node:path';
-
 import { selectActors } from '../../actor-filtering.js';
-import { isPathWithinScope } from '../../path-utils.js';
 import type { ActorConfig } from '../../types.js';
 import { safeReadJsonObjectFile } from '../json-file.js';
+import { type ExistingDir, ExistingFile, type RelativeDir } from '../path/repo-relative.js';
+import { type ActorJsonPaths, readActorJson } from './actor-json.js';
 import { parseConfigFile } from './parser.js';
-import type { ResolvedActorConfig } from './structures/base.js';
+import type { ValidatedActorConfig } from './structures/base.js';
 
 export const CONFIG_FILE_NAME = 'apify-test-tools.config.json';
 
 // Reading the config happens in three stages, each one swappable on its own:
 //
 //   1. file                -> plain object          (safeReadJsonObjectFile)
-//   2. plain object        -> ResolvedActorConfig[] (parseConfigFile — picks a strategy, validates
+//   2. plain object        -> ValidatedActorConfig[] (parseConfigFile — picks a strategy, validates
 //                                                    and normalizes; see ./parser.ts)
-//   3. ResolvedActorConfig -> ActorConfig           (loadActorConfig — merges in .actor/actor.json)
+//   3. ValidatedActorConfig -> LoadedActorConfig    (loadActorConfig — reads .actor/actor.json)
 
 // #region utils
 
-const findOverlappingContextPaths = (contextPaths: string[]): [string, string] | undefined => {
+const findOverlappingContextPaths = (contextPaths: RelativeDir[]): [RelativeDir, RelativeDir] | undefined => {
     for (let i = 0; i < contextPaths.length; i++) {
         for (let j = i + 1; j < contextPaths.length; j++) {
-            if (
-                isPathWithinScope(contextPaths[i], contextPaths[j]) ||
-                isPathWithinScope(contextPaths[j], contextPaths[i])
-            ) {
+            if (contextPaths[i].contains(contextPaths[j]) || contextPaths[j].contains(contextPaths[i])) {
                 return [contextPaths[i], contextPaths[j]];
             }
         }
@@ -32,9 +28,17 @@ const findOverlappingContextPaths = (contextPaths: string[]): [string, string] |
     return undefined;
 };
 
-// The repo root is spelled "" internally but "." in a config file, so report it the way a reader
-// would have written it.
-const displayFolder = (folder: string): string => folder || '.';
+// Downstream ActorConfig consumers still use "" for the repo root.
+const legacyPath = (dir: RelativeDir): string => (dir.path === '.' ? '' : dir.path);
+
+export interface LoadedActorConfig {
+    actorFullName: string;
+    folder: ExistingDir;
+    tokenEnvVar: string;
+    actorJson: ActorJsonPaths;
+    dockerContextDir: RelativeDir;
+    contextPaths: RelativeDir[];
+}
 
 // #endregion
 
@@ -42,7 +46,16 @@ const displayFolder = (folder: string): string => folder || '.';
 
 /** Stage 1 — the config file as a plain object, or a failure phrased for whoever wrote it. */
 const readConfigFileContents = async (): Promise<Record<string, unknown>> => {
-    const file = safeReadJsonObjectFile(CONFIG_FILE_NAME);
+    let configFile: ExistingFile;
+    try {
+        configFile = new ExistingFile(CONFIG_FILE_NAME);
+    } catch {
+        throw new Error(
+            `Config file "${CONFIG_FILE_NAME}" not found in the current directory. ` +
+                `Please create one with the required actor entries.`,
+        );
+    }
+    const file = safeReadJsonObjectFile(configFile);
     if (file.success) {
         return file.contents;
     }
@@ -66,57 +79,44 @@ const readConfigFileContents = async (): Promise<Record<string, unknown>> => {
  * Stage 3 — resolves one normalized entry against the repo, reading the actor's `.actor/actor.json`
  * for its `dockerContextDir` and deciding which paths count as the actor's context.
  */
-export const loadActorConfig = (entry: ResolvedActorConfig): ActorConfig => {
+export const loadActorConfig = (entry: ValidatedActorConfig): LoadedActorConfig => {
     const { folder } = entry;
-    const actorJsonPath = folder ? `${folder}/.actor/actor.json` : '.actor/actor.json';
-
-    const actorJson = safeReadJsonObjectFile(actorJsonPath);
-    if (!actorJson.success) {
-        throw new Error(
-            `Cannot read "${actorJsonPath}". Every actor entry in "${CONFIG_FILE_NAME}" ` +
-                `must have a corresponding .actor/actor.json file.`,
-        );
-    }
-
-    const actorDotDir = folder ? `${folder}/.actor` : '.actor';
-    const rawDockerContextDir =
-        typeof actorJson.contents.dockerContextDir === 'string' ? actorJson.contents.dockerContextDir : '..';
-    const resolved = path.resolve(process.cwd(), actorDotDir, rawDockerContextDir);
-    const dockerContextDir = path.relative(process.cwd(), resolved);
-
-    if (dockerContextDir.startsWith('..')) {
-        throw new Error(
-            `"dockerContextDir" for folder "${displayFolder(folder)}" resolves outside the repository root. ` +
-                `Resolved path: "${dockerContextDir}".`,
-        );
-    }
-
-    const normalizedDockerContextDir = dockerContextDir === '.' ? '' : dockerContextDir;
-    const contextPaths = [...(entry.overrideActorContext ?? [normalizedDockerContextDir])];
+    const actorJson = readActorJson(entry);
+    const { dockerContextDir } = actorJson;
+    const contextPaths = [...(entry.overrideActorContext ?? [dockerContextDir])];
 
     // The actor's own folder is always part of its context. When an explicit "overrideActorContext"
     // doesn't already cover it, add it automatically instead of failing the workflow.
-    if (!contextPaths.some((contextPath) => isPathWithinScope(folder, contextPath))) {
+    if (!contextPaths.some((contextPath) => contextPath.contains(folder))) {
         contextPaths.push(folder);
     }
 
     const overlap = findOverlappingContextPaths(contextPaths);
     if (overlap) {
         throw new Error(
-            `Invalid context paths for folder "${displayFolder(folder)}" in "${CONFIG_FILE_NAME}": ` +
+            `Invalid context paths for folder "${folder}" in "${CONFIG_FILE_NAME}": ` +
                 `"${overlap[0]}" and "${overlap[1]}" overlap. Context paths must not be prefixes of one another.`,
         );
     }
 
     return {
         actorFullName: entry.actorFullName,
-        folder,
+        folder: entry.folder,
         tokenEnvVar: entry.tokenEnvVar,
-        dockerContextDir: normalizedDockerContextDir,
+        actorJson,
+        dockerContextDir,
         contextPaths,
     };
 };
 
+const toLegacyActorConfig = (entry: LoadedActorConfig): ActorConfig => ({
+    actorFullName: entry.actorFullName,
+    folder: legacyPath(entry.folder),
+    tokenEnvVar: entry.tokenEnvVar,
+    dockerContextDir: legacyPath(entry.dockerContextDir),
+    contextPaths: entry.contextPaths.map(legacyPath),
+});
+
 // #endregion
 
 export const readConfigFile = async (selection: { actors: string[]; ignore: string[] }): Promise<ActorConfig[]> => {
@@ -126,7 +126,7 @@ export const readConfigFile = async (selection: { actors: string[]; ignore: stri
     const actorConfigs: ActorConfig[] = [];
     for (const parsed of parsedConfigs) {
         // Sequential on purpose: the first actor with a problem should be the one reported.
-        actorConfigs.push(loadActorConfig(parsed));
+        actorConfigs.push(toLegacyActorConfig(loadActorConfig(parsed)));
     }
 
     return selectActors(selection, actorConfigs);

package/bin/utils/config/parser.ts

@@ -1,6 +1,12 @@
 import z from 'zod';
 
-import { CONFIG_FILE_STRATEGY, type ResolvedActorConfig, type StrategyParser } from './structures/base.js';
+import { ExistingDirSchema, RelativeDirSchema } from '../path/schema.js';
+import {
+    CONFIG_FILE_STRATEGY,
+    type ResolvedActorConfig,
+    type StrategyParser,
+    type ValidatedActorConfig,
+} from './structures/base.js';
 import { GROUPED_PARSER } from './structures/grouped.js';
 import { LEGACY_PARSER } from './structures/legacy.js';
 
@@ -32,32 +38,34 @@ const normalizeFolder = (folder: string): string => {
     return stripped === '.' ? '' : stripped;
 };
 
-/**
- * Normalizes the paths the user wrote and checks the cross-entry invariants a per-entry schema
- * cannot: that no two actors claim the same folder once normalized, nor the same actor on the
- * platform. Collects every violation before throwing, so one run reports all of them rather than
- * only the first.
- *
- * @returns the actors it vouched for, with their paths normalized.
- * @throws Error listing every problem found.
- */
-function verifyConfiguration(body: ResolvedActorConfig[]): ResolvedActorConfig[] {
-    const seenFolders = new Set<string>();
-    const seenActorFullNames = new Set<string>();
-    const errors: string[] = [];
-
+const ValidatedConfigSchema = z.array(
+    z.object({
+        actorFullName: z.string(),
+        folder: ExistingDirSchema,
+        tokenEnvVar: z.string(),
+        overrideActorContext: z.array(RelativeDirSchema).optional(),
+    }),
+);
+
+/** Normalize and validate paths, then check collisions using their final spelling. */
+function verifyConfiguration(body: ResolvedActorConfig[]): ValidatedActorConfig[] {
     const normalized = body.map((entry) => ({
         ...entry,
         folder: normalizeFolder(entry.folder),
         overrideActorContext: entry.overrideActorContext?.map(stripTrailingSlash),
     }));
+    const parsed = ValidatedConfigSchema.safeParse(normalized);
+    if (!parsed.success) throw new Error(z.prettifyError(parsed.error));
 
-    for (const [index, entry] of normalized.entries()) {
+    const seenFolders = new Set<string>();
+    const seenActorFullNames = new Set<string>();
+    const errors: string[] = [];
+    for (const [index, entry] of parsed.data.entries()) {
         // TODO: drop folder uniqueness (this requires several changes on other places)
-        if (seenFolders.has(entry.folder)) {
+        if (seenFolders.has(entry.folder.path)) {
             errors.push(`Duplicate folder "${body[index].folder}". Each actor must have a unique folder.`);
         } else {
-            seenFolders.add(entry.folder);
+            seenFolders.add(entry.folder.path);
         }
 
         if (seenActorFullNames.has(entry.actorFullName)) {
@@ -67,11 +75,8 @@ function verifyConfiguration(body: ResolvedActorConfig[]): ResolvedActorConfig[]
         }
     }
 
-    if (errors.length > 0) {
-        throw new Error(errors.join('\n'));
-    }
-
-    return normalized;
+    if (errors.length > 0) throw new Error(errors.join('\n'));
+    return parsed.data;
 }
 
 // eslint-disable-next-line no-underscore-dangle
@@ -80,10 +85,10 @@ export const _privates = {
     verifyConfiguration,
 };
 
-export function parseConfigFile(body: Record<string, unknown>): ResolvedActorConfig[] {
-    const strategy = selectStrategy(body);
+export function parseConfigFile(body: Record<string, unknown>): ValidatedActorConfig[] {
+    const { mode, ...rest } = body;
+    const strategy = selectStrategy({ mode });
 
-    const resolved = strategy.parse(body);
-    const validated = verifyConfiguration(resolved);
-    return validated;
+    const resolved = strategy.parse(rest);
+    return verifyConfiguration(resolved);
 }

package/bin/utils/config/structures/base.ts

@@ -2,6 +2,8 @@ import { prettifyError, type ZodType } from 'zod';
 
 import { ACTOR_NAME, USERNAME } from '@apify/consts';
 
+import type { ExistingDir, RelativeDir } from '../../path/repo-relative.js';
+
 function stripRegexAnchor(regex: string): string {
     return regex.replace(/^\^/, '').replace(/\$$/, '');
 }
@@ -21,6 +23,11 @@ export interface ResolvedActorConfig {
     overrideActorContext: string[] | undefined;
 }
 
+export interface ValidatedActorConfig extends Omit<ResolvedActorConfig, 'folder' | 'overrideActorContext'> {
+    folder: ExistingDir;
+    overrideActorContext?: RelativeDir[];
+}
+
 export enum CONFIG_FILE_STRATEGY {
     LEGACY = 'legacy',
     GROUPED = 'grouped',

package/bin/utils/json-file.ts

@@ -1,11 +1,13 @@
-import { readFileSync, statSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
+
+import type { ExistingFile } from './path/repo-relative.js';
 
 /**
  * Why a JSON object could not be produced from a path. Callers that already have their own
  * user-facing wording (e.g. the config file reader) switch on this instead of re-deriving the
  * cause from an error message.
  */
-export type JsonObjectReadFailureReason = 'not-a-file' | 'unreadable' | 'invalid-json' | 'not-an-object';
+export type JsonObjectReadFailureReason = 'unreadable' | 'invalid-json' | 'not-an-object';
 
 export type JsonObjectReadResult =
     | { success: true; contents: Record<string, unknown> }
@@ -21,34 +23,29 @@ const failed = (reason: JsonObjectReadFailureReason, message: string): JsonObjec
  * Reads a file and parses it as a JSON object, reporting every way that can go wrong as a value
  * instead of a thrown error — the caller decides which failures are fatal and how to word them.
  */
-export function safeReadJsonObjectFile(path: string): JsonObjectReadResult {
+export function safeReadJsonObjectFile(filePath: ExistingFile): JsonObjectReadResult {
     let file: string;
     try {
-        // `stat`, not `lstat`: a symlink must resolve to its target, matching what `readFile` does below.
-        const stats = statSync(path);
-        if (!stats.isFile()) {
-            return failed('not-a-file', `Expected ${path} to be a file`);
-        }
-        file = readFileSync(path, 'utf8');
+        file = readFileSync(filePath.path, 'utf8');
     } catch {
-        return failed('unreadable', `Expected ${path} to exist or be readable`);
+        return failed('unreadable', `Expected ${filePath} to exist or be readable`);
     }
 
     let parsed: unknown;
     try {
         parsed = JSON.parse(file);
     } catch (err) {
-        return failed('invalid-json', `Failed to parse ${path}: ${err}`);
+        return failed('invalid-json', `Failed to parse ${filePath}: ${err}`);
     }
 
     if (parsed === null) {
-        return failed('not-an-object', `Expected ${path} to be a JSON object, not null`);
+        return failed('not-an-object', `Expected ${filePath} to be a JSON object, not null`);
     }
     if (Array.isArray(parsed)) {
-        return failed('not-an-object', `Expected ${path} to be a JSON object, not an array`);
+        return failed('not-an-object', `Expected ${filePath} to be a JSON object, not an array`);
     }
     if (typeof parsed !== 'object') {
-        return failed('not-an-object', `Expected ${path} to be a JSON object`);
+        return failed('not-an-object', `Expected ${filePath} to be a JSON object`);
     }
 
     return { success: true, contents: parsed as Record<string, unknown> };

package/bin/utils/path/repo-relative.ts

@@ -0,0 +1,156 @@
+/* eslint-disable max-classes-per-file */
+import { statSync } from 'node:fs';
+import path from 'node:path';
+
+// Git and the config file always use "/", so paths are POSIX regardless of the host OS.
+const { posix } = path;
+
+// A file path cannot end in "/", ".", "..", or be empty: each of those names a directory.
+const assertNamesFile = (rawPath: string): void => {
+    const lastSegment = rawPath.slice(rawPath.lastIndexOf('/') + 1);
+    if (lastSegment === '' || lastSegment === '.' || lastSegment === '..') {
+        throw new Error(`Expected a file path, got directory path "${rawPath}".`);
+    }
+};
+
+// Shared by the file and directory paths. Use it as a parameter type where either kind is fine.
+export abstract class AbstractPath {
+    readonly #path: string;
+    constructor(rawPath: string) {
+        if (posix.isAbsolute(rawPath)) {
+            throw new Error(`Expected a relative path, got absolute path "${rawPath}".`);
+        }
+        const normalized = posix.normalize(rawPath);
+        // normalize keeps a trailing slash ("actors/foo/"), which would make equal paths compare unequal.
+        this.#path = normalized.endsWith('/') ? normalized.slice(0, -1) : normalized;
+        this.assertNoEscape(rawPath);
+    }
+
+    // A file and a directory are never equal, even when spelled the same.
+    isEqualTo(other: AbstractPath): boolean {
+        // inheritance safe check, at least one of the two is a subclass of the other
+        const isRelativeOf = this instanceof other.constructor || other instanceof this.constructor;
+        return isRelativeOf && this.#path === other.#path;
+    }
+
+    get path(): string {
+        return this.#path;
+    }
+
+    toString(): string {
+        return this.path;
+    }
+
+    toJSON(): string {
+        return this.path;
+    }
+
+    private assertNoEscape(raw: string): void {
+        if (this.#path === '..' || this.#path.startsWith('../')) {
+            throw new Error(`Path "${raw}" escapes the repo root.`);
+        }
+    }
+}
+
+export class RelativeDir extends AbstractPath {
+    static readonly ROOT = new RelativeDir('.');
+
+    joinDir(relativePath: string): RelativeDir {
+        return new RelativeDir(this.join(relativePath));
+    }
+
+    joinFile(relativePath: string): RelativeFile {
+        // Must be checked before joining: posix.join('actors/foo', '.') is "actors/foo", which looks like a file.
+        assertNamesFile(relativePath);
+        return new RelativeFile(this.join(relativePath));
+    }
+
+    // True when `other` is this directory itself or lies inside it.
+    contains(other: AbstractPath): boolean {
+        // the root contains every path
+        if (this.path === '.') return true;
+        return this.isEqualTo(other) || other.path.startsWith(`${this.path}/`);
+    }
+
+    isStrictAncestorOf(other: AbstractPath): boolean {
+        // you are not an ancestor of yourself
+        return !this.isEqualTo(other) && this.contains(other);
+    }
+
+    // Throws unless this path exists and is a directory. Paths resolve against the process working
+    // directory, which is the repo root.
+    assertIsDir(): this {
+        // `stat`, not `lstat`: a symlink must resolve to its target, matching what reading it does.
+        const stats = statSync(this.path, { throwIfNoEntry: false });
+        if (!stats) throw new Error(`Expected directory "${this}" to exist.`);
+        if (!stats.isDirectory()) throw new Error(`Expected "${this}" to be a directory.`);
+        return this;
+    }
+
+    private join(relativePath: string): string {
+        // Must be checked here: posix.join('.', '/etc') is "etc", so the constructor would not catch it.
+        if (posix.isAbsolute(relativePath)) {
+            throw new Error(`Expected a relative path to join with "${this}", got absolute path "${relativePath}".`);
+        }
+        return posix.join(this.path, relativePath);
+    }
+}
+
+export class ExistingDir extends RelativeDir {
+    constructor(rawPath: string) {
+        super(rawPath);
+        this.assertIsDir();
+    }
+
+    static initialize(dir: RelativeDir): ExistingDir {
+        return new ExistingDir(dir.path);
+    }
+}
+
+export class RelativeFile extends AbstractPath {
+    constructor(rawPath: string) {
+        assertNamesFile(rawPath);
+        super(rawPath);
+    }
+
+    // The directory containing this file.
+    get parent(): RelativeDir {
+        return new RelativeDir(posix.dirname(this.path));
+    }
+
+    // Resolves against the file's directory, the way a path written inside the file is meant
+    // (e.g. `dockerContextDir: ".."` in `.actor/actor.json` is the actor folder).
+    joinDir(relativePath: string): RelativeDir {
+        return this.parent.joinDir(relativePath);
+    }
+
+    // Resolves against the file's directory, e.g. a sibling file.
+    joinFile(relativePath: string): RelativeFile {
+        return this.parent.joinFile(relativePath);
+    }
+
+    isWithin(scope: RelativeDir): boolean {
+        return scope.contains(this);
+    }
+
+    // Throws unless this path exists and is a file. Paths resolve against the process working
+    // directory, which is the repo root.
+    assertIsFile(): this {
+        // `stat`, not `lstat`: a symlink must resolve to its target, matching what reading it does.
+        const stats = statSync(this.path, { throwIfNoEntry: false });
+        if (!stats) throw new Error(`Expected file "${this}" to exist.`);
+        if (!stats.isFile()) throw new Error(`Expected "${this}" to be a file.`);
+        return this;
+    }
+}
+
+export class ExistingFile extends RelativeFile {
+    constructor(rawPath: string) {
+        super(rawPath);
+        this.assertIsFile();
+    }
+
+    static initialize(file: RelativeFile): ExistingFile {
+        return new ExistingFile(file.path);
+    }
+}

package/bin/utils/path/schema.ts

@@ -0,0 +1,18 @@
+import z from 'zod';
+
+import { ExistingDir, ExistingFile, RelativeDir, RelativeFile } from './repo-relative.js';
+
+const parsePath = <T>(construct: (value: string) => T) =>
+    z.string().transform((value, ctx): T | typeof z.NEVER => {
+        try {
+            return construct(value);
+        } catch (error) {
+            ctx.addIssue({ code: 'custom', message: error instanceof Error ? error.message : String(error) });
+            return z.NEVER;
+        }
+    });
+
+export const RelativeDirSchema = parsePath((value) => new RelativeDir(value));
+export const ExistingDirSchema = parsePath((value) => new ExistingDir(value));
+export const RelativeFileSchema = parsePath((value) => new RelativeFile(value));
+export const ExistingFileSchema = parsePath((value) => new ExistingFile(value));