locter 3.0.0 → 4.0.0-beta.0

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { BaseError, ErrorOptions } from "@ebec/core";
 import { createJiti } from "jiti";
-
+import { ToStringOptions } from "yaml";
 //#region src/errors/base.d.ts
 type LocterErrorOptions = ErrorOptions & {
   path?: string;
@@ -36,28 +36,13 @@ declare class LocterUnknownExtensionError extends LocterError {
 //#endregion
 //#region src/errors/wrap.d.ts
 declare function wrapLoaderError(input: unknown, path: string): LocterError;
+declare function wrapWriteError(input: unknown, path: string): LocterError;
 //#endregion
-//#region src/loader/type.d.ts
-type Loader = {
-  execute: (input: string) => Promise<any>;
-  executeSync: (input: string) => any;
-};
-type Rule = {
-  test: RegExp | string[];
-  loader: Loader | string;
-};
-//#endregion
-//#region src/loader/built-in/conf/module.d.ts
-declare class ConfLoader implements Loader {
-  execute(input: string): Promise<Record<string, any>>;
-  executeSync(input: string): Record<string, any>;
-  parse(contents: string): Record<string, any>;
-}
-//#endregion
-//#region src/loader/built-in/json/module.d.ts
-declare class JSONLoader implements Loader {
-  execute(input: string): Promise<any>;
-  executeSync(input: string): any;
+//#region src/errors/write.d.ts
+declare const LOCTER_WRITE_ERROR_MARKER: unique symbol;
+declare class LocterWriteError extends LocterError {
+  static [Symbol.hasInstance](input: unknown): boolean;
+  constructor(input?: LocterErrorInput);
 }
 //#endregion
 //#region src/locator/types.d.ts
@@ -96,15 +81,123 @@ declare function locateUp(pattern: string | string[], options?: LocatorUpOptions
 declare function locateUpSync(pattern: string | string[], options?: LocatorUpOptionsInput): LocatorInfo | undefined;
 //#endregion
 //#region src/locator/utils.d.ts
-declare function buildLocatorPatterns(pattern: string | string[]): string[];
-declare function buildLocatorOptions(options?: LocatorOptionsInput): LocatorOptions;
-declare function pathToLocatorInfo(input: string, skipResolve?: boolean): LocatorInfo;
 declare function isLocatorInfo(input: unknown): input is LocatorInfo;
 declare function buildFilePath(input: LocatorInfo | string): string;
-declare function buildFilePathWithoutExtension(input: LocatorInfo | string): string;
 //#endregion
-//#region src/loader/built-in/module/type.d.ts
-type LoaderFilterFn = (key: string, value: unknown) => boolean;
+//#region src/utils/twin.d.ts
+/**
+ * Internal protocol to derive the parallel sync + async public surfaces
+ * from one shared body. A body is a generator that yields effect pairs —
+ * an async and a sync thunk for the same operation — and the two drivers
+ * (runTwinAsync / runTwinSync) execute the side they stand for. Effect
+ * errors are re-entered into the body via `Generator.throw`, so try/catch
+ * inside a body behaves identically in both variants.
+ *
+ * Deliberately NOT exported from the utils barrel — this is internal
+ * plumbing, not public API.
+ */
+type TwinOp<T = unknown> = {
+  async: () => Promise<T>;
+  sync: () => T;
+};
+type TwinBody<R> = Generator<TwinOp<any>, R, any>;
+//#endregion
+//#region src/format/type.d.ts
+interface IReader {
+  read: (input: string) => Promise<any>;
+  readSync: (input: string) => any;
+}
+interface IWriter {
+  write: (path: string, value: unknown) => Promise<void>;
+  writeSync: (path: string, value: unknown) => void;
+}
+//#endregion
+//#region src/format/text-file/reader.d.ts
+/**
+ * Base class for readers of text-based file formats: reads the file as
+ * UTF-8, delegates to `parse`, and wraps I/O and parse errors in typed
+ * LocterError subclasses. Subclasses implement `parse` only — both
+ * `read` variants are derived from the same body.
+ */
+declare abstract class TextFileReader implements IReader {
+  abstract parse(content: string): any;
+  read(input: string): Promise<any>;
+  readSync(input: string): any;
+  protected body(input: string): TwinBody<any>;
+}
+//#endregion
+//#region src/format/text-file/writer.d.ts
+/**
+ * Base class for writers of text-based file formats: serializes via
+ * `stringify`, creates missing parent directories, writes the file as
+ * UTF-8 (always terminated by a single trailing newline), and wraps
+ * failures in LocterWriteError. Subclasses implement `stringify` only —
+ * both `write` variants are derived from the same body.
+ */
+declare abstract class TextFileWriter implements IWriter {
+  /**
+   * Opt-in: when true, the body reads the target file first (undefined
+   * if absent) and passes its content to `stringify` as `existing` —
+   * the hook behind format-preserving write-back (YAML comment
+   * grafting, JSON indent detection).
+   */
+  protected get usesExistingContent(): boolean;
+  abstract stringify(value: unknown, existing?: string): string;
+  write(input: string, value: unknown): Promise<void>;
+  writeSync(input: string, value: unknown): void;
+  protected body(input: string, value: unknown): TwinBody<void>;
+}
+//#endregion
+//#region src/format/built-in/conf/reader.d.ts
+declare class ConfReader extends TextFileReader {
+  parse(contents: string): Record<string, any>;
+}
+//#endregion
+//#region src/format/built-in/conf/writer.d.ts
+/**
+ * Serializes an object to `key=value` lines (the inverse of ConfReader):
+ * nested objects become dot-separated keys, arrays become repeated
+ * `key[]=` lines. Round-trips are structural, not textual — comments,
+ * blank lines, and line order of an existing file are not preserved,
+ * and a string that parses as another type (e.g. '123') reads back as
+ * that type.
+ */
+declare class ConfWriter extends TextFileWriter {
+  stringify(value: unknown): string;
+}
+//#endregion
+//#region src/format/built-in/json/reader.d.ts
+declare class JSONReader extends TextFileReader {
+  parse(content: string): any;
+}
+//#endregion
+//#region src/format/built-in/json/writer.d.ts
+type JSONWriterOptions = {
+  /**
+   * Indentation of the emitted JSON. A number of spaces, a literal
+   * indent string, or 'auto' — detect the indentation of the existing
+   * target file and keep it (falls back to 4 for new files).
+   *
+   * @default 4
+   */
+  indent?: number | string | 'auto';
+};
+declare class JSONWriter extends TextFileWriter {
+  protected options: JSONWriterOptions;
+  constructor(options?: JSONWriterOptions);
+  protected get usesExistingContent(): boolean;
+  stringify(value: unknown, existing?: string): string;
+}
+//#endregion
+//#region src/format/built-in/module/constants.d.ts
+/**
+ * Single source of truth for the extensions handled by the module loader:
+ * consumed by BOTH the built-in routing registry and the jiti config.
+ */
+declare const MODULE_FILE_EXTENSIONS: readonly [".js", ".mjs", ".mts", ".cjs", ".cts", ".ts"];
+//#endregion
+//#region src/format/built-in/module/type.d.ts
+type ModuleExportFilterFn = (key: string, value: unknown) => boolean;
 type ModuleExport = {
   key: string;
   value: any;
@@ -114,7 +207,7 @@ type ModuleLoadOptions = {
 };
 type ModuleLoadFn = (id: string) => unknown | Promise<unknown>;
 type ModuleLoadSyncFn = (id: string) => unknown;
-type ModuleLoaderOptions = {
+type ModuleReaderOptions = {
   /**
    * Custom asynchronous module loader. When set, this replaces the
    * built-in `await import(id)` call. Useful for test runners (e.g. Vitest)
@@ -130,115 +223,341 @@ type ModuleLoaderOptions = {
   loadSync?: ModuleLoadSyncFn;
 };
 //#endregion
-//#region src/loader/built-in/module/module.d.ts
+//#region src/format/built-in/module/reader.d.ts
 type Jiti = ReturnType<typeof createJiti>;
-declare class ModuleLoader implements Loader {
+declare class ModuleReader implements IReader {
   protected instance: Jiti;
   protected loadFn?: ModuleLoadFn;
   protected loadSyncFn?: ModuleLoadSyncFn;
-  constructor(options?: ModuleLoaderOptions);
-  configure(options: ModuleLoaderOptions): void;
-  execute(input: string): Promise<any>;
-  executeSync(input: string): any;
+  constructor(options?: ModuleReaderOptions);
+  /**
+   * Returns the previous configuration, so callers can restore it.
+   */
+  configure(options: ModuleReaderOptions): ModuleReaderOptions;
+  /**
+   * Returns the raw module value (import / require / jiti output) —
+   * normalization to a module record happens once, at the
+   * FormatRegistry boundary.
+   *
+   * read/readSync are deliberately NOT derived from a shared body
+   * (unlike every other sync/async twin in this package): their
+   * recovery paths differ. The async variant falls back to loadSync
+   * under ts-node (jiti's async path does not cooperate with ts-node)
+   * and to the jiti instance otherwise; the sync variant only has the
+   * jiti fallback. The divergence is pinned by the fallback tests in
+   * test/unit/format/module.spec.ts.
+   */
+  read(input: string): Promise<any>;
+  readSync(input: string): any;
   load(data: LocatorInfo | string, options?: ModuleLoadOptions): Promise<unknown>;
   loadSync(data: LocatorInfo | string, options?: ModuleLoadOptions): unknown;
   private build;
 }
 //#endregion
-//#region src/loader/built-in/module/utils.d.ts
-type ESModule = {
-  [key: string]: any;
-  __esModule: boolean;
+//#region src/format/built-in/module/utils.d.ts
+/**
+ * True when the value is a record produced by locter's read()/toModuleRecord.
+ * Detection is brand-based; a plain object with an `__esModule` key is NOT
+ * a module record.
+ */
+declare function isModuleRecord(input: unknown): input is Record<string, any>;
+declare function getModuleExport(data: Record<string, any>, filterFn: ModuleExportFilterFn): ModuleExport | undefined;
+//#endregion
+//#region src/format/built-in/yaml/reader.d.ts
+declare class YAMLReader extends TextFileReader {
+  parse(content: string): any;
+}
+//#endregion
+//#region src/format/built-in/yaml/writer.d.ts
+type YAMLWriterOptions = ToStringOptions;
+/**
+ * Writes YAML preserving hand-edited structure where possible: when the
+ * target file already exists, the new value is grafted into its parsed
+ * document, so comments and anchors attached to surviving keys survive
+ * the write-back. New files are plain `yaml.stringify` output. An
+ * existing file that fails to parse throws (wrapped as LocterWriteError)
+ * instead of being silently overwritten.
+ */
+declare class YAMLWriter extends TextFileWriter {
+  protected options: YAMLWriterOptions;
+  constructor(options?: YAMLWriterOptions);
+  protected get usesExistingContent(): boolean;
+  stringify(value: unknown, existing?: string): string;
+}
+//#endregion
+//#region src/format/built-in/registry.d.ts
+/**
+ * Every built-in format, in one place. Keys are the format ids; each entry
+ * couples routing and construction. The id union, the extension → format
+ * table, lazy caching, and the typed `builtInReader()` accessor are all
+ * DERIVED from this object. Adding a format = adding one entry.
+ *
+ * Intentionally NOT re-exported from any barrel (internal API).
+ */
+declare const BUILT_IN_PRESETS: {
+  readonly module: {
+    readonly extensions: readonly [".js", ".mjs", ".mts", ".cjs", ".cts", ".ts"];
+    readonly reader: () => ModuleReader;
+  };
+  readonly conf: {
+    readonly extensions: readonly [".conf"];
+    readonly reader: () => ConfReader;
+    readonly writer: () => ConfWriter;
+  };
+  readonly json: {
+    readonly extensions: readonly [".json"];
+    readonly reader: () => JSONReader;
+    readonly writer: () => JSONWriter;
+  };
+  readonly yaml: {
+    readonly extensions: readonly [".yml", ".yaml"];
+    readonly reader: () => YAMLReader;
+    readonly writer: () => YAMLWriter;
+  };
+};
+type BuiltInFormatId = keyof typeof BUILT_IN_PRESETS;
+type BuiltInReaderOf<K extends BuiltInFormatId> = ReturnType<(typeof BUILT_IN_PRESETS)[K]['reader']>;
+/**
+ * Built-in format ids whose preset declares a writer — derived at the type
+ * level, so builtInWriter('module') is a compile error, not a runtime one.
+ */
+type WritableBuiltInFormatId = { [K in BuiltInFormatId]: (typeof BUILT_IN_PRESETS)[K] extends {
+  writer: () => IWriter;
+} ? K : never; }[BuiltInFormatId];
+type BuiltInWriterOf<K extends WritableBuiltInFormatId> = ReturnType<(typeof BUILT_IN_PRESETS)[K]['writer']>;
+//#endregion
+//#region src/format/registry/type.d.ts
+/**
+ * Lazy reader construction. Invoked on the first input that matches the
+ * rule it was registered for; the first successfully constructed reader
+ * is cached (a factory that throws is retried on the next match).
+ */
+type ReaderFactory = () => IReader;
+/**
+ * Lazy writer construction — same lifecycle as ReaderFactory.
+ */
+type WriterFactory = () => IWriter;
+/**
+ * A user-registered dispatch rule. Rules are matched in registration order,
+ * BEFORE the built-in extension table (i.e. user rules override built-ins).
+ * Rules only ever see file paths — bare module specifiers (no extension)
+ * are always routed to the module reader first.
+ *
+ * The reader and writer slots are independent: read dispatch only
+ * considers rules with a reader, write dispatch only rules with a writer.
+ * A reader-only rule for '.json' overrides how '.json' is read without
+ * shadowing the built-in JSON writer (and vice versa). At least one slot
+ * is required.
+ */
+type Rule = {
+  /**
+   * Stable identity. Registering an existing id REPLACES that rule in
+   * place (position preserved, cached instance evicted). Built-in ids
+   * ('module', 'conf', 'json', 'yaml') are reserved. Omitted → auto-generated.
+   */
+  id?: string;
+  test: RegExp | string[];
+  reader?: IReader | ReaderFactory;
+  writer?: IWriter | WriterFactory;
+};
+/**
+ * Normalized registration record — returned by register()/entries().
+ */
+type FormatRegistration = {
+  id: string;
+  test: RegExp | string[];
+  /**
+   * true for entries derived from the built-in registry; those cannot
+   * be unregistered (but can be shadowed by user rules).
+   */
+  builtIn: boolean;
+};
+/**
+ * One built-in format: routing (extensions) + instantiation (reader and
+ * optional writer), inseparable by construction. A preset without a
+ * writer is a read-only format (e.g. module).
+ */
+type FormatPreset = {
+  /** Extensions (with leading dot) routed to this format. Must be disjoint across presets. */
+  extensions: readonly string[];
+  /** Lazy reader factory — invoked at most once per FormatRegistry instance. */
+  reader: () => IReader;
+  /** Lazy writer factory — invoked at most once per FormatRegistry instance. */
+  writer?: () => IWriter;
 };
-declare function isESModule(input: unknown): input is ESModule;
-declare function toModuleRecord(data: unknown): any;
-declare function getModuleExport(data: Record<string, any>, filterFn: LoaderFilterFn): ModuleExport | undefined;
 //#endregion
-//#region src/loader/built-in/yaml/module.d.ts
-declare class YAMLLoader implements Loader {
-  execute(input: string): Promise<any>;
-  executeSync(input: string): any;
+//#region src/format/registry/module.d.ts
+type FormatRegistryOptions = {
+  /**
+   * Seed user rules (matched before built-ins, in array order).
+   */
+  rules?: Rule[];
+};
+/**
+ * A rule compiled to memoizing per-slot accessors. Caller-owned Rule
+ * objects are never mutated; factory caching lives in the closures.
+ */
+type CompiledRule = {
+  id: string;
+  test: RegExp | string[];
+  getReader?: () => IReader;
+  getWriter?: () => IWriter;
+};
+declare class FormatRegistry {
+  /**
+   * User rules only — built-ins live in the extension table instead.
+   */
+  protected rules: CompiledRule[];
+  /**
+   * Lazy per-instance cache of built-in reader instances.
+   */
+  protected builtInReaderCache: Map<BuiltInFormatId, IReader>;
+  /**
+   * Lazy per-instance cache of built-in writer instances.
+   */
+  protected builtInWriterCache: Map<BuiltInFormatId, IWriter>;
+  /**
+   * extension → built-in format id, precomputed once from BUILT_IN_PRESETS.
+   */
+  protected builtInExtensions: Map<string, BuiltInFormatId>;
+  protected ruleCounter: number;
+  constructor(options?: FormatRegistryOptions);
+  register(rule: Rule): FormatRegistration;
+  /**
+   * Remove a user-registered rule by id. Built-in ids cannot be
+   * unregistered (returns false).
+   */
+  unregister(id: string): boolean;
+  has(id: string): boolean;
+  /**
+   * All registrations in effective match order: user rules
+   * (registration order) first, then the built-ins.
+   */
+  entries(): FormatRegistration[];
+  /**
+   * Restore the registry to its construction state: drop all user rules
+   * and evict every cached reader instance (including a module reader
+   * configured via setModuleReader / configure).
+   */
+  reset(): void;
+  read(input: LocatorInfo | string): Promise<any>;
+  readSync(input: LocatorInfo | string): any;
+  /**
+   * Shared body of read/readSync: dispatch, read, normalize, wrap.
+   */
+  protected readBody(input: LocatorInfo | string): TwinBody<any>;
+  write(input: LocatorInfo | string, value: unknown): Promise<void>;
+  writeSync(input: LocatorInfo | string, value: unknown): void;
+  /**
+   * Shared body of write/writeSync: dispatch, unwrap records, write, wrap.
+   * The inverse boundary of readBody: a record produced by read() (brand
+   * detected) is unwrapped to its `.default` value; anything else is
+   * written as-is.
+   */
+  protected writeBody(input: LocatorInfo | string, value: unknown): TwinBody<void>;
+  /**
+   * The single normalization boundary: every read result becomes a module
+   * record (`.default` is always the loaded value, top-level keys stay
+   * accessible as named exports). Provenance decides how: module-reader
+   * output may legitimately already be a record (`__esModule` is meaningful
+   * there); any other reader returns arbitrary parsed data, which is always
+   * wrapped — even if it happens to contain an `__esModule` key.
+   */
+  protected toRecord(output: unknown, reader: IReader): any;
+  /**
+   * Typed accessor for the LIVE built-in reader instance (lazy, cached).
+   */
+  builtInReader<K extends BuiltInFormatId>(id: K): BuiltInReaderOf<K>;
+  /**
+   * Typed accessor for the LIVE built-in writer instance (lazy, cached).
+   * Only writable format ids are accepted — read-only formats (module)
+   * are a compile error.
+   */
+  builtInWriter<K extends WritableBuiltInFormatId>(id: K): BuiltInWriterOf<K>;
+  /**
+   * Dispatch order:
+   *   1. bare specifier (no extension)  → module reader, always
+   *   2. user rules, registration order → first match wins (can override built-ins)
+   *   3. built-in extension table
+   *   4. undefined → read/readSync throw LocterUnknownExtensionError
+   */
+  findReader(input: string): IReader | undefined;
+  /**
+   * Write-side dispatch. No bare-specifier step (there is nothing to
+   * write to); only rules with a writer slot participate, then built-in
+   * presets that declare a writer.
+   */
+  findWriter(input: string): IWriter | undefined;
+  protected findRule(input: string, filter: (rule: CompiledRule) => boolean): CompiledRule | undefined;
+  protected findBuiltInId(input: string): BuiltInFormatId | undefined;
+  protected unknownExtensionError(input: string): LocterUnknownExtensionError;
+  protected compile(id: string, rule: Rule): CompiledRule;
+  protected generateRuleId(): string;
 }
 //#endregion
-//#region src/loader/helpers.d.ts
-declare function registerLoader(rule: Rule): void;
-declare function registerLoader(test: string[] | RegExp, loader: Loader): void;
-declare function load(input: LocatorInfo | string): Promise<any>;
-declare function loadSync(input: LocatorInfo | string): any;
+//#region src/format/registry/singleton.d.ts
+declare function useFormatRegistry(): FormatRegistry;
+//#endregion
+//#region src/format/helpers.d.ts
+declare function registerFormat(rule: Rule): FormatRegistration;
+/**
+ * Remove a rule from the process-global registry by its id
+ * (as returned by registerFormat). Built-in ids cannot be unregistered.
+ */
+declare function unregisterFormat(id: string): boolean;
+declare function read(input: LocatorInfo | string): Promise<any>;
+declare function readSync(input: LocatorInfo | string): any;
+declare function write(input: LocatorInfo | string, value: unknown): Promise<void>;
+declare function writeSync(input: LocatorInfo | string, value: unknown): void;
 /**
- * Override the built-in module loader's `import` / `require` calls.
+ * Override the built-in module reader's `import` / `require` calls.
  *
  * Useful for test runners (e.g. Vitest) where the dynamic `import()` inside
  * `node_modules/locter` would bypass the runner's module graph. Calling this
  * from user code (e.g. a Vitest setup file) lets the runner rewrite the
  * `import()` so loaded modules share identity with statically imported ones.
  *
+ * Returns a restore function that re-applies the previous configuration —
+ * handy for scoped overrides (e.g. test teardown). The restore function is
+ * scoped to the exact reader instance it configured: after a registry
+ * reset() (which discards that instance) it becomes a no-op instead of
+ * re-applying stale configuration to the fresh instance.
+ *
  * @example
  * ```ts
  * // vitest setup file
- * import { setModuleLoader } from 'locter';
+ * import { setModuleReader } from 'locter';
  *
- * setModuleLoader({
+ * setModuleReader({
  *     load: (id) => import(id),
  * });
  * ```
  */
-declare function setModuleLoader(options: ModuleLoaderOptions): void;
-//#endregion
-//#region src/loader/module.d.ts
-declare class LoaderManager implements Loader {
-  protected loaders: Record<string, Loader>;
-  protected rules: Rule[];
-  constructor();
-  register(rule: Rule): void;
-  register(test: string[] | RegExp, loader: Loader): void;
-  execute(input: string): Promise<any>;
-  executeSync(input: string): any;
-  protected unknownExtensionError(input: string): LocterUnknownExtensionError;
-  findLoader(input: string): Loader | string | undefined;
-  /**
-   * Resolve loader by id.
-   *
-   * @param id
-   */
-  resolve(id: string | Loader): Loader;
-  normalizePath(input: string): string;
-}
+declare function setModuleReader(options: ModuleReaderOptions): () => void;
 //#endregion
-//#region src/loader/package-field.d.ts
-type LoadPackageFieldOptions = {
+//#region src/format/package-field.d.ts
+type ReadPackageFieldOptions = {
   cwd?: string;
   walkUp?: boolean;
   stopAt?: string;
 };
-declare function loadPackageField<T = unknown>(field: string, options?: LoadPackageFieldOptions): Promise<T | undefined>;
-declare function loadPackageFieldSync<T = unknown>(field: string, options?: LoadPackageFieldOptions): T | undefined;
-//#endregion
-//#region src/utils/file-name.d.ts
-declare function getFileNameExtension(input: string, allowed?: string[]): string | undefined;
-declare function removeFileNameExtension(input: string, extensions?: string[]): string;
-//#endregion
-//#region src/utils/has-property.d.ts
-declare function hasOwnProperty<X extends Record<string, any>, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
-declare function hasStringProperty<X extends Record<string, any>, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, string>;
-//#endregion
-//#region src/utils/object.d.ts
-declare function isObject(item: unknown): item is Record<string, any>;
-declare function isSafeObjectKey(key: string): boolean;
-//#endregion
-//#region src/utils/to-array.d.ts
-declare function toArray(input: string | string[]): string[];
-//#endregion
-//#region src/utils/file-path.d.ts
-declare function isFilePath(input: string): boolean | "";
+type WritePackageFieldOptions = ReadPackageFieldOptions;
+declare function readPackageField<T = unknown>(field: string, options?: ReadPackageFieldOptions): Promise<T | undefined>;
+declare function readPackageFieldSync<T = unknown>(field: string, options?: ReadPackageFieldOptions): T | undefined;
+/**
+ * Set a top-level field of the nearest `package.json` (same locate
+ * semantics as readPackageField) and write it back, preserving the
+ * file's existing indentation. Passing `undefined` removes the field.
+ * Throws LocterNotFoundError when no package.json could be located.
+ */
+declare function writePackageField(field: string, value: unknown, options?: WritePackageFieldOptions): Promise<void>;
+declare function writePackageFieldSync(field: string, value: unknown, options?: WritePackageFieldOptions): void;
 //#endregion
 //#region src/utils/runtime.d.ts
 declare function isJestRuntimeEnvironment(): boolean;
 declare function isVitestRuntimeEnvironment(): boolean;
 declare function isTsNodeRuntimeEnvironment(): boolean;
+declare function isTsxRuntimeEnvironment(): boolean;
 //#endregion
-//#region src/utils/typescript.d.ts
-declare function isTypeScriptError(input: unknown): input is Error;
-//#endregion
-export { ConfLoader, JSONLoader, LOCTER_ERROR_MARKER, LOCTER_LOAD_ERROR_MARKER, LOCTER_NOT_FOUND_ERROR_MARKER, LOCTER_UNKNOWN_EXTENSION_ERROR_MARKER, LoadPackageFieldOptions, LoaderFilterFn, LoaderManager, LocatorInfo, LocatorOptions, LocatorOptionsInput, LocatorUpOptionsInput, LocterError, LocterErrorInput, LocterErrorOptions, LocterLoadError, LocterNotFoundError, LocterUnknownExtensionError, ModuleExport, ModuleLoadFn, ModuleLoadOptions, ModuleLoadSyncFn, ModuleLoader, ModuleLoaderOptions, YAMLLoader, buildFilePath, buildFilePathWithoutExtension, buildLocatorOptions, buildLocatorPatterns, getFileNameExtension, getModuleExport, hasOwnProperty, hasStringProperty, isESModule, isFilePath, isJestRuntimeEnvironment, isLocatorInfo, isObject, isSafeObjectKey, isTsNodeRuntimeEnvironment, isTypeScriptError, isVitestRuntimeEnvironment, load, loadPackageField, loadPackageFieldSync, loadSync, locate, locateMany, locateManySync, locateSync, locateUp, locateUpSync, pathToLocatorInfo, registerLoader, removeFileNameExtension, setModuleLoader, toArray, toModuleRecord, wrapLoaderError };
+export { ConfReader, ConfWriter, type FormatPreset, type FormatRegistration, FormatRegistry, type FormatRegistryOptions, type IReader, type IWriter, JSONReader, JSONWriter, type JSONWriterOptions, LOCTER_ERROR_MARKER, LOCTER_LOAD_ERROR_MARKER, LOCTER_NOT_FOUND_ERROR_MARKER, LOCTER_UNKNOWN_EXTENSION_ERROR_MARKER, LOCTER_WRITE_ERROR_MARKER, type LocatorInfo, type LocatorOptions, type LocatorOptionsInput, type LocatorUpOptionsInput, LocterError, type LocterErrorInput, type LocterErrorOptions, LocterLoadError, LocterNotFoundError, LocterUnknownExtensionError, LocterWriteError, MODULE_FILE_EXTENSIONS, type ModuleExport, type ModuleExportFilterFn, type ModuleLoadFn, type ModuleLoadOptions, type ModuleLoadSyncFn, ModuleReader, type ModuleReaderOptions, type ReadPackageFieldOptions, type ReaderFactory, type Rule, TextFileReader, TextFileWriter, type WritePackageFieldOptions, type WriterFactory, YAMLReader, YAMLWriter, type YAMLWriterOptions, buildFilePath, getModuleExport, isJestRuntimeEnvironment, isLocatorInfo, isModuleRecord, isTsNodeRuntimeEnvironment, isTsxRuntimeEnvironment, isVitestRuntimeEnvironment, locate, locateMany, locateManySync, locateSync, locateUp, locateUpSync, read, readPackageField, readPackageFieldSync, readSync, registerFormat, setModuleReader, unregisterFormat, useFormatRegistry, wrapLoaderError, wrapWriteError, write, writePackageField, writePackageFieldSync, writeSync };
 //# sourceMappingURL=index.d.mts.map