@camstack/system 1.2.390 → 1.2.391

package/dist/builtins/sqlite-storage/wal-maintenance.d.ts

@@ -1,113 +1,113 @@
-import { IScopedLogger } from '@camstack/types';
-import { default as Database } from 'better-sqlite3';
+import type { IScopedLogger } from "@camstack/types";
+import type Database from "better-sqlite3";
 /**
- * Size at or above which the WAL is a candidate for a truncating checkpoint,
- * in bytes. 67108864 = **64 MiB**.
- *
- * Matched to `SQLITE_JOURNAL_SIZE_LIMIT_BYTES`: below this, the passive
- * mechanism (autocheckpoint + `journal_size_limit`) is doing its job and there
- * is nothing to reclaim. The live hub's WAL had reached 248,955,152 bytes —
- * roughly 2x the 130 MB database — which is what says the passive path alone
- * had stopped keeping up.
- */
+* Size at or above which the WAL is a candidate for a truncating checkpoint,
+* in bytes. 67108864 = **64 MiB**.
+*
+* Matched to `SQLITE_JOURNAL_SIZE_LIMIT_BYTES`: below this, the passive
+* mechanism (autocheckpoint + `journal_size_limit`) is doing its job and there
+* is nothing to reclaim. The live hub's WAL had reached 248,955,152 bytes —
+* roughly 2x the 130 MB database — which is what says the passive path alone
+* had stopped keeping up.
+*/
 export declare const WAL_HIGH_WATER_BYTES = 67108864;
 /**
- * How long the WAL must have gone UNWRITTEN before a truncating checkpoint is
- * allowed, in ms.
- *
- * This is the stall guard and the reason this file exists. `wal_checkpoint
- * (TRUNCATE)` takes the writer lock, waits for readers, and copies the whole
- * WAL back into the database — synchronously, on the thread that serves every
- * request. An unconditional periodic one on a busy NVR would be the disease
- * (hub-main already spends 42 s per 2 minutes inside uninterrupted blocks),
- * not the cure.
- *
- * The idle signal is the WAL file's own mtime. It is one `stat`, and unlike a
- * write counter maintained in this class it covers EVERY writer on the file —
- * the settings backend, the sqlite-vec index sharing the handle, and the
- * short-lived second connection system-backup opens. On a genuinely busy NVR
- * this gate simply never opens, and `journal_size_limit` remains the only
- * thing bounding the file. That is the intended failure mode: doing nothing is
- * strictly better than a 249 MB copy in the middle of a live request.
- */
-export declare const WAL_IDLE_QUIET_MS = 30000;
+* How long the WAL must have gone UNWRITTEN before a truncating checkpoint is
+* allowed, in ms.
+*
+* This is the stall guard and the reason this file exists. `wal_checkpoint
+* (TRUNCATE)` takes the writer lock, waits for readers, and copies the whole
+* WAL back into the database — synchronously, on the thread that serves every
+* request. An unconditional periodic one on a busy NVR would be the disease
+* (hub-main already spends 42 s per 2 minutes inside uninterrupted blocks),
+* not the cure.
+*
+* The idle signal is the WAL file's own mtime. It is one `stat`, and unlike a
+* write counter maintained in this class it covers EVERY writer on the file —
+* the settings backend, the sqlite-vec index sharing the handle, and the
+* short-lived second connection system-backup opens. On a genuinely busy NVR
+* this gate simply never opens, and `journal_size_limit` remains the only
+* thing bounding the file. That is the intended failure mode: doing nothing is
+* strictly better than a 249 MB copy in the middle of a live request.
+*/
+export declare const WAL_IDLE_QUIET_MS = 3e4;
 /**
- * Ceiling on how long the checkpoint may wait for a lock, in ms.
- *
- * better-sqlite3 defaults `busy_timeout` to 5000. A checkpoint invokes the
- * busy handler while waiting for readers, so without this a "quiet" moment
- * that turns out not to be quiet could park the main thread for 5 s. 250 ms
- * means the checkpoint gives up and we try again on the next tick — the WAL
- * staying big for another minute costs nothing.
- */
+* Ceiling on how long the checkpoint may wait for a lock, in ms.
+*
+* better-sqlite3 defaults `busy_timeout` to 5000. A checkpoint invokes the
+* busy handler while waiting for readers, so without this a "quiet" moment
+* that turns out not to be quiet could park the main thread for 5 s. 250 ms
+* means the checkpoint gives up and we try again on the next tick — the WAL
+* staying big for another minute costs nothing.
+*/
 export declare const WAL_CHECKPOINT_BUSY_TIMEOUT_MS = 250;
 /** How often the gate is evaluated, in ms. Cheap: a `stat` unless it fires. */
-export declare const WAL_MAINTENANCE_INTERVAL_MS = 60000;
+export declare const WAL_MAINTENANCE_INTERVAL_MS = 6e4;
 /** What a single maintenance tick did. Every branch is named. */
 export type WalMaintenanceOutcome = {
-    readonly kind: 'no-wal';
+	readonly kind: "no-wal";
 } | {
-    readonly kind: 'below-high-water';
-    readonly walBytes: number;
+	readonly kind: "below-high-water";
+	readonly walBytes: number;
 } | {
-    readonly kind: 'deferred-not-idle';
-    readonly walBytes: number;
-    readonly quietForMs: number;
+	readonly kind: "deferred-not-idle";
+	readonly walBytes: number;
+	readonly quietForMs: number;
 } | {
-    readonly kind: 'checkpointed';
-    readonly beforeBytes: number;
-    readonly afterBytes: number;
-    readonly busy: boolean;
-    readonly walFrames: number;
-    readonly checkpointedFrames: number;
+	readonly kind: "checkpointed";
+	readonly beforeBytes: number;
+	readonly afterBytes: number;
+	readonly busy: boolean;
+	readonly walFrames: number;
+	readonly checkpointedFrames: number;
 } | {
-    readonly kind: 'failed';
-    readonly error: string;
+	readonly kind: "failed";
+	readonly error: string;
 };
 /** Construction inputs for {@link WalMaintenance}. */
 export interface WalMaintenanceOptions {
-    readonly db: Database.Database;
-    /** Path to the main database file; the WAL is `${dbPath}-wal`. */
-    readonly dbPath: string;
-    readonly logger: IScopedLogger;
-    readonly highWaterBytes?: number;
-    readonly idleQuietMs?: number;
-    readonly intervalMs?: number;
-    readonly busyTimeoutMs?: number;
+	readonly db: Database.Database;
+	/** Path to the main database file; the WAL is `${dbPath}-wal`. */
+	readonly dbPath: string;
+	readonly logger: IScopedLogger;
+	readonly highWaterBytes?: number;
+	readonly idleQuietMs?: number;
+	readonly intervalMs?: number;
+	readonly busyTimeoutMs?: number;
 }
 /**
- * Periodic, heavily gated `wal_checkpoint(TRUNCATE)`.
- *
- * The interesting behaviour is all refusal. A tick costs one `stat` in the
- * common case; it escalates to a lock-taking checkpoint only when the WAL is
- * over the high-water mark AND nothing has written to it for
- * {@link WAL_IDLE_QUIET_MS}, and even then the wait is bounded to
- * {@link WAL_CHECKPOINT_BUSY_TIMEOUT_MS}.
- */
+* Periodic, heavily gated `wal_checkpoint(TRUNCATE)`.
+*
+* The interesting behaviour is all refusal. A tick costs one `stat` in the
+* common case; it escalates to a lock-taking checkpoint only when the WAL is
+* over the high-water mark AND nothing has written to it for
+* {@link WAL_IDLE_QUIET_MS}, and even then the wait is bounded to
+* {@link WAL_CHECKPOINT_BUSY_TIMEOUT_MS}.
+*/
 export declare class WalMaintenance {
-    private readonly db;
-    private readonly walPath;
-    private readonly logger;
-    private readonly highWaterBytes;
-    private readonly idleQuietMs;
-    private readonly intervalMs;
-    private readonly busyTimeoutMs;
-    private timer;
-    constructor(options: WalMaintenanceOptions);
-    start(): void;
-    stop(): void;
-    isRunning(): boolean;
-    /** Evaluate the gate once and act. Never throws. */
-    runOnce(): WalMaintenanceOutcome;
-    private evaluate;
-    /**
-     * Take the writer lock and fold the WAL back, with the wait bounded.
-     *
-     * The original `busy_timeout` is restored in a `finally`: this connection is
-     * shared with the settings backend and the vector index, and leaving them on
-     * a 250 ms timeout would turn an ordinary contended write into a spurious
-     * SQLITE_BUSY.
-     */
-    private checkpoint;
-    private statWal;
+	private readonly db;
+	private readonly walPath;
+	private readonly logger;
+	private readonly highWaterBytes;
+	private readonly idleQuietMs;
+	private readonly intervalMs;
+	private readonly busyTimeoutMs;
+	private timer;
+	constructor(options: WalMaintenanceOptions);
+	start(): void;
+	stop(): void;
+	isRunning(): boolean;
+	/** Evaluate the gate once and act. Never throws. */
+	runOnce(): WalMaintenanceOutcome;
+	private evaluate;
+	/**
+	* Take the writer lock and fold the WAL back, with the wait bounded.
+	*
+	* The original `busy_timeout` is restored in a `finally`: this connection is
+	* shared with the settings backend and the vector index, and leaving them on
+	* a 250 ms timeout would turn an ordinary contended write into a spurious
+	* SQLITE_BUSY.
+	*/
+	private checkpoint;
+	private statWal;
 }

package/dist/builtins/storage-orchestrator/access-guards.d.ts

@@ -1,32 +1,43 @@
-import { StorageLocation } from '@camstack/types';
+/**
+* The two decisions the orchestrator makes from "is this location backed by a
+* local filesystem?", extracted so both are directly testable without standing
+* up an addon.
+*
+* They are the second and third locks of D296. The first is
+* `upsertLocation`'s refusal, which stops the configuration from existing.
+* These two hold for a row that predates the guard, for one written by a
+* future code path, and for a provider that changes its own `nodeLocal`
+* answer after a location was made.
+*/
+import type { StorageLocation } from "@camstack/types";
 /** What a provider answered about itself; `undefined` = not yet classified. */
 export type ProviderLocality = boolean | undefined;
 /**
- * May `storage.resolve` return a path for this location?
- *
- * `resolve` is the only method on the cap whose result LEAVES the storage
- * abstraction — every caller of it opens the string with `node:fs`. A remote
- * provider answers with a path on the remote host, which on this node is
- * either missing or an unrelated local directory of the same name. For the
- * recorder, writing to the wrong place is not an error the operator sees; it
- * is a black window in the footage.
- *
- * Only a POSITIVE `false` refuses. `undefined` is "not yet classified", not
- * "remote" — and a conclusion drawn from a read that was never made is how a
- * doorbell rang 0/3 (D49).
- */
+* May `storage.resolve` return a path for this location?
+*
+* `resolve` is the only method on the cap whose result LEAVES the storage
+* abstraction — every caller of it opens the string with `node:fs`. A remote
+* provider answers with a path on the remote host, which on this node is
+* either missing or an unrelated local directory of the same name. For the
+* recorder, writing to the wrong place is not an error the operator sees; it
+* is a black window in the footage.
+*
+* Only a POSITIVE `false` refuses. `undefined` is "not yet classified", not
+* "remote" — and a conclusion drawn from a read that was never made is how a
+* doorbell rang 0/3 (D49).
+*/
 export declare function resolveRefusalFor(location: StorageLocation, locality: ProviderLocality): string | null;
 /**
- * Can this node's filesystem answer "does this location still hold anything?"
- *
- * Only for a provider it KNOWS to be node-local. Everything else is `unknown`,
- * which refuses a delete.
- *
- * The direction that matters is the one this closes. A remote location carries
- * a plain-looking `basePath` (`/backups/camstack`); `fs.readdir` of it on the
- * hub answers `ENOENT`, and `ENOENT` is deliberately read as `empty` — because
- * for a LOCAL location an absent root means there is nothing the delete can
- * strand. Applied to a remote row, that same reasoning turns a full share into
- * a vacant one and walks D293's delete guard straight past it.
- */
+* Can this node's filesystem answer "does this location still hold anything?"
+*
+* Only for a provider it KNOWS to be node-local. Everything else is `unknown`,
+* which refuses a delete.
+*
+* The direction that matters is the one this closes. A remote location carries
+* a plain-looking `basePath` (`/backups/camstack`); `fs.readdir` of it on the
+* hub answers `ENOENT`, and `ENOENT` is deliberately read as `empty` — because
+* for a LOCAL location an absent root means there is nothing the delete can
+* strand. Applied to a remote row, that same reasoning turns a full share into
+* a vacant one and walks D293's delete guard straight past it.
+*/
 export declare function canProbeOccupancyLocally(locality: ProviderLocality): boolean;

package/dist/builtins/storage-orchestrator/data-store-dispatch.d.ts

@@ -1,24 +1,39 @@
-import { IDataStoreProvider, ISettingsStoreProvider } from '@camstack/types';
+/**
+* The data door's dispatcher — the `settings-store` provider the storage
+* orchestrator registers, forwarding every call to the
+* `data-store-provider` engine behind it ([D44](../../../../../docs/decisions/adr-0044.md)).
+*
+* It is a ROUTER, not a translator. The two cap surfaces are deliberately
+* identical, so every method here is the same forward, and the payload
+* crosses untouched. That matters more than it looks: the engine composes
+* its table name from `namespace` + `collection` **out of the payload**,
+* so a dispatcher that injected, defaulted or stripped a namespace would
+* silently rename every table in the database.
+*
+* Extracted from the addon so the forwarding is unit-testable without
+* booting a `BaseAddon` — the same reason `provider-discovery.ts` exists.
+*/
+import type { IDataStoreProvider, ISettingsStoreProvider } from "@camstack/types";
 /** How the dispatcher reaches the registered engines, read per call. */
 export type GetDataStoreEngines = () => readonly IDataStoreProvider[];
 /**
- * How the dispatcher reaches the node that owns the store when THIS node
- * does not — an agent, whose persistence is the hub's
- * (`createHubSettingsForward`). Read per call for the same reason
- * `getEngines` is: the broker reconnects, and a snapshot taken at
- * construction time would go stale exactly when the hub came back.
- *
- * `null` (and an omitted getter) means "there is no remote" — a hub, where a
- * remote could only be this very door, reached back through `$hub-cap-fwd`.
- */
+* How the dispatcher reaches the node that owns the store when THIS node
+* does not — an agent, whose persistence is the hub's
+* (`createHubSettingsForward`). Read per call for the same reason
+* `getEngines` is: the broker reconnects, and a snapshot taken at
+* construction time would go stale exactly when the hub came back.
+*
+* `null` (and an omitted getter) means "there is no remote" — a hub, where a
+* remote could only be this very door, reached back through `$hub-cap-fwd`.
+*/
 export type GetRemoteDataStore = () => ISettingsStoreProvider | null;
 /**
- * Build the `settings-store` provider that fronts the registered engines,
- * with an optional remote behind it for a node that registers none.
- *
- * `getEngines` and `getRemote` are read on every call, never captured:
- * engines register during boot and a runner respawn replaces the instance, so
- * a snapshot taken at construction time would go stale exactly when an addon
- * crashed and came back.
- */
+* Build the `settings-store` provider that fronts the registered engines,
+* with an optional remote behind it for a node that registers none.
+*
+* `getEngines` and `getRemote` are read on every call, never captured:
+* engines register during boot and a runner respawn replaces the instance, so
+* a snapshot taken at construction time would go stale exactly when an addon
+* crashed and came back.
+*/
 export declare function createDataStoreDispatch(getEngines: GetDataStoreEngines, getRemote?: GetRemoteDataStore): ISettingsStoreProvider;

package/dist/builtins/storage-orchestrator/drain-ratchet.d.ts

@@ -1,104 +1,104 @@
 /**
- * The growth-matched drain ratchet (D386).
- *
- * `readonly` takes a location OUT of pressure eviction. `drain` must instead
- * SHRINK it — and priority ordering alone does nothing, because the draining
- * disk and the destination are different physical devices: pressure on one can
- * never trigger eviction on the other.
- *
- * So a draining location gets a **monotonically descending effective usage
- * cap**, enforced through the existing `relieveToUsageCap` machinery rather
- * than a second eviction path. The pace is GROWTH-MATCHED: each sweep, the
- * draining location cedes as many bytes as the ACTIVE locations of its class
- * gained since the previous sweep. There is no operator-facing rate — the
- * operator sets one flag and nothing else.
- *
- * The properties this module exists to hold, each one a named test:
- *
- *   - no growth in the destination ⇒ nothing is deleted this sweep;
- *   - the cap never rises again — a shrunken cap survives a sweep where growth
- *     is negative or unmeasurable;
- *   - the state survives a process restart (it is PERSISTED, never recomputed
- *     from scratch — a recomputed cap would start again at today's usage and
- *     silently undo every byte of progress);
- *   - reaching zero stops the ratchet and reports the location as drained;
- *   - switching back to `readonly` or `active` stops it immediately (the caller
- *     clears the state; nothing here keeps running on its own).
- *
- * Pure. Every input is a parameter, every output is a new object.
- */
+* The growth-matched drain ratchet (D386).
+*
+* `readonly` takes a location OUT of pressure eviction. `drain` must instead
+* SHRINK it — and priority ordering alone does nothing, because the draining
+* disk and the destination are different physical devices: pressure on one can
+* never trigger eviction on the other.
+*
+* So a draining location gets a **monotonically descending effective usage
+* cap**, enforced through the existing `relieveToUsageCap` machinery rather
+* than a second eviction path. The pace is GROWTH-MATCHED: each sweep, the
+* draining location cedes as many bytes as the ACTIVE locations of its class
+* gained since the previous sweep. There is no operator-facing rate — the
+* operator sets one flag and nothing else.
+*
+* The properties this module exists to hold, each one a named test:
+*
+*   - no growth in the destination ⇒ nothing is deleted this sweep;
+*   - the cap never rises again — a shrunken cap survives a sweep where growth
+*     is negative or unmeasurable;
+*   - the state survives a process restart (it is PERSISTED, never recomputed
+*     from scratch — a recomputed cap would start again at today's usage and
+*     silently undo every byte of progress);
+*   - reaching zero stops the ratchet and reports the location as drained;
+*   - switching back to `readonly` or `active` stops it immediately (the caller
+*     clears the state; nothing here keeps running on its own).
+*
+* Pure. Every input is a parameter, every output is a new object.
+*/
 /** What one sweep measured about a draining location and its class. */
 export interface DrainObservation {
-    readonly locationId: string;
-    /** Evictable bytes on the DRAINING location, now. */
-    readonly usedBytes: number;
-    /**
-     * Evictable bytes held by the ACTIVE locations of the same class, now.
-     * `null` when this sweep could not measure them — no active peer, or a
-     * provider read that failed. Unmeasurable is NOT zero growth with a
-     * different name: it must never be allowed to move the cap in either
-     * direction, and it must never be folded into the observed growth rate the
-     * estimate is derived from.
-     */
-    readonly peerUsedBytes: number | null;
-    readonly atMs: number;
+	readonly locationId: string;
+	/** Evictable bytes on the DRAINING location, now. */
+	readonly usedBytes: number;
+	/**
+	* Evictable bytes held by the ACTIVE locations of the same class, now.
+	* `null` when this sweep could not measure them — no active peer, or a
+	* provider read that failed. Unmeasurable is NOT zero growth with a
+	* different name: it must never be allowed to move the cap in either
+	* direction, and it must never be folded into the observed growth rate the
+	* estimate is derived from.
+	*/
+	readonly peerUsedBytes: number | null;
+	readonly atMs: number;
 }
 /** The persisted ratchet state for one draining location. */
 export interface DrainState {
-    readonly locationId: string;
-    /** When the drain began. Persisted so a restart reports real elapsed time. */
-    readonly startedAtMs: number;
-    /** Evictable bytes at that moment — the denominator of "progress". */
-    readonly startBytes: number;
-    /** The effective usage cap. NEVER rises. */
-    readonly capBytes: number;
-    /** Peer footprint at the previous sweep; the next sweep's growth is measured
-     *  against it. `null` until a sweep manages to measure it. */
-    readonly lastPeerBytes: number | null;
-    readonly lastSweepMs: number;
-    /** Total MEASURED growth ceded so far, and the wall time it took. The empty
-     *  estimate is derived from these two and from nothing else — a rate the
-     *  system has not observed is reported as absent, never as a date. */
-    readonly observedGrowthBytes: number;
-    readonly observedElapsedMs: number;
+	readonly locationId: string;
+	/** When the drain began. Persisted so a restart reports real elapsed time. */
+	readonly startedAtMs: number;
+	/** Evictable bytes at that moment — the denominator of "progress". */
+	readonly startBytes: number;
+	/** The effective usage cap. NEVER rises. */
+	readonly capBytes: number;
+	/** Peer footprint at the previous sweep; the next sweep's growth is measured
+	*  against it. `null` until a sweep manages to measure it. */
+	readonly lastPeerBytes: number | null;
+	readonly lastSweepMs: number;
+	/** Total MEASURED growth ceded so far, and the wall time it took. The empty
+	*  estimate is derived from these two and from nothing else — a rate the
+	*  system has not observed is reported as absent, never as a date. */
+	readonly observedGrowthBytes: number;
+	readonly observedElapsedMs: number;
 }
 /** One sweep's decision. */
 export interface DrainStep {
-    readonly state: DrainState;
-    /**
-     * The cap to enforce this sweep, or `null` when nothing is to be evicted —
-     * the first sweep (no growth measured yet) and a location already drained.
-     */
-    readonly capBytes: number | null;
-    /** The location holds nothing more: the ratchet stops and the caller reports
-     *  it drained. */
-    readonly drained: boolean;
-    /** Growth measured this sweep, or `null` when it was unmeasurable. */
-    readonly growthBytes: number | null;
+	readonly state: DrainState;
+	/**
+	* The cap to enforce this sweep, or `null` when nothing is to be evicted —
+	* the first sweep (no growth measured yet) and a location already drained.
+	*/
+	readonly capBytes: number | null;
+	/** The location holds nothing more: the ratchet stops and the caller reports
+	*  it drained. */
+	readonly drained: boolean;
+	/** Growth measured this sweep, or `null` when it was unmeasurable. */
+	readonly growthBytes: number | null;
 }
 /** Progress a UI can render. */
 export interface DrainProgress {
-    readonly locationId: string;
-    readonly startedAtMs: number;
-    readonly startBytes: number;
-    readonly bytesRemaining: number;
-    readonly drained: boolean;
-    /**
-     * Epoch ms this location is expected to be empty, or `null` when the growth
-     * rate is unknown. Never a fabricated date: a drain with no observed growth
-     * has no honest ETA, and inventing one is how an operator learns not to
-     * believe the screen.
-     */
-    readonly estimatedEmptyAtMs: number | null;
+	readonly locationId: string;
+	readonly startedAtMs: number;
+	readonly startBytes: number;
+	readonly bytesRemaining: number;
+	readonly drained: boolean;
+	/**
+	* Epoch ms this location is expected to be empty, or `null` when the growth
+	* rate is unknown. Never a fabricated date: a drain with no observed growth
+	* has no honest ETA, and inventing one is how an operator learns not to
+	* believe the screen.
+	*/
+	readonly estimatedEmptyAtMs: number | null;
 }
 /** The state a drain starts from. No deletion happens on this sweep. */
 export declare function beginDrain(observation: DrainObservation): DrainState;
 /**
- * Advance the ratchet by one sweep. `previous` is `null` on the first sweep of
- * a drain (and after a state the caller cleared), which only ARMS the ratchet:
- * the first growth can be measured no earlier than the second sweep, and a cap
- * derived from no measurement would be a rate the operator never asked for.
- */
+* Advance the ratchet by one sweep. `previous` is `null` on the first sweep of
+* a drain (and after a state the caller cleared), which only ARMS the ratchet:
+* the first growth can be measured no earlier than the second sweep, and a cap
+* derived from no measurement would be a rate the operator never asked for.
+*/
 export declare function stepDrain(previous: DrainState | null, observation: DrainObservation): DrainStep;
 /** Progress for a UI, derived from the persisted state and today's usage. */
 export declare function drainProgressOf(state: DrainState, usedBytes: number, nowMs: number): DrainProgress;

package/dist/builtins/storage-orchestrator/drain-state-store.d.ts

@@ -1,13 +1,23 @@
-import { ISettingsStoreProvider } from '@camstack/types';
-import { DrainState } from './drain-ratchet.js';
-import { DrainStateStore } from './storage-pressure-manager.js';
+/**
+* Durable home for the drain ratchet (D386).
+*
+* The cap MUST survive a restart. Recomputing it from today's usage would
+* restart the ratchet at the top of the disk and silently undo every byte of
+* progress — the operator would see a drain that never finishes and no line
+* saying why. So the cap, the drain start and the observed growth are persisted
+* on every sweep, through the same `settings-store` door the location table
+* uses.
+*/
+import type { ISettingsStoreProvider } from "@camstack/types";
+import type { DrainState } from "./drain-ratchet.js";
+import type { DrainStateStore } from "./storage-pressure-manager.js";
 /** {@link DrainStateStore} on the `settings-store` collection surface. */
 export declare class SqliteDrainStateStore implements DrainStateStore {
-    private readonly store;
-    private declared;
-    constructor(store: ISettingsStoreProvider);
-    private ensureDeclared;
-    load(): Promise<readonly DrainState[]>;
-    save(state: DrainState): Promise<void>;
-    clear(locationId: string): Promise<void>;
+	private readonly store;
+	private declared;
+	constructor(store: ISettingsStoreProvider);
+	private ensureDeclared;
+	load(): Promise<readonly DrainState[]>;
+	save(state: DrainState): Promise<void>;
+	clear(locationId: string): Promise<void>;
 }