pyric-tools 0.1.0-alpha.7

package/dist/discover/concurrency.d.ts

@@ -0,0 +1,42 @@
+/**
+ * FIFO counting semaphore. `acquire()` resolves immediately while
+ * fewer than `max` permits are checked out, otherwise it queues until
+ * a `release()` frees a slot. Waiters are served in arrival order.
+ *
+ * `release()` without a prior `acquire()` is a no-op (does not go
+ * negative). This is intentional — it lets defensive `try/finally`
+ * release in error paths without bookkeeping.
+ */
+export declare class Semaphore {
+    private readonly max;
+    private active;
+    private queue;
+    constructor(max: number);
+    acquire(): Promise<void>;
+    release(): void;
+    /**
+     * Number of permits currently checked out. For tests and instrumentation
+     * only; do not branch on this in production logic.
+     */
+    get inFlight(): number;
+    /**
+     * Number of waiters queued. For tests and instrumentation only.
+     */
+    get pending(): number;
+}
+/**
+ * Run `items` through `producer` concurrently, capping in-flight calls
+ * at `limit`. Returns results in input order (same shape as
+ * `Promise.all(items.map(producer))` — but bounded).
+ *
+ * `producer` may throw; the rejection propagates after in-flight work
+ * settles. Other items continue running so the rejection isn't masked
+ * by a Promise.all-style fast-fail leaving zombie pending work.
+ *
+ * Implementation detail: uses an internal `Semaphore(limit)`; callers
+ * who need to share a permit pool across multiple `runWithLimit` calls
+ * (e.g. crawler global RPC cap) should use the `Semaphore` class
+ * directly via `acquire`/`release`.
+ */
+export declare function runWithLimit<T, R>(items: readonly T[], limit: number, producer: (item: T, index: number) => Promise<R>): Promise<R[]>;
+//# sourceMappingURL=concurrency.d.ts.map

package/dist/discover/concurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../../src/discover/concurrency.ts"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,KAAK,CAAyB;gBAE1B,GAAG,EAAE,MAAM;IASjB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAa9B,OAAO,IAAI,IAAI;IAOf;;;OAGG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;CACF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,CAAC,EACrC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAC/C,OAAO,CAAC,CAAC,EAAE,CAAC,CAgCd"}

package/dist/discover/concurrency.js

@@ -0,0 +1,113 @@
+/**
+ * Bounded concurrency primitives for the Firestore discover_paths crawler.
+ *
+ * Phase 0.3 of the validation plan locked layered BFS with `Promise.all`-per-
+ * layer as the production strategy (38× faster than serial DFS on the
+ * representative corpus). This module provides the two pieces every layer
+ * needs:
+ *
+ *   - `Semaphore` — FIFO-ordered counting semaphore with `acquire`/`release`.
+ *   - `runWithLimit` — ergonomic wrapper that maps a list of async producers
+ *     through the semaphore and resolves to the ordered results.
+ *
+ * Kept self-contained (no `database/crawl/semaphore.ts` reuse) so the
+ * `firestore/discover` subsystem owns its own concurrency contract.
+ */
+'use strict';
+/**
+ * FIFO counting semaphore. `acquire()` resolves immediately while
+ * fewer than `max` permits are checked out, otherwise it queues until
+ * a `release()` frees a slot. Waiters are served in arrival order.
+ *
+ * `release()` without a prior `acquire()` is a no-op (does not go
+ * negative). This is intentional — it lets defensive `try/finally`
+ * release in error paths without bookkeeping.
+ */
+export class Semaphore {
+    max;
+    active = 0;
+    queue = [];
+    constructor(max) {
+        if (!Number.isInteger(max) || max < 1) {
+            throw new RangeError(`Semaphore: max must be a positive integer, got ${max}`);
+        }
+        this.max = max;
+    }
+    async acquire() {
+        if (this.active < this.max) {
+            this.active++;
+            return;
+        }
+        return new Promise((resolve) => {
+            this.queue.push(() => {
+                this.active++;
+                resolve();
+            });
+        });
+    }
+    release() {
+        if (this.active === 0)
+            return; // never go negative
+        this.active--;
+        const next = this.queue.shift();
+        if (next)
+            next();
+    }
+    /**
+     * Number of permits currently checked out. For tests and instrumentation
+     * only; do not branch on this in production logic.
+     */
+    get inFlight() {
+        return this.active;
+    }
+    /**
+     * Number of waiters queued. For tests and instrumentation only.
+     */
+    get pending() {
+        return this.queue.length;
+    }
+}
+/**
+ * Run `items` through `producer` concurrently, capping in-flight calls
+ * at `limit`. Returns results in input order (same shape as
+ * `Promise.all(items.map(producer))` — but bounded).
+ *
+ * `producer` may throw; the rejection propagates after in-flight work
+ * settles. Other items continue running so the rejection isn't masked
+ * by a Promise.all-style fast-fail leaving zombie pending work.
+ *
+ * Implementation detail: uses an internal `Semaphore(limit)`; callers
+ * who need to share a permit pool across multiple `runWithLimit` calls
+ * (e.g. crawler global RPC cap) should use the `Semaphore` class
+ * directly via `acquire`/`release`.
+ */
+export async function runWithLimit(items, limit, producer) {
+    if (!Number.isInteger(limit) || limit < 1) {
+        throw new RangeError(`runWithLimit: limit must be a positive integer, got ${limit}`);
+    }
+    if (items.length === 0)
+        return [];
+    const sem = new Semaphore(limit);
+    const results = new Array(items.length);
+    const errors = [];
+    await Promise.all(items.map(async (item, index) => {
+        await sem.acquire();
+        try {
+            results[index] = await producer(item, index);
+        }
+        catch (error) {
+            errors.push({ index, error });
+        }
+        finally {
+            sem.release();
+        }
+    }));
+    if (errors.length > 0) {
+        // Surface the first error in input order — agents/tests can rely on
+        // a deterministic surface even when multiple producers throw.
+        errors.sort((a, b) => a.index - b.index);
+        throw errors[0].error;
+    }
+    return results;
+}
+//# sourceMappingURL=concurrency.js.map

package/dist/discover/concurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.js","sourceRoot":"","sources":["../../src/discover/concurrency.ts"],"names":[],"mappings":"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"}

package/dist/discover/crawler-adapter.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Adapter wrapping {@link LocalEnvironment} so it satisfies the
+ * `CrawlerFirestore` + `CollectionGroupCapableFirestore` contracts that
+ * `firestore_discover_paths` and `firestore_find_collection_group`
+ * depend on.
+ *
+ * Why this exists:
+ *   The discover tools normally target firebase-admin's `Firestore`
+ *   over the network. Driving them against {@link LocalEnvironment}
+ *   instead lets unit + integration tests run hermetically — no
+ *   service-account credentials, no live project, no permissions
+ *   surprises. The adapter:
+ *     - derives collection IDs from the in-memory keyspace
+ *     - synthesizes `_fieldsProto` via {@link ../simulator/wire-encoder}
+ *       so the crawler's wire-format reader sees what it expects
+ *     - implements `collectionGroup(id)` by scanning paths whose
+ *       penultimate segment matches `id`
+ *
+ * Phantom parent docs (Item 4):
+ *   `LocalEnvironment.listDocuments(parent)` synthesizes empty records
+ *   for any parent id whose only existence is via descendant paths. This
+ *   adapter forwards those phantoms as doc refs whose `.get()` returns
+ *   an empty `_fieldsProto` — matching how live Firestore exposes parent
+ *   docs that have subcollections but no fields. Phantom refs are
+ *   detected via the `phantom` flag on the list result.
+ *
+ * Limitations:
+ *   - `collectionGroup().select()` is a no-op chainable: the discover
+ *     tools call `.select()` with no args (refs only), so projection
+ *     semantics aren't needed.
+ */
+import type { LocalEnvironment } from 'pyric/sandbox/internal';
+import type { CrawlerCollectionRef, CrawlerDocumentRef, CrawlerFirestore } from 'pyric-tools/discover';
+import type { CollectionGroupCapableFirestore, CollectionGroupQuery } from 'pyric-tools/discover';
+/**
+ * Wrap a {@link LocalEnvironment} as a Firestore root that satisfies
+ * the discover/crawler + find-collection-group contracts.
+ */
+export declare class LocalEnvironmentCrawlerAdapter implements CrawlerFirestore, CollectionGroupCapableFirestore {
+    private readonly env;
+    constructor(env: LocalEnvironment);
+    listCollections(): Promise<CrawlerCollectionRef[]>;
+    collection(path: string): CrawlerCollectionRef;
+    doc(path: string): CrawlerDocumentRef;
+    collectionGroup(collectionId: string): CollectionGroupQuery;
+    private makeCollectionRef;
+    private makeDocRef;
+}
+//# sourceMappingURL=crawler-adapter.d.ts.map

package/dist/discover/crawler-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crawler-adapter.d.ts","sourceRoot":"","sources":["../../src/discover/crawler-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EACV,oBAAoB,EACpB,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,+BAA+B,EAC/B,oBAAoB,EAErB,MAAM,sBAAsB,CAAC;AAI9B;;;GAGG;AACH,qBAAa,8BACX,YAAW,gBAAgB,EAAE,+BAA+B;IAEhD,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,gBAAgB;IAE5C,eAAe,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;IAIxD,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB;IAI9C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB;IAIrC,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,oBAAoB;IAkB3D,OAAO,CAAC,iBAAiB;IAmBzB,OAAO,CAAC,UAAU;CA0BnB"}

package/dist/discover/crawler-adapter.js

@@ -0,0 +1,92 @@
+import { encodeFieldsProto } from 'pyric/sandbox/internal';
+/**
+ * Wrap a {@link LocalEnvironment} as a Firestore root that satisfies
+ * the discover/crawler + find-collection-group contracts.
+ */
+export class LocalEnvironmentCrawlerAdapter {
+    env;
+    constructor(env) {
+        this.env = env;
+    }
+    async listCollections() {
+        return this.env.listRootCollections().map((id) => this.makeCollectionRef(id));
+    }
+    collection(path) {
+        return this.makeCollectionRef(path);
+    }
+    doc(path) {
+        return this.makeDocRef(path);
+    }
+    collectionGroup(collectionId) {
+        // Scan the keyspace for docs whose penultimate segment equals `collectionId`.
+        // A document path is always odd-segments-deep — collection/doc/collection/doc...
+        // so segments.length is even and segments[length-2] is the host collection ID.
+        const matches = [];
+        for (const path of Object.keys(this.env.snapshot())) {
+            const segments = path.split('/');
+            if (segments.length < 2 || segments.length % 2 !== 0)
+                continue;
+            const hostId = segments[segments.length - 2];
+            if (hostId !== collectionId)
+                continue;
+            const parentPath = segments.slice(0, -1).join('/');
+            matches.push({ ref: { parent: { path: parentPath } } });
+        }
+        return makeChainableQuery(matches);
+    }
+    // ─── Internal factories ───────────────────────────────────────────────
+    makeCollectionRef(path) {
+        const id = path.split('/').pop();
+        const env = this.env;
+        const adapter = this;
+        return {
+            id,
+            path,
+            async listDocuments() {
+                return env.listDocuments(path).map(({ path: docPath, data, phantom }) => 
+                // Phantom parents: pass `{}` so `.get()` materializes an empty
+                // `_fieldsProto`, matching live Firestore's parent-with-only-
+                // subcollections shape. We feed `knownData` either way so the
+                // crawler avoids a redundant lookup against a non-existent doc.
+                adapter.makeDocRef(docPath, phantom ? {} : data));
+            },
+        };
+    }
+    makeDocRef(path, knownData) {
+        const id = path.split('/').pop();
+        const env = this.env;
+        const adapter = this;
+        return {
+            id,
+            path,
+            async listCollections() {
+                return env
+                    .listSubcollections(path)
+                    .map((subId) => adapter.makeCollectionRef(`${path}/${subId}`));
+            },
+            async get() {
+                // Prefer cached data from the listDocuments traversal; fall back to
+                // a fresh lookup for ad-hoc doc() refs (e.g., the resume path).
+                const data = knownData ?? env.getDocument(path) ?? {};
+                return {
+                    _fieldsProto: encodeFieldsProto(data),
+                    ref: { path },
+                };
+            },
+        };
+    }
+}
+/**
+ * Build a chainable {@link CollectionGroupQuery} over an in-memory match
+ * list. Mirrors the firebase-admin `Query` shape used by `findCollectionGroup`:
+ * `select()` is a no-op (refs only); `limit(n)` truncates; `get()` resolves.
+ */
+function makeChainableQuery(matches) {
+    const build = (current) => ({
+        select: () => build(current),
+        limit: (n) => build(current.slice(0, n)),
+        get: async () => ({ docs: current }),
+    });
+    return build(matches);
+}
+//# sourceMappingURL=crawler-adapter.js.map

package/dist/discover/crawler-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crawler-adapter.js","sourceRoot":"","sources":["../../src/discover/crawler-adapter.ts"],"names":[],"mappings":"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"}

package/dist/discover/crawler.d.ts

@@ -0,0 +1,333 @@
+import { SessionStore } from './session.js';
+import { type WireDocumentSnapshot } from './wire.js';
+import type { CollectionSchema, DiscoverEvent } from './types.js';
+/**
+ * Minimal collection-reference contract the crawler depends on. Structurally
+ * compatible with `firebase-admin/firestore`'s `CollectionReference` so the
+ * crawler can be passed a real `Firestore` *and* mocked in unit tests with
+ * no firebase-admin import.
+ */
+export interface CrawlerCollectionRef {
+    readonly id: string;
+    readonly path: string;
+    listDocuments(): Promise<CrawlerDocumentRef[]>;
+}
+/** Minimal document-reference contract — structural twin of admin SDK. */
+export interface CrawlerDocumentRef {
+    readonly id: string;
+    readonly path: string;
+    listCollections(): Promise<CrawlerCollectionRef[]>;
+    /**
+     * Fetch the document snapshot. Item 2.3+ uses this to feed wire values
+     * into the merge layer. Returns a `WireDocumentSnapshot` (the structural
+     * shape `wire.ts` expects) — admin SDK's `DocumentSnapshot` satisfies it
+     * by virtue of exposing `_fieldsProto` and `ref.path`.
+     */
+    get(): Promise<WireDocumentSnapshot>;
+}
+/**
+ * Minimal Firestore root contract.
+ *
+ * `listCollections` is required for any crawl. `collection(path)` and
+ * `doc(path)` are only required when continuations are in play (Item 4.2):
+ * resuming a paused crawl reconstructs frontier/sample refs from
+ * persisted paths via these factories. firebase-admin's `Firestore`
+ * provides both natively; the `CrawlOptions.continuation` code path
+ * fails loud if they're absent.
+ */
+export interface CrawlerFirestore {
+    listCollections(): Promise<CrawlerCollectionRef[]>;
+    collection?(path: string): CrawlerCollectionRef;
+    doc?(path: string): CrawlerDocumentRef;
+}
+/**
+ * Crawl options. All fields are optional with documented defaults.
+ *
+ * - `maxConcurrency`: in-flight RPC cap. Default 32 per the Risk #1 sweep
+ *   on 2026-05-05. Sweep over `{4, 8, 16, 32, 64}` against the corpus
+ *   showed `4 → 8 → 16 → 32 → 64` was a steady ~10–15% per-doubling
+ *   descent (no plateau). 32 was picked over 64 because the curve hadn't
+ *   flattened — 64 was the cap of the test range, not a true knee — and
+ *   doubling in-flight RPCs again increases the chance of tripping
+ *   per-project connection/quota limits in agent environments. Agents
+ *   that want max speed can override.
+ * - `maxDepth`: hard cap on BFS layers from the root. Defaults to 10
+ *   (well above any real-world Firestore tree). Used as a runaway guard,
+ *   not an agent-facing knob.
+ * - `rootFilter`: optional predicate on root collection IDs. Used by tests
+ *   and the corpus harness to scope discovery to a known prefix without
+ *   walking the entire database.
+ */
+export interface CrawlOptions {
+    maxConcurrency?: number;
+    maxDepth?: number;
+    rootFilter?: (collectionId: string) => boolean;
+    /**
+     * Hard cap on docs sampled per templatePath. Default 50 per Phase 2.1
+     * lock. Item 3 will add adaptive `stopOnStable` early-exit on top of
+     * this cap; for now sampling reads exactly `min(maxSamples, available)`
+     * docs per templatePath.
+     */
+    maxSamples?: number;
+    /**
+     * Per-templatePath cap on tolerated PERMISSION_DENIED / transient errors
+     * during sampling. Default 3 per prerequisite 0.E. Past this threshold,
+     * sampling for the templatePath stops and `samplingComplete` is set to
+     * `sampling_open` so the agent can see the collection wasn't fully
+     * sampled. Errors during structure discovery are emitted but do not
+     * count toward this cap.
+     */
+    maxErrorsPerCollection?: number;
+    /**
+     * Adaptive early-exit threshold. After this many consecutive
+     * no-change merges in a templatePath's sampling stream, sampling stops
+     * and `samplingComplete` is set to `converged_via_stable`. Default 8 per
+     * Phase 2.1 lock. Set to a value > maxSamples to disable early-exit
+     * (the hard cap then governs).
+     *
+     * Reads are issued in chunks of `stopOnStable` so an early-exit avoids
+     * fetching the remainder of `sampleRefs`. Worst-case wasted-read
+     * count per templatePath is `stopOnStable - 1`.
+     */
+    stopOnStable?: number;
+    /**
+     * Resume a previously paused crawl. Only valid when a `SessionStore` is
+     * passed to `crawl()`. The token is the `continuation` value from a
+     * prior paused result. Malformed/expired tokens surface as a
+     * `SESSION_EXPIRED`/`SESSION_EVICTED`/`SESSION_MALFORMED_TOKEN`
+     * error event with no other side effects (per 0.C).
+     */
+    continuation?: string;
+    /**
+     * Pause threshold for batch payload size. After each layer (structure
+     * phase) and each templatePath (sampling phase) the crawler measures
+     * the JSON-serialized state size; if it exceeds this many bytes, the
+     * crawl pauses and returns a continuation token. Default 1 MB per
+     * Phase 0.4 sizing — well below `maxSessionBytes=32MB` so the agent
+     * has headroom for response framing.
+     *
+     * Only effective when a `SessionStore` is provided to `crawl()`. With
+     * no store, single-call mode runs to completion regardless of size.
+     */
+    maxBatchBytes?: number;
+    /**
+     * Informational-only cost preview. When `true`, the crawler issues
+     * exactly **one** RPC — `db.listCollections()` at the root — and
+     * returns a heuristic projection of what a real crawl would cost.
+     *
+     * No documents are read, no per-doc `listCollections` calls are
+     * made, no sampling occurs. The result has empty `discovered` and
+     * `finalizedSchemas`, `complete: true`, and `continuation: undefined`.
+     * It is **not** a partial crawl that can be resumed — to "commit",
+     * call `crawl()` again with `dryRun: false` (a fresh full crawl).
+     *
+     * Rationale: an agent reading `dryRun: true` reasonably expects no
+     * real crawl happened. Doing a structure walk under that flag would
+     * let the agent make decisions on data it didn't realize it paid
+     * for. See Item 5 revision in the implementation plan.
+     *
+     * Default `false`.
+     */
+    dryRun?: boolean;
+    /**
+     * Heuristic multiplier used in the dryRun cost projection: assumes
+     * each root collection has roughly this many subtree-collections
+     * (root + descendants) on average. Default 3 — conservative for
+     * typical app schemas. Surfaced as an option so agents tuning for
+     * known shapes can revise.
+     *
+     * Only consulted when `dryRun: true`.
+     */
+    dryRunSubtreeMultiplier?: number;
+}
+/**
+ * Per-template-path bookkeeping built up during a crawl. Collection refs
+ * are kept here for Item 2.3 to drive document sampling.
+ *
+ * Multiple concrete collection paths may collapse to the same template
+ * path (e.g. `users/uid_1/posts` and `users/uid_2/posts` both map to
+ * `users/{userId}/posts`); their refs are accumulated under one entry.
+ */
+export interface DiscoveredCollection {
+    templatePath: string;
+    depth: number;
+    /** First concrete collection path encountered for this template. */
+    examplePath: string;
+    /** All concrete collection refs that share this template path. */
+    refs: CrawlerCollectionRef[];
+    /**
+     * Doc refs accumulated across `refs` during BFS expansion. Sampling
+     * draws from this pool — re-listing would double the listDocuments
+     * cost we already paid during structure discovery.
+     */
+    docRefs: CrawlerDocumentRef[];
+}
+export interface CrawlResult {
+    events: DiscoverEvent[];
+    discovered: Map<string, DiscoveredCollection>;
+    /** Total `listCollections` + `listDocuments` calls — feeds cost reporting. */
+    listOps: number;
+}
+/**
+ * Result of a full crawl (structure + sampling). Augments `CrawlResult`
+ * with the per-templatePath finalized schemas the agent surface consumes.
+ *
+ * `continuation` is present iff the crawl paused at a `maxBatchBytes`
+ * boundary; agents resume by calling `crawl(db, { continuation }, sessions)`.
+ * `complete` is true iff the crawl finished — equivalent to
+ * `continuation === undefined` but more readable at call sites.
+ *
+ * Counter fields (`listOps`, `readOps`) are *cumulative* across batches:
+ * a paused crawl returns the running total so the agent's cost-reporting
+ * doesn't have to do the bookkeeping.
+ */
+export interface FullCrawlResult extends CrawlResult {
+    finalizedSchemas: Map<string, CollectionSchema>;
+    /** `.get()` calls issued during sampling — feeds cost reporting. */
+    readOps: number;
+    /** Opaque resume handle (only present when paused). */
+    continuation?: string;
+    /** True iff the crawl completed (no continuation pending). */
+    complete: boolean;
+    /**
+     * Present iff the crawl was a `dryRun: true` preview. Heuristic
+     * projection of what a full crawl would cost; see {@link CrawlOptions.dryRun}.
+     */
+    dryRunCostEstimate?: DryRunCostEstimate;
+}
+/**
+ * Heuristic cost projection returned by `dryRun: true`. The numbers are
+ * upper-bound estimates — agents should treat them as "no more than"
+ * figures, not exact predictions. Formulas are documented in-line so
+ * consumers can sanity-check.
+ */
+export interface DryRunCostEstimate {
+    /** Number of root collections discovered by the single root listCollections call. */
+    rootCollectionCount: number;
+    /** The root collection IDs (after `rootFilter` is applied, if any). */
+    rootCollectionIds: string[];
+    /** The `maxSamples` value the projection used. */
+    maxSamples: number;
+    /** The `dryRunSubtreeMultiplier` value the projection used. */
+    subtreeMultiplier: number;
+    /**
+     * Projected total `listCollections` + `listDocuments` cost of a real
+     * crawl: `1 + rootCount × subtreeMultiplier`. The `1` is the root
+     * `listCollections`; each subtree contributes one `listDocuments`
+     * call to enumerate docs. Per-doc `listCollections` cost is folded
+     * into the multiplier (a subtree of 3 implies ~2 layers of doc
+     * listings).
+     */
+    estimatedListOps: number;
+    /**
+     * Projected total `.get()` cost of sampling: `rootCount ×
+     * subtreeMultiplier × maxSamples`. Upper bound — `stopOnStable`
+     * early-exit and `cappedByMax` can reduce the actual draw.
+     */
+    estimatedReadOps: number;
+}
+/**
+ * JSON-serializable snapshot of an in-progress crawl. Stored in the
+ * session between batches. Refs (CollectionRef/DocumentRef) carry
+ * methods so they can't be persisted directly — we serialize their
+ * paths and reconstruct via `db.collection(path)` / `db.doc(path)` on
+ * resume.
+ *
+ * Phase invariants:
+ *   - `structure` phase: `frontierPaths` may be non-empty; `samplingQueue`
+ *     is empty.
+ *   - `sampling` phase: `frontierPaths` is empty; `samplingQueue` lists
+ *     the templatePaths still pending. Existing entries in
+ *     `finalizedSchemas` are immutable across the rest of the crawl.
+ */
+export interface PersistedCrawlState {
+    phase: 'structure' | 'sampling';
+    /** Layer index after the last completed structure pass. */
+    currentDepth: number;
+    /** Crawl options carried so resume preserves caps the agent set. */
+    maxDepth: number;
+    /** Concrete collection paths to expand in the next structure layer. */
+    frontierPaths: string[];
+    /** Discovered map serialized — all paths only, refs reconstructed on resume. */
+    discovered: Record<string, PersistedDiscoveredCollection>;
+    /** TemplatePaths still to sample. Drained left-to-right. */
+    samplingQueue: string[];
+    /** Per-templatePath finalized schemas — immutable once set. */
+    finalizedSchemas: Record<string, CollectionSchema>;
+    /** Cumulative cost counters across batches. */
+    listOps: number;
+    readOps: number;
+}
+/** Persisted shape of a `DiscoveredCollection` (refs → paths). */
+export interface PersistedDiscoveredCollection {
+    templatePath: string;
+    depth: number;
+    examplePath: string;
+    refPaths: string[];
+    docRefPaths: string[];
+}
+/**
+ * Map a concrete collection path to its template-path form per Phase 3.1
+ * lock. Doc-id segments become `{singular(parentColl)Id}` so the result
+ * matches Firestore rules' `path.raw` segments under typical naming
+ * conventions (TTT corpus verified: `ttt_lobbies` → `{lobbyId}`).
+ *
+ * Inputs alternate `coll/doc/coll/doc/.../coll`. Length is always odd (a
+ * collection path ends on a collection segment).
+ *
+ * Heuristic — agents needing strict alignment with rules should normalize
+ * both sides before joining. See Risk 6 in the implementation plan.
+ *
+ * Examples:
+ *   `users` → `users`
+ *   `users/uid_1/posts` → `users/{userId}/posts`
+ *   `ttt_lobbies/abc/games/g1/moves` → `ttt_lobbies/{lobbyId}/games/{gameId}/moves`
+ */
+export declare function toTemplatePath(concretePath: string): string;
+/**
+ * Convert a collection ID to the conventional template-variable name a
+ * Firestore rules author would write for its docs. Strips a trailing
+ * snake/dot-cased prefix word so `ttt_lobbies` → `lobbyId` (not
+ * `ttt_lobbieId`).
+ */
+export declare function inferTemplateVariable(collectionId: string): string;
+/**
+ * Walk the Firestore tree breadth-first. Each layer issues its
+ * `listDocuments` + per-doc `listCollections` calls in parallel under a
+ * shared concurrency cap.
+ *
+ * Returns once every reachable collection (within `maxDepth`) is recorded.
+ * The returned `discovered` map is keyed by templatePath; `events` is the
+ * ordered event log emitted during the walk (currently only
+ * `collection_discovered`).
+ */
+export declare function crawlStructure(db: CrawlerFirestore, options?: CrawlOptions): Promise<CrawlResult>;
+/**
+ * Full crawl: discover structure, then sample up to `maxSamples` docs per
+ * discovered templatePath and feed them through the merge layer. Emits
+ * `schema_updated` events for every non-empty merge and `sampling_complete`
+ * once per templatePath.
+ *
+ * **Pause/resume (Item 4.2).** When a `SessionStore` is supplied, the
+ * crawler measures the persisted-state size at two pause boundaries:
+ *
+ *   1. End of every BFS layer in the structure phase
+ *   2. End of every templatePath in the sampling phase
+ *
+ * If the persisted state exceeds `maxBatchBytes` (default 1 MB), the
+ * crawler persists state and returns a `continuation` token. The agent
+ * resumes by passing `{ continuation }` on the next call. Counters
+ * (`listOps`, `readOps`) are cumulative across batches; events are
+ * per-batch only (agents accumulate them themselves).
+ *
+ * Without a `SessionStore`, the crawler runs to completion regardless of
+ * size — single-call mode is unchanged.
+ *
+ * **Continuation lifecycle.** Continuation handles are minted/validated by
+ * the supplied `SessionStore` (see `discover/session.ts`). Malformed,
+ * expired, or evicted tokens surface as a single `error` event and an
+ * otherwise-empty result — agents can re-issue without continuation
+ * per the recovery hint.
+ */
+export declare function crawl(db: CrawlerFirestore, options?: CrawlOptions, sessions?: SessionStore<PersistedCrawlState>): Promise<FullCrawlResult>;
+//# sourceMappingURL=crawler.d.ts.map

package/dist/discover/crawler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crawler.d.ts","sourceRoot":"","sources":["../../src/discover/crawler.ts"],"names":[],"mappings":"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"}