@hyperfrontend/project-scope 0.2.1 → 0.2.3

package/project/index.cjs.js

@@ -1,413 +1,29 @@
 'use strict';
 
-var node_path = require('node:path');
-var node_fs = require('node:fs');
-
-/**
- * Safe copies of Error built-ins via factory functions.
- *
- * Since constructors cannot be safely captured via Object.assign, this module
- * provides factory functions that use Reflect.construct internally.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/error
- */
-const _Error = globalThis.Error;
-const _Reflect$2 = globalThis.Reflect;
-/**
- * (Safe copy) Creates a new Error using the captured Error constructor.
- * Use this instead of `new Error()`.
- *
- * @param message - Optional error message.
- * @param options - Optional error options.
- * @returns A new Error instance.
- */
-const createError = (message, options) => _Reflect$2.construct(_Error, [message, options]);
-
-/**
- * Safe copies of JSON built-in methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/json
- */
-const _JSON = globalThis.JSON;
-/**
- * (Safe copy) Converts a JavaScript Object Notation (JSON) string into an object.
- */
-const parse = _JSON.parse;
-/**
- * (Safe copy) Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
- */
-const stringify = _JSON.stringify;
-
-/**
- * Safe copies of Object built-in methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/object
- */
-const _Object = globalThis.Object;
-/**
- * (Safe copy) Prevents modification of existing property attributes and values,
- * and prevents the addition of new properties.
- */
-const freeze = _Object.freeze;
-/**
- * (Safe copy) Returns the names of the enumerable string properties and methods of an object.
- */
-const keys = _Object.keys;
-/**
- * (Safe copy) Returns an array of key/values of the enumerable own properties of an object.
- */
-const entries = _Object.entries;
-/**
- * (Safe copy) Returns an array of values of the enumerable own properties of an object.
- */
-const values = _Object.values;
-/**
- * (Safe copy) Adds one or more properties to an object, and/or modifies attributes of existing properties.
- */
-const defineProperties = _Object.defineProperties;
-
-/**
- * Safe copies of Array built-in static methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/array
- */
-const _Array = globalThis.Array;
-/**
- * (Safe copy) Determines whether the passed value is an Array.
- */
-const isArray = _Array.isArray;
-
-/**
- * Safe copies of Console built-in methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/console
- */
-const _console = globalThis.console;
-/**
- * (Safe copy) Outputs a message to the console.
- */
-const log = _console.log.bind(_console);
-/**
- * (Safe copy) Outputs a warning message to the console.
- */
-const warn = _console.warn.bind(_console);
-/**
- * (Safe copy) Outputs an error message to the console.
- */
-const error = _console.error.bind(_console);
-/**
- * (Safe copy) Outputs an informational message to the console.
- */
-const info = _console.info.bind(_console);
-/**
- * (Safe copy) Outputs a debug message to the console.
- */
-const debug = _console.debug.bind(_console);
-/**
- * (Safe copy) Outputs a stack trace to the console.
- */
-_console.trace.bind(_console);
-/**
- * (Safe copy) Displays an interactive listing of the properties of a specified object.
- */
-_console.dir.bind(_console);
-/**
- * (Safe copy) Displays tabular data as a table.
- */
-_console.table.bind(_console);
-/**
- * (Safe copy) Writes an error message to the console if the assertion is false.
- */
-_console.assert.bind(_console);
-/**
- * (Safe copy) Clears the console.
- */
-_console.clear.bind(_console);
-/**
- * (Safe copy) Logs the number of times that this particular call to count() has been called.
- */
-_console.count.bind(_console);
-/**
- * (Safe copy) Resets the counter used with console.count().
- */
-_console.countReset.bind(_console);
-/**
- * (Safe copy) Creates a new inline group in the console.
- */
-_console.group.bind(_console);
-/**
- * (Safe copy) Creates a new inline group in the console that is initially collapsed.
- */
-_console.groupCollapsed.bind(_console);
-/**
- * (Safe copy) Exits the current inline group.
- */
-_console.groupEnd.bind(_console);
-/**
- * (Safe copy) Starts a timer with a name specified as an input parameter.
- */
-_console.time.bind(_console);
-/**
- * (Safe copy) Stops a timer that was previously started.
- */
-_console.timeEnd.bind(_console);
-/**
- * (Safe copy) Logs the current value of a timer that was previously started.
- */
-_console.timeLog.bind(_console);
-
-/**
- * Safe copies of Set built-in via factory function.
- *
- * Since constructors cannot be safely captured via Object.assign, this module
- * provides a factory function that uses Reflect.construct internally.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/set
- */
-const _Set = globalThis.Set;
-const _Reflect$1 = globalThis.Reflect;
-/**
- * (Safe copy) Creates a new Set using the captured Set constructor.
- * Use this instead of `new Set()`.
- *
- * @param iterable - Optional iterable of values.
- * @returns A new Set instance.
- */
-const createSet = (iterable) => _Reflect$1.construct(_Set, iterable ? [iterable] : []);
-
-const registeredClasses = [];
-
-/**
- * Returns the data type of the target.
- * Uses native `typeof` operator, however, makes distinction between `null`, `array`, and `object`.
- * Also, when classes are registered via `registerClass`, it checks if objects are instance of any known registered class.
- *
- * @param target - The target to get the data type of.
- * @returns The data type of the target.
- */
-const getType = (target) => {
-    if (target === null)
-        return 'null';
-    const nativeDataType = typeof target;
-    if (nativeDataType === 'object') {
-        if (isArray(target))
-            return 'array';
-        for (const registeredClass of registeredClasses) {
-            if (target instanceof registeredClass)
-                return registeredClass.name;
-        }
-    }
-    return nativeDataType;
-};
-
-/**
- * Safe copies of Map built-in via factory function.
- *
- * Since constructors cannot be safely captured via Object.assign, this module
- * provides a factory function that uses Reflect.construct internally.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/map
- */
-const _Map = globalThis.Map;
-const _Reflect = globalThis.Reflect;
-/**
- * (Safe copy) Creates a new Map using the captured Map constructor.
- * Use this instead of `new Map()`.
- *
- * @param iterable - Optional iterable of key-value pairs.
- * @returns A new Map instance.
- */
-const createMap = (iterable) => _Reflect.construct(_Map, iterable ? [iterable] : []);
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * Creates a wrapper function that only executes the wrapped function if the condition function returns true.
- *
- * @param func - The function to be conditionally executed.
- * @param conditionFunc - A function that returns a boolean, determining if `func` should be executed.
- * @returns A wrapped version of `func` that executes conditionally.
- */
-function createConditionalExecutionFunction(func, conditionFunc) {
-    return function (...args) {
-        if (conditionFunc()) {
-            return func(...args);
-        }
-    };
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * Creates a wrapper function that silently ignores any errors thrown by the wrapped void function.
- * This function is specifically for wrapping functions that do not return a value (void functions).
- * Exceptions are swallowed without any logging or handling.
- *
- * @param func - The void function to be wrapped.
- * @returns A wrapped version of the input function that ignores errors.
- */
-function createErrorIgnoringFunction(func) {
-    return function (...args) {
-        try {
-            func(...args);
-        }
-        catch {
-            // Deliberately swallowing/ignoring the exception
-        }
-    };
-}
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/**
- * A no-operation function (noop) that does nothing regardless of the arguments passed.
- * It is designed to be as permissive as possible in its typing without using the `Function` keyword.
- *
- * @param args - Any arguments passed to the function (ignored)
- */
-const noop = (...args) => {
-    // Intentionally does nothing
-};
-
-const logLevels = ['none', 'error', 'warn', 'log', 'info', 'debug'];
-const priority = {
-    error: 4,
-    warn: 3,
-    log: 2,
-    info: 1,
-    debug: 0,
-};
-/**
- * Validates whether a given string is a valid log level.
- *
- * @param level - The log level to validate
- * @returns True if the level is valid, false otherwise
- */
-function isValidLogLevel(level) {
-    return logLevels.includes(level);
-}
-/**
- * Creates a log level configuration manager for controlling logging behavior.
- * Provides methods to get, set, and evaluate log levels based on priority.
- *
- * @param level - The initial log level (defaults to 'error')
- * @returns A configuration object with log level management methods
- * @throws {Error} When the provided level is not a valid log level
- */
-function createLogLevelConfig(level = 'error') {
-    if (!isValidLogLevel(level)) {
-        throw createError('Cannot create log level configuration with a valid default log level');
-    }
-    const state = { level };
-    const getLogLevel = () => state.level;
-    const setLogLevel = (level) => {
-        if (!isValidLogLevel(level)) {
-            throw createError(`Cannot set value '${level}' level. Expected levels are ${logLevels}.`);
-        }
-        state.level = level;
-    };
-    const shouldLog = (level) => {
-        if (state.level === 'none' || level === 'none' || !isValidLogLevel(level)) {
-            return false;
-        }
-        return priority[level] >= priority[state.level];
-    };
-    return freeze({
-        getLogLevel,
-        setLogLevel,
-        shouldLog,
-    });
-}
-
-/**
- * Creates a logger instance with configurable log level filtering.
- * Each log function is wrapped to respect the current log level setting.
- *
- * @param error - Function to handle error-level logs (required)
- * @param warn - Function to handle warning-level logs (optional, defaults to noop)
- * @param log - Function to handle standard logs (optional, defaults to noop)
- * @param info - Function to handle info-level logs (optional, defaults to noop)
- * @param debug - Function to handle debug-level logs (optional, defaults to noop)
- * @returns A frozen logger object with log methods and level control
- * @throws {ErrorLevelFn} When any provided log function is invalid
- */
-function createLogger(error, warn = noop, log = noop, info = noop, debug = noop) {
-    if (notValidLogFn(error)) {
-        throw createError(notFnMsg('error'));
-    }
-    if (notValidLogFn(warn)) {
-        throw createError(notFnMsg('warn'));
-    }
-    if (notValidLogFn(log)) {
-        throw createError(notFnMsg('log'));
-    }
-    if (notValidLogFn(info)) {
-        throw createError(notFnMsg('info'));
-    }
-    if (notValidLogFn(debug)) {
-        throw createError(notFnMsg('debug'));
-    }
-    const { setLogLevel, getLogLevel, shouldLog } = createLogLevelConfig();
-    const wrapLogFn = (fn, level) => {
-        if (fn === noop)
-            return fn;
-        const condition = () => shouldLog(level);
-        return createConditionalExecutionFunction(createErrorIgnoringFunction(fn), condition);
-    };
-    return freeze({
-        error: wrapLogFn(error, 'error'),
-        warn: wrapLogFn(warn, 'warn'),
-        log: wrapLogFn(log, 'log'),
-        info: wrapLogFn(info, 'info'),
-        debug: wrapLogFn(debug, 'debug'),
-        setLogLevel,
-        getLogLevel,
-    });
-}
-/**
- * Validates whether a given value is a valid log function.
- *
- * @param fn - The value to validate
- * @returns True if the value is not a function (invalid), false if it is valid
- */
-function notValidLogFn(fn) {
-    return getType(fn) !== 'function' && fn !== noop;
-}
-/**
- * Generates an error message for invalid log function parameters.
- *
- * @param label - The name of the log function that failed validation
- * @returns A formatted error message string
- */
-function notFnMsg(label) {
-    return `Cannot create a logger when ${label} is not a function`;
-}
-
-createLogger(error, warn, log, info, debug);
+const node_path = require('node:path');
+const index_cjs_js$2 = require('../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.cjs.js');
+const index_cjs_js$1 = require('../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/map/index.cjs.js');
+const index_cjs_js = require('../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.cjs.js');
+const node_fs = require('node:fs');
+const index_cjs_js$5 = require('../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.cjs.js');
+const index_cjs_js$4 = require('../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/console/index.cjs.js');
+const index_cjs_js$6 = require('../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/json/index.cjs.js');
+const index_cjs_js$3 = require('../_dependencies/@hyperfrontend/logging/index.cjs.js');
+const index_cjs_js$7 = require('../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.cjs.js');
+const index_cjs_js$8 = require('../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/number/index.cjs.js');
+const { isSafePath } = require('../_shared/core/fs/guard/index.cjs.js');
+const { isDirectory, exists } = require('../_shared/core/fs/stat/index.cjs.js');
+const { join } = require('../_shared/core/path/join/index.cjs.js');
+const { createConfigError } = require('../_shared/core/errors/structured-errors/index.cjs.js');
+const { createCache } = require('../_shared/core/cache/index.cjs.js');
+const { matchGlobPattern } = require('../_shared/core/patterns/glob/index.cjs.js');
+const { CONFIG_PATTERNS, getConfigPatternsByType } = require('../_shared/project/config/patterns/index.cjs.js');
 
 /**
  * Global log level registry.
  * Tracks all created scoped loggers to allow global log level changes.
  */
-const loggerRegistry = createSet();
+const loggerRegistry = index_cjs_js.createSet();
 /** Redacted placeholder for sensitive values */
 const REDACTED = '[REDACTED]';
 /**
@@ -441,17 +57,24 @@ function isSensitiveKey(key) {
  *
  * @param obj - Object to sanitize
  * @returns New object with sensitive values redacted
+ *
+ * @example Sanitizing sensitive data
+ * ```typescript
+ * const config = { apiKey: 'secret123', endpoint: 'https://api.example.com' }
+ * const safe = sanitize(config)
+ * // => { apiKey: '[REDACTED]', endpoint: 'https://api.example.com' }
+ * ```
  */
 function sanitize(obj) {
     if (obj === null || obj === undefined) {
         return obj;
     }
-    if (isArray(obj)) {
+    if (index_cjs_js$5.isArray(obj)) {
         return obj.map((item) => sanitize(item));
     }
     if (typeof obj === 'object') {
         const result = {};
-        for (const [key, value] of entries(obj)) {
+        for (const [key, value] of index_cjs_js$2.entries(obj)) {
             if (isSensitiveKey(key)) {
                 result[key] = REDACTED;
             }
@@ -476,9 +99,9 @@ function sanitize(obj) {
  */
 function formatMessage(namespace, message, meta) {
     const prefix = `[${namespace}]`;
-    if (meta && keys(meta).length > 0) {
+    if (meta && index_cjs_js$2.keys(meta).length > 0) {
         const sanitizedMeta = sanitize(meta);
-        return `${prefix} ${message} ${stringify(sanitizedMeta)}`;
+        return `${prefix} ${message} ${index_cjs_js$6.stringify(sanitizedMeta)}`;
     }
     return `${prefix} ${message}`;
 }
@@ -491,7 +114,7 @@ function formatMessage(namespace, message, meta) {
  * @param options - Logger configuration options
  * @returns A configured scoped logger instance
  *
- * @example
+ * @example Creating a scoped logger
  * ```typescript
  * const logger = createScopedLogger('project-scope')
  * logger.setLogLevel('debug')
@@ -510,9 +133,9 @@ function createScopedLogger(namespace, options = {}) {
         const processedMeta = sanitizeSecrets && meta ? sanitize(meta) : meta;
         baseFn(formatMessage(namespace, message, processedMeta));
     };
-    const baseLogger = createLogger(createLogFn(error), createLogFn(warn), createLogFn(log), createLogFn(info), createLogFn(debug));
+    const baseLogger = index_cjs_js$3.createLogger(createLogFn(index_cjs_js$4.error), createLogFn(index_cjs_js$4.warn), createLogFn(index_cjs_js$4.log), createLogFn(index_cjs_js$4.info), createLogFn(index_cjs_js$4.debug));
     baseLogger.setLogLevel(level);
-    const scopedLogger = freeze({
+    const scopedLogger = index_cjs_js$2.freeze({
         error: (message, meta) => baseLogger.error(message, meta),
         warn: (message, meta) => baseLogger.warn(message, meta),
         log: (message, meta) => baseLogger.log(message, meta),
@@ -528,7 +151,7 @@ function createScopedLogger(namespace, options = {}) {
  * Default logger instance for the project-scope library.
  * Use this for general logging within the library.
  *
- * @example
+ * @example Using the default logger
  * ```typescript
  * import { logger } from '@hyperfrontend/project-scope/core'
  *
@@ -546,10 +169,19 @@ const fsLogger = createScopedLogger('project-scope:fs');
  * @param code - The category code for this type of filesystem failure
  * @param context - Additional context including path, operation, and cause
  * @returns A configured Error object with code and context properties
+ *
+ * @example Creating a file system error
+ * ```typescript
+ * throw createFileSystemError(
+ *   'Cannot read file',
+ *   'FS_READ_ERROR',
+ *   { path: './missing.txt', operation: 'read' }
+ * )
+ * ```
  */
 function createFileSystemError(message, code, context) {
-    const error = createError(message);
-    defineProperties(error, {
+    const error = index_cjs_js$7.createError(message);
+    index_cjs_js$2.defineProperties(error, {
         code: { value: code, enumerable: true },
         context: { value: context, enumerable: true },
     });
@@ -563,7 +195,7 @@ function createFileSystemError(message, code, context) {
  * @returns File contents as string
  * @throws {Error} If file doesn't exist or can't be read
  *
- * @example
+ * @example Reading file contents
  * ```typescript
  * import { readFileContent } from '@hyperfrontend/project-scope'
  *
@@ -572,6 +204,9 @@ function createFileSystemError(message, code, context) {
  * ```
  */
 function readFileContent(filePath, encoding = 'utf-8') {
+    if (!isSafePath(filePath)) {
+        throw createFileSystemError(`Unsafe file path: ${filePath}`, 'FS_READ_ERROR', { path: filePath, operation: 'read' });
+    }
     if (!node_fs.existsSync(filePath)) {
         fsLogger.debug('File not found', { path: filePath });
         throw createFileSystemError(`File not found: ${filePath}`, 'FS_NOT_FOUND', { path: filePath, operation: 'read' });
@@ -590,9 +225,17 @@ function readFileContent(filePath, encoding = 'utf-8') {
  * @param filePath - Path to file
  * @param encoding - File encoding (default: utf-8)
  * @returns File contents or null if file doesn't exist
+ *
+ * @example Reading file if it exists
+ * ```typescript
+ * const content = readFileIfExists('./optional-config.json')
+ * if (content) {
+ *   // File existed, use content
+ * }
+ * ```
  */
 function readFileIfExists(filePath, encoding = 'utf-8') {
-    if (!node_fs.existsSync(filePath)) {
+    if (!isSafePath(filePath) || !node_fs.existsSync(filePath)) {
         return null;
     }
     try {
@@ -603,56 +246,6 @@ function readFileIfExists(filePath, encoding = 'utf-8') {
     }
 }
 
-createScopedLogger('project-scope:fs:write');
-
-/**
- * Get file stats with error handling.
- *
- * @param filePath - Path to file
- * @param followSymlinks - Whether to follow symlinks (default: true)
- * @returns File stats or null if path doesn't exist
- */
-function getFileStat(filePath, followSymlinks = true) {
-    if (!node_fs.existsSync(filePath)) {
-        return null;
-    }
-    try {
-        const stat = followSymlinks ? node_fs.statSync(filePath) : node_fs.lstatSync(filePath);
-        return {
-            isFile: stat.isFile(),
-            isDirectory: stat.isDirectory(),
-            isSymlink: stat.isSymbolicLink(),
-            size: stat.size,
-            created: stat.birthtime,
-            modified: stat.mtime,
-            accessed: stat.atime,
-            mode: stat.mode,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Check if path is a directory.
- *
- * @param dirPath - Path to check
- * @returns True if path is a directory
- */
-function isDirectory(dirPath) {
-    const stats = getFileStat(dirPath);
-    return stats?.isDirectory ?? false;
-}
-/**
- * Check if path exists.
- *
- * @param filePath - Path to check
- * @returns True if path exists
- */
-function exists(filePath) {
-    return node_fs.existsSync(filePath);
-}
-
 const fsDirLogger = createScopedLogger('project-scope:fs:dir');
 /**
  * List immediate contents of a directory.
@@ -661,7 +254,7 @@ const fsDirLogger = createScopedLogger('project-scope:fs:dir');
  * @returns Array of entries with metadata for each file/directory
  * @throws {Error} If directory doesn't exist or isn't a directory
  *
- * @example
+ * @example Listing directory contents
  * ```typescript
  * import { readDirectory } from '@hyperfrontend/project-scope'
  *
@@ -702,17 +295,6 @@ function readDirectory(dirPath) {
     }
 }
 
-/**
- * Join path segments.
- * Uses platform-specific separators (e.g., / or \).
- *
- * @param paths - Path segments to join
- * @returns Joined path
- */
-function join(...paths) {
-    return node_path.join(...paths);
-}
-
 const fsTraversalLogger = createScopedLogger('project-scope:fs:traversal');
 /**
  * Generic upward directory traversal.
@@ -721,6 +303,15 @@ const fsTraversalLogger = createScopedLogger('project-scope:fs:traversal');
  * @param startPath - Starting directory
  * @param predicate - Function to test each directory
  * @returns First matching directory or null
+ *
+ * @example Finding directory containing README
+ * ```typescript
+ * // Find first directory containing a README
+ * const readmeDir = traverseUpward('./src/utils', (dir) =>
+ *   existsSync(join(dir, 'README.md'))
+ * )
+ * // => '/project' or null
+ * ```
  */
 function traverseUpward(startPath, predicate) {
     fsTraversalLogger.debug('Starting upward traversal', { startPath });
@@ -746,6 +337,17 @@ function traverseUpward(startPath, predicate) {
  * @param startPath - Starting directory
  * @param markers - Array of marker file names to search for
  * @returns First directory containing any marker, or null
+ *
+ * @example Finding project root by marker files
+ * ```typescript
+ * // Find project root by looking for common marker files
+ * const projectRoot = locateByMarkers('./src/components', [
+ *   'package.json',
+ *   'nx.json',
+ *   'tsconfig.base.json'
+ * ])
+ * // => '/workspace/my-project'
+ * ```
  */
 function locateByMarkers(startPath, markers) {
     fsTraversalLogger.debug('Locating by markers', { startPath, markers });
@@ -761,203 +363,21 @@ function locateByMarkers(startPath, markers) {
  * @param startPath - Starting directory
  * @param test - Function to test if directory matches criteria
  * @returns Matching directory path or null
+ *
+ * @example Finding directory with specific config
+ * ```typescript
+ * // Find directory with a specific config
+ * const configDir = findUpwardWhere('./deep/nested/path', (dir) =>
+ *   existsSync(join(dir, '.eslintrc.js'))
+ * )
+ * ```
  */
 function findUpwardWhere(startPath, test) {
     fsTraversalLogger.debug('Finding upward where condition met', { startPath });
     return traverseUpward(startPath, test);
 }
 
-/**
- * Match path against glob pattern using safe character iteration.
- * Avoids regex to prevent ReDoS attacks.
- *
- * Supported patterns:
- * - * matches any characters except /
- * - ** matches any characters including /
- * - ? matches exactly one character except /
- * - {a,b,c} matches any of the alternatives
- *
- * @param path - The filesystem path to test against the pattern
- * @param pattern - The glob pattern to match against
- * @returns True if path matches pattern
- *
- * @example
- * ```typescript
- * import { matchGlobPattern } from '@hyperfrontend/project-scope'
- *
- * matchGlobPattern('src/utils/helper.ts', '\*\*\/*.ts')     // true
- * matchGlobPattern('test.spec.ts', '\*.spec.ts')          // true
- * matchGlobPattern('config.json', '\*.{json,yaml}')       // true
- * matchGlobPattern('src/index.ts', 'src/\*.ts')           // true
- * ```
- */
-function matchGlobPattern(path, pattern) {
-    return matchSegments(path.split('/'), pattern.split('/'), 0, 0);
-}
-/**
- * Internal recursive function to match path segments against pattern segments.
- *
- * @param pathParts - Array of path segments split by '/'
- * @param patternParts - Array of pattern segments split by '/'
- * @param pathIdx - Current index in pathParts being examined
- * @param patternIdx - Current index in patternParts being examined
- * @returns True if remaining segments match
- */
-function matchSegments(pathParts, patternParts, pathIdx, patternIdx) {
-    if (pathIdx === pathParts.length && patternIdx === patternParts.length) {
-        return true;
-    }
-    if (patternIdx >= patternParts.length) {
-        return false;
-    }
-    const patternPart = patternParts[patternIdx];
-    if (patternPart === '**') {
-        for (let i = pathIdx; i <= pathParts.length; i++) {
-            if (matchSegments(pathParts, patternParts, i, patternIdx + 1)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    if (pathIdx >= pathParts.length) {
-        return false;
-    }
-    const pathPart = pathParts[pathIdx];
-    if (matchSegment(pathPart, patternPart)) {
-        return matchSegments(pathParts, patternParts, pathIdx + 1, patternIdx + 1);
-    }
-    return false;
-}
-/**
- * Match a single path segment against a pattern segment.
- * Handles *, ?, and {a,b,c} patterns.
- *
- * @param text - The path segment text to match
- * @param pattern - The pattern segment to match against
- * @returns True if the text matches the pattern
- */
-function matchSegment(text, pattern) {
-    let textIdx = 0;
-    let patternIdx = 0;
-    while (patternIdx < pattern.length) {
-        const char = pattern[patternIdx];
-        if (char === '*') {
-            patternIdx++;
-            if (patternIdx === pattern.length) {
-                return true;
-            }
-            for (let i = textIdx; i <= text.length; i++) {
-                if (matchSegmentFrom(text, i, pattern, patternIdx)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        else if (char === '?') {
-            if (textIdx >= text.length) {
-                return false;
-            }
-            textIdx++;
-            patternIdx++;
-        }
-        else if (char === '{') {
-            const closeIdx = findClosingBrace(pattern, patternIdx);
-            if (closeIdx === -1) {
-                if (textIdx >= text.length || text[textIdx] !== char) {
-                    return false;
-                }
-                textIdx++;
-                patternIdx++;
-            }
-            else {
-                const alternatives = extractAlternatives(pattern.slice(patternIdx + 1, closeIdx));
-                for (const alt of alternatives) {
-                    if (matchSegmentFrom(text, textIdx, text.slice(0, textIdx) + alt + pattern.slice(closeIdx + 1), textIdx)) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-        }
-        else {
-            if (textIdx >= text.length || text[textIdx] !== char) {
-                return false;
-            }
-            textIdx++;
-            patternIdx++;
-        }
-    }
-    return textIdx === text.length;
-}
-/**
- * Helper to match from a specific position.
- *
- * @param text - The full text being matched
- * @param textIdx - The starting index in text to match from
- * @param pattern - The full pattern being matched
- * @param patternIdx - The starting index in pattern to match from
- * @returns True if the text matches the pattern from the given positions
- */
-function matchSegmentFrom(text, textIdx, pattern, patternIdx) {
-    const remainingText = text.slice(textIdx);
-    const remainingPattern = pattern.slice(patternIdx);
-    return matchSegment(remainingText, remainingPattern);
-}
-/**
- * Find closing brace for {a,b,c} pattern.
- *
- * @param pattern - The pattern string to search within
- * @param startIdx - The index of the opening brace
- * @returns The index of the matching closing brace, or -1 if not found
- */
-function findClosingBrace(pattern, startIdx) {
-    let depth = 0;
-    for (let i = startIdx; i < pattern.length; i++) {
-        if (pattern[i] === '{') {
-            depth++;
-        }
-        else if (pattern[i] === '}') {
-            depth--;
-            if (depth === 0) {
-                return i;
-            }
-        }
-    }
-    return -1;
-}
-/**
- * Extract alternatives from {a,b,c} pattern content.
- *
- * @param content - The content between braces (without the braces themselves)
- * @returns Array of alternative strings split by commas at depth 0
- */
-function extractAlternatives(content) {
-    const alternatives = [];
-    let current = '';
-    let depth = 0;
-    for (let i = 0; i < content.length; i++) {
-        const char = content[i];
-        if (char === '{') {
-            depth++;
-            current += char;
-        }
-        else if (char === '}') {
-            depth--;
-            current += char;
-        }
-        else if (char === ',' && depth === 0) {
-            alternatives.push(current);
-            current = '';
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current) {
-        alternatives.push(current);
-    }
-    return alternatives;
-}
+createScopedLogger('project-scope:fs:write');
 
 const walkLogger = createScopedLogger('project-scope:project:walk');
 /**
@@ -1024,6 +444,18 @@ function matchPattern(path, pattern) {
  * @param startPath - Root directory to begin traversal
  * @param visitor - Callback function invoked for each file system entry
  * @param options - Configuration for traversal behavior
+ *
+ * @example Walking a directory tree
+ * ```typescript
+ * import { walkDirectory } from '@hyperfrontend/project-scope'
+ *
+ * const tsFiles: string[] = []
+ * walkDirectory('./src', (entry) => {
+ *   if (entry.isFile && entry.name.endsWith('.ts')) {
+ *     tsFiles.push(entry.relativePath)
+ *   }
+ * }, { maxDepth: 5, respectGitignore: true })
+ * ```
  */
 function walkDirectory(startPath, visitor, options) {
     walkLogger.debug('Starting directory walk', {
@@ -1106,6 +538,19 @@ function walkDirectory(startPath, visitor, options) {
  * @param startPath - Root path within the tree to begin traversal
  * @param visitor - Callback function invoked for each tree entry
  * @param options - Configuration for traversal behavior
+ *
+ * @example Walking a virtual tree
+ * ```typescript
+ * import { createTree, walkTree } from '@hyperfrontend/project-scope'
+ *
+ * const tree = createTree('/workspace')
+ * walkTree(tree, 'src', (entry) => {
+ *   if (entry.isDirectory) {
+ *     console.log('Dir:', entry.relativePath)
+ *     return 'skip' // Don't recurse into this directory
+ *   }
+ * })
+ * ```
  */
 function walkTree(tree, startPath, visitor, options) {
     const maxDepth = options?.maxDepth ?? -1;
@@ -1186,7 +631,7 @@ function matchesPatterns(path, patterns) {
  * @param options - Configuration for search behavior
  * @returns List of relative file paths that match the patterns
  *
- * @example
+ * @example Finding files by pattern
  * ```typescript
  * import { findFiles } from '@hyperfrontend/project-scope'
  *
@@ -1204,7 +649,7 @@ function matchesPatterns(path, patterns) {
  * ```
  */
 function findFiles(startPath, patterns, options) {
-    const normalizedPatterns = isArray(patterns) ? patterns : [patterns];
+    const normalizedPatterns = index_cjs_js$5.isArray(patterns) ? patterns : [patterns];
     searchLogger.debug('Finding files', { startPath, patterns: normalizedPatterns, maxResults: options?.maxResults });
     const results = [];
     const maxResults = options?.maxResults ?? Infinity;
@@ -1231,9 +676,18 @@ function findFiles(startPath, patterns, options) {
  * @param patterns - Glob patterns (e.g., '*.ts', '**\/*.json') to filter files
  * @param options - Configuration for search behavior
  * @returns List of virtual file paths that match the patterns
+ *
+ * @example Finding files in a virtual tree
+ * ```typescript
+ * import { createTree, findFilesInTree } from '@hyperfrontend/project-scope'
+ *
+ * const tree = createTree('/workspace')
+ * const tsFiles = findFilesInTree(tree, '**\/*.ts', { maxDepth: 3 })
+ * // => ['src/index.ts', 'src/utils/helpers.ts']
+ * ```
  */
 function findFilesInTree(tree, patterns, options) {
-    const normalizedPatterns = isArray(patterns) ? patterns : [patterns];
+    const normalizedPatterns = index_cjs_js$5.isArray(patterns) ? patterns : [patterns];
     const results = [];
     const maxResults = options?.maxResults ?? Infinity;
     walkTree(tree, tree.root || '', (entry) => {
@@ -1258,9 +712,17 @@ function findFilesInTree(tree, patterns, options) {
  * @param patterns - Glob patterns to filter directories (supports wildcards)
  * @param options - Configuration for search behavior
  * @returns List of relative directory paths that match the patterns
+ *
+ * @example Finding directories by pattern
+ * ```typescript
+ * import { findDirectories } from '@hyperfrontend/project-scope'
+ *
+ * const componentDirs = findDirectories('./src', 'components')
+ * // => ['features/auth/components', 'features/dashboard/components']
+ * ```
  */
 function findDirectories(startPath, patterns, options) {
-    const normalizedPatterns = isArray(patterns) ? patterns : [patterns];
+    const normalizedPatterns = index_cjs_js$5.isArray(patterns) ? patterns : [patterns];
     const results = [];
     const maxResults = options?.maxResults ?? Infinity;
     walkDirectory(startPath, (entry) => {
@@ -1278,311 +740,6 @@ function findDirectories(startPath, patterns, options) {
     return results;
 }
 
-/**
- * Known configuration file patterns organized by type.
- */
-const CONFIG_PATTERNS = {
-    'package.json': {
-        patterns: ['package.json'],
-        format: 'json',
-        description: 'NPM package manifest',
-    },
-    'package-lock.json': {
-        patterns: ['package-lock.json'],
-        format: 'json',
-        description: 'NPM lockfile',
-    },
-    'pnpm-lock.yaml': {
-        patterns: ['pnpm-lock.yaml'],
-        format: 'yaml',
-        description: 'PNPM lockfile',
-    },
-    'yarn.lock': {
-        patterns: ['yarn.lock'],
-        format: 'text',
-        description: 'Yarn lockfile',
-    },
-    '.npmrc': {
-        patterns: ['.npmrc'],
-        format: 'ini',
-        description: 'NPM configuration',
-        sensitive: true,
-    },
-    tsconfig: {
-        patterns: ['tsconfig.json', 'tsconfig.*.json'],
-        format: 'jsonc',
-        description: 'TypeScript configuration',
-        canExtend: true,
-    },
-    nx: {
-        patterns: ['nx.json'],
-        format: 'json',
-        description: 'NX workspace configuration',
-    },
-    'project.json': {
-        patterns: ['project.json', '**/project.json'],
-        format: 'json',
-        description: 'NX project configuration',
-    },
-    'workspace.json': {
-        patterns: ['workspace.json'],
-        format: 'json',
-        description: 'NX workspace projects (deprecated)',
-    },
-    turbo: {
-        patterns: ['turbo.json'],
-        format: 'jsonc',
-        description: 'TurboRepo configuration',
-    },
-    lerna: {
-        patterns: ['lerna.json'],
-        format: 'json',
-        description: 'Lerna configuration',
-    },
-    webpack: {
-        patterns: ['webpack.config.js', 'webpack.config.ts', 'webpack.config.cjs', 'webpack.config.mjs'],
-        format: 'js',
-        description: 'Webpack configuration',
-    },
-    rollup: {
-        patterns: ['rollup.config.js', 'rollup.config.ts', 'rollup.config.mjs'],
-        format: 'js',
-        description: 'Rollup configuration',
-    },
-    vite: {
-        patterns: ['vite.config.js', 'vite.config.ts', 'vite.config.mjs'],
-        format: 'js',
-        description: 'Vite configuration',
-    },
-    esbuild: {
-        patterns: ['esbuild.config.js', 'esbuild.config.ts', 'esbuild.config.mjs'],
-        format: 'js',
-        description: 'esbuild configuration',
-    },
-    babel: {
-        patterns: ['babel.config.js', 'babel.config.json', '.babelrc', '.babelrc.js', '.babelrc.json'],
-        format: 'json',
-        description: 'Babel configuration',
-    },
-    swc: {
-        patterns: ['.swcrc'],
-        format: 'json',
-        description: 'SWC configuration',
-    },
-    jest: {
-        patterns: ['jest.config.js', 'jest.config.ts', 'jest.config.mjs'],
-        description: 'Jest configuration',
-    },
-    vitest: {
-        patterns: ['vitest.config.js', 'vitest.config.ts'],
-        description: 'Vitest configuration',
-    },
-    cypress: {
-        patterns: ['cypress.config.js', 'cypress.config.ts'],
-        description: 'Cypress configuration',
-    },
-    playwright: {
-        patterns: ['playwright.config.js', 'playwright.config.ts'],
-        description: 'Playwright configuration',
-    },
-    next: {
-        patterns: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
-        format: 'js',
-        description: 'Next.js configuration',
-    },
-    angular: {
-        patterns: ['angular.json'],
-        format: 'json',
-        description: 'Angular CLI configuration',
-    },
-    nuxt: {
-        patterns: ['nuxt.config.js', 'nuxt.config.ts'],
-        format: 'js',
-        description: 'Nuxt.js configuration',
-    },
-    svelte: {
-        patterns: ['svelte.config.js', 'svelte.config.ts'],
-        format: 'js',
-        description: 'SvelteKit configuration',
-    },
-    astro: {
-        patterns: ['astro.config.js', 'astro.config.ts', 'astro.config.mjs'],
-        format: 'js',
-        description: 'Astro configuration',
-    },
-    eslint: {
-        patterns: [
-            'eslint.config.js',
-            'eslint.config.cjs',
-            'eslint.config.mjs',
-            '.eslintrc',
-            '.eslintrc.js',
-            '.eslintrc.json',
-            '.eslintrc.yml',
-        ],
-        format: 'js',
-        description: 'ESLint configuration',
-    },
-    prettier: {
-        patterns: ['prettier.config.js', 'prettier.config.cjs', '.prettierrc', '.prettierrc.js', '.prettierrc.json', '.prettierrc.yml'],
-        format: 'json',
-        description: 'Prettier configuration',
-    },
-    env: {
-        patterns: ['.env', '.env.*', '*.env'],
-        format: 'dotenv',
-        description: 'Environment variables',
-        sensitive: true,
-    },
-    '.gitignore': {
-        patterns: ['.gitignore'],
-        format: 'text',
-        description: 'Git ignore patterns',
-    },
-    '.gitattributes': {
-        patterns: ['.gitattributes'],
-        format: 'text',
-        description: 'Git attributes',
-    },
-};
-/**
- * Get patterns for specific config types.
- *
- * @param types - Array of config types to get patterns for
- * @returns Array of file patterns
- */
-function getConfigPatternsByType(types) {
-    return types.flatMap((type) => CONFIG_PATTERNS[type]?.patterns ?? []);
-}
-
-/**
- * Global registry of all caches for bulk operations.
- */
-const cacheRegistry = createSet();
-/**
- * Create a cache with optional TTL and size limits.
- *
- * The cache provides a simple key-value store with:
- * - Optional TTL (time-to-live) for automatic expiration
- * - Optional maxSize for limiting cache size with FIFO eviction
- * - Lazy expiration (entries are checked on access)
- *
- * @param options - Cache configuration options
- * @returns Cache instance
- *
- * @example
- * ```typescript
- * // Basic cache
- * const cache = createCache<string, number>()
- * cache.set('answer', 42)
- * cache.get('answer') // 42
- *
- * // Cache with TTL (expires after 60 seconds)
- * const ttlCache = createCache<string, object>({ ttl: 60000 })
- *
- * // Cache with max size (evicts oldest when full)
- * const lruCache = createCache<string, object>({ maxSize: 100 })
- *
- * // Combined options
- * const configCache = createCache<string, object>({
- *   ttl: 30000,
- *   maxSize: 50
- * })
- * ```
- */
-function createCache(options) {
-    const { ttl, maxSize } = options ?? {};
-    const store = createMap();
-    const insertionOrder = [];
-    /**
-     * Check if an entry is expired.
-     *
-     * @param entry - Cache entry to check
-     * @returns True if entry is expired
-     */
-    function isExpired(entry) {
-        if (ttl === undefined)
-            return false;
-        // eslint-disable-next-line workspace/no-unsafe-builtin-methods -- Date.now() is needed for Jest fake timers compatibility
-        return Date.now() - entry.timestamp > ttl;
-    }
-    /**
-     * Evict oldest entries to make room for new ones.
-     */
-    function evictIfNeeded() {
-        if (maxSize === undefined)
-            return;
-        while (store.size >= maxSize && insertionOrder.length > 0) {
-            const oldestKey = insertionOrder.shift();
-            if (oldestKey !== undefined) {
-                store.delete(oldestKey);
-            }
-        }
-    }
-    /**
-     * Remove key from insertion order tracking.
-     *
-     * @param key - Key to remove from order tracking
-     */
-    function removeFromOrder(key) {
-        const index = insertionOrder.indexOf(key);
-        if (index !== -1) {
-            insertionOrder.splice(index, 1);
-        }
-    }
-    const cache = {
-        get(key) {
-            const entry = store.get(key);
-            if (!entry)
-                return undefined;
-            if (isExpired(entry)) {
-                store.delete(key);
-                removeFromOrder(key);
-                return undefined;
-            }
-            return entry.value;
-        },
-        set(key, value) {
-            if (store.has(key)) {
-                removeFromOrder(key);
-            }
-            else {
-                evictIfNeeded();
-            }
-            // eslint-disable-next-line workspace/no-unsafe-builtin-methods -- Date.now() is needed for Jest fake timers compatibility
-            store.set(key, { value, timestamp: Date.now() });
-            insertionOrder.push(key);
-        },
-        has(key) {
-            const entry = store.get(key);
-            if (!entry)
-                return false;
-            if (isExpired(entry)) {
-                store.delete(key);
-                removeFromOrder(key);
-                return false;
-            }
-            return true;
-        },
-        delete(key) {
-            removeFromOrder(key);
-            return store.delete(key);
-        },
-        clear() {
-            store.clear();
-            insertionOrder.length = 0;
-        },
-        size() {
-            return store.size;
-        },
-        keys() {
-            return [...insertionOrder];
-        },
-    };
-    cacheRegistry.add(cache);
-    return freeze(cache);
-}
-
 const configLogger = createScopedLogger('project-scope:config');
 /**
  * Cache for config detection results.
@@ -1600,7 +757,7 @@ const configDetectionCache = createCache({ ttl: 30000, maxSize: 50 });
  * @param options - Detection options
  * @returns Array of detected configuration files
  *
- * @example
+ * @example Detecting configuration files
  * ```typescript
  * import { detectConfigs } from '@hyperfrontend/project-scope'
  *
@@ -1619,7 +776,7 @@ const configDetectionCache = createCache({ ttl: 30000, maxSize: 50 });
  * ```
  */
 function detectConfigs(rootPath, types, options) {
-    const typesToCheck = types ?? keys(CONFIG_PATTERNS);
+    const typesToCheck = types ?? index_cjs_js$2.keys(CONFIG_PATTERNS);
     const results = [];
     const maxDepth = options?.maxDepth ?? 10;
     const includeHidden = options?.includeHidden ?? true;
@@ -1680,6 +837,14 @@ function detectConfigs(rootPath, types, options) {
  * Clear the config detection cache.
  *
  * Useful for testing or when the project files have changed.
+ *
+ * @example Clearing the config detection cache
+ * ```typescript
+ * import { clearConfigDetectionCache } from '@hyperfrontend/project-scope'
+ *
+ * // Reset cache after modifying config files
+ * clearConfigDetectionCache()
+ * ```
  */
 function clearConfigDetectionCache() {
     configDetectionCache.clear();
@@ -1690,6 +855,17 @@ function clearConfigDetectionCache() {
  * @param rootPath - Project root directory
  * @param type - Config type to find
  * @returns Full path to config file or null if not found
+ *
+ * @example Finding a specific config file
+ * ```typescript
+ * import { findConfigFile } from '@hyperfrontend/project-scope'
+ *
+ * const tsConfig = findConfigFile('/project', 'typescript')
+ * // => '/project/tsconfig.json'
+ *
+ * const eslint = findConfigFile('/project', 'eslint')
+ * // => '/project/.eslintrc.js' or null if not found
+ * ```
  */
 function findConfigFile(rootPath, type) {
     const info = CONFIG_PATTERNS[type];
@@ -1713,72 +889,6 @@ function findConfigFile(rootPath, type) {
     }
     return null;
 }
-/**
- * Get all known config file patterns for a given configuration type.
- *
- * @param type - Configuration type identifier
- * @returns Array of glob patterns for matching config files
- */
-function getConfigPaths(type) {
-    const info = CONFIG_PATTERNS[type];
-    return info?.patterns ?? [];
-}
-
-/**
- * Safe copies of Number built-in methods and constants.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/number
- */
-const _parseInt = globalThis.parseInt;
-const _parseFloat = globalThis.parseFloat;
-/**
- * (Safe copy) Parses a string and returns an integer.
- */
-const parseInt = _parseInt;
-/**
- * (Safe copy) Parses a string and returns a floating point number.
- */
-const parseFloat = _parseFloat;
-
-/**
- * Create a structured error with code and optional context.
- *
- * @param message - The human-readable error message
- * @param code - The machine-readable error code for programmatic handling
- * @param context - Additional contextual information about the error
- * @returns Structured error instance with code and context properties
- *
- * @example
- * ```typescript
- * import { createStructuredError } from '@hyperfrontend/project-scope'
- *
- * throw createStructuredError(
- *   'Configuration file not found',
- *   'CONFIG_NOT_FOUND',
- *   { path: './config.json', searched: ['./config.json', './settings.json'] }
- * )
- * ```
- */
-function createStructuredError(message, code, context) {
-    const error = createError(message);
-    error.code = code;
-    error.context = context ?? {};
-    return error;
-}
-/**
- * Create a configuration-related error.
- *
- * @param message - The human-readable error message
- * @param code - The machine-readable error code for programmatic handling
- * @param context - Additional contextual information (e.g., file path, config key)
- * @returns Structured error instance tagged with type 'config'
- */
-function createConfigError(message, code, context) {
-    return createStructuredError(message, code, { ...context, type: 'config' });
-}
 
 /**
  * Detect config type from file name.
@@ -1789,7 +899,7 @@ function createConfigError(message, code, context) {
  */
 function detectConfigType(filePath) {
     const fileName = node_path.basename(filePath);
-    for (const [type, info] of entries(CONFIG_PATTERNS)) {
+    for (const [type, info] of index_cjs_js$2.entries(CONFIG_PATTERNS)) {
         for (const pattern of info.patterns) {
             if (matchGlobPattern(fileName, pattern)) {
                 return type;
@@ -1910,10 +1020,10 @@ function parseSimpleYaml(content) {
                 result[key] = null;
             }
             else if (/^-?\d+$/.test(value)) {
-                result[key] = parseInt(value, 10);
+                result[key] = index_cjs_js$8.parseInt(value, 10);
             }
             else if (/^-?\d+\.\d+$/.test(value)) {
-                result[key] = parseFloat(value);
+                result[key] = index_cjs_js$8.parseFloat(value);
             }
             else {
                 result[key] = value.replace(/^["']|["']$/g, '');
@@ -1991,16 +1101,28 @@ function parseDotenv(content) {
  * @param type - Category of configuration (e.g., typescript, eslint)
  * @param format - Whether to strip comments (jsonc) or parse strictly (json)
  * @returns Configuration object with parsed data and extends references
+ *
+ * @example Parsing JSON configuration
+ * ```typescript
+ * import { parseJsonConfig } from '@hyperfrontend/project-scope'
+ *
+ * const config = parseJsonConfig(
+ *   'tsconfig.json',
+ *   '{ "extends": "./base.json", "compilerOptions": {} }',
+ *   'typescript'
+ * )
+ * // => { type: 'typescript', path: 'tsconfig.json', data: {...}, extends: ['./base.json'] }
+ * ```
  */
 function parseJsonConfig(filePath, content, type, format = 'json') {
     const cleanContent = format === 'jsonc' ? stripJsonComments(content) : content;
     try {
-        const data = parse(cleanContent);
+        const data = index_cjs_js$6.parse(cleanContent);
         let extendsPath;
         if (typeof data['extends'] === 'string') {
             extendsPath = [data['extends']];
         }
-        else if (isArray(data['extends'])) {
+        else if (index_cjs_js$5.isArray(data['extends'])) {
             extendsPath = data['extends'];
         }
         return {
@@ -2026,6 +1148,14 @@ function parseJsonConfig(filePath, content, type, format = 'json') {
  * @param content - Raw file content to parse
  * @param type - Category of configuration (e.g., github-actions, docker-compose)
  * @returns Configuration object with parsed YAML data
+ *
+ * @example Parsing YAML configuration
+ * ```typescript
+ * import { parseYamlConfig } from '@hyperfrontend/project-scope'
+ *
+ * const config = parseYamlConfig('.github/workflows/ci.yml', yamlContent, 'github-actions')
+ * // => { type: 'github-actions', path: '...', format: 'yaml', data: {...} }
+ * ```
  */
 function parseYamlConfig(filePath, content, type) {
     const data = parseSimpleYaml(content);
@@ -2042,6 +1172,14 @@ function parseYamlConfig(filePath, content, type) {
  * @param filePath - Path to config file
  * @param type - Optional config type (auto-detected if not provided)
  * @returns Parsed configuration
+ *
+ * @example Parsing a configuration file
+ * ```typescript
+ * import { parseConfig } from '@hyperfrontend/project-scope'
+ *
+ * const tsConfig = parseConfig('/project/tsconfig.json')
+ * const eslintConfig = parseConfig('/project/.eslintrc.yml', 'eslint')
+ * ```
  */
 function parseConfig(filePath, type) {
     const content = readFileContent(filePath);
@@ -2086,33 +1224,6 @@ function parseConfig(filePath, type) {
             };
     }
 }
-/**
- * Read and parse config file if it exists.
- *
- * @param configPath - Path to config file
- * @returns Parsed config or null if file doesn't exist
- */
-function readConfigIfExists(configPath) {
-    const content = readFileIfExists(configPath);
-    if (!content)
-        return null;
-    try {
-        const format = detectFormat(configPath);
-        switch (format) {
-            case 'json':
-                return parse(content);
-            case 'jsonc':
-                return parse(stripJsonComments(content));
-            case 'yaml':
-                return parseSimpleYaml(content);
-            default:
-                return null;
-        }
-    }
-    catch {
-        return null;
-    }
-}
 
 const packageLogger = createScopedLogger('project-scope:project:package');
 /**
@@ -2125,7 +1236,7 @@ const packageLogger = createScopedLogger('project-scope:project:package');
 function isStringRecord(value) {
     if (typeof value !== 'object' || value === null)
         return false;
-    return values(value).every((v) => typeof v === 'string');
+    return index_cjs_js$2.values(value).every((v) => typeof v === 'string');
 }
 /**
  * Extracts and normalizes the workspaces field from package.json,
@@ -2135,12 +1246,12 @@ function isStringRecord(value) {
  * @returns Normalized workspace patterns or undefined if invalid
  */
 function parseWorkspaces(value) {
-    if (isArray(value) && value.every((v) => typeof v === 'string')) {
+    if (index_cjs_js$5.isArray(value) && value.every((v) => typeof v === 'string')) {
         return value;
     }
     if (typeof value === 'object' && value !== null) {
         const obj = value;
-        if (isArray(obj['packages'])) {
+        if (index_cjs_js$5.isArray(obj['packages'])) {
             return { packages: obj['packages'] };
         }
     }
@@ -2154,7 +1265,7 @@ function parseWorkspaces(value) {
  */
 function validatePackageJson(data) {
     if (typeof data !== 'object' || data === null) {
-        throw createError('package.json must be an object');
+        throw index_cjs_js$7.createError('package.json must be an object');
     }
     const pkg = data;
     return {
@@ -2184,13 +1295,21 @@ function validatePackageJson(data) {
  * @param projectPath - Project directory path or path to package.json
  * @returns Parsed package.json
  * @throws {Error} Error if file doesn't exist or is invalid
+ *
+ * @example Reading package.json
+ * ```typescript
+ * import { readPackageJson } from '@hyperfrontend/project-scope'
+ *
+ * const pkg = readPackageJson('/path/to/project')
+ * console.log(pkg.name, pkg.version)
+ * ```
  */
 function readPackageJson(projectPath) {
     const packageJsonPath = projectPath.endsWith('package.json') ? projectPath : node_path.join(projectPath, 'package.json');
     packageLogger.debug('Reading package.json', { path: packageJsonPath });
     const content = readFileContent(packageJsonPath);
     try {
-        const data = parse(content);
+        const data = index_cjs_js$6.parse(content);
         const validated = validatePackageJson(data);
         packageLogger.debug('Package.json read successfully', { path: packageJsonPath, name: validated.name });
         return validated;
@@ -2212,6 +1331,16 @@ function readPackageJson(projectPath) {
  *
  * @param projectPath - Project directory path or path to package.json
  * @returns Parsed package.json or null if not found
+ *
+ * @example Reading package.json if it exists
+ * ```typescript
+ * import { readPackageJsonIfExists } from '@hyperfrontend/project-scope'
+ *
+ * const pkg = readPackageJsonIfExists('/path/to/project')
+ * if (pkg) {
+ *   console.log('Found:', pkg.name)
+ * }
+ * ```
  */
 function readPackageJsonIfExists(projectPath) {
     const packageJsonPath = projectPath.endsWith('package.json') ? projectPath : node_path.join(projectPath, 'package.json');
@@ -2221,7 +1350,7 @@ function readPackageJsonIfExists(projectPath) {
         return null;
     }
     try {
-        const validated = validatePackageJson(parse(content));
+        const validated = validatePackageJson(index_cjs_js$6.parse(content));
         packageLogger.debug('Package.json loaded', { path: packageJsonPath, name: validated.name });
         return validated;
     }
@@ -2235,6 +1364,14 @@ function readPackageJsonIfExists(projectPath) {
  *
  * @param startPath - Starting path
  * @returns Path to directory containing package.json, or null if not found
+ *
+ * @example Finding nearest package.json
+ * ```typescript
+ * import { findNearestPackageJson } from '@hyperfrontend/project-scope'
+ *
+ * const pkgDir = findNearestPackageJson('./src/deep/nested/file.ts')
+ * // => '/path/to/project'
+ * ```
  */
 function findNearestPackageJson(startPath) {
     return locateByMarkers(startPath, ['package.json']);
@@ -2245,6 +1382,15 @@ function findNearestPackageJson(startPath) {
  *
  * @param packageJson - Parsed package.json
  * @returns All dependencies categorized
+ *
+ * @example Extracting all dependencies
+ * ```typescript
+ * import { getDependencies } from '@hyperfrontend/project-scope'
+ *
+ * const deps = getDependencies(packageJson)
+ * console.log('Runtime:', Object.keys(deps.dependencies))
+ * console.log('Dev:', Object.keys(deps.devDependencies))
+ * ```
  */
 function getDependencies(packageJson) {
     return {
@@ -2259,6 +1405,14 @@ function getDependencies(packageJson) {
  *
  * @param packageJson - Parsed package.json
  * @returns Map of dependency name to version for runtime dependencies
+ *
+ * @example Getting production dependencies
+ * ```typescript
+ * import { getProductionDependencies } from '@hyperfrontend/project-scope'
+ *
+ * const prodDeps = getProductionDependencies(packageJson)
+ * // => { 'express': '^4.18.0', 'lodash': '^4.17.21' }
+ * ```
  */
 function getProductionDependencies(packageJson) {
     return packageJson.dependencies ?? {};
@@ -2268,6 +1422,14 @@ function getProductionDependencies(packageJson) {
  *
  * @param packageJson - Parsed package.json
  * @returns Map of dependency name to version for dev-time dependencies
+ *
+ * @example Getting development dependencies
+ * ```typescript
+ * import { getDevDependencies } from '@hyperfrontend/project-scope'
+ *
+ * const devDeps = getDevDependencies(packageJson)
+ * // => { 'jest': '^29.0.0', 'typescript': '^5.0.0' }
+ * ```
  */
 function getDevDependencies(packageJson) {
     return packageJson.devDependencies ?? {};
@@ -2277,6 +1439,14 @@ function getDevDependencies(packageJson) {
  *
  * @param packageJson - Parsed package.json
  * @returns Map of dependency name to version for peer requirements
+ *
+ * @example Getting peer dependencies
+ * ```typescript
+ * import { getPeerDependencies } from '@hyperfrontend/project-scope'
+ *
+ * const peerDeps = getPeerDependencies(packageJson)
+ * // => { 'react': '^18.0.0', 'react-dom': '^18.0.0' }
+ * ```
  */
 function getPeerDependencies(packageJson) {
     return packageJson.peerDependencies ?? {};
@@ -2286,6 +1456,16 @@ function getPeerDependencies(packageJson) {
  *
  * @param packageJson - Parsed package.json
  * @returns All dependencies merged
+ *
+ * @example Getting all merged dependencies
+ * ```typescript
+ * import { getAllDependencies } from '@hyperfrontend/project-scope'
+ *
+ * const allDeps = getAllDependencies(packageJson)
+ * if ('typescript' in allDeps) {
+ *   console.log('TypeScript version:', allDeps['typescript'])
+ * }
+ * ```
  */
 function getAllDependencies(packageJson) {
     return {
@@ -2302,6 +1482,17 @@ function getAllDependencies(packageJson) {
  * @param name - Name of the dependency to check
  * @param depTypes - Optional array of dependency types to check (defaults to all)
  * @returns True if dependency exists in specified categories
+ *
+ * @example Checking for a dependency
+ * ```typescript
+ * import { hasDependency } from '@hyperfrontend/project-scope'
+ *
+ * // Check any dependency type
+ * hasDependency(packageJson, 'lodash')
+ *
+ * // Check only production dependencies
+ * hasDependency(packageJson, 'lodash', ['dependencies'])
+ * ```
  */
 function hasDependency(packageJson, name, depTypes) {
     const typesToCheck = depTypes ?? ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
@@ -2318,6 +1509,14 @@ function hasDependency(packageJson, name, depTypes) {
  * @param packageJson - Parsed package.json content
  * @param name - Name of the dependency to look up
  * @returns Version string or null if not found
+ *
+ * @example Getting dependency version
+ * ```typescript
+ * import { getDependencyVersion } from '@hyperfrontend/project-scope'
+ *
+ * const version = getDependencyVersion(packageJson, 'react')
+ * // => '^18.2.0' or null
+ * ```
  */
 function getDependencyVersion(packageJson, name) {
     const deps = getDependencies(packageJson);
@@ -2328,11 +1527,19 @@ function getDependencyVersion(packageJson, name) {
  *
  * @param packageJson - Parsed package.json
  * @returns Array of workspace patterns or empty array
+ *
+ * @example Getting workspace patterns
+ * ```typescript
+ * import { getWorkspaces } from '@hyperfrontend/project-scope'
+ *
+ * const patterns = getWorkspaces(packageJson)
+ * // => ['packages/*', 'apps/*']
+ * ```
  */
 function getWorkspaces(packageJson) {
     if (!packageJson.workspaces)
         return [];
-    if (isArray(packageJson.workspaces)) {
+    if (index_cjs_js$5.isArray(packageJson.workspaces)) {
         return packageJson.workspaces;
     }
     if (typeof packageJson.workspaces === 'object' && 'packages' in packageJson.workspaces) {
@@ -2345,6 +1552,15 @@ function getWorkspaces(packageJson) {
  *
  * @param packageJson - Parsed package.json
  * @returns True if workspaces are defined
+ *
+ * @example Checking for workspaces
+ * ```typescript
+ * import { hasWorkspaces } from '@hyperfrontend/project-scope'
+ *
+ * if (hasWorkspaces(packageJson)) {
+ *   console.log('This is a monorepo')
+ * }
+ * ```
  */
 function hasWorkspaces(packageJson) {
     return getWorkspaces(packageJson).length > 0;
@@ -2355,22 +1571,20 @@ function hasWorkspaces(packageJson) {
  * @param projectPath - Project root directory
  * @param packageName - Package name to check
  * @returns Boolean indicating whether the package exists in node_modules
+ *
+ * @example Checking installed packages
+ * ```typescript
+ * import { hasInstalledPackage } from '@hyperfrontend/project-scope'
+ *
+ * if (hasInstalledPackage('/project', 'typescript')) {
+ *   console.log('TypeScript is installed')
+ * }
+ * ```
  */
 function hasInstalledPackage(projectPath, packageName) {
     const pkgPath = node_path.join(projectPath, 'node_modules', packageName, 'package.json');
     return readPackageJsonIfExists(pkgPath) !== null;
 }
-/**
- * Get installed package version from node_modules.
- *
- * @param projectPath - Project root directory
- * @param packageName - Name of the npm package to look up
- * @returns Installed version or null if not found
- */
-function getInstalledVersion(projectPath, packageName) {
-    const pkg = readPackageJsonIfExists(node_path.join(projectPath, 'node_modules', packageName, 'package.json'));
-    return pkg?.version ?? null;
-}
 
 const rootLogger = createScopedLogger('project-scope:root');
 /**
@@ -2410,7 +1624,7 @@ function looksLikeProjectDir(dirPath) {
  * @param startPath - Starting path
  * @returns Project root path or null
  *
- * @example
+ * @example Finding project root
  * ```typescript
  * import { findProjectRoot } from '@hyperfrontend/project-scope'
  *
@@ -2450,7 +1664,7 @@ function findProjectRoot(startPath) {
  * @param startPath - Starting path
  * @returns Workspace root path or null
  *
- * @example
+ * @example Finding workspace root
  * ```typescript
  * import { findWorkspaceRoot } from '@hyperfrontend/project-scope'
  *
@@ -2490,6 +1704,15 @@ function findWorkspaceRoot(startPath) {
  * @param startPath - Starting path
  * @param markers - Files to search for
  * @returns Root directory path or null
+ *
+ * @example Finding root by marker files
+ * ```typescript
+ * import { findRootDirectory } from '@hyperfrontend/project-scope'
+ *
+ * // Find monorepo root by looking for nx.json or lerna.json
+ * const root = findRootDirectory('./libs/my-lib', ['nx.json', 'lerna.json'])
+ * // => '/path/to/monorepo'
+ * ```
  */
 function findRootDirectory(startPath, markers) {
     return locateByMarkers(startPath, markers);
@@ -2499,6 +1722,14 @@ function findRootDirectory(startPath, markers) {
  *
  * @param startPath - Starting path
  * @returns Git root path or null
+ *
+ * @example Finding Git repository root
+ * ```typescript
+ * import { findGitRoot } from '@hyperfrontend/project-scope'
+ *
+ * const gitRoot = findGitRoot('./src/deep/nested/file.ts')
+ * // => '/path/to/repository'
+ * ```
  */
 function findGitRoot(startPath) {
     return locateByMarkers(startPath, ['.git']);
@@ -2519,12 +1750,10 @@ exports.findProjectRoot = findProjectRoot;
 exports.findRootDirectory = findRootDirectory;
 exports.findWorkspaceRoot = findWorkspaceRoot;
 exports.getAllDependencies = getAllDependencies;
-exports.getConfigPaths = getConfigPaths;
 exports.getConfigPatternsByType = getConfigPatternsByType;
 exports.getDependencies = getDependencies;
 exports.getDependencyVersion = getDependencyVersion;
 exports.getDevDependencies = getDevDependencies;
-exports.getInstalledVersion = getInstalledVersion;
 exports.getPeerDependencies = getPeerDependencies;
 exports.getProductionDependencies = getProductionDependencies;
 exports.getWorkspaces = getWorkspaces;
@@ -2534,9 +1763,7 @@ exports.hasWorkspaces = hasWorkspaces;
 exports.parseConfig = parseConfig;
 exports.parseJsonConfig = parseJsonConfig;
 exports.parseYamlConfig = parseYamlConfig;
-exports.readConfigIfExists = readConfigIfExists;
 exports.readPackageJson = readPackageJson;
 exports.readPackageJsonIfExists = readPackageJsonIfExists;
 exports.walkDirectory = walkDirectory;
 exports.walkTree = walkTree;
-//# sourceMappingURL=index.cjs.js.map