abb-opencode-local-rag 0.1.0

package/dist/features/sync.d.ts

@@ -0,0 +1,207 @@
+import type { ScanEntryKind } from '../utils/scan.js';
+/** Path-granular facts about the regions a directory scan could not observe. */
+export interface SyncScanCoverage {
+    unreadableDirs: {
+        dirPath: string;
+        code: string;
+    }[];
+    depthLimitedDirs: string[];
+    skippedSymlinks: string[];
+}
+/**
+ * Everything one run could not observe: the scan facts plus the files whose
+ * bytes were never read because they exceed the configured size limit. Every
+ * path here is an unobserved prefix, so the rows under it are protected from
+ * prune.
+ */
+export interface SyncCoverage extends SyncScanCoverage {
+    /** Files skipped by `hashFile` for exceeding the configured size limit. */
+    oversizedFiles: string[];
+}
+/** One bounded directory scan: the supported files found plus its coverage facts. */
+export interface SyncScanResult extends SyncScanCoverage {
+    files: string[];
+}
+/**
+ * One stored chunk row (or row group) of the database manifest. `filePath` is
+ * the verbatim stored spelling — the only value valid for deletion. A `null` or
+ * absent `contentHash` marks the row hashless, which makes its file dirty.
+ */
+export interface SyncManifestRow {
+    filePath: string;
+    contentHash?: string | null;
+}
+/** One supported file found on disk, with the hash of its current bytes. */
+export interface SyncDiskFile {
+    filePath: string;
+    contentHash: string;
+}
+/** How a sync invocation was addressed, after validation and classification. */
+export type SyncRequest = {
+    kind: 'roots';
+} | {
+    kind: 'directory';
+    path: string;
+} | {
+    kind: 'file';
+    path: string;
+};
+/**
+ * Result of classifying a requested path on disk. Anything other than
+ * `directory` or `file` is refused before the path is read: the union is the
+ * walker's own {@link ScanEntryKind} plus `missing`, so a path a caller names and
+ * a path the walk discovers pass the identical predicates.
+ */
+export type SyncPathKind = ScanEntryKind | 'missing';
+/** Re-ingest one disk file, then drop the other stored spellings of its key. */
+export interface SyncUpsertAction {
+    /** Verbatim disk path handed to `ingestFile`. */
+    filePath: string;
+    /** Verbatim stored spellings of the same comparison key, excluding `filePath`. */
+    staleStoredPaths: string[];
+}
+/** Remove every stored spelling of one comparison key that left the disk. */
+export interface SyncPruneAction {
+    storedPaths: string[];
+}
+export interface SyncPlan {
+    upserts: SyncUpsertAction[];
+    /** Files whose stored content identity already matches the disk bytes. */
+    skipped: number;
+    prunes: SyncPruneAction[];
+}
+export interface SyncPlanInput {
+    roots: readonly string[];
+    dbPath: string;
+    /** Configured database/cache prefixes that must never be pruned. */
+    excludePaths: readonly string[];
+    platform: NodeJS.Platform;
+    request: SyncRequest;
+    diskFiles: readonly SyncDiskFile[];
+    dbRows: readonly SyncManifestRow[];
+    coverage: SyncCoverage;
+}
+/** The one controlled error a failed run exposes. */
+export interface SyncError {
+    message: string;
+    /** The file, root, or requested path a failure is attributable to. */
+    filePath: string | null;
+}
+/** Append an attributable path only when the underlying message does not already contain it. */
+export declare function formatSyncError({ message, filePath }: SyncError): string;
+export interface SyncCounters {
+    upserted: number;
+    skipped: number;
+    empty: number;
+    /** Comparison keys removed from the index. Counts files, not rows, and is not part of `completed`. */
+    pruned: number;
+}
+/** One stored spelling per pruned comparison key, so a count of N reports N paths. */
+interface PrunedPaths {
+    prunedPaths: string[];
+}
+export interface SyncExecutionResult extends SyncCounters, PrunedPaths {
+    error: SyncError | null;
+}
+export interface SyncResult extends SyncCounters, PrunedPaths {
+    /** Scanner facts as data. Formatting and reporting belong to the adapters. */
+    coverage: SyncCoverage;
+    error: SyncError | null;
+}
+/** Mutating collaborators, injected by the CLI and MCP adapters. */
+export interface SyncExecutor {
+    /**
+     * Parse, chunk, embed, build vectors, then delete-and-insert for this one
+     * file, returning the inserted chunk count. Returning `0` must leave the
+     * store untouched: the executor relies on that to keep a zero-chunk file's
+     * prior rows and hash intact.
+     */
+    ingestFile(filePath: string, images: boolean): Promise<number>;
+    /** Delete the rows of exactly one stored path spelling. */
+    deleteExactPath(filePath: string): Promise<number>;
+    optimize(): Promise<void>;
+}
+/** Everything {@link runSync} needs from the outside world. */
+export interface SyncCollaborators extends SyncExecutor {
+    /**
+     * Canonical form of the requested path — its parent chain resolved through
+     * symbolic links, the final component verbatim — or `null` when that chain
+     * cannot be resolved. Injected because this module performs no filesystem
+     * access; both adapters supply `canonicalizeRequestedPath` from `utils/scan.ts`.
+     */
+    canonicalizeRequestedPath(path: string): Promise<string | null>;
+    /**
+     * Classify the requested path WITHOUT reading it, applying the walker's collect
+     * predicates (`classifyRequestedPath` in `utils/scan.ts`) so both surfaces
+     * refuse the same paths.
+     */
+    classifyPath(path: string): Promise<SyncPathKind>;
+    /**
+     * Bounded scan of one root. Deliberately takes no scope predicate: a
+     * scope-pruned directory is reported in none of the coverage arrays, so a
+     * scope filter here would make unobserved regions invisible and prune unsafe.
+     */
+    scanDir(rootPath: string): Promise<SyncScanResult>;
+    /**
+     * Hash the file's current bytes, or return `null` to decline reading it because
+     * it exceeds the configured size limit. A declined file is left out of the disk
+     * manifest and recorded in `coverage.oversizedFiles`, which protects its stored
+     * rows from prune — omitting it without that record would make it look deleted.
+     */
+    hashFile(filePath: string): Promise<string | null>;
+    /** Every stored chunk row's verbatim path and hash, for the whole table. */
+    loadDbManifest(): Promise<SyncManifestRow[]>;
+}
+export interface RunSyncInput {
+    /** Configured roots in the `resolve()`-only spelling the DB keys live in. */
+    roots: readonly string[];
+    /**
+     * The same configured roots, canonicalized (realpath'd) — the security domain
+     * the requested path's canonical form is checked against. Both adapters already
+     * hold this list: the MCP server as `baseDirs`, the CLI as
+     * `config.baseDirs.baseDirs`, each the counterpart of its `roots` entry.
+     */
+    canonicalRoots: readonly string[];
+    dbPath: string;
+    excludePaths: readonly string[];
+    platform: NodeJS.Platform;
+    /** Omitted means "every configured root". */
+    requestedPath?: string | undefined;
+    /** `true` stores images for files already selected as new or changed. */
+    images?: boolean | undefined;
+    collaborators: SyncCollaborators;
+}
+/**
+ * Decide the skip, upsert, and prune actions for one sync run. Pure: all
+ * filesystem and database facts arrive pre-fetched.
+ *
+ * A prune action is emitted only when all four conditions hold for the key: it
+ * is inside the requested scope, absent from the disk manifest, outside the
+ * configured excluded and managed paths, and outside every unobserved prefix —
+ * unreadable, depth-limited, symlinked, or too large to have been read.
+ * Dropping any one of them protects the rows.
+ */
+export declare function planSync(input: SyncPlanInput): SyncPlan;
+/**
+ * Apply a plan: upserts first, then prune, then a single `optimize()`.
+ *
+ * The first failure anywhere stops the run. Earlier successful mutations stay,
+ * every remaining upsert and the entire prune phase are abandoned, and exactly
+ * one error is returned. No rollback, retry, or failure classification is
+ * attempted — an interrupted run is recovered by rerunning sync.
+ *
+ * A zero-chunk ingest counts as `empty` and mutates nothing for that file, so
+ * its prior rows stay searchable and the next run plans it again.
+ */
+export declare function executeSyncPlan(plan: SyncPlan, executor: SyncExecutor, images?: boolean): Promise<SyncExecutionResult>;
+/**
+ * Run one full sync: gather, plan, execute.
+ *
+ * Returned counters and coverage facts are plain data; the caller decides how to
+ * print them and what exit status or job state they imply. A run with nothing to
+ * do calls neither `ingestFile` nor `optimize`, so a true no-op never pays for
+ * loading the embedding model or compacting the table.
+ */
+export declare function runSync(input: RunSyncInput): Promise<SyncResult>;
+export {};
+//# sourceMappingURL=sync.d.ts.map

package/dist/features/sync.d.ts.map

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

package/dist/features/sync.js

@@ -0,0 +1,380 @@
+// Dispatch-agnostic incremental-sync planning and execution.
+//
+// The single core shared by the `sync` CLI subcommand and the MCP `sync_start`
+// tool. Every collaborator is declared here as a local structural interface, so
+// this module imports nothing from `vectordb/`, `parser/`, `chunker/`,
+// `embedder/`, or `ingest/` — not even for types. Persistence, output
+// formatting, exit codes, and logging belong to the adapters.
+//
+// Path identity: reconciliation compares generated keys
+// (`toSyncPathKey(path, platform)`), and every containment question is answered
+// by the unchanged `isUnderOrEqual` from `scope-match.ts`. This module defines
+// no exact-or-descendant, separator-boundary, or trailing-separator logic of its
+// own. Deletion, by contrast, always uses the verbatim stored `filePath`
+// spellings, because those are what the storage predicate matches.
+//
+// Two spellings, one matcher: `toSyncPathKey` stays purely lexical (a key must be
+// derivable for a file that is no longer on disk) and is what keys, prune
+// identity, and display use, while the requested path's CONTAINMENT is decided
+// against canonicalized values — see `isRequestedPathContained`. This is the same
+// split `DocumentParser` already uses: canonicalize to decide the boundary, store
+// the `resolve()` spelling. Do not collapse it by making key generation follow
+// symbolic links.
+//
+// `platform` is an explicit input rather than a host-platform read, so the
+// Windows key semantics are provable from a POSIX host.
+import { isManagedRawDataPath } from '../utils/raw-data-utils.js';
+import { isUnderOrEqual } from '../utils/scope-match.js';
+import { toSyncPathKey } from '../utils/sync-path-key.js';
+/** Append an attributable path only when the underlying message does not already contain it. */
+export function formatSyncError({ message, filePath }) {
+    return filePath === null || message.includes(filePath) ? message : `${message} (${filePath})`;
+}
+/**
+ * A comparison key is converged only when it is stored under exactly one
+ * spelling and every one of that spelling's rows carries the current disk hash.
+ * No rows, a hashless row, disagreeing rows, or a stale hash all make it dirty.
+ *
+ * The single-spelling condition matters because deletion is by exact path: on
+ * Windows, ingesting `C:\Docs\A.md` and later `c:\docs\a.md` leaves two row sets
+ * for one file, both with the correct hash. Without this condition sync would
+ * skip the key forever and searches would keep returning duplicate hits; with
+ * it, the key is re-ingested and the other spellings become stale deletions, so
+ * one run converges it back to a single spelling.
+ */
+function isConverged(stored, diskHash) {
+    return stored.paths.length === 1 && stored.hashes.every((hash) => hash === diskHash);
+}
+/**
+ * Decide the skip, upsert, and prune actions for one sync run. Pure: all
+ * filesystem and database facts arrive pre-fetched.
+ *
+ * A prune action is emitted only when all four conditions hold for the key: it
+ * is inside the requested scope, absent from the disk manifest, outside the
+ * configured excluded and managed paths, and outside every unobserved prefix —
+ * unreadable, depth-limited, symlinked, or too large to have been read.
+ * Dropping any one of them protects the rows.
+ */
+export function planSync(input) {
+    const keyOf = (path) => toSyncPathKey(path, input.platform);
+    const isKeyUnder = (key, prefixes) => prefixes.some((prefix) => isUnderOrEqual(key, keyOf(prefix)));
+    const request = input.request;
+    const scopePrefixes = request.kind === 'roots' ? input.roots : [request.path];
+    // A file request addresses exactly one comparison key, so its prune scope is
+    // equality rather than `isKeyUnder`'s exact-or-descendant membership: a stored
+    // row at `<requested file>/child.md` — left behind by a directory that was later
+    // replaced by a file of the same name — is a different key and must survive.
+    // Directory and roots requests keep the descendant semantics.
+    const requestedFileKey = request.kind === 'file' ? keyOf(request.path) : null;
+    const isInRequestedScope = (rowKey) => requestedFileKey === null ? isKeyUnder(rowKey, scopePrefixes) : rowKey === requestedFileKey;
+    const diskByKey = new Map();
+    for (const file of input.diskFiles) {
+        const fileKey = keyOf(file.filePath);
+        if (!diskByKey.has(fileKey))
+            diskByKey.set(fileKey, file);
+    }
+    const storedByKey = new Map();
+    for (const row of input.dbRows) {
+        const rowKey = keyOf(row.filePath);
+        let group = storedByKey.get(rowKey);
+        if (!group) {
+            group = { paths: [], hashes: [] };
+            storedByKey.set(rowKey, group);
+        }
+        if (!group.paths.includes(row.filePath))
+            group.paths.push(row.filePath);
+        group.hashes.push(row.contentHash ?? null);
+    }
+    const upserts = [];
+    let skipped = 0;
+    for (const [fileKey, file] of diskByKey) {
+        const group = storedByKey.get(fileKey);
+        if (group && isConverged(group, file.contentHash)) {
+            skipped += 1;
+            continue;
+        }
+        upserts.push({
+            filePath: file.filePath,
+            // `ingestFile` replaces its own spelling; any other spelling of the same
+            // key would otherwise survive as a duplicate of the same file.
+            staleStoredPaths: (group?.paths ?? []).filter((path) => path !== file.filePath),
+        });
+    }
+    const unobservedPrefixes = [
+        ...input.coverage.unreadableDirs.map((dir) => dir.dirPath),
+        ...input.coverage.depthLimitedDirs,
+        ...input.coverage.skippedSymlinks,
+        ...input.coverage.oversizedFiles,
+    ];
+    const prunes = [];
+    for (const [rowKey, group] of storedByKey) {
+        if (diskByKey.has(rowKey))
+            continue;
+        if (!isInRequestedScope(rowKey))
+            continue;
+        if (isKeyUnder(rowKey, unobservedPrefixes))
+            continue;
+        if (isKeyUnder(rowKey, input.excludePaths))
+            continue;
+        if (group.paths.some((path) => isManagedRawDataPath(path, input.dbPath)))
+            continue;
+        prunes.push({ storedPaths: group.paths });
+    }
+    return { upserts, skipped, prunes };
+}
+// ============================================
+// Execution (steps 5-10)
+// ============================================
+function toMessage(caught) {
+    return caught instanceof Error ? caught.message : String(caught);
+}
+/**
+ * The controlled error for a requested path the collect predicates refuse. One
+ * message per rejection, owned here rather than in the adapters, so the CLI and
+ * MCP surfaces refuse the same paths with the same words.
+ *
+ * The `irregular` case is also what keeps a caller from handing sync something
+ * whose read never returns (a FIFO). It fixes that trigger only: nothing here
+ * bounds a collaborator that hangs for some other reason, and the MCP mutation
+ * guard is still released solely by the job promise settling.
+ */
+function requestedPathRejection(kind, path) {
+    switch (kind) {
+        case 'missing':
+            return `Sync path does not exist: ${path}`;
+        case 'irregular':
+            return `Sync path is not a regular file or directory: ${path}`;
+        case 'symlink':
+            return `Sync path is a symbolic link, which sync never follows: ${path}`;
+        case 'excluded':
+            return `Sync path is inside the database or cache directory: ${path}`;
+        case 'unsupported':
+            return `Sync path is not a supported document type: ${path}`;
+    }
+}
+/**
+ * The one message every out-of-root request receives. A readable target, an
+ * unreadable one, and an absent one are deliberately indistinguishable here, so
+ * the error text cannot be used to probe for the existence or readability of
+ * paths outside the configured roots. Requests that ARE inside a root keep their
+ * specific messages ({@link requestedPathRejection}): those name nothing the
+ * caller did not already supply.
+ */
+function outsideConfiguredRootsMessage(path) {
+    return `Sync path is outside every configured root: ${path}`;
+}
+/**
+ * Containment of an explicitly requested path, decided before anything reads it.
+ * Two questions, both answered by composing generated keys with the unchanged
+ * `isUnderOrEqual`:
+ *
+ * 1. Is the requested spelling under a configured root spelling? This keeps the
+ *    request in the same lexical space as the stored DB keys.
+ * 2. Is its canonical form under a canonicalized root? This is the security
+ *    boundary. `resolve()` cannot see that an intermediate component is a
+ *    symbolic link, so question 1 alone accepts `<root>/link/secret.md` whose
+ *    real location is outside every root, and the walker's own symlink skipping
+ *    does not help: nothing walks an explicitly named path.
+ *
+ * A path that cannot be canonicalized fails, which is also what makes the
+ * rejection uniform.
+ */
+async function isRequestedPathContained(requestedPath, input) {
+    const { platform } = input;
+    const isUnderAny = (path, prefixes) => prefixes.some((prefix) => isUnderOrEqual(toSyncPathKey(path, platform), toSyncPathKey(prefix, platform)));
+    if (!isUnderAny(requestedPath, input.roots))
+        return false;
+    const canonicalPath = await input.collaborators.canonicalizeRequestedPath(requestedPath);
+    return canonicalPath !== null && isUnderAny(canonicalPath, input.canonicalRoots);
+}
+/**
+ * Apply a plan: upserts first, then prune, then a single `optimize()`.
+ *
+ * The first failure anywhere stops the run. Earlier successful mutations stay,
+ * every remaining upsert and the entire prune phase are abandoned, and exactly
+ * one error is returned. No rollback, retry, or failure classification is
+ * attempted — an interrupted run is recovered by rerunning sync.
+ *
+ * A zero-chunk ingest counts as `empty` and mutates nothing for that file, so
+ * its prior rows stay searchable and the next run plans it again.
+ */
+export async function executeSyncPlan(plan, executor, images = false) {
+    let upserted = 0;
+    let empty = 0;
+    let pruned = 0;
+    let mutated = false;
+    let error = null;
+    const prunedPaths = [];
+    for (const action of plan.upserts) {
+        try {
+            const chunkCount = await executor.ingestFile(action.filePath, images);
+            if (chunkCount === 0) {
+                empty += 1;
+                continue;
+            }
+            upserted += 1;
+            mutated = true;
+            // After the insert, not before: a zero-chunk result must leave every
+            // stored spelling of this key untouched.
+            for (const stalePath of action.staleStoredPaths) {
+                await executor.deleteExactPath(stalePath);
+            }
+        }
+        catch (caught) {
+            error = { message: toMessage(caught), filePath: action.filePath };
+            break;
+        }
+    }
+    if (error === null) {
+        for (const action of plan.prunes) {
+            const [reported] = action.storedPaths;
+            try {
+                for (const storedPath of action.storedPaths) {
+                    await executor.deleteExactPath(storedPath);
+                    mutated = true;
+                }
+                pruned += 1;
+                if (reported !== undefined)
+                    prunedPaths.push(reported);
+            }
+            catch (caught) {
+                error = { message: toMessage(caught), filePath: reported ?? null };
+                break;
+            }
+        }
+    }
+    if (error === null && mutated) {
+        try {
+            await executor.optimize();
+        }
+        catch (caught) {
+            error = { message: toMessage(caught), filePath: null };
+        }
+    }
+    return { upserted, skipped: plan.skipped, empty, pruned, prunedPaths, error };
+}
+/**
+ * Steps 1-3: validate and classify the requested path, scan the roots it
+ * implies, hash the supported disk files, and load the database manifest.
+ *
+ * `attributedPath` tracks what a thrown error should be blamed on, so an
+ * orchestration failure still names the file, root, or requested path involved.
+ */
+async function gatherSyncInputs(input) {
+    const { collaborators, platform } = input;
+    const coverage = {
+        unreadableDirs: [],
+        depthLimitedDirs: [],
+        skippedSymlinks: [],
+        oversizedFiles: [],
+    };
+    let attributedPath = null;
+    try {
+        const requestedPath = input.requestedPath;
+        let request;
+        let scanRoots;
+        if (requestedPath === undefined) {
+            request = { kind: 'roots' };
+            scanRoots = input.roots;
+        }
+        else {
+            attributedPath = requestedPath;
+            // Containment first, and against canonical values: a path that reaches
+            // outside a configured root through a symlinked ancestor must be refused
+            // before anything classifies, walks, hashes, or ingests it.
+            if (!(await isRequestedPathContained(requestedPath, input))) {
+                throw new Error(outsideConfiguredRootsMessage(requestedPath));
+            }
+            // Classification happens before any read, and only a directory or a
+            // supported regular file survives it: a link, an irregular file, an
+            // excluded path, or an unsupported extension is refused here rather than
+            // after its bytes have been read and hashed.
+            const kind = await collaborators.classifyPath(requestedPath);
+            if (kind !== 'directory' && kind !== 'file') {
+                throw new Error(requestedPathRejection(kind, requestedPath));
+            }
+            request = { kind, path: requestedPath };
+            // An explicit directory becomes its own depth-zero BFS root; an explicit
+            // file needs no directory walk and no depth evaluation at all.
+            scanRoots = kind === 'directory' ? [requestedPath] : [];
+        }
+        const scannedFiles = [];
+        for (const root of scanRoots) {
+            attributedPath = root;
+            const scan = await collaborators.scanDir(root);
+            scannedFiles.push(...scan.files);
+            coverage.unreadableDirs.push(...scan.unreadableDirs);
+            coverage.depthLimitedDirs.push(...scan.depthLimitedDirs);
+            coverage.skippedSymlinks.push(...scan.skippedSymlinks);
+        }
+        if (request.kind === 'file') {
+            scannedFiles.push(request.path);
+        }
+        // Overlapping roots can surface the same file twice; hash each comparison
+        // key once, keeping the first spelling encountered.
+        const diskByKey = new Map();
+        for (const filePath of scannedFiles) {
+            const fileKey = toSyncPathKey(filePath, platform);
+            if (!diskByKey.has(fileKey))
+                diskByKey.set(fileKey, filePath);
+        }
+        const diskFiles = [];
+        for (const filePath of diskByKey.values()) {
+            attributedPath = filePath;
+            const contentHash = await collaborators.hashFile(filePath);
+            if (contentHash === null) {
+                // Its bytes were never read, so its content identity is unknown for this
+                // run. Recording it as an unobserved region is what keeps its stored rows
+                // alive: leaving it out of the manifest alone would look like a deletion.
+                coverage.oversizedFiles.push(filePath);
+                continue;
+            }
+            diskFiles.push({ filePath, contentHash });
+        }
+        attributedPath = null;
+        const dbRows = await collaborators.loadDbManifest();
+        return { ok: true, coverage, request, diskFiles, dbRows };
+    }
+    catch (caught) {
+        return {
+            ok: false,
+            coverage,
+            error: { message: toMessage(caught), filePath: attributedPath },
+        };
+    }
+}
+/**
+ * Run one full sync: gather, plan, execute.
+ *
+ * Returned counters and coverage facts are plain data; the caller decides how to
+ * print them and what exit status or job state they imply. A run with nothing to
+ * do calls neither `ingestFile` nor `optimize`, so a true no-op never pays for
+ * loading the embedding model or compacting the table.
+ */
+export async function runSync(input) {
+    const gathered = await gatherSyncInputs(input);
+    if (!gathered.ok) {
+        return {
+            upserted: 0,
+            skipped: 0,
+            empty: 0,
+            pruned: 0,
+            prunedPaths: [],
+            coverage: gathered.coverage,
+            error: gathered.error,
+        };
+    }
+    const plan = planSync({
+        roots: input.roots,
+        dbPath: input.dbPath,
+        excludePaths: input.excludePaths,
+        platform: input.platform,
+        request: gathered.request,
+        diskFiles: gathered.diskFiles,
+        dbRows: gathered.dbRows,
+        coverage: gathered.coverage,
+    });
+    const execution = await executeSyncPlan(plan, input.collaborators, input.images === true);
+    return { ...execution, coverage: gathered.coverage };
+}
+//# sourceMappingURL=sync.js.map

package/dist/features/sync.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}