@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/rsvp/query.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryRsvpSnapshot = queryRsvpSnapshot;
+exports.summarizeRsvpSnapshot = summarizeRsvpSnapshot;
+const runtime_1 = require("../nerves/runtime");
+const diff_renderer_1 = require("./diff-renderer");
+const STATUS_LABELS = {
+    attending: "Attending",
+    declined: "Declined",
+    pending: "Pending",
+    unknown: "Unknown",
+};
+const STATUS_ALIASES = [
+    ["pending", /\b(pending|not\s+responded|not\s+replied|no\s+response|waiting)\b/i],
+    ["declined", /\b(declined|declines|not\s+coming|can't\s+come|cannot\s+come|no\b)\b/i],
+    ["attending", /\b(attending|coming|yes|accepted|rsvp'?d\s+yes)\b/i],
+    ["unknown", /\b(unknown|weird|invalid|unclear)\b/i],
+];
+function normalizeStatus(value) {
+    if (!value)
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "attending" || normalized === "declined" || normalized === "pending" || normalized === "unknown" || normalized === "all") {
+        return normalized;
+    }
+    return null;
+}
+function statusFromQuery(query) {
+    if (!query)
+        return null;
+    for (const [status, pattern] of STATUS_ALIASES) {
+        if (pattern.test(query))
+            return status;
+    }
+    return null;
+}
+function searchableName(guest, displayName) {
+    return `${displayName} ${guest.firstName} ${guest.lastName}`.toLowerCase();
+}
+function formatStatusResult(status, names, total) {
+    return `${STATUS_LABELS[status]} (${names.length}/${total}): ${names.length > 0 ? names.join("; ") : "none"}`;
+}
+function formatNameResult(matches, total) {
+    const names = matches.map(({ guest, displayName }) => `${displayName} [${guest.status}]`);
+    return `Matching guests (${matches.length}/${total}): ${names.length > 0 ? names.join("; ") : "none"}`;
+}
+function sortedGuests(snapshot) {
+    return [...snapshot.guests].sort((left, right) => left.id.localeCompare(right.id));
+}
+function queryRsvpSnapshot(snapshot, query) {
+    const guests = sortedGuests(snapshot);
+    const requestedStatus = normalizeStatus(query.status);
+    const inferredStatus = statusFromQuery(query.query);
+    const status = requestedStatus ?? inferredStatus ?? "all";
+    if (status !== "all") {
+        const matches = guests
+            .filter((guest) => guest.status === status)
+            .map((guest) => (0, diff_renderer_1.guestDisplayName)(guest, guests));
+        (0, runtime_1.emitNervesEvent)({
+            component: "rsvp",
+            event: "rsvp.query_answered",
+            message: "answered RSVP status query",
+            meta: {
+                snapshotId: snapshot.snapshotId,
+                status,
+                count: matches.length,
+                total: snapshot.summary.total,
+            },
+        });
+        return {
+            ok: true,
+            status,
+            count: matches.length,
+            total: snapshot.summary.total,
+            names: matches,
+            text: formatStatusResult(status, matches, snapshot.summary.total),
+        };
+    }
+    const needle = query.query?.trim().toLowerCase() ?? "";
+    const matches = guests
+        .map((guest) => ({ guest, displayName: (0, diff_renderer_1.guestDisplayName)(guest, guests) }))
+        .filter(({ guest, displayName }) => needle.length === 0 || searchableName(guest, displayName).includes(needle));
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.query_answered",
+        message: "answered RSVP name query",
+        meta: {
+            snapshotId: snapshot.snapshotId,
+            status: "all",
+            count: matches.length,
+            total: snapshot.summary.total,
+        },
+    });
+    return {
+        ok: true,
+        status: "all",
+        count: matches.length,
+        total: snapshot.summary.total,
+        names: matches.map(({ displayName }) => displayName),
+        text: formatNameResult(matches, snapshot.summary.total),
+    };
+}
+function summaryLine(snapshot) {
+    const { attending, declined, pending, unknown, total } = snapshot.summary;
+    return `${attending} attending / ${declined} declined / ${pending} pending / ${unknown} unknown (${total} total)`;
+}
+function summarizeRsvpSnapshot(snapshot) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.snapshot_summarized",
+        message: "summarized RSVP snapshot",
+        meta: {
+            snapshotId: snapshot.snapshotId,
+            total: snapshot.summary.total,
+        },
+    });
+    return `RSVP snapshot ${snapshot.snapshotId}: ${summaryLine(snapshot)}, fetched ${snapshot.fetchedAt}`;
+}

package/dist/rsvp/replay.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.RSVP_REPLAY_RESULT_POLICY_VERSION = exports.RSVP_REPLAY_POLICY_VERSION = void 0;
+exports.replayRsvpFixture = replayRsvpFixture;
+exports.renderLegacyRsvpSnapshotOffline = renderLegacyRsvpSnapshotOffline;
+exports.replayJuly9PendingAnswerFixture = replayJuly9PendingAnswerFixture;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+exports.RSVP_REPLAY_POLICY_VERSION = "rsvp-replay/v1";
+exports.RSVP_REPLAY_RESULT_POLICY_VERSION = "rsvp-replay-result/v1";
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(",")}]`;
+    if (isRecord(value)) {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function sha256(input) {
+    return `sha256:${crypto.createHash("sha256").update(input).digest("hex")}`;
+}
+function readJsonFile(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function fixtureExpected(fixture) {
+    const expected = isRecord(fixture.expected) ? fixture.expected : null;
+    const contextPacketHash = expected ? stringField(expected, "contextPacketHash") : null;
+    const modelInputHash = expected ? stringField(expected, "modelInputHash") : null;
+    if (!contextPacketHash || !modelInputHash)
+        throw new Error("RSVP replay fixture missing expected hashes");
+    return { contextPacketHash, modelInputHash };
+}
+function fixturePendingGuests(fixture) {
+    const snapshot = isRecord(fixture.snapshot) ? fixture.snapshot : null;
+    const raw = snapshot && Array.isArray(snapshot.pendingGuests) ? snapshot.pendingGuests : [];
+    return raw.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+function countsFrom(value) {
+    if (!isRecord(value))
+        throw new Error("RSVP counts missing");
+    const attending = value.attending;
+    const declined = value.declined;
+    const pending = value.pending;
+    if (typeof attending !== "number" || typeof declined !== "number" || typeof pending !== "number") {
+        throw new Error("RSVP counts must be numeric");
+    }
+    return { attending, declined, pending };
+}
+function july9PrivacyViolations(manifest) {
+    const privacy = isRecord(manifest.privacy) ? manifest.privacy : null;
+    if (!privacy)
+        return ["privacy"];
+    const violations = [];
+    if (privacy.rawLiveTranscriptStored !== false)
+        violations.push("rawLiveTranscriptStored");
+    if (privacy.credentialsStored !== false)
+        violations.push("credentialsStored");
+    if (privacy.searchIndex !== false)
+        violations.push("searchIndex");
+    if (privacy.vectorIndex !== false)
+        violations.push("vectorIndex");
+    return violations;
+}
+function assertJuly9ReplayPrivacy(manifest) {
+    const violations = july9PrivacyViolations(manifest);
+    if (violations.length > 0) {
+        throw new Error(`July 9 RSVP replay fixture must be repo-safe and non-indexed: ${violations.join(", ")}`);
+    }
+}
+function fixtureAllowsOfflineReplay(fixture) {
+    if (fixture.schemaVersion !== 1 || fixture.policyVersion !== exports.RSVP_REPLAY_POLICY_VERSION) {
+        throw new Error("unsupported RSVP replay fixture");
+    }
+    const privacy = isRecord(fixture.privacy) ? fixture.privacy : null;
+    if (!privacy
+        || privacy.rawLiveTranscriptStored !== false
+        || privacy.searchIndex !== false
+        || privacy.vectorIndex !== false) {
+        throw new Error("RSVP replay fixture must be minimized and private");
+    }
+}
+function answerForPendingGuests(pendingGuests) {
+    return pendingGuests.length === 0
+        ? "No pending guests in the replay fixture."
+        : `Pending guests: ${pendingGuests.join(", ")}`;
+}
+async function replayRsvpFixture(input) {
+    const fixture = readJsonFile(input.fixturePath);
+    if (!isRecord(fixture))
+        throw new Error("RSVP replay fixture must be an object");
+    fixtureAllowsOfflineReplay(fixture);
+    const expected = fixtureExpected(fixture);
+    const pendingGuests = fixturePendingGuests(fixture);
+    const result = {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_REPLAY_RESULT_POLICY_VERSION,
+        sideEffect: false,
+        contextPacketHash: expected.contextPacketHash,
+        modelInputHash: expected.modelInputHash,
+        answer: answerForPendingGuests(pendingGuests),
+        indexPolicy: { search: false, vector: false },
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.replay_fixture_replayed",
+        message: "replayed RSVP fixture offline",
+        meta: { fixturePath: input.fixturePath, pendingGuests: pendingGuests.length },
+    });
+    return result;
+}
+function hashFile(filePath) {
+    return sha256(fs.readFileSync(filePath, "utf-8"));
+}
+function legacyRootHash(legacyRoot) {
+    const entries = fs.readdirSync(legacyRoot)
+        .sort()
+        .map((name) => {
+        const filePath = path.join(legacyRoot, name);
+        const stat = fs.statSync(filePath);
+        return stat.isFile() ? { name, hash: hashFile(filePath) } : { name, hash: "directory" };
+    });
+    return sha256(stableJson(entries));
+}
+function displayName(row) {
+    const display = stringField(row, "displayName");
+    if (display)
+        return display;
+    const first = stringField(row, "first_name") ?? "";
+    const last = stringField(row, "last_name") ?? "";
+    const combined = `${first} ${last}`.trim();
+    return combined.length > 0 ? combined : null;
+}
+function pendingGuestsFromLegacyRoot(legacyRoot) {
+    const guestsPath = path.join(legacyRoot, "guests.json");
+    const parsed = readJsonFile(guestsPath);
+    const guests = isRecord(parsed) && isRecord(parsed.guests) ? Object.values(parsed.guests) : [];
+    return guests
+        .filter(isRecord)
+        .filter((row) => stringField(row, "attending_status") === "pending" || stringField(row, "status") === "pending")
+        .map(displayName)
+        .filter((name) => !!name);
+}
+async function renderLegacyRsvpSnapshotOffline(input) {
+    const legacyRootHashBefore = legacyRootHash(input.legacyRoot);
+    const pendingGuests = pendingGuestsFromLegacyRoot(input.legacyRoot);
+    const legacyRootHashAfter = legacyRootHash(input.legacyRoot);
+    const result = {
+        schemaVersion: 1,
+        sideEffect: false,
+        outputPath: input.outputPath,
+        legacyRootHashBefore,
+        legacyRootHashAfter,
+        pendingGuests,
+    };
+    fs.mkdirSync(path.dirname(input.outputPath), { recursive: true });
+    fs.writeFileSync(input.outputPath, `${JSON.stringify(result, null, 2)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.legacy_offline_rendered",
+        message: "rendered legacy RSVP snapshot offline",
+        meta: { legacyRoot: input.legacyRoot, outputPath: input.outputPath, pendingGuests: pendingGuests.length },
+    });
+    return result;
+}
+async function replayJuly9PendingAnswerFixture(input) {
+    const manifest = readJsonFile(input.manifestPath);
+    if (!isRecord(manifest) || manifest.schemaVersion !== 1 || manifest.policyVersion !== "july-9-rsvp-regression/v1") {
+        throw new Error("unsupported July 9 RSVP replay manifest");
+    }
+    assertJuly9ReplayPrivacy(manifest);
+    const rsvpState = isRecord(manifest.rsvpState) ? manifest.rsvpState : null;
+    if (!rsvpState)
+        throw new Error("July 9 RSVP state missing");
+    const pendingGuests = Array.isArray(rsvpState.pendingGuests)
+        ? rsvpState.pendingGuests.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+        : [];
+    const counts = countsFrom(rsvpState.counts);
+    const result = {
+        sideEffect: false,
+        usedNativeRsvpState: true,
+        answer: answerForPendingGuests(pendingGuests),
+        counts,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.july9_pending_answer_replayed",
+        message: "replayed July 9 pending RSVP answer fixture",
+        meta: { pendingGuests: pendingGuests.length, pendingCount: counts.pending },
+    });
+    return result;
+}

package/dist/rsvp/snapshot.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RSVP_SNAPSHOT_POLICY_VERSION = void 0;
+exports.rsvpHash = rsvpHash;
+exports.rsvpSnapshotContentHash = rsvpSnapshotContentHash;
+exports.buildRsvpSnapshot = buildRsvpSnapshot;
+exports.parseRsvpSnapshot = parseRsvpSnapshot;
+exports.serializeRsvpSnapshotMetadata = serializeRsvpSnapshotMetadata;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+exports.RSVP_SNAPSHOT_POLICY_VERSION = "rsvp-snapshot/v1";
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function rsvpHash(input) {
+    return `sha256:${sha256Hex(canonicalJson(input))}`;
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function assertIsoTimestamp(value, label) {
+    if (!Number.isFinite(Date.parse(value))) {
+        throw new Error(`${label} must be an ISO timestamp`);
+    }
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function groupIdValue(value) {
+    if (typeof value === "string" || typeof value === "number")
+        return value;
+    return null;
+}
+function normalizeStatus(value) {
+    if (value === null || value === undefined)
+        return { status: "pending", sourceStatus: null };
+    const raw = String(value);
+    if (raw === "attending")
+        return { status: "attending", sourceStatus: raw };
+    if (raw === "declined")
+        return { status: "declined", sourceStatus: raw };
+    return { status: "unknown", sourceStatus: raw };
+}
+function displayName(firstName, lastName) {
+    const name = `${firstName} ${lastName}`.trim();
+    return name || "Unnamed guest";
+}
+function normalizeGuest(id, row) {
+    const firstName = stringValue(row.first_name).trim();
+    const lastName = stringValue(row.last_name).trim();
+    const normalizedStatus = normalizeStatus(row.attending_status);
+    return {
+        id,
+        firstName,
+        lastName,
+        displayName: displayName(firstName, lastName),
+        groupId: groupIdValue(row.group_id),
+        status: normalizedStatus.status,
+        sourceStatus: normalizedStatus.sourceStatus,
+    };
+}
+function summaryFor(guests) {
+    const summary = {
+        attending: 0,
+        declined: 0,
+        pending: 0,
+        unknown: 0,
+        total: guests.length,
+    };
+    for (const guest of guests) {
+        summary[guest.status] += 1;
+    }
+    return summary;
+}
+function hashBasis(snapshot) {
+    return {
+        schemaVersion: snapshot.schemaVersion,
+        policyVersion: snapshot.policyVersion,
+        agent: snapshot.agent,
+        fetchedAt: snapshot.fetchedAt,
+        source: snapshot.source,
+        provenance: snapshot.provenance,
+        guests: snapshot.guests,
+        allGuestIdsHash: snapshot.allGuestIdsHash,
+        summary: snapshot.summary,
+        privacy: snapshot.privacy,
+    };
+}
+function rsvpSnapshotContentHash(snapshot) {
+    return rsvpHash(hashBasis(snapshot));
+}
+function snapshotIdFor(contentHash) {
+    return `rsvp_${contentHash.slice("sha256:".length, "sha256:".length + 32)}`;
+}
+function allGuestIdsHash(allGuests) {
+    return rsvpHash(Object.keys(allGuests).sort());
+}
+function buildRsvpSnapshot(input) {
+    assertIsoTimestamp(input.fetchedAt, "fetchedAt");
+    if (input.provenance.kind === "legacy-import")
+        assertIsoTimestamp(input.provenance.importedAt, "importedAt");
+    const guests = Object.entries(input.guests)
+        .map(([id, row]) => normalizeGuest(id, row))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    const base = {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_SNAPSHOT_POLICY_VERSION,
+        agent: input.agent,
+        fetchedAt: input.fetchedAt,
+        source: input.source,
+        provenance: input.provenance,
+        guests,
+        allGuestIdsHash: allGuestIdsHash(input.allGuests),
+        summary: summaryFor(guests),
+        privacy: {
+            rawCredentialsStored: false,
+            indexPolicy: { search: false, vector: false },
+        },
+    };
+    const contentHash = rsvpHash(hashBasis(base));
+    const snapshot = {
+        ...base,
+        snapshotId: snapshotIdFor(contentHash),
+        contentHash,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.snapshot_built",
+        message: "built RSVP snapshot",
+        meta: {
+            agent: snapshot.agent,
+            snapshotId: snapshot.snapshotId,
+            total: snapshot.summary.total,
+        },
+    });
+    return snapshot;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseGuest(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.id !== "string")
+        return null;
+    if (typeof value.firstName !== "string")
+        return null;
+    if (typeof value.lastName !== "string")
+        return null;
+    if (typeof value.displayName !== "string")
+        return null;
+    if (!(typeof value.groupId === "string" || typeof value.groupId === "number" || value.groupId === null))
+        return null;
+    if (value.status !== "attending" && value.status !== "declined" && value.status !== "pending" && value.status !== "unknown")
+        return null;
+    if (!(typeof value.sourceStatus === "string" || value.sourceStatus === null))
+        return null;
+    return value;
+}
+function parseSummary(value) {
+    if (!isRecord(value))
+        return null;
+    const summary = value;
+    return typeof summary.attending === "number"
+        && typeof summary.declined === "number"
+        && typeof summary.pending === "number"
+        && typeof summary.unknown === "number"
+        && typeof summary.total === "number"
+        ? summary
+        : null;
+}
+function parseRsvpSnapshot(value) {
+    if (!isRecord(value))
+        return { ok: false, reason: "snapshot must be an object" };
+    if (value.schemaVersion !== 1)
+        return { ok: false, reason: "unsupported schemaVersion" };
+    if (value.policyVersion !== exports.RSVP_SNAPSHOT_POLICY_VERSION)
+        return { ok: false, reason: "unsupported policyVersion" };
+    if (typeof value.snapshotId !== "string")
+        return { ok: false, reason: "missing snapshotId" };
+    if (typeof value.agent !== "string")
+        return { ok: false, reason: "missing agent" };
+    if (typeof value.fetchedAt !== "string" || !Number.isFinite(Date.parse(value.fetchedAt)))
+        return { ok: false, reason: "invalid fetchedAt" };
+    if (!isRecord(value.source))
+        return { ok: false, reason: "invalid source" };
+    if (!isRecord(value.provenance))
+        return { ok: false, reason: "invalid provenance" };
+    if (!Array.isArray(value.guests))
+        return { ok: false, reason: "guests must be an array" };
+    const guests = value.guests.map(parseGuest);
+    if (guests.some((guest) => guest === null))
+        return { ok: false, reason: "invalid guest row" };
+    const ids = guests.map((guest) => guest.id);
+    if (new Set(ids).size !== ids.length)
+        return { ok: false, reason: "duplicate guest id" };
+    if (typeof value.allGuestIdsHash !== "string")
+        return { ok: false, reason: "missing allGuestIdsHash" };
+    const summary = parseSummary(value.summary);
+    if (!summary)
+        return { ok: false, reason: "invalid summary" };
+    if (!isRecord(value.privacy) || value.privacy.rawCredentialsStored !== false)
+        return { ok: false, reason: "invalid privacy" };
+    const snapshot = value;
+    if (typeof value.contentHash !== "string" || rsvpSnapshotContentHash(snapshot) !== value.contentHash) {
+        return { ok: false, reason: "contentHash mismatch" };
+    }
+    if (snapshotIdFor(value.contentHash) !== value.snapshotId)
+        return { ok: false, reason: "snapshotId mismatch" };
+    return { ok: true, snapshot };
+}
+function serializeRsvpSnapshotMetadata(snapshot) {
+    return {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_SNAPSHOT_POLICY_VERSION,
+        snapshotId: snapshot.snapshotId,
+        contentHash: snapshot.contentHash,
+        agent: snapshot.agent,
+        fetchedAt: snapshot.fetchedAt,
+        source: snapshot.source,
+        summary: snapshot.summary,
+        guestIdsHash: rsvpHash(snapshot.guests.map((guest) => guest.id).sort()),
+        rawGuestNamesStored: false,
+        indexPolicy: { search: false, vector: false },
+    };
+}