@wirecat/cli-core 0.399.0 → 0.400.0

package/dist/entities/store-maintenance.d.ts

@@ -0,0 +1,319 @@
+import * as v from "valibot";
+export declare const storeInfo: v.UnionSchema<[v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<false, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    path: v.StringSchema<undefined>;
+    exists: v.LiteralSchema<true, undefined>;
+    opens: v.LiteralSchema<false, undefined>;
+    error: v.StringSchema<undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<true, undefined>;
+    readonly bytes: v.StrictObjectSchema<{
+        readonly file: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly wal: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly schema: v.StrictObjectSchema<{
+        readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly writable: v.BooleanSchema<undefined>;
+        readonly speaks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly rows: Omit<v.StrictObjectSchema<{
+        readonly accounts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly chats: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly messages: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly attachments: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly identities: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
+        readonly entries: {
+            readonly accounts: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly chats: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly messages: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly attachments: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly identities: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        };
+        readonly "~standard": v.StandardProps<{
+            accounts?: number | undefined;
+            chats?: number | undefined;
+            messages?: number | undefined;
+            attachments?: number | undefined;
+            identities?: number | undefined;
+        }, {
+            accounts?: number | undefined;
+            chats?: number | undefined;
+            messages?: number | undefined;
+            attachments?: number | undefined;
+            identities?: number | undefined;
+        }>;
+        readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+            accounts?: number | undefined;
+            chats?: number | undefined;
+            messages?: number | undefined;
+            attachments?: number | undefined;
+            identities?: number | undefined;
+        }, v.IntegerIssue<number> | v.MinValueIssue<number, 0> | v.NumberIssue | v.StrictObjectIssue>;
+        readonly "~types"?: {
+            readonly input: {
+                accounts?: number | undefined;
+                chats?: number | undefined;
+                messages?: number | undefined;
+                attachments?: number | undefined;
+                identities?: number | undefined;
+            };
+            readonly output: {
+                accounts?: number | undefined;
+                chats?: number | undefined;
+                messages?: number | undefined;
+                attachments?: number | undefined;
+                identities?: number | undefined;
+            };
+            readonly issue: v.IntegerIssue<number> | v.MinValueIssue<number, 0> | v.NumberIssue | v.StrictObjectIssue;
+        } | undefined;
+    };
+    readonly pending_normalization: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly word_index: v.NullableSchema<v.StrictObjectSchema<{
+        readonly watermark: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly filled_through: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly pending_normalization: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly ready: v.BooleanSchema<undefined>;
+        readonly terms_through: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly newest: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly terms_ready: v.BooleanSchema<undefined>;
+        readonly built_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly stem_index: v.NullableSchema<v.StrictObjectSchema<{
+        readonly watermark: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly filled_through: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly pending: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly built: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly wanted: v.StringSchema<undefined>;
+        readonly ready: v.BooleanSchema<undefined>;
+        readonly cause: v.OptionalSchema<v.PicklistSchema<["building", "stemmer_changed", "stemmer_unknown"], undefined>, undefined>;
+        readonly built_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>], undefined>;
+export declare const storeCheck: v.UnionSchema<[v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<false, undefined>;
+    readonly ok: v.LiteralSchema<true, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<true, undefined>;
+    readonly opens: v.LiteralSchema<false, undefined>;
+    readonly error: v.StringSchema<undefined>;
+    readonly ok: v.LiteralSchema<false, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<true, undefined>;
+    readonly opens: v.LiteralSchema<true, undefined>;
+    readonly ok: v.BooleanSchema<undefined>;
+    readonly checks: v.StrictObjectSchema<{
+        readonly schema: v.BooleanSchema<undefined>;
+        readonly integrity: v.BooleanSchema<undefined>;
+        readonly foreign_keys: v.BooleanSchema<undefined>;
+        readonly search_indexes: v.BooleanSchema<undefined>;
+        readonly disk: v.BooleanSchema<undefined>;
+    }, undefined>;
+    readonly schema: v.StrictObjectSchema<{
+        readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly min_compatible: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly writable: v.BooleanSchema<undefined>;
+        readonly speaks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly integrity: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly foreign_key_violations: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly search_indexes: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+    readonly disk: v.StrictObjectSchema<{
+        readonly free: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly needed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly pending_normalization: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly word_index: v.NullableSchema<v.StrictObjectSchema<{
+        readonly watermark: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly filled_through: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly pending_normalization: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly ready: v.BooleanSchema<undefined>;
+        readonly terms_through: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly newest: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly terms_ready: v.BooleanSchema<undefined>;
+        readonly built_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly stem_index: v.NullableSchema<v.StrictObjectSchema<{
+        readonly watermark: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly filled_through: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly pending: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly built: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly wanted: v.StringSchema<undefined>;
+        readonly ready: v.BooleanSchema<undefined>;
+        readonly cause: v.OptionalSchema<v.PicklistSchema<["building", "stemmer_changed", "stemmer_unknown"], undefined>, undefined>;
+        readonly built_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly chats_behind: v.ArraySchema<v.StrictObjectSchema<{
+        readonly provider: v.StringSchema<undefined>;
+        readonly account: v.StringSchema<undefined>;
+        readonly chat: v.StringSchema<undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly newest: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly held: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        readonly refreshed: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+    }, undefined>, undefined>;
+    readonly orphan_pointers: v.ArraySchema<v.StrictObjectSchema<{
+        readonly table: v.StringSchema<undefined>;
+        readonly pointer: v.StringSchema<undefined>;
+        readonly type: v.StringSchema<undefined>;
+        readonly count: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly known: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly conversations: v.ArraySchema<v.StrictObjectSchema<{
+        readonly provider: v.StringSchema<undefined>;
+        readonly account: v.StringSchema<undefined>;
+        readonly chat: v.StringSchema<undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly built_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        readonly rules_version: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly current: v.BooleanSchema<undefined>;
+        readonly stale_agent_links: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    readonly vectors: v.NullableSchema<v.StrictObjectSchema<{
+        readonly models: v.RecordSchema<v.StringSchema<undefined>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly unused: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    readonly not_applicable: v.StrictObjectSchema<{
+        readonly extensions: v.StringSchema<undefined>;
+    }, undefined>;
+}, undefined>], undefined>;
+export declare const storeMigration: v.UnionSchema<[v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<false, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly normalized: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly indexed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly terms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly stemmed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly notes_indexed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<true, undefined>;
+    readonly from: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly to: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>], undefined>;
+export declare const storeReindex: v.UnionSchema<[v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<false, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly normalized: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly indexed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly terms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly stemmed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly notes_indexed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<true, undefined>;
+    readonly file_texts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly involvements: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>], undefined>;
+export declare const storeBackup: v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly from: v.StringSchema<undefined>;
+    readonly bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly schema: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly rows: v.StrictObjectSchema<{
+        readonly chats: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly messages: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly encrypted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+}, undefined>;
+export declare const storeDecrypt: v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly from: v.StringSchema<undefined>;
+    readonly bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export declare const storeRestore: v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly restored_from: v.StringSchema<undefined>;
+    readonly kept_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly schema: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export declare const storeReset: v.UnionSchema<[v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<false, undefined>;
+    readonly reset: v.LiteralSchema<false, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<true, undefined>;
+    readonly reset: v.LiteralSchema<true, undefined>;
+    readonly backup: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly backed_up: v.NullableSchema<v.StrictObjectSchema<{
+        readonly schema: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly rows: Omit<v.StrictObjectSchema<{
+            readonly chats: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly messages: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
+            readonly entries: {
+                readonly chats: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly messages: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            };
+            readonly "~standard": v.StandardProps<{
+                chats?: number | undefined;
+                messages?: number | undefined;
+            }, {
+                chats?: number | undefined;
+                messages?: number | undefined;
+            }>;
+            readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                chats?: number | undefined;
+                messages?: number | undefined;
+            }, v.IntegerIssue<number> | v.MinValueIssue<number, 0> | v.NumberIssue | v.StrictObjectIssue>;
+            readonly "~types"?: {
+                readonly input: {
+                    chats?: number | undefined;
+                    messages?: number | undefined;
+                };
+                readonly output: {
+                    chats?: number | undefined;
+                    messages?: number | undefined;
+                };
+                readonly issue: v.IntegerIssue<number> | v.MinValueIssue<number, 0> | v.NumberIssue | v.StrictObjectIssue;
+            } | undefined;
+        };
+    }, undefined>, undefined>;
+    readonly schema: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>], undefined>;
+export declare const storeRepair: v.UnionSchema<[v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly exists: v.LiteralSchema<false, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly dry_run: v.BooleanSchema<undefined>;
+    readonly repaired: v.ArraySchema<v.StrictObjectSchema<{
+        readonly table: v.StringSchema<undefined>;
+        readonly action: v.PicklistSchema<["created", "columns-added", "rebuilt"], undefined>;
+        readonly columns_added: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly copy: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly rows_in_copy: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly rows_copied: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly only_in_copy: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly dropped_from_copy: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly indexes_created: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly triggers_created: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly mismatches: v.ArraySchema<v.StrictObjectSchema<{
+        readonly table: v.StringSchema<undefined>;
+        readonly what: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly foreign_key_violations: v.ArraySchema<v.StrictObjectSchema<{
+        readonly table: v.StringSchema<undefined>;
+        readonly rows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    readonly copies: v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly rows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+}, undefined>], undefined>;
+export declare const storeCopyRemoval: v.StrictObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly deleted: v.StrictObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly rows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+}, undefined>;

package/dist/entities/store-maintenance.js

@@ -0,0 +1,145 @@
+import * as v from "valibot";
+import { count, text, time } from "./fields.js";
+const absent = v.strictObject({ path: text, exists: v.literal(false) });
+const schema = v.strictObject({ version: count, min_compatible: count, writable: v.boolean(), speaks: count });
+const wordIndex = v.strictObject({
+    watermark: count,
+    filled_through: count,
+    pending_normalization: count,
+    ready: v.boolean(),
+    terms_through: count,
+    newest: count,
+    terms_ready: v.boolean(),
+    built_at: v.nullable(time),
+});
+const stemIndex = v.strictObject({
+    watermark: count,
+    filled_through: count,
+    pending: count,
+    built: v.nullable(text),
+    wanted: text,
+    ready: v.boolean(),
+    cause: v.optional(v.picklist(["building", "stemmer_changed", "stemmer_unknown"])),
+    built_at: v.nullable(time),
+});
+const readFailure = { path: text, exists: v.literal(true), opens: v.literal(false), error: text };
+const rows = v.partial(v.strictObject({ accounts: count, chats: count, messages: count, attachments: count, identities: count }));
+export const storeInfo = v.union([
+    absent,
+    v.strictObject(readFailure),
+    v.strictObject({
+        path: text,
+        exists: v.literal(true),
+        bytes: v.strictObject({ file: count, wal: count }),
+        schema,
+        rows,
+        pending_normalization: v.nullable(count),
+        word_index: v.nullable(wordIndex),
+        stem_index: v.nullable(stemIndex),
+    }),
+]);
+export const storeCheck = v.union([
+    v.strictObject({ ...absent.entries, ok: v.literal(true) }),
+    v.strictObject({ ...readFailure, ok: v.literal(false) }),
+    v.strictObject({
+        path: text,
+        exists: v.literal(true),
+        opens: v.literal(true),
+        ok: v.boolean(),
+        checks: v.strictObject({
+            schema: v.boolean(),
+            integrity: v.boolean(),
+            foreign_keys: v.boolean(),
+            search_indexes: v.boolean(),
+            disk: v.boolean(),
+        }),
+        schema,
+        integrity: v.array(text),
+        foreign_key_violations: count,
+        search_indexes: v.record(text, text),
+        disk: v.strictObject({ free: count, needed: count }),
+        pending_normalization: v.nullable(count),
+        word_index: v.nullable(wordIndex),
+        stem_index: v.nullable(stemIndex),
+        chats_behind: v.array(v.strictObject({
+            provider: text,
+            account: text,
+            chat: text,
+            title: v.nullable(text),
+            newest: time,
+            held: v.nullable(time),
+            refreshed: time,
+        })),
+        orphan_pointers: v.array(v.strictObject({ table: text, pointer: text, type: text, count, known: v.boolean() })),
+        conversations: v.array(v.strictObject({
+            provider: text,
+            account: text,
+            chat: text,
+            title: v.nullable(text),
+            built_at: v.nullable(time),
+            rules_version: v.nullable(count),
+            current: v.boolean(),
+            stale_agent_links: count,
+        })),
+        vectors: v.nullable(v.strictObject({ models: v.record(text, count), unused: count })),
+        not_applicable: v.strictObject({ extensions: text }),
+    }),
+]);
+const indexed = { normalized: count, indexed: count, terms: count, stemmed: count, notes_indexed: count };
+export const storeMigration = v.union([
+    absent,
+    v.strictObject({ path: text, exists: v.literal(true), from: count, to: count, ...indexed }),
+]);
+export const storeReindex = v.union([
+    absent,
+    v.strictObject({ path: text, exists: v.literal(true), ...indexed, file_texts: count, involvements: count }),
+]);
+export const storeBackup = v.strictObject({
+    path: text,
+    from: text,
+    bytes: count,
+    schema: count,
+    rows: v.strictObject({ chats: count, messages: count }),
+    encrypted: v.optional(v.literal(true)),
+});
+export const storeDecrypt = v.strictObject({ path: text, from: text, bytes: count });
+export const storeRestore = v.strictObject({
+    path: text,
+    restored_from: text,
+    kept_at: v.nullable(text),
+    schema: count,
+});
+export const storeReset = v.union([
+    v.strictObject({ ...absent.entries, reset: v.literal(false) }),
+    v.strictObject({
+        path: text,
+        exists: v.literal(true),
+        reset: v.literal(true),
+        backup: v.nullable(text),
+        backed_up: v.nullable(v.strictObject({ schema: count, rows: v.partial(v.strictObject({ chats: count, messages: count })) })),
+        schema: count,
+    }),
+]);
+export const storeRepair = v.union([
+    absent,
+    v.strictObject({
+        path: text,
+        dry_run: v.boolean(),
+        repaired: v.array(v.strictObject({
+            table: text,
+            action: v.picklist(["created", "columns-added", "rebuilt"]),
+            columns_added: v.optional(v.array(text)),
+            copy: v.optional(text),
+            rows_in_copy: v.optional(count),
+            rows_copied: v.optional(count),
+            only_in_copy: v.optional(v.array(text)),
+            dropped_from_copy: v.optional(v.array(text)),
+        })),
+        indexes_created: v.array(text),
+        triggers_created: v.array(text),
+        mismatches: v.array(v.strictObject({ table: text, what: text })),
+        foreign_key_violations: v.array(v.strictObject({ table: text, rows: count })),
+        copies: v.array(v.strictObject({ name: text, rows: count })),
+    }),
+]);
+export const storeCopyRemoval = v.strictObject({ path: text, deleted: v.strictObject({ name: text, rows: count }) });