@smeltjs/core 0.1.0

package/dist/store-dir.d.ts

@@ -0,0 +1,98 @@
+import type { RawRetrieveCounters } from './stats.ts';
+import type { ElisionStore, RetrieveStats } from './types.ts';
+/**
+ * The format marker every store directory carries, and the one version this code
+ * understands. A future layout is a new version, refused loudly by old code — never a
+ * quiet reinterpretation of someone's stored bytes.
+ */
+export declare const DIRECTORY_STORE_FORMAT = "smelt-elision-store";
+export declare const DIRECTORY_STORE_VERSION = 1;
+/** See {@link MemoryElisionStoreOptions} in `store.ts` — same escape hatch, same reason. */
+export interface DirectoryElisionStoreOptions {
+    /**
+     * Override the hash function, so the collision branch — unreachable with sha256 —
+     * can be tested. Production has no reason to pass this.
+     */
+    readonly hash?: (content: string) => string;
+}
+/**
+ * A persistent {@link ElisionStore} over a content-addressed directory. `node:fs` only —
+ * no SQLite, no new dependency, nothing that phones home. Elisions put here outlive the
+ * process, so a long-lived agent session can `retrieve()` across restarts.
+ *
+ * ## Storage layout
+ *
+ * ```text
+ * <root>/
+ *   format.json      { "format": "smelt-elision-store", "version": 1 } — refused if unknown
+ *   blobs/<hash>     one file per elision: the exact UTF-8 bytes, named by their content hash
+ *   tmp/             staging for atomic writes; never read, safe to sweep
+ *   retrievals.log   append-only journal: `hit "<hash>"` | `miss "<hash>"` | `corrupt "<hash>"`
+ * ```
+ *
+ * **Nothing lives in memory.** Every read — `stats()` included — comes off the disk, so
+ * two instances over the same directory (two processes, or one process before and after
+ * a restart) always agree. `stats()` is a scan; elision counts per session are small and
+ * retrieval is the model asking for material back, which is rare by design.
+ *
+ * ## Durability
+ *
+ * - **Writes are crash-safe.** A blob is written to `tmp/`, `fsync`ed, then `link(2)`ed
+ *   into `blobs/` — an atomic, no-clobber publish. A torn write dies in `tmp/`, where
+ *   nothing looks; a name in `blobs/` always refers to a fully written file.
+ * - **Reads verify.** `retrieve()` and `peek()` re-hash the bytes and refuse a mismatch
+ *   with {@link StoreCorruptionError} — a damaged blob is never handed back as a
+ *   retrieval, and "we hold damaged bytes" is distinct from {@link UnknownHashError}'s
+ *   "never existed". The guard in `test/guards/persistent-store.test.ts` watches this.
+ * - **Counters survive a restart.** Every `retrieve()` appends one `fsync`ed line to
+ *   `retrievals.log`, and `stats()` is a fold over it — so `expansionRate` stays
+ *   meaningful across a whole session, not just one process. A crash in the middle of
+ *   an append can tear at most that one line; a torn tail is skipped, costing at most
+ *   the single count that was being written when the process died.
+ * - **Concurrent writers are safe.** `link(2)` refuses to clobber, so two processes
+ *   putting at once race to publish and the loser verifies byte-for-byte agreement with
+ *   the winner — identical content dedupes, different content under one hash is a
+ *   {@link HashCollisionError}. Journal appends use `O_APPEND`. Tested with two real
+ *   processes in `test/store-dir.test.ts`.
+ *
+ * ## No eviction
+ *
+ * Same rule as {@link MemoryElisionStore}: no cap, no LRU, no `clear()`. A store that
+ * can forget turns Law 3 into "reversible, usually". Elided text is smaller than the
+ * session that produced it; if disk pressure ever forces a cap, retrieval of an evicted
+ * hash must throw a distinct "evicted" error — never {@link UnknownHashError} — so the
+ * model can tell "we lost it" from "never existed". Today there is no such error because
+ * there is no such cap.
+ *
+ * ## Two deliberate choices around the edges
+ *
+ * - **The root is resolved to an absolute path at construction.** Every later path is
+ *   joined from that, so a `process.chdir()` after construction cannot silently
+ *   re-target the store — the bytes a relative-rooted store put before a chdir would
+ *   otherwise be unreachable after it, which reads exactly like data loss.
+ * - **A failed journal append never withholds intact bytes.** `retrieve()`'s order of
+ *   business is: read, verify, count, return. When the *count* cannot be written (a
+ *   read-only journal, a full disk), the bytes are still returned — they are verified
+ *   and the caller asked for them; refusing would turn a bookkeeping failure into
+ *   Law 3 breaking. The failure is surfaced distinctly instead: a
+ *   `process.emitWarning` with name `SmeltCounterWriteFailure`, so "your retrieval
+ *   worked" and "your counters just went quiet" stay two separate facts. The same
+ *   applies to the `miss`/`corrupt` journal lines: the store's own error for the
+ *   lookup still wins over the journal's I/O error.
+ */
+export declare class DirectoryElisionStore implements ElisionStore {
+    #private;
+    constructor(root: string, options?: DirectoryElisionStoreOptions);
+    put(content: string): string;
+    peek(hash: string): string | undefined;
+    retrieve(hash: string): string;
+    has(hash: string): boolean;
+    /**
+     * The five directly-observed counts, every one read off the disk — a scan of
+     * `blobs/` plus a fold over `retrievals.log`. See {@link RawRetrieveCounters}; the
+     * derived half of the stats comes from the shared `retrieveStats()`, never here.
+     */
+    rawCounters(): RawRetrieveCounters;
+    stats(): RetrieveStats;
+}
+//# sourceMappingURL=store-dir.d.ts.map

package/dist/store-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-dir.d.ts","sourceRoot":"","sources":["../src/store-dir.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE9D;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,wBAAwB,CAAC;AAC5D,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAYzC,4FAA4F;AAC5F,MAAM,WAAW,4BAA4B;IAC3C;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,qBAAa,qBAAsB,YAAW,YAAY;;IAMxD,YAAY,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,4BAAiC,EAiBnE;IAED,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoC3B;IAED,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKrC;IAED,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAY7B;IAED,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzB;IAED;;;;OAIG;IACH,WAAW,IAAI,mBAAmB,CAqBjC;IAED,KAAK,IAAI,aAAa,CAErB;CA6IF"}

package/dist/store-dir.js

@@ -0,0 +1,379 @@
+import { closeSync, fsyncSync, linkSync, mkdirSync, openSync, readdirSync, readFileSync, statSync, unlinkSync, writeSync, } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import process from 'node:process';
+import { HashCollisionError, SmeltError, StoreCorruptionError, StoreFormatError, UnknownHashError, } from './errors.js';
+import { contentHash } from './hash.js';
+import { retrieveStats } from './stats.js';
+/**
+ * The format marker every store directory carries, and the one version this code
+ * understands. A future layout is a new version, refused loudly by old code — never a
+ * quiet reinterpretation of someone's stored bytes.
+ */
+export const DIRECTORY_STORE_FORMAT = 'smelt-elision-store';
+export const DIRECTORY_STORE_VERSION = 1;
+/**
+ * What a storage key may look like. `contentHash` produces 16 lowercase hex characters;
+ * the pattern is wider so an injected test hash still works, and strict enough that a
+ * key can never traverse out of `blobs/` or collide with `format.json`.
+ */
+const KEY_PATTERN = /^[0-9a-f]{4,128}$/;
+/** One journal line: a kind, a space, and the hash as a JSON string literal. */
+const LOG_LINE = /^(hit|miss|corrupt) ("(?:[^"\\]|\\.)*")$/;
+/**
+ * A persistent {@link ElisionStore} over a content-addressed directory. `node:fs` only —
+ * no SQLite, no new dependency, nothing that phones home. Elisions put here outlive the
+ * process, so a long-lived agent session can `retrieve()` across restarts.
+ *
+ * ## Storage layout
+ *
+ * ```text
+ * <root>/
+ *   format.json      { "format": "smelt-elision-store", "version": 1 } — refused if unknown
+ *   blobs/<hash>     one file per elision: the exact UTF-8 bytes, named by their content hash
+ *   tmp/             staging for atomic writes; never read, safe to sweep
+ *   retrievals.log   append-only journal: `hit "<hash>"` | `miss "<hash>"` | `corrupt "<hash>"`
+ * ```
+ *
+ * **Nothing lives in memory.** Every read — `stats()` included — comes off the disk, so
+ * two instances over the same directory (two processes, or one process before and after
+ * a restart) always agree. `stats()` is a scan; elision counts per session are small and
+ * retrieval is the model asking for material back, which is rare by design.
+ *
+ * ## Durability
+ *
+ * - **Writes are crash-safe.** A blob is written to `tmp/`, `fsync`ed, then `link(2)`ed
+ *   into `blobs/` — an atomic, no-clobber publish. A torn write dies in `tmp/`, where
+ *   nothing looks; a name in `blobs/` always refers to a fully written file.
+ * - **Reads verify.** `retrieve()` and `peek()` re-hash the bytes and refuse a mismatch
+ *   with {@link StoreCorruptionError} — a damaged blob is never handed back as a
+ *   retrieval, and "we hold damaged bytes" is distinct from {@link UnknownHashError}'s
+ *   "never existed". The guard in `test/guards/persistent-store.test.ts` watches this.
+ * - **Counters survive a restart.** Every `retrieve()` appends one `fsync`ed line to
+ *   `retrievals.log`, and `stats()` is a fold over it — so `expansionRate` stays
+ *   meaningful across a whole session, not just one process. A crash in the middle of
+ *   an append can tear at most that one line; a torn tail is skipped, costing at most
+ *   the single count that was being written when the process died.
+ * - **Concurrent writers are safe.** `link(2)` refuses to clobber, so two processes
+ *   putting at once race to publish and the loser verifies byte-for-byte agreement with
+ *   the winner — identical content dedupes, different content under one hash is a
+ *   {@link HashCollisionError}. Journal appends use `O_APPEND`. Tested with two real
+ *   processes in `test/store-dir.test.ts`.
+ *
+ * ## No eviction
+ *
+ * Same rule as {@link MemoryElisionStore}: no cap, no LRU, no `clear()`. A store that
+ * can forget turns Law 3 into "reversible, usually". Elided text is smaller than the
+ * session that produced it; if disk pressure ever forces a cap, retrieval of an evicted
+ * hash must throw a distinct "evicted" error — never {@link UnknownHashError} — so the
+ * model can tell "we lost it" from "never existed". Today there is no such error because
+ * there is no such cap.
+ *
+ * ## Two deliberate choices around the edges
+ *
+ * - **The root is resolved to an absolute path at construction.** Every later path is
+ *   joined from that, so a `process.chdir()` after construction cannot silently
+ *   re-target the store — the bytes a relative-rooted store put before a chdir would
+ *   otherwise be unreachable after it, which reads exactly like data loss.
+ * - **A failed journal append never withholds intact bytes.** `retrieve()`'s order of
+ *   business is: read, verify, count, return. When the *count* cannot be written (a
+ *   read-only journal, a full disk), the bytes are still returned — they are verified
+ *   and the caller asked for them; refusing would turn a bookkeeping failure into
+ *   Law 3 breaking. The failure is surfaced distinctly instead: a
+ *   `process.emitWarning` with name `SmeltCounterWriteFailure`, so "your retrieval
+ *   worked" and "your counters just went quiet" stay two separate facts. The same
+ *   applies to the `miss`/`corrupt` journal lines: the store's own error for the
+ *   lookup still wins over the journal's I/O error.
+ */
+export class DirectoryElisionStore {
+    #blobsDir;
+    #tmpDir;
+    #logPath;
+    #hash;
+    constructor(root, options = {}) {
+        this.#hash = options.hash ?? contentHash;
+        // Resolve NOW, against the working directory the caller constructed with — a
+        // later chdir must never re-point an already-constructed store. See the class doc.
+        const absoluteRoot = resolve(root);
+        this.#blobsDir = join(absoluteRoot, 'blobs');
+        this.#tmpDir = join(absoluteRoot, 'tmp');
+        this.#logPath = join(absoluteRoot, 'retrievals.log');
+        const markerPath = join(absoluteRoot, 'format.json');
+        // Validate before mutating: a directory carrying a marker this code does not
+        // understand is refused with the directory exactly as it was found — no blobs/,
+        // no tmp/, no staged temp file created inside someone else's layout.
+        const existing = this.#readMarker(markerPath);
+        if (existing !== undefined)
+            this.#verifyMarker(markerPath, existing);
+        mkdirSync(this.#blobsDir, { recursive: true });
+        mkdirSync(this.#tmpDir, { recursive: true });
+        this.#claimFormat(markerPath);
+    }
+    put(content) {
+        const hash = this.#hash(content);
+        if (!KEY_PATTERN.test(hash)) {
+            throw new SmeltError(`smelt: hash "${hash}" is not usable as a storage key — it must match ` +
+                `${String(KEY_PATTERN)} so it can name a file inside blobs/ and nothing else.`);
+        }
+        const existing = this.#readBlob(hash);
+        if (existing !== undefined) {
+            // Verify the stored bytes before comparing: a damaged blob is corruption, not a
+            // collision. Only intact bytes that still differ earn HashCollisionError.
+            if (this.#hash(existing) !== hash)
+                throw new StoreCorruptionError(hash);
+            if (existing !== content)
+                throw new HashCollisionError(hash);
+            return hash;
+        }
+        const tmpPath = this.#writeTemp(content);
+        try {
+            // link(2) is the atomic, no-clobber publish: it fails with EEXIST rather than
+            // overwrite, so a concurrent writer can never silently replace someone's bytes.
+            linkSync(tmpPath, join(this.#blobsDir, hash));
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            // Another writer published this hash between our existence check and our link.
+            // Same bytes: idempotent put, done. Damaged or vanished bytes: corruption — the
+            // store was torn or edited outside smelt. Intact different bytes: a collision.
+            const winner = this.#readBlob(hash);
+            if (winner === undefined || this.#hash(winner) !== hash) {
+                throw new StoreCorruptionError(hash);
+            }
+            if (winner !== content)
+                throw new HashCollisionError(hash);
+        }
+        finally {
+            unlinkSync(tmpPath);
+        }
+        fsyncDirBestEffort(this.#blobsDir);
+        return hash;
+    }
+    peek(hash) {
+        const content = this.#readBlob(hash);
+        if (content === undefined)
+            return undefined;
+        if (this.#hash(content) !== hash)
+            throw new StoreCorruptionError(hash);
+        return content;
+    }
+    retrieve(hash) {
+        const content = this.#readBlob(hash);
+        if (content === undefined) {
+            this.#appendLogCounting('miss', hash);
+            throw new UnknownHashError(hash);
+        }
+        if (this.#hash(content) !== hash) {
+            this.#appendLogCounting('corrupt', hash);
+            throw new StoreCorruptionError(hash);
+        }
+        this.#appendLogCounting('hit', hash);
+        return content;
+    }
+    has(hash) {
+        return this.#readBlob(hash) !== undefined;
+    }
+    /**
+     * The five directly-observed counts, every one read off the disk — a scan of
+     * `blobs/` plus a fold over `retrievals.log`. See {@link RawRetrieveCounters}; the
+     * derived half of the stats comes from the shared `retrieveStats()`, never here.
+     */
+    rawCounters() {
+        let elisionsStored = 0;
+        let bytesStored = 0;
+        for (const entry of readdirSync(this.#blobsDir)) {
+            if (!KEY_PATTERN.test(entry))
+                continue; // `.DS_Store` and friends are not blobs
+            elisionsStored += 1;
+            bytesStored += statSync(join(this.#blobsDir, entry)).size;
+        }
+        let retrieveCalls = 0;
+        let misses = 0;
+        const hits = new Set();
+        for (const line of this.#readLog().split('\n')) {
+            const match = LOG_LINE.exec(line);
+            if (match === null)
+                continue; // a torn tail from a crash mid-append, or blank
+            retrieveCalls += 1;
+            if (match[1] === 'miss')
+                misses += 1;
+            else if (match[1] === 'hit')
+                hits.add(JSON.parse(match[2]));
+        }
+        return { elisionsStored, bytesStored, retrieveCalls, uniqueRetrieved: hits.size, misses };
+    }
+    stats() {
+        return retrieveStats(this.rawCounters());
+    }
+    /** The blob's exact content, or `undefined` when no such blob is stored. */
+    #readBlob(hash) {
+        if (!KEY_PATTERN.test(hash))
+            return undefined; // never a path component
+        try {
+            return readFileSync(join(this.#blobsDir, hash), 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        }
+    }
+    /** Write content to a unique file in `tmp/`, fsynced, and return its path. */
+    #writeTemp(content) {
+        const tmpPath = join(this.#tmpDir, `${String(process.pid)}-${randomBytes(8).toString('hex')}`);
+        const fd = openSync(tmpPath, 'wx');
+        try {
+            // writeSync may write fewer bytes than asked; loop, or a short write would be
+            // fsynced and published under the full content's hash as a torn blob.
+            const bytes = Buffer.from(content, 'utf8');
+            let written = 0;
+            while (written < bytes.length) {
+                written += writeSync(fd, bytes, written);
+            }
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        return tmpPath;
+    }
+    /**
+     * A journal append on the `retrieve()` path — counting, not custody. A failure here
+     * must never decide whether the caller gets its verified bytes (or its true error),
+     * so it is caught and surfaced as a distinct `process.emitWarning` — see the class
+     * doc, and the read-only-journal case in `test/store-dir.test.ts`.
+     */
+    #appendLogCounting(kind, hash) {
+        try {
+            this.#appendLog(kind, hash);
+        }
+        catch (error) {
+            process.emitWarning(`smelt: could not journal a "${kind}" for hash "${hash}" in ${this.#logPath} ` +
+                `(${error instanceof Error ? error.message : String(error)}). The retrieval ` +
+                `itself is unaffected, but this count is lost — retrieveCalls and ` +
+                `expansionRate now UNDER-report until the journal is writable again.`, 'SmeltCounterWriteFailure');
+        }
+    }
+    /**
+     * One durable journal line. The hash is JSON-encoded because `retrieve()` takes it
+     * from the model verbatim — a hash containing a newline must not forge a second line.
+     * The record starts with its own newline so a torn tail from an earlier crash — a
+     * partial record with no trailing newline — can never bleed into this one: the tear
+     * stays on its own line and is skipped by `stats()`, as blank lines are.
+     */
+    #appendLog(kind, hash) {
+        const fd = openSync(this.#logPath, 'a');
+        try {
+            const record = Buffer.from(`\n${kind} ${JSON.stringify(hash)}\n`, 'utf8');
+            let written = 0;
+            while (written < record.length) {
+                written += writeSync(fd, record, written);
+            }
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    #readLog() {
+        try {
+            return readFileSync(this.#logPath, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return '';
+            throw error;
+        }
+    }
+    /**
+     * Write the format marker if this directory has none, or verify the one it has.
+     * Creation is atomic (write to `tmp/`, then `link`), so a concurrent creator never
+     * observes a half-written marker. The constructor pre-verified any pre-existing
+     * marker; the verify here catches only a concurrent creator's claim.
+     */
+    #claimFormat(markerPath) {
+        const claim = () => {
+            const body = `${JSON.stringify({
+                format: DIRECTORY_STORE_FORMAT,
+                version: DIRECTORY_STORE_VERSION,
+            })}\n`;
+            const tmpPath = this.#writeTemp(body);
+            try {
+                linkSync(tmpPath, markerPath);
+                return undefined; // claimed by us; nothing to verify
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                return readFileSync(markerPath, 'utf8');
+            }
+            finally {
+                unlinkSync(tmpPath);
+            }
+        };
+        const existing = claim();
+        if (existing === undefined)
+            return;
+        this.#verifyMarker(markerPath, existing);
+    }
+    /** The marker's body, or `undefined` when the directory carries none. */
+    #readMarker(markerPath) {
+        try {
+            return readFileSync(markerPath, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        }
+    }
+    /** Refuse a marker this version of smelt does not understand. */
+    #verifyMarker(markerPath, existing) {
+        let parsed;
+        try {
+            parsed = JSON.parse(existing);
+        }
+        catch {
+            throw new StoreFormatError(`smelt: "${markerPath}" is not parseable JSON, so this directory cannot be ` +
+                `trusted as an elision store. Refusing to read or write it.`);
+        }
+        if (parsed.format !== DIRECTORY_STORE_FORMAT || parsed.version !== DIRECTORY_STORE_VERSION) {
+            throw new StoreFormatError(`smelt: "${markerPath}" declares format ${JSON.stringify(parsed.format)} ` +
+                `version ${JSON.stringify(parsed.version)}; this code understands ` +
+                `"${DIRECTORY_STORE_FORMAT}" version ${String(DIRECTORY_STORE_VERSION)}. ` +
+                `Refusing to reinterpret someone else's layout.`);
+        }
+    }
+}
+/**
+ * Flush the directory entry after a publish, so the *name* survives a crash as well as
+ * the bytes. Where the platform refuses to fsync a directory (Windows does), the publish
+ * is still atomic — only the durability of the directory entry falls back to the OS's
+ * own schedule. Only that refusal is swallowed: a real I/O failure (`EIO`) propagates,
+ * because "the disk could not flush" must never be reported as a successful put.
+ */
+function fsyncDirBestEffort(path) {
+    let fd;
+    try {
+        fd = openSync(path, 'r');
+    }
+    catch {
+        return; // the platform refuses to even open a directory for reading (Windows)
+    }
+    try {
+        fsyncSync(fd);
+    }
+    catch (error) {
+        const code = error.code;
+        // EINVAL/ENOTSUP/EPERM/EBADF: the platform refuses to fsync a directory — see the
+        // doc comment. Anything else (EIO above all) is a genuine write failure.
+        if (code !== 'EINVAL' && code !== 'ENOTSUP' && code !== 'EPERM' && code !== 'EBADF') {
+            throw error;
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+//# sourceMappingURL=store-dir.js.map

package/dist/store-dir.js.map

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

package/dist/store.d.ts

@@ -0,0 +1,36 @@
+import type { RawRetrieveCounters } from './stats.ts';
+import type { ElisionStore, RetrieveStats } from './types.ts';
+/**
+ * The default store: in-process, content-addressed, no eviction.
+ *
+ * In-process is the right default because it is the only one with no failure modes to
+ * explain. A consumer that needs elisions to survive a process restart (a long-lived
+ * agent session, say) hands `createSmelter()` a {@link DirectoryElisionStore} — or
+ * implements {@link ElisionStore} over storage of its own; the interface is five
+ * methods wide for exactly that reason.
+ *
+ * There is no `clear()` and no LRU. A store that can forget turns Law 3 into
+ * "reversible, usually", and a `retrieve()` that fails after an eviction is
+ * indistinguishable to the model from a hallucinated hash.
+ */
+export interface MemoryElisionStoreOptions {
+    /**
+     * Override the hash function. The only reason this exists: the collision branch in
+     * {@link MemoryElisionStore.put} is unreachable with sha256, and an untestable branch
+     * is a branch nobody knows works. A test injects a colliding hash and watches it
+     * throw. Production has no reason to pass this.
+     */
+    readonly hash?: (content: string) => string;
+}
+export declare class MemoryElisionStore implements ElisionStore {
+    #private;
+    constructor(options?: MemoryElisionStoreOptions);
+    put(content: string): string;
+    peek(hash: string): string | undefined;
+    retrieve(hash: string): string;
+    has(hash: string): boolean;
+    /** The five directly-observed counts. See {@link RawRetrieveCounters} — no derivation here. */
+    rawCounters(): RawRetrieveCounters;
+    stats(): RetrieveStats;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE9D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7C;AAED,qBAAa,kBAAmB,YAAW,YAAY;;IAQrD,YAAY,OAAO,GAAE,yBAA8B,EAElD;IAED,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAU3B;IAED,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAErC;IAED,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAS7B;IAED,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzB;IAED,+FAA+F;IAC/F,WAAW,IAAI,mBAAmB,CAQjC;IAED,KAAK,IAAI,aAAa,CAErB;CACF"}

package/dist/store.js

@@ -0,0 +1,56 @@
+import { HashCollisionError, UnknownHashError } from './errors.js';
+import { contentHash } from './hash.js';
+import { retrieveStats } from './stats.js';
+export class MemoryElisionStore {
+    #blobs = new Map();
+    #hash;
+    #bytesStored = 0;
+    #retrieveCalls = 0;
+    #misses = 0;
+    #retrievedHashes = new Set();
+    constructor(options = {}) {
+        this.#hash = options.hash ?? contentHash;
+    }
+    put(content) {
+        const hash = this.#hash(content);
+        const existing = this.#blobs.get(hash);
+        if (existing !== undefined) {
+            if (existing !== content)
+                throw new HashCollisionError(hash);
+            return hash;
+        }
+        this.#blobs.set(hash, content);
+        this.#bytesStored += Buffer.byteLength(content, 'utf8');
+        return hash;
+    }
+    peek(hash) {
+        return this.#blobs.get(hash);
+    }
+    retrieve(hash) {
+        this.#retrieveCalls += 1;
+        const content = this.#blobs.get(hash);
+        if (content === undefined) {
+            this.#misses += 1;
+            throw new UnknownHashError(hash);
+        }
+        this.#retrievedHashes.add(hash);
+        return content;
+    }
+    has(hash) {
+        return this.#blobs.has(hash);
+    }
+    /** The five directly-observed counts. See {@link RawRetrieveCounters} — no derivation here. */
+    rawCounters() {
+        return {
+            elisionsStored: this.#blobs.size,
+            bytesStored: this.#bytesStored,
+            retrieveCalls: this.#retrieveCalls,
+            uniqueRetrieved: this.#retrievedHashes.size,
+            misses: this.#misses,
+        };
+    }
+    stats() {
+        return retrieveStats(this.rawCounters());
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA2B3C,MAAM,OAAO,kBAAkB;IACpB,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IACnC,KAAK,CAA8B;IAC5C,YAAY,GAAG,CAAC,CAAC;IACjB,cAAc,GAAG,CAAC,CAAC;IACnB,OAAO,GAAG,CAAC,CAAC;IACH,gBAAgB,GAAG,IAAI,GAAG,EAAU,CAAC;IAE9C,YAAY,OAAO,GAA8B,EAAE;QACjD,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,IAAI,IAAI,WAAW,CAAC;IAC3C,CAAC;IAED,GAAG,CAAC,OAAe;QACjB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACjC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,IAAI,QAAQ,KAAK,OAAO;gBAAE,MAAM,IAAI,kBAAkB,CAAC,IAAI,CAAC,CAAC;YAC7D,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC/B,IAAI,CAAC,YAAY,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACxD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC,IAAY;QACf,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,QAAQ,CAAC,IAAY;QACnB,IAAI,CAAC,cAAc,IAAI,CAAC,CAAC;QACzB,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;YAClB,MAAM,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACnC,CAAC;QACD,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAChC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,+FAA+F;IAC/F,WAAW;QACT,OAAO;YACL,cAAc,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI;YAChC,WAAW,EAAE,IAAI,CAAC,YAAY;YAC9B,aAAa,EAAE,IAAI,CAAC,cAAc;YAClC,eAAe,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI;YAC3C,MAAM,EAAE,IAAI,CAAC,OAAO;SACrB,CAAC;IACJ,CAAC;IAED,KAAK;QACH,OAAO,aAAa,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;IAC3C,CAAC;CACF"}