@effect-vfs/core 0.7.1 → 0.8.0

package/dist/Search.d.ts

@@ -0,0 +1,730 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import { BytePath } from "./BytePath.js";
+import type { Snapshot } from "./Snapshot.js";
+import type { FsFailure, ImageFailure } from "./VfsError.js";
+/**
+ * Entry kinds selected by filename queries.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const Kind: Schema.Literals<readonly ["file", "directory", "symlink"]>;
+/**
+ * Entry kinds selected by filename queries.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type Kind = typeof Kind.Type;
+/**
+ * Complete finite namespace, matching, content and output limits.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const Limits: Schema.Struct<{
+    maxEntries: Schema.Natural;
+    maxDepth: Schema.Natural;
+    maxPathBytes: Schema.ByteSize;
+    maxResults: Schema.Natural;
+    maxResultBytes: Schema.ByteSize;
+    maxPatternBytes: Schema.ByteSize;
+    maxPatterns: Schema.Natural;
+    maxPatternListBytes: Schema.ByteSize;
+    maxExpansions: Schema.Natural;
+    maxTokens: Schema.Natural;
+    maxMatchingWork: Schema.Natural;
+    maxScannedBytes: Schema.ByteSize;
+    maxFileBytes: Schema.ByteSize;
+    maxLineEvaluations: Schema.Natural;
+    maxExcerptBytes: Schema.ByteSize;
+}>;
+/**
+ * Complete finite search limits.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type Limits = typeof Limits.Type;
+/**
+ * Optional overrides applied to default limits.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const LimitOverrides: Schema.Struct<{
+    readonly maxEntries: Schema.optionalKey<Schema.Natural>;
+    readonly maxDepth: Schema.optionalKey<Schema.Natural>;
+    readonly maxPathBytes: Schema.optionalKey<Schema.ByteSize>;
+    readonly maxResults: Schema.optionalKey<Schema.Natural>;
+    readonly maxResultBytes: Schema.optionalKey<Schema.ByteSize>;
+    readonly maxPatternBytes: Schema.optionalKey<Schema.ByteSize>;
+    readonly maxPatterns: Schema.optionalKey<Schema.Natural>;
+    readonly maxPatternListBytes: Schema.optionalKey<Schema.ByteSize>;
+    readonly maxExpansions: Schema.optionalKey<Schema.Natural>;
+    readonly maxTokens: Schema.optionalKey<Schema.Natural>;
+    readonly maxMatchingWork: Schema.optionalKey<Schema.Natural>;
+    readonly maxScannedBytes: Schema.optionalKey<Schema.ByteSize>;
+    readonly maxFileBytes: Schema.optionalKey<Schema.ByteSize>;
+    readonly maxLineEvaluations: Schema.optionalKey<Schema.Natural>;
+    readonly maxExcerptBytes: Schema.optionalKey<Schema.ByteSize>;
+}>;
+/**
+ * Optional overrides applied to default limits.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type LimitOverrides = typeof LimitOverrides.Type;
+/**
+ * Names of compiler, traversal, output and content bounds.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const Limit: Schema.Literals<readonly ["maxEntries", "maxDepth", "maxPathBytes", "maxResults", "maxResultBytes", "maxPatternBytes", "maxPatterns", "maxPatternListBytes", "maxExpansions", "maxTokens", "maxMatchingWork", "maxScannedBytes", "maxFileBytes", "maxLineEvaluations", "maxExcerptBytes"]>;
+/**
+ * Names of compiler, traversal, output and content bounds.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type Limit = typeof Limit.Type;
+/**
+ * Finite default work policy. Byte limits use exact `ByteSize` values.
+ *
+ * Defaults are 100,000 entries, depth 256, 4 KiB paths, 100 rows, 64 KiB
+ * result payload, 4 KiB per pattern, 128 pattern sources, 64 KiB aggregate
+ * sources, 1,024 expanded alternatives, 65,536 compiled tokens, and 10 million
+ * matching operations. Content defaults are 64 MiB scanned bytes, 1 MiB per
+ * file, 100,000 line evaluations and 1 KiB excerpts. Glob performs no content work. These bounds do not promise a deadline or
+ * measure JavaScript heap or serialized JSON size.
+ *
+ * @category defaults
+ * @since 0.8.0
+ */
+export declare const defaultLimits: Limits;
+/**
+ * An explicit directory root, nonempty include list and optional exclusions,
+ * kinds and limits. All patterns are root-relative and case-sensitive.
+ *
+ * Wildcards and classes match Unicode code points without normalization.
+ * Supports `*`, `?`, classes, comma brace alternatives, whole-segment `**`,
+ * backslash escapes, and a directory-only trailing slash. Excluded directories
+ * prune traversal. Include selectors and kind filters do not prune directories.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const GlobQuery: Schema.Struct<{
+    readonly root: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    readonly include: Schema.NonEmptyArray<Schema.String>;
+    readonly exclude: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly kinds: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["file", "directory", "symlink"]>>>;
+    readonly limits: Schema.optionalKey<Schema.Struct<{
+        readonly maxEntries: Schema.optionalKey<Schema.Natural>;
+        readonly maxDepth: Schema.optionalKey<Schema.Natural>;
+        readonly maxPathBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxResults: Schema.optionalKey<Schema.Natural>;
+        readonly maxResultBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxPatternBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxPatterns: Schema.optionalKey<Schema.Natural>;
+        readonly maxPatternListBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxExpansions: Schema.optionalKey<Schema.Natural>;
+        readonly maxTokens: Schema.optionalKey<Schema.Natural>;
+        readonly maxMatchingWork: Schema.optionalKey<Schema.Natural>;
+        readonly maxScannedBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxFileBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxLineEvaluations: Schema.optionalKey<Schema.Natural>;
+        readonly maxExcerptBytes: Schema.optionalKey<Schema.ByteSize>;
+    }>>;
+}>;
+/**
+ * Filename query decoded by `GlobQuery`.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type GlobQuery = typeof GlobQuery.Type;
+/**
+ * Work counts, with exact raw UTF-8 result bytes.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const Work: Schema.Struct<{
+    readonly entries: Schema.Natural;
+    readonly matchingWork: Schema.Natural;
+    readonly resultBytes: Schema.ByteSize;
+    readonly scannedBytes: Schema.ByteSize;
+    readonly lineEvaluations: Schema.Natural;
+}>;
+/**
+ * Work counts, with exact raw UTF-8 result bytes.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type Work = typeof Work.Type;
+/**
+ * Counted policy skips. Descendants of skipped directories are not estimated.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const Skips: Schema.Struct<{
+    readonly invalidNames: Schema.Natural;
+    readonly invalidNameSubtrees: Schema.Natural;
+    readonly oversizedFiles: Schema.Natural;
+    readonly invalidUtf8Files: Schema.Natural;
+    readonly binaryFiles: Schema.Natural;
+}>;
+/**
+ * Counted policy skips.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type Skips = typeof Skips.Type;
+/**
+ * `Complete` exhausts the eligible namespace, possibly with skips. `Stopped`
+ * names the exhausted bound and a root-relative path when representable.
+ * The empty string identifies the selected root. Stopping does not assert
+ * that another matching entry exists.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const Completion: Schema.Union<readonly [Schema.TaggedStruct<"Complete", {}>, Schema.TaggedStruct<"Stopped", {
+    readonly limit: Schema.Literals<readonly ["maxEntries", "maxDepth", "maxPathBytes", "maxResults", "maxResultBytes", "maxPatternBytes", "maxPatterns", "maxPatternListBytes", "maxExpansions", "maxTokens", "maxMatchingWork", "maxScannedBytes", "maxFileBytes", "maxLineEvaluations", "maxExcerptBytes"]>;
+    readonly path: Schema.optionalKey<Schema.String>;
+}>]>;
+/**
+ * Query completion with an actual stopping bound.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type Completion = typeof Completion.Type;
+/**
+ * A selected root, preceding results, counters and completion.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const GlobReport: Schema.Struct<{
+    readonly root: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    readonly results: Schema.$Array<Schema.String>;
+    readonly work: Schema.Struct<{
+        readonly entries: Schema.Natural;
+        readonly matchingWork: Schema.Natural;
+        readonly resultBytes: Schema.ByteSize;
+        readonly scannedBytes: Schema.ByteSize;
+        readonly lineEvaluations: Schema.Natural;
+    }>;
+    readonly skips: Schema.Struct<{
+        readonly invalidNames: Schema.Natural;
+        readonly invalidNameSubtrees: Schema.Natural;
+        readonly oversizedFiles: Schema.Natural;
+        readonly invalidUtf8Files: Schema.Natural;
+        readonly binaryFiles: Schema.Natural;
+    }>;
+    readonly completion: Schema.Union<readonly [Schema.TaggedStruct<"Complete", {}>, Schema.TaggedStruct<"Stopped", {
+        readonly limit: Schema.Literals<readonly ["maxEntries", "maxDepth", "maxPathBytes", "maxResults", "maxResultBytes", "maxPatternBytes", "maxPatterns", "maxPatternListBytes", "maxExpansions", "maxTokens", "maxMatchingWork", "maxScannedBytes", "maxFileBytes", "maxLineEvaluations", "maxExcerptBytes"]>;
+        readonly path: Schema.optionalKey<Schema.String>;
+    }>]>;
+}>;
+/**
+ * A selected root, preceding results, counters and completion.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type GlobReport = typeof GlobReport.Type;
+declare const QueryFailure_base: Schema.Class<QueryFailure, Schema.TaggedStruct<"SearchQueryFailure", {
+    readonly field: Schema.String;
+    readonly message: Schema.String;
+    readonly pattern: Schema.optionalKey<Schema.String>;
+    readonly limit: Schema.optionalKey<Schema.Literals<readonly ["maxEntries", "maxDepth", "maxPathBytes", "maxResults", "maxResultBytes", "maxPatternBytes", "maxPatterns", "maxPatternListBytes", "maxExpansions", "maxTokens", "maxMatchingWork", "maxScannedBytes", "maxFileBytes", "maxLineEvaluations", "maxExcerptBytes"]>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Invalid query, pattern syntax or aggregate compilation limit.
+ *
+ * @category errors
+ * @since 0.8.0
+ */
+export declare class QueryFailure extends QueryFailure_base {
+}
+declare const BudgetExceeded_base: Schema.Class<BudgetExceeded, Schema.TaggedStruct<"SearchBudgetExceeded", {
+    readonly limit: Schema.Literals<readonly ["maxEntries", "maxDepth", "maxPathBytes", "maxResults", "maxResultBytes", "maxPatternBytes", "maxPatterns", "maxPatternListBytes", "maxExpansions", "maxTokens", "maxMatchingWork", "maxScannedBytes", "maxFileBytes", "maxLineEvaluations", "maxExcerptBytes"]>;
+    readonly path: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Typed runtime budget exhaustion.
+ *
+ * @category errors
+ * @since 0.8.0
+ */
+export declare class BudgetExceeded extends BudgetExceeded_base {
+}
+/**
+ * Query and snapshot failures preserved by collectors.
+ *
+ * @category errors
+ * @since 0.8.0
+ */
+export type GlobFailure = QueryFailure | FsFailure | ImageFailure;
+/**
+ * Stream failures, including exhaustion after earlier rows.
+ *
+ * @category errors
+ * @since 0.8.0
+ */
+export type ScanGlobFailure = GlobFailure | BudgetExceeded;
+/**
+ * Explicit content interpretation. Literal strings never become regex implicitly.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const Pattern: Schema.TaggedUnion<{
+    readonly Literal: Schema.TaggedStruct<"Literal", {
+        readonly pattern: Schema.NonEmptyString;
+    }>;
+    readonly Regex: Schema.TaggedStruct<"Regex", {
+        readonly pattern: Schema.String;
+    }>;
+}>;
+/**
+ * Explicit literal or native regex content pattern.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type Pattern = typeof Pattern.Type;
+/**
+ * Regular-file content selection using the same case-sensitive filename globs as
+ * `GlobQuery`. Content `ignoreCase` defaults to false and never affects filenames.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const ContentQuery: Schema.Struct<{
+    readonly root: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    readonly include: Schema.NonEmptyArray<Schema.String>;
+    readonly exclude: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly pattern: Schema.TaggedUnion<{
+        readonly Literal: Schema.TaggedStruct<"Literal", {
+            readonly pattern: Schema.NonEmptyString;
+        }>;
+        readonly Regex: Schema.TaggedStruct<"Regex", {
+            readonly pattern: Schema.String;
+        }>;
+    }>;
+    readonly ignoreCase: Schema.optionalKey<Schema.Boolean>;
+    readonly limits: Schema.optionalKey<Schema.Struct<{
+        readonly maxEntries: Schema.optionalKey<Schema.Natural>;
+        readonly maxDepth: Schema.optionalKey<Schema.Natural>;
+        readonly maxPathBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxResults: Schema.optionalKey<Schema.Natural>;
+        readonly maxResultBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxPatternBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxPatterns: Schema.optionalKey<Schema.Natural>;
+        readonly maxPatternListBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxExpansions: Schema.optionalKey<Schema.Natural>;
+        readonly maxTokens: Schema.optionalKey<Schema.Natural>;
+        readonly maxMatchingWork: Schema.optionalKey<Schema.Natural>;
+        readonly maxScannedBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxFileBytes: Schema.optionalKey<Schema.ByteSize>;
+        readonly maxLineEvaluations: Schema.optionalKey<Schema.Natural>;
+        readonly maxExcerptBytes: Schema.optionalKey<Schema.ByteSize>;
+    }>>;
+}>;
+/**
+ * Validated snapshot content query.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type ContentQuery = typeof ContentQuery.Type;
+/**
+ * Half-open, file-absolute UTF-8 byte offsets. These are safe integers, not UTF-16
+ * indices or character columns.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const MatchRange: Schema.Struct<{
+    readonly start: Schema.Natural;
+    readonly end: Schema.Natural;
+}>;
+/**
+ * First whole-match byte range.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type MatchRange = typeof MatchRange.Type;
+/**
+ * UTF-8-bounded text beginning at the match, with its original file-byte start.
+ * `truncated` is true when any line prefix or suffix is omitted. The full match
+ * range can extend beyond this text. A zero-width end match can have empty text.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const Excerpt: Schema.Struct<{
+    readonly text: Schema.String;
+    readonly start: Schema.Natural;
+    readonly truncated: Schema.Boolean;
+}>;
+/**
+ * Bounded excerpt of one matching line.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type Excerpt = typeof Excerpt.Type;
+/**
+ * One matching line, its first whole match and bounded excerpt. Line numbers are
+ * 1-based; paths are root-relative. LF separates lines, CR is stripped only before
+ * LF, BOM and lone CR are preserved, and a final LF adds no synthetic empty line.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const LineResult: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly lineNumber: Schema.Int;
+    readonly range: Schema.Struct<{
+        readonly start: Schema.Natural;
+        readonly end: Schema.Natural;
+    }>;
+    readonly excerpt: Schema.Struct<{
+        readonly text: Schema.String;
+        readonly start: Schema.Natural;
+        readonly truncated: Schema.Boolean;
+    }>;
+}>;
+/**
+ * One matching line result.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type LineResult = typeof LineResult.Type;
+/**
+ * Exact matching-line count for one completely scanned matching file. This counts
+ * lines, not occurrences. Incomplete files never produce a count row.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const CountResult: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly count: Schema.Int;
+}>;
+/**
+ * One completed file matching-line count.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type CountResult = typeof CountResult.Type;
+/**
+ * Preceding line matches with coverage, work and skips.
+ * `Complete` covers eligible content and can still contain skips. Stopped or skipped
+ * query totals are lower bounds for the original scope.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const LinesReport: Schema.Struct<{
+    readonly root: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    readonly results: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly lineNumber: Schema.Int;
+        readonly range: Schema.Struct<{
+            readonly start: Schema.Natural;
+            readonly end: Schema.Natural;
+        }>;
+        readonly excerpt: Schema.Struct<{
+            readonly text: Schema.String;
+            readonly start: Schema.Natural;
+            readonly truncated: Schema.Boolean;
+        }>;
+    }>>;
+    readonly work: Schema.Struct<{
+        readonly entries: Schema.Natural;
+        readonly matchingWork: Schema.Natural;
+        readonly resultBytes: Schema.ByteSize;
+        readonly scannedBytes: Schema.ByteSize;
+        readonly lineEvaluations: Schema.Natural;
+    }>;
+    readonly skips: Schema.Struct<{
+        readonly invalidNames: Schema.Natural;
+        readonly invalidNameSubtrees: Schema.Natural;
+        readonly oversizedFiles: Schema.Natural;
+        readonly invalidUtf8Files: Schema.Natural;
+        readonly binaryFiles: Schema.Natural;
+    }>;
+    readonly completion: Schema.Union<readonly [Schema.TaggedStruct<"Complete", {}>, Schema.TaggedStruct<"Stopped", {
+        readonly limit: Schema.Literals<readonly ["maxEntries", "maxDepth", "maxPathBytes", "maxResults", "maxResultBytes", "maxPatternBytes", "maxPatterns", "maxPatternListBytes", "maxExpansions", "maxTokens", "maxMatchingWork", "maxScannedBytes", "maxFileBytes", "maxLineEvaluations", "maxExcerptBytes"]>;
+        readonly path: Schema.optionalKey<Schema.String>;
+    }>]>;
+}>;
+/**
+ * Bounded snapshot content report.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type LinesReport = typeof LinesReport.Type;
+/**
+ * Preceding matching filenames with coverage, work and skips.
+ * `Complete` covers eligible content and can still contain skips. Stopped or skipped
+ * query totals are lower bounds for the original scope.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const FilesReport: Schema.Struct<{
+    readonly root: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    readonly results: Schema.$Array<Schema.String>;
+    readonly work: Schema.Struct<{
+        readonly entries: Schema.Natural;
+        readonly matchingWork: Schema.Natural;
+        readonly resultBytes: Schema.ByteSize;
+        readonly scannedBytes: Schema.ByteSize;
+        readonly lineEvaluations: Schema.Natural;
+    }>;
+    readonly skips: Schema.Struct<{
+        readonly invalidNames: Schema.Natural;
+        readonly invalidNameSubtrees: Schema.Natural;
+        readonly oversizedFiles: Schema.Natural;
+        readonly invalidUtf8Files: Schema.Natural;
+        readonly binaryFiles: Schema.Natural;
+    }>;
+    readonly completion: Schema.Union<readonly [Schema.TaggedStruct<"Complete", {}>, Schema.TaggedStruct<"Stopped", {
+        readonly limit: Schema.Literals<readonly ["maxEntries", "maxDepth", "maxPathBytes", "maxResults", "maxResultBytes", "maxPatternBytes", "maxPatterns", "maxPatternListBytes", "maxExpansions", "maxTokens", "maxMatchingWork", "maxScannedBytes", "maxFileBytes", "maxLineEvaluations", "maxExcerptBytes"]>;
+        readonly path: Schema.optionalKey<Schema.String>;
+    }>]>;
+}>;
+/**
+ * Bounded snapshot content report.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type FilesReport = typeof FilesReport.Type;
+/**
+ * Preceding completed-file counts with coverage, work and skips.
+ * `Complete` covers eligible content and can still contain skips. Stopped or skipped
+ * query totals are lower bounds for the original scope.
+ *
+ * @category schemas
+ * @since 0.8.0
+ */
+export declare const CountLinesReport: Schema.Struct<{
+    readonly root: Schema.Union<readonly [Schema.String, Schema.declare<BytePath, BytePath>]>;
+    readonly results: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly count: Schema.Int;
+    }>>;
+    readonly work: Schema.Struct<{
+        readonly entries: Schema.Natural;
+        readonly matchingWork: Schema.Natural;
+        readonly resultBytes: Schema.ByteSize;
+        readonly scannedBytes: Schema.ByteSize;
+        readonly lineEvaluations: Schema.Natural;
+    }>;
+    readonly skips: Schema.Struct<{
+        readonly invalidNames: Schema.Natural;
+        readonly invalidNameSubtrees: Schema.Natural;
+        readonly oversizedFiles: Schema.Natural;
+        readonly invalidUtf8Files: Schema.Natural;
+        readonly binaryFiles: Schema.Natural;
+    }>;
+    readonly completion: Schema.Union<readonly [Schema.TaggedStruct<"Complete", {}>, Schema.TaggedStruct<"Stopped", {
+        readonly limit: Schema.Literals<readonly ["maxEntries", "maxDepth", "maxPathBytes", "maxResults", "maxResultBytes", "maxPatternBytes", "maxPatterns", "maxPatternListBytes", "maxExpansions", "maxTokens", "maxMatchingWork", "maxScannedBytes", "maxFileBytes", "maxLineEvaluations", "maxExcerptBytes"]>;
+        readonly path: Schema.optionalKey<Schema.String>;
+    }>]>;
+}>;
+/**
+ * Bounded snapshot content report.
+ *
+ * @category models
+ * @since 0.8.0
+ */
+export type CountLinesReport = typeof CountLinesReport.Type;
+/**
+ * Typed query, pattern-compilation and snapshot failures for content collectors.
+ *
+ * @category errors
+ * @since 0.8.0
+ */
+export type ContentFailure = QueryFailure | FsFailure | ImageFailure;
+/**
+ * Content Stream failures, including budget exhaustion after earlier rows.
+ *
+ * @category errors
+ * @since 0.8.0
+ */
+export type ScanContentFailure = ContentFailure | BudgetExceeded;
+/**
+ * Stream ordinary root-relative strings in depth-first preorder, with each
+ * directory sorted by raw name bytes. Resolve the root through directory
+ * symlinks; never follow discovered symlinks or emit the root itself.
+ *
+ * A budget failure may follow earlier rows. Taking a prefix establishes no
+ * completion. Use `glob` when skip counts or coverage matter. Each evaluation
+ * owns fresh traversal and counters, including repeated or concurrent runs.
+ *
+ * @example
+ * ```ts
+ * import * as BunCrypto from "@effect/platform-bun/BunCrypto"
+ * import { Search, VirtualFileSystem as Vfs } from "@effect-vfs/core"
+ * import { Effect, Stream } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const volume = yield* Vfs.fromFixture({ entries: [
+ *     { kind: "file", path: "/😀.ts", bytes: new Uint8Array() }
+ *   ] })
+ *   const snapshot = yield* volume.snapshot
+ *   return yield* Stream.runCollect(Search.scanGlob(snapshot, { root: "/", include: ["?.ts"] }))
+ * })
+ * Effect.runPromise(program.pipe(Effect.provide(BunCrypto.layer))).then(console.log)
+ * // [ '😀.ts' ]
+ * ```
+ *
+ * @category operations
+ * @since 0.8.0
+ */
+export declare const scanGlob: (snapshot: Snapshot, query: GlobQuery) => Stream.Stream<string, ScanGlobFailure>;
+/**
+ * Collect bounded matches and preserve preceding rows when a work or output
+ * budget stops the query. Invalid queries, malformed patterns and snapshot
+ * failures remain typed failures; interruption remains interruption.
+ *
+ * Reaching the row cap always reports `Stopped`, even for the last possible
+ * result. Invalid UTF-8 names are counted skips, and invalid-name directories
+ * count one skipped subtree without examining its descendants.
+ *
+ * @example
+ * ```ts
+ * import * as BunCrypto from "@effect/platform-bun/BunCrypto"
+ * import { Search, VirtualFileSystem as Vfs } from "@effect-vfs/core"
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const volume = yield* Vfs.fromFixture({ entries: [
+ *     { kind: "file", path: "/a.ts", bytes: new Uint8Array() },
+ *     { kind: "file", path: "/b.ts", bytes: new Uint8Array() }
+ *   ] })
+ *   return yield* Search.glob(yield* volume.snapshot, {
+ *     root: "/", include: ["*.ts"], limits: { maxResults: 1 }
+ *   })
+ * })
+ * Effect.runPromise(program.pipe(Effect.provide(BunCrypto.layer))).then((report) => {
+ *   console.log(report.results, report.completion._tag)
+ * })
+ * // [ "a.ts" ] Stopped
+ * ```
+ *
+ * @category operations
+ * @since 0.8.0
+ */
+export declare const glob: (snapshot: Snapshot, query: GlobQuery) => Effect.Effect<GlobReport, GlobFailure>;
+/**
+ * Stream one result per matching line after classifying the complete file for
+ * strict UTF-8 and NUL. Each row contains the first whole-match byte range and
+ * a UTF-8-bounded excerpt beginning at the match. Files and hard-link names are
+ * selected independently; invalid, binary and oversized files are skipped.
+ *
+ * A budget failure can follow earlier rows. A prefix establishes no completion;
+ * use `lines` for coverage and skip counters. Each evaluation owns fresh state.
+ * Native regex can block within one call; Effect timeouts cannot preempt it.
+ *
+ * @example
+ * ```ts
+ * import * as BunCrypto from "@effect/platform-bun/BunCrypto"
+ * import { Search, VirtualFileSystem as Vfs } from "@effect-vfs/core"
+ * import { Effect, Stream } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const volume = yield* Vfs.fromFixture({ entries: [
+ *     { kind: "file", path: "/note", bytes: new TextEncoder().encode("😀TODO\n") }
+ *   ] })
+ *   return yield* Stream.runCollect(Search.scanLines(yield* volume.snapshot, {
+ *     root: "/", include: ["**"], pattern: Search.Pattern.cases.Literal.make({ pattern: "TODO" })
+ *   }))
+ * })
+ * Effect.runPromise(program.pipe(Effect.provide(BunCrypto.layer))).then((rows) => {
+ *   console.log(rows[0]?.range)
+ * })
+ * // { start: 4, end: 8 }
+ * ```
+ *
+ * @category operations
+ * @since 0.8.0
+ */
+export declare const scanLines: (snapshot: Snapshot, query: ContentQuery) => Stream.Stream<LineResult, ScanContentFailure>;
+/**
+ * Collect matching lines, preceding rows, skips, work and completion. Catch only
+ * budget exhaustion; query, pattern and snapshot failures remain typed failures,
+ * and interruption propagates. Reaching the result cap reports `Stopped` with
+ * no lookahead, even for the last possible result.
+ *
+ * Raw row bytes are UTF-8 path and excerpt bytes plus 16 bytes for the range.
+ * Scalar metadata is excluded; this is not heap or serialized JSON accounting.
+ * Complete classification charges full eligible file bytes, including skips and
+ * repeated hard-link scans. Empty files have no lines.
+ *
+ * @category operations
+ * @since 0.8.0
+ */
+export declare const lines: (snapshot: Snapshot, query: ContentQuery) => Effect.Effect<LinesReport, ContentFailure>;
+/**
+ * Stream one root-relative filename per matching regular-file path. Classify
+ * the complete file before testing lines and stop matching after the first hit.
+ * Build no line-result ranges or excerpts. Budget exhaustion fails the Stream;
+ * use `files` for coverage and skip counters.
+ *
+ * @category operations
+ * @since 0.8.0
+ */
+export declare const scanFiles: (snapshot: Snapshot, query: ContentQuery) => Stream.Stream<string, ScanContentFailure>;
+/**
+ * Collect matching filenames with preceding rows, work, skips and completion.
+ * Shares text classification and matching with `lines`, but evaluates only as
+ * far as the first hit in each classified file. Raw result bytes count paths
+ * only; scanned bytes still charge the full selected file before classification.
+ *
+ * @category operations
+ * @since 0.8.0
+ */
+export declare const files: (snapshot: Snapshot, query: ContentQuery) => Effect.Effect<FilesReport, ContentFailure>;
+/**
+ * Stream exact matching-line counts for completely scanned matching files.
+ * Multiple occurrences on one line count once. A stopped file emits no partial
+ * count; earlier completed rows can precede a budget failure. Builds no line
+ * ranges or excerpts. Use `countLines` when coverage information matters.
+ *
+ * @category operations
+ * @since 0.8.0
+ */
+export declare const scanCountLines: (snapshot: Snapshot, query: ContentQuery) => Stream.Stream<CountResult, ScanContentFailure>;
+/**
+ * Collect exact per-file matching-line counts with work, skips and completion.
+ * A stopped or skipped query's summed counts are lower bounds for its original
+ * scope. Raw result accounting is UTF-8 path bytes plus 8 bytes per count;
+ * scalar metadata is excluded, as in the other content modes.
+ *
+ * @category operations
+ * @since 0.8.0
+ */
+export declare const countLines: (snapshot: Snapshot, query: ContentQuery) => Effect.Effect<CountLinesReport, ContentFailure>;
+export {};
+//# sourceMappingURL=Search.d.ts.map