@pasko70/pibo 2.5.2 → 3.0.0

package/dist/apps/chat/chat-files.js

@@ -1,9 +1,10 @@
-import { createReadStream, existsSync, mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, constants, createReadStream, existsSync, fstatSync, mkdirSync, openSync, readSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, extname, isAbsolute, relative, resolve } from "node:path";
 import { Readable } from "node:stream";
 import { piboHomePath } from "../../core/pibo-home.js";
 import { protectPrivateDirectorySync, protectPrivateFileSync } from "../../core/private-path.js";
 import { PiboWebHttpError } from "../../web/http.js";
+import { imageMimeTypeFromBytes, TRACE_IMAGE_MAX_DECODED_BYTES } from "./trace-v2.js";
 export const CHAT_UPLOAD_DIR = piboHomePath("uploads");
 const CHAT_FILE_ATTACHMENT_LIMIT = 10;
 export function prepareChatFileAttachments(input) {
@@ -46,16 +47,31 @@ export async function saveUploadedChatFiles(request) {
 export function resolveDownloadPath(path, basePath) {
     return isAbsolute(path) ? resolve(path) : resolve(basePath, path);
 }
-export function responseChatFileDownload(absolutePath) {
-    let stats;
+export function resolveImagePreviewPath(path, basePath) {
+    return resolveImagePreviewPathWithinRoots(resolveDownloadPath(path, basePath), [basePath, CHAT_UPLOAD_DIR]);
+}
+export function resolveImagePreviewPathWithinRoots(path, allowedRootPaths) {
+    let canonicalPath;
     try {
-        stats = statSync(absolutePath);
+        canonicalPath = realpathSync(path);
     }
     catch {
-        throw new PiboWebHttpError("File not found: " + absolutePath, 404);
+        throw new PiboWebHttpError("Image preview file was not found", 404);
     }
-    if (!stats.isFile())
-        throw new PiboWebHttpError("Path is not a file: " + absolutePath, 400);
+    const allowedRoots = [];
+    for (const allowedRoot of allowedRootPaths) {
+        if (!existsSync(allowedRoot))
+            continue;
+        const canonicalRoot = realpathSync(allowedRoot);
+        allowedRoots.push(canonicalRoot);
+    }
+    if (allowedRoots.some((allowedRoot) => isPathInsideRoot(canonicalPath, allowedRoot))) {
+        return { path: canonicalPath, allowedRoots };
+    }
+    throw new PiboWebHttpError("Image preview path is outside its authorized roots", 403);
+}
+export function responseChatFileDownload(absolutePath) {
+    const stats = requireChatFile(absolutePath);
     return new Response(Readable.toWeb(createReadStream(absolutePath)), {
         headers: {
             "content-type": contentTypeForDownload(absolutePath),
@@ -65,6 +81,108 @@ export function responseChatFileDownload(absolutePath) {
         },
     });
 }
+export function responseChatImagePreview(absolutePath, allowedRoots) {
+    const { bytes, stats } = readBoundedImageFile(absolutePath, TRACE_IMAGE_MAX_DECODED_BYTES, allowedRoots);
+    const mimeType = imageMimeTypeFromBytes(bytes.subarray(0, Math.min(32, bytes.byteLength)));
+    if (!mimeType)
+        throw new PiboWebHttpError("Unsupported image preview format", 415);
+    return new Response(bytes, {
+        headers: imagePreviewHeaders({
+            mimeType,
+            contentLength: stats.size,
+            filename: basename(absolutePath),
+            cacheControl: "no-store",
+        }),
+    });
+}
+export function responseChatTraceImage(image) {
+    return new Response(image.bytes, {
+        headers: imagePreviewHeaders({
+            mimeType: image.mimeType,
+            contentLength: image.bytes.byteLength,
+            cacheControl: "private, max-age=31536000, immutable",
+        }),
+    });
+}
+function requireChatFile(absolutePath) {
+    let stats;
+    try {
+        stats = statSync(absolutePath);
+    }
+    catch {
+        throw new PiboWebHttpError("File not found: " + absolutePath, 404);
+    }
+    if (!stats.isFile())
+        throw new PiboWebHttpError("Path is not a file: " + absolutePath, 400);
+    return stats;
+}
+function readBoundedImageFile(absolutePath, maxBytes, allowedRoots) {
+    let descriptor;
+    try {
+        descriptor = openSync(absolutePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    }
+    catch (error) {
+        if (isFileSystemError(error) && error.code === "ELOOP")
+            throw new PiboWebHttpError("Image preview path changed during authorization", 409);
+        throw new PiboWebHttpError("File not found: " + absolutePath, 404);
+    }
+    try {
+        const stats = fstatSync(descriptor);
+        if (!stats.isFile())
+            throw new PiboWebHttpError("Path is not a file: " + absolutePath, 400);
+        if (allowedRoots?.length)
+            assertOpenedImagePathAuthority(absolutePath, stats, allowedRoots);
+        if (stats.size > maxBytes)
+            throw new PiboWebHttpError(`Image preview exceeds the ${maxBytes}-byte limit`, 413);
+        const bytes = Buffer.alloc(stats.size);
+        let offset = 0;
+        while (offset < bytes.byteLength) {
+            const read = readSync(descriptor, bytes, offset, bytes.byteLength - offset, offset);
+            if (read === 0)
+                break;
+            offset += read;
+        }
+        if (offset !== bytes.byteLength)
+            throw new PiboWebHttpError("Image changed while it was being read", 409);
+        const extra = Buffer.alloc(1);
+        if (readSync(descriptor, extra, 0, 1, offset) !== 0)
+            throw new PiboWebHttpError(`Image preview exceeds the ${maxBytes}-byte limit`, 413);
+        return { bytes, stats };
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+function assertOpenedImagePathAuthority(absolutePath, openedStats, allowedRoots) {
+    let currentPath;
+    let currentStats;
+    try {
+        currentPath = realpathSync(absolutePath);
+        currentStats = statSync(currentPath);
+    }
+    catch {
+        throw new PiboWebHttpError("Image preview path changed during authorization", 409);
+    }
+    if (currentStats.dev !== openedStats.dev || currentStats.ino !== openedStats.ino) {
+        throw new PiboWebHttpError("Image preview file changed during authorization", 409);
+    }
+    if (!allowedRoots.some((allowedRoot) => isPathInsideRoot(currentPath, allowedRoot))) {
+        throw new PiboWebHttpError("Image preview path escaped its authorized root", 403);
+    }
+}
+function isFileSystemError(error) {
+    return error instanceof Error && "code" in error;
+}
+function imagePreviewHeaders(input) {
+    return {
+        "content-type": input.mimeType,
+        "content-length": String(input.contentLength),
+        ...(input.filename ? { "content-disposition": "inline; filename*=UTF-8''" + encodeURIComponent(input.filename) } : {}),
+        "cache-control": input.cacheControl,
+        "x-content-type-options": "nosniff",
+        "cross-origin-resource-policy": "same-origin",
+    };
+}
 function normalizeChatFileAttachmentPaths(value) {
     if (value === undefined || value === null)
         return [];
@@ -100,8 +218,11 @@ function chatFileAttachmentForPath(path) {
     return { name: basename(path), path, bytes: stats.size };
 }
 function isPathInsideUploadDir(path) {
-    const uploadRelative = relative(CHAT_UPLOAD_DIR, path);
-    return uploadRelative !== "" && !uploadRelative.startsWith("..") && !isAbsolute(uploadRelative);
+    return isPathInsideRoot(path, CHAT_UPLOAD_DIR);
+}
+function isPathInsideRoot(path, root) {
+    const child = relative(root, path);
+    return child !== "" && child !== ".." && !child.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && !isAbsolute(child);
 }
 function renderAttachedChatFiles(attachments) {
     const bounded = attachments.slice(0, CHAT_FILE_ATTACHMENT_LIMIT);

package/dist/apps/chat/chat-settings-routes.js

@@ -1,6 +1,7 @@
 import { readPiboBasePrompt, savePiboCustomBasePrompt, setPiboBasePromptMode } from "../../core/base-prompt.js";
 import { readPiboCompactionPrompt, savePiboCustomCompactionPrompt, setPiboCompactionPromptMode } from "../../core/compaction-prompt.js";
 import { loadPiboGatewaySettings, sanitizeConcurrentYieldedRuns, updatePiboGatewaySettings, } from "../../core/gateway-settings.js";
+import { sanitizePreviewServerSettings } from "../../core/preview-server-settings.js";
 import { sanitizeTelemetryRetentionDays, sanitizeTelemetryRetentionSettings } from "../../core/telemetry-retention-settings.js";
 import { loadPiboUserSettings, sanitizeShortcutSettings, sanitizeTimezone, sanitizeTranscriptionProviderId, updatePiboUserSettings, updateTelemetryRetentionLastPrunedAt } from "../../core/user-settings.js";
 import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
@@ -51,7 +52,9 @@ export async function handleChatSettingsRoute(input) {
         if (route.action === "read")
             return responseJson({ userSettings: loadPiboUserSettings() });
         const body = await readJsonBody(request);
-        return responseJson({ userSettings: updatePiboUserSettings(userSettingsPatch(body, input.transcriptionProviderIds)) });
+        return responseJson({
+            userSettings: updatePiboUserSettings(userSettingsPatch(body, input.transcriptionProviderIds, input.speechProviderIds)),
+        });
     }
     if (route.kind === "gateway-settings") {
         if (route.action === "read")
@@ -106,7 +109,7 @@ function gatewaySettingsPatch(body) {
         throw new PiboWebHttpError("No gateway settings provided", 400);
     return patch;
 }
-function userSettingsPatch(body, transcriptionProviderIds) {
+function userSettingsPatch(body, transcriptionProviderIds, speechProviderIds) {
     const patch = {};
     if (body.timezone !== undefined) {
         const timezone = sanitizeTimezone(body.timezone);
@@ -128,6 +131,28 @@ function userSettingsPatch(body, transcriptionProviderIds) {
         }
         patch.transcription = { providerId };
     }
+    if (body.speech !== undefined) {
+        const raw = body.speech && typeof body.speech === "object" && !Array.isArray(body.speech)
+            ? body.speech
+            : {};
+        const providerId = sanitizeTranscriptionProviderId(raw.providerId);
+        if (!providerId)
+            throw new PiboWebHttpError("Invalid speech provider", 400);
+        if (speechProviderIds && !speechProviderIds.includes(providerId)) {
+            throw new PiboWebHttpError(`Unknown speech provider "${providerId}"`, 400);
+        }
+        patch.speech = { providerId };
+    }
+    if (body.previewServers !== undefined) {
+        const sanitized = sanitizePreviewServerSettings(body.previewServers);
+        const raw = body.previewServers && typeof body.previewServers === "object" && !Array.isArray(body.previewServers)
+            ? body.previewServers
+            : {};
+        if (raw.maxRunningServers !== sanitized.maxRunningServers || raw.autoStopMinutes !== sanitized.autoStopMinutes) {
+            throw new PiboWebHttpError("Invalid Preview server settings", 400);
+        }
+        patch.previewServers = sanitized;
+    }
     if (body.telemetryRetention !== undefined) {
         const current = loadPiboUserSettings().telemetryRetention;
         patch.telemetryRetention = {

package/dist/apps/chat/chat-speech.js

@@ -0,0 +1,100 @@
+import { loadPiboUserSettings } from "../../core/user-settings.js";
+import { PiboSpeechError, } from "../../speech/types.js";
+import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
+export const CHAT_SPEECH_MAX_CHARACTERS = 32_000;
+export const CHAT_SPEECH_MAX_OFFER_CHARACTERS = 256_000;
+export async function responseChatSpeechProviders(context) {
+    const providers = await requireProviderInfos(context);
+    return responseJson({
+        providers,
+        selectedProviderId: loadPiboUserSettings().speech.providerId,
+    });
+}
+export async function responseChatSpeechSessionStart(request, context) {
+    const startSpeechSession = context.channelContext.startSpeechSession;
+    if (!startSpeechSession)
+        throw new PiboWebHttpError("Speech synthesis is not available", 503);
+    const providerId = loadPiboUserSettings().speech.providerId;
+    const providers = await requireProviderInfos(context);
+    if (!providers.some((provider) => provider.id === providerId)) {
+        throw new PiboWebHttpError(`Speech provider "${providerId}" is not registered`, 409);
+    }
+    const body = await readJsonBody(request);
+    if (typeof body.offerSdp !== "string" || !body.offerSdp.startsWith("v=0")) {
+        throw new PiboWebHttpError("A WebRTC audio offer is required", 400);
+    }
+    if (body.offerSdp.length > CHAT_SPEECH_MAX_OFFER_CHARACTERS) {
+        throw new PiboWebHttpError("The WebRTC audio offer is too large", 413);
+    }
+    const text = requireSpeechText(body.text);
+    let speechSession;
+    try {
+        speechSession = await startSpeechSession(providerId, { offerSdp: body.offerSdp, text }, { signal: request.signal });
+        if (request.signal.aborted)
+            throw request.signal.reason;
+        return responseJson({ speechSession }, { status: 201 });
+    }
+    catch (error) {
+        if (speechSession)
+            await context.channelContext.stopSpeechSession?.(speechSession.sessionId).catch(() => { });
+        throw speechHttpError(error, "Speech session failed to start");
+    }
+}
+export async function responseChatSpeechSessionSpeak(request, context, sessionId) {
+    const speakSpeechSession = context.channelContext.speakSpeechSession;
+    if (!speakSpeechSession)
+        throw new PiboWebHttpError("Speech synthesis is not available", 503);
+    const body = await readJsonBody(request);
+    const text = requireSpeechText(body.text);
+    try {
+        await speakSpeechSession(sessionId, { text });
+        return new Response(null, { status: 204 });
+    }
+    catch (error) {
+        throw speechHttpError(error, "Speech synthesis failed");
+    }
+}
+export async function responseChatSpeechSessionStop(context, sessionId) {
+    const stopSpeechSession = context.channelContext.stopSpeechSession;
+    if (!stopSpeechSession)
+        throw new PiboWebHttpError("Speech synthesis is not available", 503);
+    try {
+        await stopSpeechSession(sessionId);
+        return new Response(null, { status: 204 });
+    }
+    catch (error) {
+        throw speechHttpError(error, "Speech session could not be stopped");
+    }
+}
+function requireSpeechText(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new PiboWebHttpError("Speech text is required", 400);
+    }
+    const text = value.trim();
+    if (text.length > CHAT_SPEECH_MAX_CHARACTERS) {
+        throw new PiboWebHttpError(`Speech text exceeds the ${CHAT_SPEECH_MAX_CHARACTERS.toLocaleString("en-US")} character limit`, 413);
+    }
+    return text;
+}
+async function requireProviderInfos(context) {
+    const getProviderInfos = context.channelContext.getSpeechProviderInfos;
+    if (!getProviderInfos)
+        throw new PiboWebHttpError("Speech providers are not available", 503);
+    return await getProviderInfos();
+}
+function speechHttpError(error, fallback) {
+    if (error instanceof PiboSpeechError) {
+        if (error.code === "invalid_offer" || error.code === "invalid_text")
+            return new PiboWebHttpError(error.message, 400);
+        if (error.code === "session_not_found")
+            return new PiboWebHttpError(error.message, 404);
+        if (error.code === "not_configured")
+            return new PiboWebHttpError(error.message, 409);
+        if (error.code === "capacity_exceeded")
+            return new PiboWebHttpError(error.message, 429);
+        if (error.code === "aborted")
+            return new PiboWebHttpError(error.message, 499);
+        return new PiboWebHttpError(error.message, 502);
+    }
+    return new PiboWebHttpError(error instanceof Error ? error.message : fallback, 502);
+}

package/dist/apps/chat/data/chat-data-mappers.js

@@ -1,11 +1,22 @@
 import { normalizeSessionErrorDetails } from "../../../core/session-errors.js";
 import { roomWorkspaceFromMetadata } from "../types/rooms.js";
+import { tracePayloadRefForStoredPayload } from "../trace-v2.js";
+const MAX_TRACE_EVENT_HYDRATION_BYTES = 1024 * 1024;
 export function storedPiboEventFromV2Row(row, payloadStore) {
     const attributes = parseJsonObject(row.attributes_json);
     const payload = outputPayloadFromV2Row(row, attributes, readPersistedPayload(row, payloadStore));
     if (!payload)
         return undefined;
-    return { id: String(row.stream_id), piboSessionId: row.session_id ?? undefined, eventSequence: row.session_sequence ?? undefined, eventId: row.event_id ?? undefined, streamId: row.stream_id, type: row.type, createdAt: row.created_at, payload };
+    const payloadIdentity = tracePayloadIdentityForEvent(row, attributes);
+    const storedPayloadRef = row.payload_ref && row.session_id && payloadStore && payloadIdentity
+        ? tracePayloadRefForStoredPayload({
+            payloadStore,
+            piboSessionId: row.session_id,
+            payloadId: row.payload_ref,
+            ...payloadIdentity,
+        })
+        : undefined;
+    return { id: String(row.stream_id), piboSessionId: row.session_id ?? undefined, eventSequence: row.session_sequence ?? undefined, eventId: row.event_id ?? undefined, streamId: row.stream_id, storedPayloadRef, type: row.type, createdAt: row.created_at, payload };
 }
 export function storedChatEventFromV2Row(row, payloadStore) {
     const attributes = parseJsonObject(row.attributes_json);
@@ -76,16 +87,25 @@ function readPersistedPayload(row, payloadStore) {
         return undefined;
     try {
         const metadata = payloadStore.getPayload(row.payload_ref);
-        if (!metadata)
+        if (!metadata || metadata.byteSize > MAX_TRACE_EVENT_HYDRATION_BYTES)
             return undefined;
-        return metadata.contentType.includes("json")
-            ? payloadStore.readPayloadJson(row.payload_ref)
-            : payloadStore.readPayloadText(row.payload_ref);
+        const text = Buffer.from(payloadStore.readPayloadBytesBounded(row.payload_ref, MAX_TRACE_EVENT_HYDRATION_BYTES)).toString("utf8");
+        return metadata.contentType.includes("json") ? JSON.parse(text) : text;
     }
     catch {
         return undefined;
     }
 }
+function tracePayloadIdentityForEvent(row, attributes) {
+    const toolCallId = stringAttribute(attributes, "toolCallId");
+    if (!toolCallId)
+        return undefined;
+    if (row.type === "tool_call" || row.type === "tool_execution_started")
+        return { nodeId: `tool:${toolCallId}`, payloadKind: "input" };
+    if (row.type === "tool_execution_updated" || row.type === "tool_execution_finished")
+        return { nodeId: `tool:${toolCallId}`, payloadKind: "output" };
+    return undefined;
+}
 export function sessionFromRow(row) { return { piboSessionId: row.id, piSessionId: row.pi_session_id ?? "", runtimeInstanceId: row.runtime_instance_id ?? undefined, runtimeAdapterId: row.runtime_adapter_id ?? undefined, runtimeBindingState: isRuntimeBindingState(row.binding_state) ? row.binding_state : undefined, nativeSessionId: row.native_session_id ?? undefined, parentId: row.parent_id ?? undefined, profile: row.profile, channel: row.channel, kind: row.kind, createdAt: row.created_at, updatedAt: row.updated_at, lastActivityAt: row.last_activity_at, status: row.status === "running" || row.status === "error" ? row.status : "idle" }; }
 export function roomFromRow(row) { const metadata = parseJsonObject(row.metadata_json); return { id: row.id, name: row.name, topic: row.topic ?? undefined, workspace: row.workspace ?? roomWorkspaceFromMetadata(metadata), type: row.type, parentRoomId: row.parent_room_id ?? undefined, createdAt: row.created_at, updatedAt: row.updated_at, retentionPolicyId: row.retention_policy_id ?? undefined, metadata }; }
 export function parseJsonObject(value) { try {

package/dist/apps/chat/data/timeline-query-service.js

@@ -1,5 +1,8 @@
+import { createHash } from "node:crypto";
 import { messageTurnTimingsFromEvents } from "../../../shared/trace-event-projection.js";
 import { storedChatEventFromV2Row, storedPiboEventFromV2Row } from "./chat-data-mappers.js";
+import { TRACE_RECONCILIATION_ENTRY_CAP, TRACE_RECONCILIATION_TIMING_CAP } from "../../../shared/trace-limits.js";
+import { parseTraceToolNodeIdentity } from "../../../shared/trace-tool-identity.js";
 export class ChatTimelineQueryService {
     store;
     constructor(store) {
@@ -37,7 +40,10 @@ export class ChatTimelineQueryService {
 			WHERE session_id = ?
 				AND type IN ('message_queued', 'message_steered', 'message_started', 'message_finished', 'session_error', 'thinking_finished', 'assistant_message')
 			ORDER BY session_sequence ASC, stream_id ASC
-		`).all(piboSessionId);
+			LIMIT ?
+		`).all(piboSessionId, TRACE_RECONCILIATION_TIMING_CAP + 1);
+        if (rows.length > TRACE_RECONCILIATION_TIMING_CAP)
+            return [];
         const events = rows.map((row) => storedPiboEventFromV2Row(row, this.store.payloads)).filter((event) => event !== undefined);
         return messageTurnTimingsFromEvents(events);
     }
@@ -70,6 +76,67 @@ export class ChatTimelineQueryService {
 		`).all(...values, limit);
         return rows.map((row) => storedPiboEventFromV2Row(row, this.store.payloads)).filter((event) => event !== undefined);
     }
+    isPayloadAttachedToTraceNode(input) {
+        const nodeIdentity = parseTraceToolNodeIdentity(input.nodeId);
+        if (!nodeIdentity)
+            return false;
+        const payload = this.store.payloads.getPayload(input.payloadId);
+        if (!payload)
+            return false;
+        const eventClause = nodeIdentity.qualifier ? "AND event_id = ?" : "";
+        const values = nodeIdentity.qualifier
+            ? [input.piboSessionId, nodeIdentity.toolCallId, nodeIdentity.qualifier.eventId]
+            : [input.piboSessionId, nodeIdentity.toolCallId];
+        const rows = this.store.db.prepare(`
+			SELECT type, event_id, payload_ref, attributes_json
+			FROM event_log
+			WHERE session_id = ?
+				AND tool_call_id = ?
+				AND type IN ('tool_execution_started', 'tool_execution_updated', 'tool_execution_finished')
+				${eventClause}
+			ORDER BY session_sequence ASC, stream_id ASC
+			LIMIT ?
+		`).all(...values, TRACE_RECONCILIATION_ENTRY_CAP + 1);
+        if (rows.length > TRACE_RECONCILIATION_ENTRY_CAP)
+            return false;
+        const lifecycles = new Map();
+        const invocations = [];
+        for (const row of rows) {
+            const lifecycle = lifecycles.get(row.event_id) ?? { nextOrdinal: 0 };
+            lifecycles.set(row.event_id, lifecycle);
+            if (row.type === "tool_execution_started") {
+                if (lifecycle.active)
+                    return false;
+                lifecycle.active = {
+                    eventId: row.event_id,
+                    invocationOrdinal: lifecycle.nextOrdinal,
+                    payloadMatches: false,
+                };
+                lifecycle.nextOrdinal += 1;
+                invocations.push(lifecycle.active);
+            }
+            else if (!lifecycle.active) {
+                lifecycle.active = {
+                    eventId: row.event_id,
+                    invocationOrdinal: lifecycle.nextOrdinal,
+                    payloadMatches: false,
+                };
+                lifecycle.nextOrdinal += 1;
+                invocations.push(lifecycle.active);
+            }
+            if (row.type !== "tool_execution_started"
+                && payloadMatchesEventRow(this.store, payload.sha256, input.payloadId, row))
+                lifecycle.active.payloadMatches = true;
+            if (row.type === "tool_execution_finished")
+                lifecycle.active = undefined;
+        }
+        if (!nodeIdentity.qualifier) {
+            return invocations.length === 1 && invocations[0].payloadMatches;
+        }
+        const exact = invocations.filter((invocation) => invocation.eventId === nodeIdentity.qualifier.eventId
+            && invocation.invocationOrdinal === nodeIdentity.qualifier.invocationOrdinal);
+        return exact.length === 1 && exact[0].payloadMatches;
+    }
     countEventsByType(input = {}) {
         const clauses = [];
         const values = [];
@@ -111,3 +178,24 @@ export class ChatTimelineQueryService {
         return row?.stream_id ?? undefined;
     }
 }
+function payloadMatchesEventRow(store, payloadSha256, payloadId, row) {
+    if (row.payload_ref === payloadId)
+        return true;
+    let attributes;
+    try {
+        const parsed = JSON.parse(row.attributes_json);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return false;
+        attributes = parsed;
+    }
+    catch {
+        return false;
+    }
+    if (!("inlinePayload" in attributes))
+        return false;
+    const bytes = Buffer.from(JSON.stringify(attributes.inlinePayload), "utf8");
+    const inlineSha256 = createHash("sha256").update(bytes).digest("hex");
+    if (payloadSha256 !== inlineSha256)
+        return false;
+    return store.payloads.findBySha256(inlineSha256)?.id === payloadId;
+}