@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.637

package/dist/mailroom/reader.js

@@ -0,0 +1,233 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMailroomConfig = parseMailroomConfig;
+exports.readMailroomRegistry = readMailroomRegistry;
+exports.writeMailroomRegistry = writeMailroomRegistry;
+exports.resolveMailroomReader = resolveMailroomReader;
+exports.resolveMailroomReaderWithRefresh = resolveMailroomReaderWithRefresh;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const storage_blob_1 = require("@azure/storage-blob");
+const identity_1 = require("@azure/identity");
+const runtime_1 = require("../nerves/runtime");
+const identity_2 = require("../heart/identity");
+const runtime_credentials_1 = require("../heart/runtime-credentials");
+const blob_store_1 = require("./blob-store");
+const file_store_1 = require("./file-store");
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function textField(value, key) {
+    const raw = value[key];
+    return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
+}
+function numberField(value, key) {
+    const raw = value[key];
+    return typeof raw === "number" && Number.isFinite(raw) ? raw : undefined;
+}
+function parseMailroomConfig(value) {
+    if (!isRecord(value))
+        return null;
+    const mailboxAddress = textField(value, "mailboxAddress");
+    if (!mailboxAddress)
+        return null;
+    if (!isRecord(value.privateKeys))
+        return null;
+    const privateKeys = Object.fromEntries(Object.entries(value.privateKeys).filter((entry) => {
+        return typeof entry[0] === "string" && typeof entry[1] === "string" && entry[1].trim().length > 0;
+    }));
+    if (Object.keys(privateKeys).length === 0)
+        return null;
+    const registryPath = textField(value, "registryPath");
+    const storePath = textField(value, "storePath");
+    const azureAccountUrl = textField(value, "azureAccountUrl");
+    const azureContainer = textField(value, "azureContainer");
+    const registryAzureAccountUrl = textField(value, "registryAzureAccountUrl");
+    const registryContainer = textField(value, "registryContainer");
+    const registryBlob = textField(value, "registryBlob");
+    const azureManagedIdentityClientId = textField(value, "azureManagedIdentityClientId");
+    const smtpPort = numberField(value, "smtpPort");
+    const httpPort = numberField(value, "httpPort");
+    const host = textField(value, "host");
+    const attentionIntervalMs = numberField(value, "attentionIntervalMs");
+    const outbound = isRecord(value.outbound) ? { ...value.outbound } : undefined;
+    const autonomousSendPolicy = isRecord(value.autonomousSendPolicy)
+        ? { ...value.autonomousSendPolicy }
+        : undefined;
+    return {
+        mailboxAddress,
+        ...(registryPath ? { registryPath } : {}),
+        ...(storePath ? { storePath } : {}),
+        ...(azureAccountUrl ? { azureAccountUrl } : {}),
+        ...(azureContainer ? { azureContainer } : {}),
+        ...(registryAzureAccountUrl ? { registryAzureAccountUrl } : {}),
+        ...(registryContainer ? { registryContainer } : {}),
+        ...(registryBlob ? { registryBlob } : {}),
+        ...(azureManagedIdentityClientId ? { azureManagedIdentityClientId } : {}),
+        ...(smtpPort !== undefined ? { smtpPort } : {}),
+        ...(httpPort !== undefined ? { httpPort } : {}),
+        ...(host ? { host } : {}),
+        ...(attentionIntervalMs !== undefined ? { attentionIntervalMs } : {}),
+        ...(outbound ? { outbound } : {}),
+        ...(autonomousSendPolicy ? { autonomousSendPolicy } : {}),
+        privateKeys,
+    };
+}
+function createBlobCredential(config) {
+    return config.azureManagedIdentityClientId
+        ? new identity_1.DefaultAzureCredential({ managedIdentityClientId: config.azureManagedIdentityClientId })
+        : new identity_1.DefaultAzureCredential();
+}
+function createMailroomStore(config, agentName) {
+    if (config.azureAccountUrl) {
+        const containerName = config.azureContainer ?? "mailroom";
+        return {
+            store: new blob_store_1.AzureBlobMailroomStore({
+                serviceClient: new storage_blob_1.BlobServiceClient(config.azureAccountUrl, createBlobCredential(config)),
+                containerName,
+                mailSearchCache: {
+                    cacheDirForAgent: (agentId) => path.join((0, identity_2.getAgentRoot)(agentId), "state", "mail-search"),
+                },
+            }),
+            storeKind: "azure-blob",
+            storeLabel: `${config.azureAccountUrl}/${containerName}`,
+        };
+    }
+    const storePath = config.storePath ?? (0, identity_2.getAgentMailroomRoot)(agentName);
+    return {
+        store: new file_store_1.FileMailroomStore({ rootDir: storePath, migrateAgentId: agentName }),
+        storeKind: "file",
+        storeLabel: storePath,
+    };
+}
+async function readMailroomRegistry(config) {
+    if (config.registryPath) {
+        return JSON.parse(fs.readFileSync(config.registryPath, "utf-8"));
+    }
+    const registryAzureAccountUrl = config.registryAzureAccountUrl ?? config.azureAccountUrl;
+    const registryContainer = config.registryContainer ?? config.azureContainer ?? "mailroom";
+    const registryBlob = config.registryBlob;
+    if (!registryAzureAccountUrl || !registryBlob) {
+        throw new Error("mailroom config is missing registryPath or hosted registry coordinates");
+    }
+    const serviceClient = new storage_blob_1.BlobServiceClient(registryAzureAccountUrl, createBlobCredential(config));
+    const blobClient = serviceClient.getContainerClient(registryContainer).getBlockBlobClient(registryBlob);
+    if (!await blobClient.exists()) {
+        throw new Error(`mailroom registry blob not found: ${registryAzureAccountUrl}/${registryContainer}/${registryBlob}`);
+    }
+    return JSON.parse((await blobClient.downloadToBuffer()).toString("utf-8"));
+}
+async function writeMailroomRegistry(config, registry) {
+    const serialized = `${JSON.stringify(registry, null, 2)}\n`;
+    if (config.registryPath) {
+        fs.mkdirSync(path.dirname(config.registryPath), { recursive: true });
+        fs.writeFileSync(config.registryPath, serialized, "utf-8");
+        return;
+    }
+    const registryAzureAccountUrl = config.registryAzureAccountUrl ?? config.azureAccountUrl;
+    const registryContainer = config.registryContainer ?? config.azureContainer ?? "mailroom";
+    const registryBlob = config.registryBlob;
+    if (!registryAzureAccountUrl || !registryBlob) {
+        throw new Error("mailroom config is missing registryPath or hosted registry coordinates");
+    }
+    const serviceClient = new storage_blob_1.BlobServiceClient(registryAzureAccountUrl, createBlobCredential(config));
+    const blobClient = serviceClient.getContainerClient(registryContainer).getBlockBlobClient(registryBlob);
+    await blobClient.upload(serialized, Buffer.byteLength(serialized), {
+        blobHTTPHeaders: {
+            blobContentType: "application/json; charset=utf-8",
+        },
+    });
+}
+function resolveMailroomReader(agentName = (0, identity_2.getAgentName)()) {
+    const runtime = (0, runtime_credentials_1.readRuntimeCredentialConfig)(agentName);
+    if (!runtime.ok) {
+        const result = {
+            ok: false,
+            agentName,
+            reason: "auth-required",
+            error: `AUTH_REQUIRED:mailroom -- Mail is not available because ${runtime.itemPath} is ${runtime.reason}. Agent-runnable repair after vault unlock: 'ouro connect mail --agent ${agentName}'.`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_reader_resolved",
+            message: "mailroom reader resolved",
+            meta: { agentName, status: result.reason },
+        });
+        return result;
+    }
+    const config = parseMailroomConfig(runtime.config.mailroom);
+    if (!config) {
+        const result = {
+            ok: false,
+            agentName,
+            reason: "misconfigured",
+            error: `AUTH_REQUIRED:mailroom -- Missing mailroom mailbox/private key config in vault runtime/config for ${agentName}.`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_reader_resolved",
+            message: "mailroom reader resolved",
+            meta: { agentName, status: result.reason },
+        });
+        return result;
+    }
+    const store = createMailroomStore(config, agentName);
+    const result = {
+        ok: true,
+        agentName,
+        config,
+        store: store.store,
+        storeKind: store.storeKind,
+        storeLabel: store.storeLabel,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_reader_resolved",
+        message: "mailroom reader resolved",
+        meta: { agentName, status: "ready", mailboxAddress: config.mailboxAddress, storeKind: store.storeKind },
+    });
+    return result;
+}
+async function resolveMailroomReaderWithRefresh(agentName = (0, identity_2.getAgentName)()) {
+    const resolved = resolveMailroomReader(agentName);
+    if (resolved.ok
+        || resolved.reason !== "auth-required"
+        || (!resolved.error.includes(" is unavailable") && !resolved.error.includes(" is missing"))) {
+        return resolved;
+    }
+    await (0, runtime_credentials_1.refreshRuntimeCredentialConfig)(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
+    return resolveMailroomReader(agentName);
+}

package/dist/mailroom/search-cache.js

@@ -0,0 +1,334 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAIL_SEARCH_TEXT_PROJECTION_VERSION = void 0;
+exports.buildMailSearchCacheDocument = buildMailSearchCacheDocument;
+exports.upsertMailSearchCacheDocument = upsertMailSearchCacheDocument;
+exports.syncMailSearchCacheMetadata = syncMailSearchCacheMetadata;
+exports.searchMailSearchCache = searchMailSearchCache;
+exports.snapshotMailSearchCacheForFilters = snapshotMailSearchCacheForFilters;
+exports.snapshotMailSearchCache = snapshotMailSearchCache;
+exports.readMailSearchCoverageRecord = readMailSearchCoverageRecord;
+exports.writeMailSearchCoverageRecord = writeMailSearchCoverageRecord;
+exports.resetMailSearchCacheForTests = resetMailSearchCacheForTests;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const core_1 = require("./core");
+const search_relevance_1 = require("./search-relevance");
+const SEARCH_TEXT_EXCERPT_LIMIT = 16_384;
+exports.MAIL_SEARCH_TEXT_PROJECTION_VERSION = 2;
+const cacheStates = new Map();
+function defaultCacheDir(agentId) {
+    return path.join((0, identity_1.getAgentRoot)(agentId), "state", "mail-search");
+}
+function cacheDir(agentId, options = {}) {
+    const resolve = options.cacheDirForAgent ?? defaultCacheDir;
+    return resolve(agentId);
+}
+function cachePath(agentId, messageId, options) {
+    return path.join(cacheDir(agentId, options), `${messageId}.json`);
+}
+function coverageDir(agentId, options) {
+    return path.join(cacheDir(agentId, options), "coverage");
+}
+function normalizedCoverageKey(key) {
+    return {
+        agentId: key.agentId,
+        storeKind: key.storeKind,
+        ...(key.placement ? { placement: key.placement } : {}),
+        ...(key.compartmentKind ? { compartmentKind: key.compartmentKind } : {}),
+        ...(key.source ? { source: key.source.toLowerCase() } : {}),
+    };
+}
+function coveragePath(key, options) {
+    const normalized = normalizedCoverageKey(key);
+    const encoded = Buffer.from(JSON.stringify(normalized)).toString("base64url");
+    return path.join(coverageDir(normalized.agentId, options), `${encoded}.json`);
+}
+function normalizeSearchText(privateEnvelope) {
+    const readableText = (0, core_1.privateMailEnvelopeReadableText)(privateEnvelope);
+    return [
+        privateEnvelope.subject,
+        privateEnvelope.snippet,
+        readableText.slice(0, SEARCH_TEXT_EXCERPT_LIMIT),
+        privateEnvelope.from.join(" "),
+    ].join("\n").toLowerCase();
+}
+function readJsonDocument(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function cacheState(agentId, options) {
+    const key = `${agentId}:${cacheDir(agentId, options)}`;
+    let state = cacheStates.get(key);
+    if (state)
+        return state;
+    state = { loaded: false, docs: new Map() };
+    cacheStates.set(key, state);
+    return state;
+}
+function loadCache(agentId, options) {
+    const state = cacheState(agentId, options);
+    if (state.loaded)
+        return state.docs;
+    state.loaded = true;
+    const dir = cacheDir(agentId, options);
+    if (!fs.existsSync(dir))
+        return state.docs;
+    for (const entry of fs.readdirSync(dir)) {
+        if (!entry.endsWith(".json"))
+            continue;
+        const document = readJsonDocument(path.join(dir, entry));
+        if (!document || document.agentId !== agentId)
+            continue;
+        state.docs.set(document.messageId, document);
+    }
+    return state.docs;
+}
+function buildMailSearchCacheDocument(message, privateEnvelope) {
+    const readableText = (0, core_1.privateMailEnvelopeReadableText)(privateEnvelope);
+    return {
+        schemaVersion: 1,
+        messageId: message.id,
+        agentId: message.agentId,
+        receivedAt: message.receivedAt,
+        placement: message.placement,
+        compartmentKind: message.compartmentKind,
+        ...(message.ownerEmail ? { ownerEmail: message.ownerEmail } : {}),
+        ...(message.source ? { source: message.source } : {}),
+        from: [...privateEnvelope.from],
+        subject: privateEnvelope.subject,
+        snippet: privateEnvelope.snippet,
+        textExcerpt: readableText.slice(0, SEARCH_TEXT_EXCERPT_LIMIT),
+        untrustedContentWarning: privateEnvelope.untrustedContentWarning,
+        searchText: normalizeSearchText(privateEnvelope),
+        textProjectionVersion: exports.MAIL_SEARCH_TEXT_PROJECTION_VERSION,
+        attachmentCount: privateEnvelope.attachments.length,
+    };
+}
+function upsertMailSearchCacheDocument(message, privateEnvelope, options) {
+    const document = buildMailSearchCacheDocument(message, privateEnvelope);
+    const dir = cacheDir(message.agentId, options);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(cachePath(message.agentId, message.id, options), `${JSON.stringify(document)}\n`, "utf-8");
+    const state = cacheState(message.agentId, options);
+    if (state.loaded)
+        state.docs.set(document.messageId, document);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_search_cache_upserted",
+        message: "mail search cache entry written",
+        meta: {
+            agentId: message.agentId,
+            messageId: document.messageId,
+            placement: document.placement,
+            compartmentKind: document.compartmentKind,
+        },
+    });
+    return document;
+}
+function syncMailSearchCacheMetadata(message, options) {
+    const existing = readJsonDocument(cachePath(message.agentId, message.id, options));
+    if (!existing)
+        return;
+    const updated = {
+        ...existing,
+        receivedAt: message.receivedAt,
+        placement: message.placement,
+        compartmentKind: message.compartmentKind,
+        ...(message.ownerEmail ? { ownerEmail: message.ownerEmail } : {}),
+        ...(message.source ? { source: message.source } : {}),
+    };
+    fs.writeFileSync(cachePath(message.agentId, message.id, options), `${JSON.stringify(updated)}\n`, "utf-8");
+    const state = cacheState(message.agentId, options);
+    if (state.loaded)
+        state.docs.set(updated.messageId, updated);
+}
+function sourceMatches(source, filter) {
+    if (!filter)
+        return true;
+    if (!source)
+        return false;
+    return source.toLowerCase() === filter.toLowerCase();
+}
+function documentMatchesFilters(document, filters) {
+    const queryTerms = filters.queryTerms ?? [];
+    return (filters.placement ? document.placement === filters.placement : true)
+        && (filters.compartmentKind ? document.compartmentKind === filters.compartmentKind : true)
+        && sourceMatches(document.source, filters.source)
+        && (queryTerms.length
+            ? queryTerms.some((term) => document.searchText.includes(term))
+            : true);
+}
+function* readCacheDocuments(agentId, options) {
+    const dir = cacheDir(agentId, options);
+    if (!fs.existsSync(dir))
+        return;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith(".json"))
+            continue;
+        const document = readJsonDocument(path.join(dir, entry.name));
+        if (!document || document.agentId !== agentId)
+            continue;
+        yield document;
+    }
+}
+function insertLimitedMatch(matches, candidate, filters) {
+    matches.push(candidate);
+    const queryTerms = filters.queryTerms ?? [];
+    if (queryTerms.length > 0) {
+        matches.sort((left, right) => (0, search_relevance_1.compareByRelevanceThenRecency)({ document: left, relevance: (0, search_relevance_1.scoreMailSearchDocument)(left, queryTerms) }, { document: right, relevance: (0, search_relevance_1.scoreMailSearchDocument)(right, queryTerms) }));
+    }
+    else {
+        matches.sort((left, right) => right.receivedAt.localeCompare(left.receivedAt));
+    }
+    if (matches.length > filters.limit)
+        matches.length = filters.limit;
+}
+function streamSearchMailSearchCache(filters, options) {
+    const matches = [];
+    for (const document of readCacheDocuments(filters.agentId, options)) {
+        if (!documentMatchesFilters(document, filters))
+            continue;
+        insertLimitedMatch(matches, document, filters);
+    }
+    return matches;
+}
+function searchMailSearchCache(filters, options) {
+    if (typeof filters.limit === "number" && !cacheState(filters.agentId, options).loaded) {
+        return streamSearchMailSearchCache({ ...filters, limit: filters.limit }, options);
+    }
+    const queryTerms = filters.queryTerms ?? [];
+    const docs = [...loadCache(filters.agentId, options).values()]
+        .filter((document) => documentMatchesFilters(document, filters));
+    let ordered;
+    if (queryTerms.length > 0) {
+        ordered = docs
+            .map((document) => ({ document, relevance: (0, search_relevance_1.scoreMailSearchDocument)(document, queryTerms) }))
+            .sort(search_relevance_1.compareByRelevanceThenRecency)
+            .map((entry) => entry.document);
+    }
+    else {
+        ordered = docs.sort((left, right) => right.receivedAt.localeCompare(left.receivedAt));
+    }
+    return typeof filters.limit === "number" ? ordered.slice(0, filters.limit) : ordered;
+}
+function snapshotMailSearchCacheForFilters(filters, options) {
+    let totalDocuments = 0;
+    let currentProjectionDocuments = 0;
+    let oldestReceivedAt;
+    let newestReceivedAt;
+    for (const document of readCacheDocuments(filters.agentId, options)) {
+        if (!documentMatchesFilters(document, filters))
+            continue;
+        totalDocuments += 1;
+        if (document.textProjectionVersion === exports.MAIL_SEARCH_TEXT_PROJECTION_VERSION) {
+            currentProjectionDocuments += 1;
+        }
+        if (!oldestReceivedAt || document.receivedAt < oldestReceivedAt)
+            oldestReceivedAt = document.receivedAt;
+        if (!newestReceivedAt || document.receivedAt > newestReceivedAt)
+            newestReceivedAt = document.receivedAt;
+    }
+    return {
+        totalDocuments,
+        currentProjectionDocuments,
+        ...(oldestReceivedAt ? { oldestReceivedAt } : {}),
+        ...(newestReceivedAt ? { newestReceivedAt } : {}),
+    };
+}
+function snapshotMailSearchCache(agentId, options) {
+    const dir = cacheDir(agentId, options);
+    if (!fs.existsSync(dir))
+        return { totalDocuments: 0 };
+    let total = 0;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isFile() && entry.name.endsWith(".json"))
+            total += 1;
+    }
+    return { totalDocuments: total };
+}
+function readMailSearchCoverageRecord(key, options) {
+    const document = readJsonDocument(coveragePath(key, options));
+    if (!document || document.schemaVersion !== 1 || document.agentId !== key.agentId)
+        return null;
+    const normalized = normalizedCoverageKey(key);
+    const stored = normalizedCoverageKey(document);
+    if (JSON.stringify(stored) !== JSON.stringify(normalized))
+        return null;
+    return document;
+}
+function writeMailSearchCoverageRecord(record, options) {
+    const normalized = normalizedCoverageKey(record);
+    const document = {
+        schemaVersion: 1,
+        ...normalized,
+        indexedAt: record.indexedAt,
+        visibleMessageCount: record.visibleMessageCount,
+        cachedMessageCount: record.cachedMessageCount,
+        decryptableMessageCount: record.decryptableMessageCount,
+        skippedMessageCount: record.skippedMessageCount,
+        ...(record.messageIndexFingerprint ? { messageIndexFingerprint: record.messageIndexFingerprint } : {}),
+        textProjectionVersion: record.textProjectionVersion,
+        ...(record.oldestReceivedAt ? { oldestReceivedAt: record.oldestReceivedAt } : {}),
+        ...(record.newestReceivedAt ? { newestReceivedAt: record.newestReceivedAt } : {}),
+    };
+    fs.mkdirSync(coverageDir(document.agentId, options), { recursive: true });
+    fs.writeFileSync(coveragePath(document, options), `${JSON.stringify(document)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_search_coverage_written",
+        message: "mail search coverage record written",
+        meta: {
+            agentId: document.agentId,
+            placement: document.placement ?? null,
+            compartmentKind: document.compartmentKind ?? null,
+            source: document.source ?? null,
+            storeKind: document.storeKind,
+            visibleMessageCount: document.visibleMessageCount,
+            decryptableMessageCount: document.decryptableMessageCount,
+        },
+    });
+    return document;
+}
+function resetMailSearchCacheForTests() {
+    cacheStates.clear();
+}