terminal-pilot 0.0.30 → 0.0.32

package/node_modules/@poe-code/config-mutations/dist/execution/path-utils.d.ts

@@ -0,0 +1,17 @@
+import type { PathMapper } from "../types.js";
+/**
+ * Expand ~ shortcut to the provided home directory.
+ */
+export declare function expandHome(targetPath: string, homeDir: string): string;
+/**
+ * Validate that a path is home-relative (starts with ~).
+ * Throws if the path is not home-relative.
+ */
+export declare function validateHomePath(targetPath: string): void;
+/**
+ * Resolve a path with optional path mapping for isolated configurations.
+ * 1. Validates the path starts with ~
+ * 2. Expands ~ to home directory
+ * 3. If pathMapper is provided, maps the directory portion and reconstructs the path
+ */
+export declare function resolvePath(rawPath: string, homeDir: string, pathMapper?: PathMapper): string;

package/node_modules/@poe-code/config-mutations/dist/execution/path-utils.js

@@ -0,0 +1,64 @@
+import path from "node:path";
+/**
+ * Expand ~ shortcut to the provided home directory.
+ */
+export function expandHome(targetPath, homeDir) {
+    if (!targetPath?.startsWith("~")) {
+        return targetPath;
+    }
+    // Handle ~./ -> ~/.
+    if (targetPath.startsWith("~./")) {
+        targetPath = `~/.${targetPath.slice(3)}`;
+    }
+    let remainder = targetPath.slice(1);
+    // Remove leading slash or backslash
+    if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+        remainder = remainder.slice(1);
+    }
+    else if (remainder.startsWith(".")) {
+        // Handle ~/.
+        remainder = remainder.slice(1);
+        if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+            remainder = remainder.slice(1);
+        }
+    }
+    return remainder.length === 0 ? homeDir : path.join(homeDir, remainder);
+}
+/**
+ * Validate that a path is home-relative (starts with ~).
+ * Throws if the path is not home-relative.
+ */
+export function validateHomePath(targetPath) {
+    if (typeof targetPath !== "string" || targetPath.length === 0) {
+        throw new Error("Target path must be a non-empty string.");
+    }
+    if (!targetPath.startsWith("~")) {
+        throw new Error(`All target paths must be home-relative (start with ~). Received: "${targetPath}"`);
+    }
+}
+/**
+ * Resolve a path with optional path mapping for isolated configurations.
+ * 1. Validates the path starts with ~
+ * 2. Expands ~ to home directory
+ * 3. If pathMapper is provided, maps the directory portion and reconstructs the path
+ */
+export function resolvePath(rawPath, homeDir, pathMapper) {
+    validateHomePath(rawPath);
+    const expanded = expandHome(rawPath, homeDir);
+    const canonicalHome = path.resolve(homeDir);
+    const canonicalExpanded = path.resolve(expanded);
+    const relative = path.relative(canonicalHome, canonicalExpanded);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error(`Target path resolves outside home directory: "${rawPath}"`);
+    }
+    if (!pathMapper) {
+        return canonicalExpanded;
+    }
+    // Map the directory portion
+    const rawDirectory = path.dirname(expanded);
+    const mappedDirectory = pathMapper.mapTargetDirectory({
+        targetDirectory: rawDirectory
+    });
+    const filename = path.basename(expanded);
+    return filename.length === 0 ? mappedDirectory : path.join(mappedDirectory, filename);
+}

package/node_modules/@poe-code/config-mutations/dist/execution/run-mutations.d.ts

@@ -0,0 +1,7 @@
+import type { Mutation, MutationContext, MutationResult, MutationOptions } from "../types.js";
+/**
+ * Execute an array of mutations in order.
+ *
+ * All dependencies must be injected - no defaults, no globals.
+ */
+export declare function runMutations(mutations: Mutation[], context: MutationContext, options?: MutationOptions): Promise<MutationResult>;

package/node_modules/@poe-code/config-mutations/dist/execution/run-mutations.js

@@ -0,0 +1,39 @@
+import { applyMutation, resolveMutationDetails } from "./apply-mutation.js";
+/**
+ * Execute an array of mutations in order.
+ *
+ * All dependencies must be injected - no defaults, no globals.
+ */
+export async function runMutations(mutations, context, options) {
+    const effects = [];
+    let anyChanged = false;
+    const resolverOptions = options ?? {};
+    for (const mutation of mutations) {
+        const { outcome } = await executeMutation(mutation, context, resolverOptions);
+        effects.push(outcome);
+        if (outcome.changed) {
+            anyChanged = true;
+        }
+    }
+    return {
+        changed: anyChanged,
+        effects
+    };
+}
+async function executeMutation(mutation, context, options) {
+    const pendingDetails = resolveMutationDetails(mutation, context, options);
+    // Call onStart observer
+    context.observers?.onStart?.(pendingDetails);
+    try {
+        const { outcome, details } = await applyMutation(mutation, context, options);
+        // Call onComplete observer
+        context.observers?.onComplete?.(details, outcome);
+        return { outcome, details };
+    }
+    catch (error) {
+        // Call onError observer
+        context.observers?.onError?.(pendingDetails, error);
+        // Re-throw the error
+        throw error;
+    }
+}

package/node_modules/@poe-code/config-mutations/dist/formats/index.d.ts

@@ -0,0 +1,13 @@
+import type { ConfigFormat } from "../types.js";
+export type FormatName = "json" | "toml" | "yaml";
+/**
+ * Get a format handler by path (auto-detect from extension) or explicit format name.
+ */
+export declare function getConfigFormat(pathOrFormat: string): ConfigFormat;
+/**
+ * Detect format name from a file path.
+ */
+export declare function detectFormat(path: string): FormatName | undefined;
+export { jsonFormat } from "./json.js";
+export { tomlFormat } from "./toml.js";
+export { yamlFormat } from "./yaml.js";

package/node_modules/@poe-code/config-mutations/dist/formats/index.js

@@ -0,0 +1,49 @@
+import { jsonFormat } from "./json.js";
+import { tomlFormat } from "./toml.js";
+import { yamlFormat } from "./yaml.js";
+const formatRegistry = {
+    json: jsonFormat,
+    toml: tomlFormat,
+    yaml: yamlFormat
+};
+const extensionMap = {
+    ".json": "json",
+    ".toml": "toml",
+    ".yaml": "yaml",
+    ".yml": "yaml"
+};
+/**
+ * Get a format handler by path (auto-detect from extension) or explicit format name.
+ */
+export function getConfigFormat(pathOrFormat) {
+    // Check if it's an explicit format name
+    if (Object.prototype.hasOwnProperty.call(formatRegistry, pathOrFormat)) {
+        return formatRegistry[pathOrFormat];
+    }
+    // Try to detect from extension
+    const ext = getExtension(pathOrFormat);
+    const formatName = extensionMap[ext];
+    if (!formatName) {
+        throw new Error(`Unsupported config format. Cannot detect format from "${pathOrFormat}". ` +
+            `Supported extensions: ${Object.keys(extensionMap).join(", ")}. ` +
+            `Supported format names: ${Object.keys(formatRegistry).join(", ")}.`);
+    }
+    return formatRegistry[formatName];
+}
+/**
+ * Detect format name from a file path.
+ */
+export function detectFormat(path) {
+    const ext = getExtension(path);
+    return extensionMap[ext];
+}
+function getExtension(path) {
+    const lastDot = path.lastIndexOf(".");
+    if (lastDot === -1) {
+        return "";
+    }
+    return path.slice(lastDot).toLowerCase();
+}
+export { jsonFormat } from "./json.js";
+export { tomlFormat } from "./toml.js";
+export { yamlFormat } from "./yaml.js";

package/node_modules/@poe-code/config-mutations/dist/formats/json.d.ts

@@ -0,0 +1,32 @@
+import type { ConfigFormat, ConfigObject, ConfigValue } from "../types.js";
+declare function detectIndent(content: string): string;
+/**
+ * Modify JSON content at a specific path while preserving comments and formatting.
+ * Uses jsonc-parser's modify() for targeted updates.
+ *
+ * @param content - The original JSON content (may include comments)
+ * @param path - JSON path array, e.g. ["mcpServers", "my-server"]
+ * @param value - The value to set (or undefined to remove)
+ * @returns The modified JSON content with comments preserved
+ */
+declare function modifyAtPath(content: string, path: (string | number)[], value: ConfigValue | undefined): string;
+/**
+ * Merge a patch into JSON content while preserving comments and formatting.
+ * Uses jsonc.modify() for each top-level key to preserve existing comments.
+ *
+ * @param content - The original JSON content (may include comments)
+ * @param patch - Object with values to merge
+ * @returns The modified JSON content with comments preserved
+ */
+declare function mergePreservingComments(content: string, patch: ConfigObject): string;
+/**
+ * Remove a key from JSON content while preserving comments and formatting.
+ *
+ * @param content - The original JSON content
+ * @param path - JSON path array to the key to remove
+ * @returns The modified JSON content with comments preserved
+ */
+declare function removeAtPath(content: string, path: (string | number)[]): string;
+declare function serializeUpdate(content: string, current: ConfigObject, next: ConfigObject): string;
+export { detectIndent, modifyAtPath, mergePreservingComments, removeAtPath, serializeUpdate };
+export declare const jsonFormat: ConfigFormat;

package/node_modules/@poe-code/config-mutations/dist/formats/json.js

@@ -0,0 +1,171 @@
+import * as jsonc from "jsonc-parser";
+import { cloneConfigObject, hasConfigEntry, setConfigEntry } from "./object.js";
+function isConfigObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function detectIndent(content) {
+    const match = content.match(/^[\t ]+/m);
+    if (match) {
+        return match[0];
+    }
+    return "  ";
+}
+function parse(content) {
+    if (!content || content.trim() === "") {
+        return {};
+    }
+    const errors = [];
+    const parsed = jsonc.parse(content, errors, {
+        allowTrailingComma: true,
+        disallowComments: false
+    });
+    if (errors.length > 0) {
+        throw new Error(`JSON parse error: ${jsonc.printParseErrorCode(errors[0].error)}`);
+    }
+    if (parsed === null || parsed === undefined) {
+        return {};
+    }
+    if (!isConfigObject(parsed)) {
+        throw new Error("Expected JSON object.");
+    }
+    return cloneConfigObject(parsed);
+}
+function serialize(obj) {
+    return `${JSON.stringify(obj, null, 2)}\n`;
+}
+function merge(base, patch) {
+    const result = cloneConfigObject(base);
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined) {
+            continue;
+        }
+        const existing = hasConfigEntry(result, key) ? result[key] : undefined;
+        if (isConfigObject(existing) && isConfigObject(value)) {
+            setConfigEntry(result, key, merge(existing, value));
+            continue;
+        }
+        setConfigEntry(result, key, value);
+    }
+    return result;
+}
+function configValuesEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function prune(obj, shape) {
+    let changed = false;
+    const result = cloneConfigObject(obj);
+    for (const [key, pattern] of Object.entries(shape)) {
+        if (!hasConfigEntry(result, key)) {
+            continue;
+        }
+        const current = result[key];
+        // Empty object pattern means "delete this key entirely"
+        if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+            delete result[key];
+            changed = true;
+            continue;
+        }
+        // Non-empty object pattern with object current: recurse
+        if (isConfigObject(pattern) && isConfigObject(current)) {
+            const { changed: childChanged, result: childResult } = prune(current, pattern);
+            if (childChanged) {
+                changed = true;
+            }
+            if (Object.keys(childResult).length === 0) {
+                delete result[key];
+            }
+            else {
+                setConfigEntry(result, key, childResult);
+            }
+            continue;
+        }
+        if (isConfigObject(pattern) && Object.keys(pattern).length > 0) {
+            continue;
+        }
+        delete result[key];
+        changed = true;
+    }
+    return { changed, result };
+}
+/**
+ * Modify JSON content at a specific path while preserving comments and formatting.
+ * Uses jsonc-parser's modify() for targeted updates.
+ *
+ * @param content - The original JSON content (may include comments)
+ * @param path - JSON path array, e.g. ["mcpServers", "my-server"]
+ * @param value - The value to set (or undefined to remove)
+ * @returns The modified JSON content with comments preserved
+ */
+function modifyAtPath(content, path, value) {
+    const indent = detectIndent(content);
+    const formattingOptions = {
+        tabSize: indent === "\t" ? 1 : indent.length,
+        insertSpaces: indent !== "\t",
+        eol: "\n"
+    };
+    const edits = jsonc.modify(content, path, value, { formattingOptions });
+    let result = jsonc.applyEdits(content, edits);
+    if (!result.endsWith("\n")) {
+        result += "\n";
+    }
+    return result;
+}
+/**
+ * Merge a patch into JSON content while preserving comments and formatting.
+ * Uses jsonc.modify() for each top-level key to preserve existing comments.
+ *
+ * @param content - The original JSON content (may include comments)
+ * @param patch - Object with values to merge
+ * @returns The modified JSON content with comments preserved
+ */
+function mergePreservingComments(content, patch) {
+    const current = parse(content);
+    return serializeUpdate(content || "{}", current, merge(current, patch));
+}
+/**
+ * Remove a key from JSON content while preserving comments and formatting.
+ *
+ * @param content - The original JSON content
+ * @param path - JSON path array to the key to remove
+ * @returns The modified JSON content with comments preserved
+ */
+function removeAtPath(content, path) {
+    return modifyAtPath(content, path, undefined);
+}
+function serializeUpdate(content, current, next) {
+    let result = content || "{}";
+    result = applyObjectUpdate(result, [], current, next);
+    if (!result.endsWith("\n")) {
+        result += "\n";
+    }
+    return result;
+}
+function applyObjectUpdate(content, path, current, next) {
+    let result = content;
+    for (const key of Object.keys(current)) {
+        if (!hasConfigEntry(next, key)) {
+            result = removeAtPath(result, [...path, key]);
+        }
+    }
+    for (const [key, nextValue] of Object.entries(next)) {
+        const nextPath = [...path, key];
+        const hasCurrent = hasConfigEntry(current, key);
+        const currentValue = hasCurrent ? current[key] : undefined;
+        if (hasCurrent && isConfigObject(currentValue) && isConfigObject(nextValue)) {
+            result = applyObjectUpdate(result, nextPath, currentValue, nextValue);
+            continue;
+        }
+        if (!hasCurrent || !configValuesEqual(currentValue, nextValue)) {
+            result = modifyAtPath(result, nextPath, nextValue);
+        }
+    }
+    return result;
+}
+export { detectIndent, modifyAtPath, mergePreservingComments, removeAtPath, serializeUpdate };
+export const jsonFormat = {
+    parse,
+    serialize,
+    serializeUpdate,
+    merge,
+    prune
+};

package/node_modules/@poe-code/config-mutations/dist/formats/object.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigObject, ConfigValue } from "../types.js";
+export declare function cloneConfigObject(value: ConfigObject): ConfigObject;
+export declare function setConfigEntry(target: ConfigObject, key: string, value: ConfigValue): void;
+export declare function hasConfigEntry(target: ConfigObject, key: string): boolean;

package/node_modules/@poe-code/config-mutations/dist/formats/object.js

@@ -0,0 +1,27 @@
+export function cloneConfigObject(value) {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        setConfigEntry(result, key, cloneConfigValue(entry));
+    }
+    return result;
+}
+export function setConfigEntry(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value
+    });
+}
+export function hasConfigEntry(target, key) {
+    return Object.prototype.hasOwnProperty.call(target, key);
+}
+function cloneConfigValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneConfigValue(entry));
+    }
+    if (value && typeof value === "object" && !(value instanceof Date)) {
+        return cloneConfigObject(value);
+    }
+    return value;
+}

package/node_modules/@poe-code/config-mutations/dist/formats/toml.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigFormat } from "../types.js";
+export declare const tomlFormat: ConfigFormat;

package/node_modules/@poe-code/config-mutations/dist/formats/toml.js

@@ -0,0 +1,75 @@
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { cloneConfigObject, hasConfigEntry, setConfigEntry } from "./object.js";
+function isConfigObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse(content) {
+    if (!content || content.trim() === "") {
+        return {};
+    }
+    const parsed = parseToml(content);
+    if (!isConfigObject(parsed)) {
+        throw new Error("Expected TOML document to be a table.");
+    }
+    return cloneConfigObject(parsed);
+}
+function serialize(obj) {
+    const serialized = stringifyToml(obj);
+    return serialized.endsWith("\n") ? serialized : `${serialized}\n`;
+}
+function merge(base, patch) {
+    const result = cloneConfigObject(base);
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined) {
+            continue;
+        }
+        const existing = hasConfigEntry(result, key) ? result[key] : undefined;
+        if (isConfigObject(existing) && isConfigObject(value)) {
+            setConfigEntry(result, key, merge(existing, value));
+            continue;
+        }
+        setConfigEntry(result, key, value);
+    }
+    return result;
+}
+function prune(obj, shape) {
+    let changed = false;
+    const result = cloneConfigObject(obj);
+    for (const [key, pattern] of Object.entries(shape)) {
+        if (!hasConfigEntry(result, key)) {
+            continue;
+        }
+        const current = result[key];
+        // Empty object pattern means "delete this key entirely"
+        if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+            delete result[key];
+            changed = true;
+            continue;
+        }
+        // Non-empty object pattern with object current: recurse
+        if (isConfigObject(pattern) && isConfigObject(current)) {
+            const { changed: childChanged, result: childResult } = prune(current, pattern);
+            if (childChanged) {
+                changed = true;
+            }
+            if (Object.keys(childResult).length === 0) {
+                delete result[key];
+            }
+            else {
+                setConfigEntry(result, key, childResult);
+            }
+            continue;
+        }
+        if (!isConfigObject(pattern) || Object.keys(pattern).length === 0) {
+            delete result[key];
+            changed = true;
+        }
+    }
+    return { changed, result };
+}
+export const tomlFormat = {
+    parse,
+    serialize,
+    merge,
+    prune
+};

package/node_modules/@poe-code/config-mutations/dist/formats/yaml.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigFormat } from "../types.js";
+export declare const yamlFormat: ConfigFormat;

package/node_modules/@poe-code/config-mutations/dist/formats/yaml.js

@@ -0,0 +1,76 @@
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { cloneConfigObject, hasConfigEntry, setConfigEntry } from "./object.js";
+function isConfigObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse(content) {
+    if (!content || content.trim() === "") {
+        return {};
+    }
+    const parsed = parseYaml(content);
+    if (parsed === null || parsed === undefined) {
+        return {};
+    }
+    if (!isConfigObject(parsed)) {
+        throw new Error("Expected YAML object.");
+    }
+    return cloneConfigObject(parsed);
+}
+function serialize(obj) {
+    const serialized = stringifyYaml(obj);
+    return serialized.endsWith("\n") ? serialized : `${serialized}\n`;
+}
+function merge(base, patch) {
+    const result = cloneConfigObject(base);
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined) {
+            continue;
+        }
+        const existing = hasConfigEntry(result, key) ? result[key] : undefined;
+        if (isConfigObject(existing) && isConfigObject(value)) {
+            setConfigEntry(result, key, merge(existing, value));
+            continue;
+        }
+        setConfigEntry(result, key, value);
+    }
+    return result;
+}
+function prune(obj, shape) {
+    let changed = false;
+    const result = cloneConfigObject(obj);
+    for (const [key, pattern] of Object.entries(shape)) {
+        if (!hasConfigEntry(result, key)) {
+            continue;
+        }
+        const current = result[key];
+        if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+            delete result[key];
+            changed = true;
+            continue;
+        }
+        if (isConfigObject(pattern) && isConfigObject(current)) {
+            const { changed: childChanged, result: childResult } = prune(current, pattern);
+            if (childChanged) {
+                changed = true;
+            }
+            if (Object.keys(childResult).length === 0) {
+                delete result[key];
+            }
+            else {
+                setConfigEntry(result, key, childResult);
+            }
+            continue;
+        }
+        if (!isConfigObject(pattern) || Object.keys(pattern).length === 0) {
+            delete result[key];
+            changed = true;
+        }
+    }
+    return { changed, result };
+}
+export const yamlFormat = {
+    parse,
+    serialize,
+    merge,
+    prune
+};

package/node_modules/@poe-code/config-mutations/dist/fs-utils.d.ts

@@ -0,0 +1,18 @@
+import type { FileSystem } from "./types.js";
+/**
+ * Check if an error is a "file not found" (ENOENT) error.
+ */
+export declare function isNotFound(error: unknown): boolean;
+/**
+ * Read a file if it exists, returning null if not found.
+ */
+export declare function readFileIfExists(fs: FileSystem, target: string): Promise<string | null>;
+/**
+ * Check if a path exists (file or directory).
+ */
+export declare function pathExists(fs: FileSystem, target: string): Promise<boolean>;
+/**
+ * Create an ISO timestamp safe for use in filenames.
+ * Replaces colons and dots with dashes.
+ */
+export declare function createTimestamp(): string;

package/node_modules/@poe-code/config-mutations/dist/fs-utils.js

@@ -0,0 +1,43 @@
+import { hasOwnErrorCode } from "./error-codes.js";
+/**
+ * Check if an error is a "file not found" (ENOENT) error.
+ */
+export function isNotFound(error) {
+    return hasOwnErrorCode(error, "ENOENT");
+}
+/**
+ * Read a file if it exists, returning null if not found.
+ */
+export async function readFileIfExists(fs, target) {
+    try {
+        return await fs.readFile(target, "utf8");
+    }
+    catch (error) {
+        if (isNotFound(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+/**
+ * Check if a path exists (file or directory).
+ */
+export async function pathExists(fs, target) {
+    try {
+        await fs.stat(target);
+        return true;
+    }
+    catch (error) {
+        if (isNotFound(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+/**
+ * Create an ISO timestamp safe for use in filenames.
+ * Replaces colons and dots with dashes.
+ */
+export function createTimestamp() {
+    return new Date().toISOString().replaceAll(":", "-").replaceAll(".", "-");
+}

package/node_modules/@poe-code/config-mutations/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { configMutation } from "./mutations/config-mutation.js";
+export { fileMutation } from "./mutations/file-mutation.js";
+export { templateMutation } from "./mutations/template-mutation.js";
+export { runMutations } from "./execution/run-mutations.js";
+export { renderTemplate, type TemplateVariables } from "./template/render.js";
+export { isNotFound, readFileIfExists, pathExists, createTimestamp } from "./fs-utils.js";
+export type { ConfigObject, ConfigValue, Mutation, MutationContext, MutationResult, MutationObservers, MutationDetails, MutationOutcome, FileSystem, TemplateLoader, ConfigFormat, PathMapper } from "./types.js";
+export { isConfigObject } from "./types.js";

package/node_modules/@poe-code/config-mutations/dist/index.js

@@ -0,0 +1,8 @@
+// Main exports
+export { configMutation } from "./mutations/config-mutation.js";
+export { fileMutation } from "./mutations/file-mutation.js";
+export { templateMutation } from "./mutations/template-mutation.js";
+export { runMutations } from "./execution/run-mutations.js";
+export { renderTemplate } from "./template/render.js";
+export { isNotFound, readFileIfExists, pathExists, createTimestamp } from "./fs-utils.js";
+export { isConfigObject } from "./types.js";