@ouro.bot/cli 0.1.0-alpha.696 → 0.1.0-alpha.698

package/dist/rsvp/outbound-state.js

@@ -0,0 +1,254 @@
+"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_OUTBOUND_STATE_POLICY_VERSION = void 0;
+exports.readRsvpOutboundState = readRsvpOutboundState;
+exports.writeRsvpBaseline = writeRsvpBaseline;
+exports.decideRsvpOutboundReport = decideRsvpOutboundReport;
+exports.recordRsvpOutboundAttempt = recordRsvpOutboundAttempt;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+exports.RSVP_OUTBOUND_STATE_POLICY_VERSION = "rsvp-outbound-state/v1";
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function hashString(input) {
+    return `sha256:${sha256Hex(input)}`;
+}
+function rsvpOutboundStatePath(agentRoot) {
+    return path.join(agentRoot, "state", "rsvp", "outbound-state.json");
+}
+function emptyState(now) {
+    return {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+        updatedAt: now,
+        pendingReports: [],
+    };
+}
+function nowIso(input) {
+    return input ?? new Date().toISOString();
+}
+function reportHash(reportText) {
+    return hashString(reportText.trim().replace(/\s+/g, " "));
+}
+function idempotencyKeyFor(snapshot, reportText) {
+    return [
+        "rsvp-report",
+        snapshot.agent,
+        snapshot.source.weddingId,
+        snapshot.source.eventId,
+        snapshot.snapshotId,
+        reportHash(reportText).slice("sha256:".length, "sha256:".length + 16),
+    ].join(":");
+}
+function isBaseline(value) {
+    const row = value;
+    return !!row
+        && typeof row.snapshotId === "string"
+        && typeof row.contentHash === "string"
+        && typeof row.recordedAt === "string"
+        && typeof row.reason === "string";
+}
+function isPending(value) {
+    const row = value;
+    return !!row
+        && typeof row.snapshotId === "string"
+        && typeof row.contentHash === "string"
+        && typeof row.reportHash === "string"
+        && typeof row.reportLength === "number"
+        && typeof row.idempotencyKey === "string"
+        && typeof row.bluebubblesRecordId === "string"
+        && typeof row.status === "string"
+        && typeof row.recordedAt === "string"
+        && typeof row.updatedAt === "string"
+        && row.contentStored === false;
+}
+function isState(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && row.policyVersion === exports.RSVP_OUTBOUND_STATE_POLICY_VERSION
+        && typeof row.updatedAt === "string"
+        && (row.baseline === undefined || isBaseline(row.baseline))
+        && Array.isArray(row.pendingReports);
+}
+function readRsvpOutboundState(agentRoot) {
+    const filePath = rsvpOutboundStatePath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return emptyState(new Date().toISOString());
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (!isState(parsed))
+            return emptyState(new Date().toISOString());
+        return {
+            schemaVersion: 1,
+            policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+            updatedAt: parsed.updatedAt,
+            ...(parsed.baseline ? { baseline: parsed.baseline } : {}),
+            pendingReports: parsed.pendingReports.filter(isPending),
+        };
+    }
+    catch {
+        return emptyState(new Date().toISOString());
+    }
+}
+function writeState(agentRoot, state) {
+    const filePath = rsvpOutboundStatePath(agentRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+    fs.renameSync(tmp, filePath);
+    return state;
+}
+function writeRsvpBaseline(input) {
+    const current = readRsvpOutboundState(input.agentRoot);
+    const state = writeState(input.agentRoot, {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+        updatedAt: input.recordedAt,
+        baseline: {
+            snapshotId: input.snapshot.snapshotId,
+            contentHash: input.snapshot.contentHash,
+            recordedAt: input.recordedAt,
+            reason: input.reason,
+        },
+        pendingReports: current.pendingReports.filter((entry) => entry.snapshotId !== input.snapshot.snapshotId),
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_baseline_written",
+        message: "wrote RSVP outbound baseline",
+        meta: { snapshotId: input.snapshot.snapshotId, reason: input.reason },
+    });
+    return state;
+}
+function decideRsvpOutboundReport(input) {
+    const state = readRsvpOutboundState(input.agentRoot);
+    const idempotencyKey = idempotencyKeyFor(input.currentSnapshot, input.reportText);
+    const currentSnapshotId = input.currentSnapshot.snapshotId;
+    const report = reportHash(input.reportText);
+    if (state.baseline?.snapshotId === currentSnapshotId
+        && state.baseline.contentHash === input.currentSnapshot.contentHash) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "rsvp",
+            event: "rsvp.outbound_decision",
+            message: "decided RSVP report outbound action",
+            meta: { action: "skip", snapshotId: currentSnapshotId },
+        });
+        return {
+            action: "skip",
+            reason: "baseline-current",
+            currentSnapshotId,
+            idempotencyKey,
+            reportText: input.reportText,
+        };
+    }
+    const existingPending = state.pendingReports.find((entry) => entry.snapshotId === currentSnapshotId && entry.reportHash === report);
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_decision",
+        message: "decided RSVP report outbound action",
+        meta: { action: "send", snapshotId: currentSnapshotId, existingPending: Boolean(existingPending), now: nowIso(input.now) },
+    });
+    return {
+        action: "send",
+        currentSnapshotId,
+        idempotencyKey,
+        reportText: input.reportText,
+        ...(existingPending ? { existingPending } : {}),
+    };
+}
+function isAdvanceStatus(status) {
+    return status === "accepted" || status === "enqueued" || status === "local-visible" || status === "delivered";
+}
+function pendingReportFor(input) {
+    const normalized = input.reportText.trim().replace(/\s+/g, " ");
+    return {
+        snapshotId: input.currentSnapshot.snapshotId,
+        contentHash: input.currentSnapshot.contentHash,
+        reportHash: reportHash(input.reportText),
+        reportLength: normalized.length,
+        idempotencyKey: idempotencyKeyFor(input.currentSnapshot, input.reportText),
+        bluebubblesRecordId: input.bluebubblesRecord.recordId,
+        status: input.bluebubblesRecord.status,
+        ...(input.bluebubblesRecord.tempGuid?.trim() ? { tempGuid: input.bluebubblesRecord.tempGuid.trim() } : {}),
+        ...(input.bluebubblesRecord.messageGuid?.trim() ? { messageGuid: input.bluebubblesRecord.messageGuid.trim() } : {}),
+        recordedAt: input.recordedAt,
+        updatedAt: input.recordedAt,
+        contentStored: false,
+    };
+}
+function recordRsvpOutboundAttempt(input) {
+    const current = readRsvpOutboundState(input.agentRoot);
+    const pending = pendingReportFor(input);
+    const remainingPending = current.pendingReports.filter((entry) => entry.snapshotId !== pending.snapshotId || entry.reportHash !== pending.reportHash);
+    const state = isAdvanceStatus(input.bluebubblesRecord.status)
+        ? writeState(input.agentRoot, {
+            schemaVersion: 1,
+            policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+            updatedAt: input.recordedAt,
+            baseline: {
+                snapshotId: input.currentSnapshot.snapshotId,
+                contentHash: input.currentSnapshot.contentHash,
+                recordedAt: input.recordedAt,
+                reason: "bluebubbles-outbound-accepted",
+                bluebubblesRecordId: input.bluebubblesRecord.recordId,
+                advancedBy: input.bluebubblesRecord.status,
+            },
+            pendingReports: remainingPending,
+        })
+        : writeState(input.agentRoot, {
+            schemaVersion: 1,
+            policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+            updatedAt: input.recordedAt,
+            ...(current.baseline ? { baseline: current.baseline } : {}),
+            pendingReports: [...remainingPending, pending],
+        });
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_attempt_recorded",
+        message: "recorded RSVP outbound attempt",
+        meta: {
+            snapshotId: input.currentSnapshot.snapshotId,
+            bluebubblesRecordId: input.bluebubblesRecord.recordId,
+            status: input.bluebubblesRecord.status,
+            baselineAdvanced: isAdvanceStatus(input.bluebubblesRecord.status),
+        },
+    });
+    return state;
+}

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;
+}