@effected/walker 0.3.2 → 0.3.3

package/Walker.js

@@ -1,30 +1,6 @@
 import { Effect, FileSystem, Option, Path } from "effect";
 
 //#region src/Walker.ts
-/**
-* Ascend from `start` toward the filesystem root, yielding each directory,
-* nearest first.
-*
-* @remarks
-* Lexical, not physical: `Path.dirname` does not resolve symlinks, so ascending
-* out of a symlinked directory follows the path you were given rather than the
-* real filesystem parent. That is deliberate — config discovery wants the file
-* nearest the path the user named.
-*
-* Bounded twice over: `dirname` is a fixpoint at the root, and `maxDepth` guards
-* a pathological `Path` implementation that never reaches one.
-*
-* `stopAt` is compared in normalized form — see {@link AscendOptions.stopAt}.
-* Raw string equality made the ceiling fail OPEN: an unnormalized ceiling
-* matched nothing and the ascent ran silently to the filesystem root, which is
-* the unbounded walk the option exists to prevent, with no error to notice it
-* by. A relative ceiling **dies** for the same reason — resolving one against
-* `process.cwd()` would reintroduce the silent-wrong-walk failure through a
-* different door. See {@link AscendOptions.stopAt} for why that is a defect
-* rather than a typed error; the error channel stays `never`.
-*
-* @public
-*/
 const ascend = (start, options) => Effect.gen(function* () {
 	const path = yield* Path.Path;
 	const maxDepth = options?.maxDepth ?? 256;
@@ -42,63 +18,80 @@ const ascend = (start, options) => Effect.gen(function* () {
 	}
 	return dirs;
 });
-/**
-* The first candidate whose `predicate` reports true, or `Option.none()`.
-*
-* @remarks
-* Each predicate is absorbed **individually**: a failure on one candidate is
-* treated as "this candidate did not match" and the scan continues. One
-* unreadable ancestor must never abort the walk, or a permission error deep in
-* the tree would hide a valid root above it. Not-found and cannot-look are
-* therefore indistinguishable to the caller; discovery is best-effort.
-*
-* `Effect.catch` catches failures, **not defects**. A predicate that throws is
-* programmer error and surfaces as a defect. Do not change this to
-* `Effect.catchCause` — the distinction is load-bearing.
-*
-* @public
-*/
 const firstMatch = (candidates, predicate) => Effect.gen(function* () {
 	for (const candidate of candidates) if (yield* Effect.catch(predicate(candidate), () => Effect.succeed(false))) return Option.some(candidate);
 	return Option.none();
 });
-/**
-* The first existing path among the candidates `candidatesFor` produces for each
-* directory in `dirs`, scanned in order. Nearer directories win.
-*
-* @remarks
-* Candidates materialize up front, bounded by `dirs.length × candidatesFor`'s
-* output — a few hundred strings under the default `maxDepth`.
-*
-* @public
-*/
 const findUpward = (dirs, candidatesFor) => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const candidates = [];
 	for (const dir of dirs) candidates.push(...candidatesFor(dir));
 	return yield* firstMatch(candidates, (candidate) => fs.exists(candidate));
 });
-/**
-* The first directory in `dirs` that `isRoot` accepts.
-*
-* @remarks
-* `firstMatch` over the directories themselves — the candidate expansion is the
-* identity. `isRoot` is a caller-supplied marker test (a `.git` entry, a
-* `pnpm-workspace.yaml`), and its failures are absorbed per directory.
-*
-* @public
-*/
 const findRoot = (dirs, isRoot) => firstMatch(dirs, isRoot);
 /**
 * Upward path traversal primitives.
 *
 * @public
 */
-const Walker = {
-	ascend,
-	firstMatch,
-	findUpward,
-	findRoot
+var Walker = class {
+	constructor() {}
+	/**
+	* Ascend from `start` toward the filesystem root, yielding each directory,
+	* nearest first.
+	*
+	* @remarks
+	* Lexical, not physical: `Path.dirname` does not resolve symlinks, so ascending
+	* out of a symlinked directory follows the path you were given rather than the
+	* real filesystem parent. That is deliberate — config discovery wants the file
+	* nearest the path the user named.
+	*
+	* Bounded twice over: `dirname` is a fixpoint at the root, and `maxDepth` guards
+	* a pathological `Path` implementation that never reaches one.
+	*
+	* `stopAt` is compared in normalized form — see {@link AscendOptions.stopAt}.
+	* Raw string equality made the ceiling fail OPEN: an unnormalized ceiling
+	* matched nothing and the ascent ran silently to the filesystem root, which is
+	* the unbounded walk the option exists to prevent, with no error to notice it
+	* by. A relative ceiling **dies** for the same reason — resolving one against
+	* `process.cwd()` would reintroduce the silent-wrong-walk failure through a
+	* different door. See {@link AscendOptions.stopAt} for why that is a defect
+	* rather than a typed error; the error channel stays `never`.
+	*/
+	static ascend = ascend;
+	/**
+	* The first candidate whose `predicate` reports true, or `Option.none()`.
+	*
+	* @remarks
+	* Each predicate is absorbed **individually**: a failure on one candidate is
+	* treated as "this candidate did not match" and the scan continues. One
+	* unreadable ancestor must never abort the walk, or a permission error deep in
+	* the tree would hide a valid root above it. Not-found and cannot-look are
+	* therefore indistinguishable to the caller; discovery is best-effort.
+	*
+	* `Effect.catch` catches failures, **not defects**. A predicate that throws is
+	* programmer error and surfaces as a defect. Do not change this to
+	* `Effect.catchCause` — the distinction is load-bearing.
+	*/
+	static firstMatch = firstMatch;
+	/**
+	* The first existing path among the candidates `candidatesFor` produces for each
+	* directory in `dirs`, scanned in order. Nearer directories win.
+	*
+	* @remarks
+	* Candidates materialize up front, bounded by `dirs.length × candidatesFor`'s
+	* output — a few hundred strings under the default `maxDepth`.
+	*/
+	static findUpward = findUpward;
+	/**
+	* The first directory in `dirs` that `isRoot` accepts.
+	*
+	* @remarks
+	* `firstMatch` over the directories themselves — the candidate expansion is the
+	* identity. `isRoot` is a caller-supplied marker test (a `.git` entry, a
+	* `pnpm-workspace.yaml`), and its failures are absorbed per directory.
+	*/
+	static findRoot = findRoot;
 };
 
 //#endregion

package/index.d.ts

@@ -229,12 +229,65 @@ interface AscendOptions {
  *
  * @public
  */
-declare const Walker: {
-  readonly ascend: (start: string, options?: AscendOptions) => Effect.Effect<ReadonlyArray<string>, never, Path.Path>;
-  readonly firstMatch: <E, R>(candidates: ReadonlyArray<string>, predicate: (candidate: string) => Effect.Effect<boolean, E, R>) => Effect.Effect<Option.Option<string>, never, R>;
-  readonly findUpward: (dirs: ReadonlyArray<string>, candidatesFor: (dir: string) => ReadonlyArray<string>) => Effect.Effect<Option.Option<string>, never, FileSystem.FileSystem>;
-  readonly findRoot: <E, R>(dirs: ReadonlyArray<string>, isRoot: (dir: string) => Effect.Effect<boolean, E, R>) => Effect.Effect<Option.Option<string>, never, R>;
-};
+declare class Walker {
+  private constructor();
+  /**
+   * Ascend from `start` toward the filesystem root, yielding each directory,
+   * nearest first.
+   *
+   * @remarks
+   * Lexical, not physical: `Path.dirname` does not resolve symlinks, so ascending
+   * out of a symlinked directory follows the path you were given rather than the
+   * real filesystem parent. That is deliberate — config discovery wants the file
+   * nearest the path the user named.
+   *
+   * Bounded twice over: `dirname` is a fixpoint at the root, and `maxDepth` guards
+   * a pathological `Path` implementation that never reaches one.
+   *
+   * `stopAt` is compared in normalized form — see {@link AscendOptions.stopAt}.
+   * Raw string equality made the ceiling fail OPEN: an unnormalized ceiling
+   * matched nothing and the ascent ran silently to the filesystem root, which is
+   * the unbounded walk the option exists to prevent, with no error to notice it
+   * by. A relative ceiling **dies** for the same reason — resolving one against
+   * `process.cwd()` would reintroduce the silent-wrong-walk failure through a
+   * different door. See {@link AscendOptions.stopAt} for why that is a defect
+   * rather than a typed error; the error channel stays `never`.
+   */
+  static readonly ascend: (start: string, options?: AscendOptions) => Effect.Effect<ReadonlyArray<string>, never, Path.Path>;
+  /**
+   * The first candidate whose `predicate` reports true, or `Option.none()`.
+   *
+   * @remarks
+   * Each predicate is absorbed **individually**: a failure on one candidate is
+   * treated as "this candidate did not match" and the scan continues. One
+   * unreadable ancestor must never abort the walk, or a permission error deep in
+   * the tree would hide a valid root above it. Not-found and cannot-look are
+   * therefore indistinguishable to the caller; discovery is best-effort.
+   *
+   * `Effect.catch` catches failures, **not defects**. A predicate that throws is
+   * programmer error and surfaces as a defect. Do not change this to
+   * `Effect.catchCause` — the distinction is load-bearing.
+   */
+  static readonly firstMatch: <E, R>(candidates: ReadonlyArray<string>, predicate: (candidate: string) => Effect.Effect<boolean, E, R>) => Effect.Effect<Option.Option<string>, never, R>;
+  /**
+   * The first existing path among the candidates `candidatesFor` produces for each
+   * directory in `dirs`, scanned in order. Nearer directories win.
+   *
+   * @remarks
+   * Candidates materialize up front, bounded by `dirs.length × candidatesFor`'s
+   * output — a few hundred strings under the default `maxDepth`.
+   */
+  static readonly findUpward: (dirs: ReadonlyArray<string>, candidatesFor: (dir: string) => ReadonlyArray<string>) => Effect.Effect<Option.Option<string>, never, FileSystem.FileSystem>;
+  /**
+   * The first directory in `dirs` that `isRoot` accepts.
+   *
+   * @remarks
+   * `firstMatch` over the directories themselves — the candidate expansion is the
+   * identity. `isRoot` is a caller-supplied marker test (a `.git` entry, a
+   * `pnpm-workspace.yaml`), and its failures are absorbed per directory.
+   */
+  static readonly findRoot: <E, R>(dirs: ReadonlyArray<string>, isRoot: (dir: string) => Effect.Effect<boolean, E, R>) => Effect.Effect<Option.Option<string>, never, R>;
+}
 //#endregion
 export { type AscendOptions, type CompileAndExpandOptions, DescendError, type DescendOptions, GlobExpansionError, Walker, compileAndExpand, descend };
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/walker",
-	"version": "0.3.2",
+	"version": "0.3.3",
 	"private": false,
 	"description": "Path traversal as Effect primitives: ascend a directory chain to the first matching candidate, or descend a tree expanding a glob against the filesystem.",
 	"keywords": [