@memorax/memorax-code 0.1.6 → 0.1.8

package/lib/memorax-code-backend/dist/viewer/history/session-title.js

@@ -1,93 +0,0 @@
-import { redactViewerPaths } from "../projection/redaction.js";
-const MAX_SESSION_TITLE_LENGTH = 120;
-const COMMON_RELATIVE_PATH_ROOTS = new Set([
-    "app",
-    "apps",
-    "assets",
-    "build",
-    "config",
-    "configs",
-    "crates",
-    "dist",
-    "docs",
-    "lib",
-    "node_modules",
-    "packages",
-    "private",
-    "public",
-    "resources",
-    "scripts",
-    "src",
-    "test",
-    "tests",
-    "vendor",
-]);
-export function earliestMemoryViewerSessionTitleCandidates(allEvents) {
-    const candidates = new Map();
-    for (const event of allEvents) {
-        if (event.type !== "turn_start" || !event.sessionId)
-            continue;
-        const title = normalizedMemoryViewerSessionTitle(event.prompt);
-        if (!title)
-            continue;
-        const candidate = {
-            id: event.id,
-            client: event.client,
-            timestamp: event.timestamp,
-            sessionId: event.sessionId,
-            title,
-        };
-        const key = `${event.client}\u0000${event.sessionId}`;
-        const current = candidates.get(key);
-        if (!current || compareSessionTitleCandidates(candidate, current) < 0) {
-            candidates.set(key, candidate);
-        }
-    }
-    return [...candidates.values()];
-}
-export function normalizedMemoryViewerSessionTitle(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const title = value
-        .replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ")
-        .replace(/\s+/g, " ")
-        .trim();
-    if (!title)
-        return undefined;
-    if (/^(?:[a-z]:[\\/]|[~.]?[\\/]|file:\/\/)/i.test(title))
-        return undefined;
-    const redacted = redactSessionTitlePaths(title).replace(/\s+/g, " ").trim();
-    if (!redacted || redacted === "[REDACTED]")
-        return undefined;
-    const characters = Array.from(redacted);
-    return characters.length <= MAX_SESSION_TITLE_LENGTH
-        ? redacted
-        : `${characters.slice(0, MAX_SESSION_TITLE_LENGTH - 1).join("")}…`;
-}
-function compareSessionTitleCandidates(left, right) {
-    const leftTime = Date.parse(left.timestamp);
-    const rightTime = Date.parse(right.timestamp);
-    const leftOrder = Number.isFinite(leftTime) ? leftTime : 0;
-    const rightOrder = Number.isFinite(rightTime) ? rightTime : 0;
-    return leftOrder - rightOrder || left.id.localeCompare(right.id);
-}
-function redactSessionTitlePaths(value) {
-    return redactViewerPaths(value)
-        .replace(/(^|[\s('"`])(?:~|\.\.?)?[\\/](?![\\/])[^\s)'"`]+/g, "$1[REDACTED]")
-        .replace(/(^|[\s('"`])\\\\[^\\\s]+\\[^\s)'"`]+/g, "$1[REDACTED]")
-        .replace(/(^|[\s('"`])([^\s)'"`]*[\\/][^\s)'"`]*)/g, (match, prefix, token) => (likelyPathToken(token) ? `${prefix}[REDACTED]` : match));
-}
-function likelyPathToken(token) {
-    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(token))
-        return false;
-    if (/^[a-z]:[\\/]/i.test(token))
-        return true;
-    const segments = token.split(/[\\/]/).filter(Boolean);
-    if (segments.length >= 3)
-        return true;
-    if (segments.length < 2)
-        return false;
-    if (/\.[a-z0-9]{1,16}(?:[?#].*)?$/i.test(segments.at(-1) ?? ""))
-        return true;
-    return COMMON_RELATIVE_PATH_ROOTS.has(segments[0]?.toLowerCase() ?? "");
-}

package/lib/memorax-code-backend/dist/viewer/http/public-routes.js

@@ -1,146 +0,0 @@
-import { createHash } from "node:crypto";
-import { MEMORAX_ICON_DATA_URL } from "../ui/icon.js";
-import { isMemoryProjectId, UNCLASSIFIED_PROJECT_ID } from "../../memory/project.js";
-import { MEMORAX_LOGO_DATA_URL } from "../ui/logo.js";
-import { memoryViewerUserHtml } from "../ui/user-html.js";
-import { projectMemoryViewerUserData } from "../projection/user.js";
-import { listMemoryViewerDataWithHistory } from "../store.js";
-import { repoMemoryReadinessForProject, } from "../../repository/readiness.js";
-import { json } from "../../transport/http/json.js";
-import { memoraxCodeHomeForTrace } from "../../trace/config.js";
-const MEMORY_VIEWER_SESSION_ACTIVITY_WINDOW_MS = 72 * 60 * 60 * 1_000;
-const MEMORY_VIEWER_ACTIVITY_CUTOFF_GRANULARITY_MS = 60_000;
-const MEMORY_VIEWER_LOGO = Buffer.from(MEMORAX_LOGO_DATA_URL.slice(MEMORAX_LOGO_DATA_URL.indexOf(",") + 1), "base64");
-const MEMORY_VIEWER_ICON = Buffer.from(MEMORAX_ICON_DATA_URL.slice(MEMORAX_ICON_DATA_URL.indexOf(",") + 1), "base64");
-export async function handleMemoryViewerRequest(url, req, res, options = {}) {
-    if (req.method === "GET" && url.pathname === "/memory-viewer") {
-        if (!memoryViewerUserClient(url)) {
-            json(res, 400, { ok: false, error: "client must be codex, claude-code, dsh, or opencode" });
-            return true;
-        }
-        res.writeHead(200, {
-            "content-type": "text/html; charset=utf-8",
-            "cache-control": "no-store",
-            "content-security-policy": "default-src 'self'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'self'; img-src 'self' data:; base-uri 'none'; frame-ancestors 'none'",
-            "referrer-policy": "no-referrer",
-            "x-content-type-options": "nosniff",
-            ...(options.sessionCookie ? { "set-cookie": options.sessionCookie } : {}),
-        });
-        res.end(memoryViewerUserHtml());
-        return true;
-    }
-    if (req.method === "GET" && url.pathname === "/memory-viewer/logo") {
-        res.writeHead(200, {
-            "content-type": "image/png",
-            "cache-control": "private, max-age=86400",
-            "x-content-type-options": "nosniff",
-        });
-        res.end(MEMORY_VIEWER_LOGO);
-        return true;
-    }
-    if (req.method === "GET" && url.pathname === "/memory-viewer/favicon.png") {
-        res.writeHead(200, {
-            "content-type": "image/png",
-            "cache-control": "private, max-age=86400",
-            "x-content-type-options": "nosniff",
-        });
-        res.end(MEMORY_VIEWER_ICON);
-        return true;
-    }
-    if (req.method !== "GET" || url.pathname !== "/memory-viewer/api/summary") {
-        return false;
-    }
-    const memoraxCodeHome = viewerMemoraxCodeHome(options);
-    const selectedClient = memoryViewerUserClient(url);
-    if (!selectedClient) {
-        json(res, 400, { ok: false, error: "client must be codex, claude-code, dsh, or opencode" });
-        return true;
-    }
-    const requestedProject = projectFilter(url);
-    const activeSessionSince = memoryViewerActivityCutoff(options.now?.() ?? Date.now());
-    const viewerData = await listMemoryViewerDataWithHistory(memoraxCodeHome, {
-        client: selectedClient.traceClient,
-        includePendingWritebacks: true,
-        activeSessionSince,
-        includeUserProjection: true,
-        ...(requestedProject.projectId ? { projectId: requestedProject.projectId } : {}),
-        ...(requestedProject.reject ? { rejectProjectFilter: true } : {}),
-    }, { claudeProjectsRoot: options.claudeProjectsRoot });
-    const projection = viewerData.userProjection
-        ?? projectMemoryViewerUserData(viewerData.events);
-    const readiness = options.repoMemoryReadiness ?? repoMemoryReadinessForProject;
-    const projects = await Promise.all(activeMemoryViewerProjects(viewerData.activityProjects, viewerData.activityProjectSessions, activeSessionSince).map(async (project) => ({
-        projectId: project.projectId,
-        projectLabel: project.projectLabel,
-        repoMemory: await readiness(project.projectId, memoraxCodeHome),
-    })));
-    conditionalViewerJson(req, res, {
-        ok: true,
-        selectedClient: selectedClient.publicClient,
-        availableClients: ["codex", "claude-code", "dsh", "opencode"],
-        summary: projection.summary,
-        activities: projection.activities.slice(0, 100),
-        projects,
-        ...(viewerData.selectedProjectId ? { selectedProjectId: viewerData.selectedProjectId } : {}),
-        ...(viewerData.projectFilterStatus ? { projectFilterStatus: viewerData.projectFilterStatus } : {}),
-    });
-    return true;
-}
-function viewerMemoraxCodeHome(options) {
-    return options.memoraxCodeHome
-        ?? (options.env?.MEMORAX_CODE_HOME?.trim() || memoraxCodeHomeForTrace(options.env));
-}
-function memoryViewerUserClient(url) {
-    const value = url.searchParams.get("client");
-    const traceClient = value === null ? "codex" : traceClientFromPublicValue(value.trim().toLowerCase());
-    return traceClient
-        ? { traceClient, publicClient: traceClient === "claude" ? "claude-code" : traceClient }
-        : undefined;
-}
-function traceClientFromPublicValue(value) {
-    if (value === "codex" || value === "dsh" || value === "opencode")
-        return value;
-    return value === "claude" || value === "claude-code" || value === "cc"
-        ? "claude"
-        : undefined;
-}
-function activeMemoryViewerProjects(projects, projectSessions, activeSessionSince) {
-    const activeProjectIds = new Set(projectSessions
-        .filter((entry) => {
-        const lastSeenAt = Date.parse(entry.lastSeenAt);
-        return Number.isFinite(lastSeenAt) && lastSeenAt >= activeSessionSince;
-    })
-        .map((entry) => entry.projectId));
-    return projects.filter((entry) => activeProjectIds.has(entry.projectId));
-}
-function memoryViewerActivityCutoff(now) {
-    const safeNow = Number.isFinite(now) ? now : Date.now();
-    return Math.floor(safeNow / MEMORY_VIEWER_ACTIVITY_CUTOFF_GRANULARITY_MS)
-        * MEMORY_VIEWER_ACTIVITY_CUTOFF_GRANULARITY_MS
-        - MEMORY_VIEWER_SESSION_ACTIVITY_WINDOW_MS;
-}
-function conditionalViewerJson(req, res, body) {
-    const payload = JSON.stringify(body);
-    const etag = `"${createHash("sha256").update(payload).digest("base64url")}"`;
-    const headers = {
-        "cache-control": "private, no-cache",
-        etag,
-    };
-    if (req.headers["if-none-match"] === etag) {
-        res.writeHead(304, headers);
-        res.end();
-        return;
-    }
-    res.writeHead(200, { ...headers, "content-type": "application/json" });
-    res.end(payload);
-}
-function projectFilter(url) {
-    const rawProjectId = url.searchParams.get("projectId");
-    const projectId = (rawProjectId ?? "").trim();
-    if (projectId === UNCLASSIFIED_PROJECT_ID || isMemoryProjectId(projectId)) {
-        return { projectId };
-    }
-    if (rawProjectId !== null && projectId)
-        return { reject: true };
-    return {};
-}

package/lib/memorax-code-backend/dist/viewer/model.js

@@ -1 +0,0 @@
-export {};

package/lib/memorax-code-backend/dist/viewer/projection/activity.js

@@ -1,113 +0,0 @@
-import { UNCLASSIFIED_PROJECT_ID } from "../../memory/project.js";
-import { memoryViewerEventTurnIds } from "./turn-reference.js";
-export function memoryViewerActivitySummary(allEvents) {
-    let recalledCount = 0;
-    let addCount = 0;
-    let searchCount = 0;
-    for (const event of allEvents) {
-        if (event.type === "memory_retrieve" || event.type === "memory_cli_search") {
-            searchCount += 1;
-            recalledCount += event.itemCount ?? event.results?.length ?? 0;
-        }
-        if (event.type === "memory_cli_add" || event.type === "memory_writeback")
-            addCount += 1;
-    }
-    return {
-        activityCount: allEvents.length,
-        recalledCount,
-        addCount,
-        searchCount,
-    };
-}
-export function memoryViewerActivityProjection(allEvents) {
-    const turns = new Map();
-    for (const event of allEvents) {
-        if (!event.sessionId)
-            continue;
-        const order = timestampOrder(event.timestamp);
-        for (const turnId of memoryViewerEventTurnIds(event)) {
-            const key = `${event.client}\u0000${event.sessionId}\u0000${turnId}`;
-            const current = turns.get(key);
-            if (!current) {
-                turns.set(key, {
-                    firstOrder: order,
-                    firstTimestamp: event.timestamp,
-                    ...(event.type === "turn_start" && Number.isFinite(order)
-                        ? { startOrder: order, startTimestamp: event.timestamp }
-                        : {}),
-                });
-                continue;
-            }
-            if (Number.isFinite(order)
-                && (!Number.isFinite(current.firstOrder) || order < current.firstOrder)) {
-                current.firstOrder = order;
-                current.firstTimestamp = event.timestamp;
-            }
-            if (event.type === "turn_start"
-                && Number.isFinite(order)
-                && (current.startOrder === undefined || order < current.startOrder)) {
-                current.startOrder = order;
-                current.startTimestamp = event.timestamp;
-            }
-        }
-    }
-    const eventActivityOrder = new Map();
-    const entries = new Map();
-    for (const event of allEvents) {
-        let turn;
-        if (event.sessionId) {
-            for (const turnId of memoryViewerEventTurnIds(event)) {
-                const candidate = turns.get(`${event.client}\u0000${event.sessionId}\u0000${turnId}`);
-                if (!candidate)
-                    continue;
-                const candidateOrder = candidate.startOrder ?? candidate.firstOrder;
-                const turnOrder = turn ? turn.startOrder ?? turn.firstOrder : Number.NEGATIVE_INFINITY;
-                if (!turn || candidateOrder > turnOrder)
-                    turn = candidate;
-            }
-        }
-        const activityOrder = turn?.startOrder ?? turn?.firstOrder ?? timestampOrder(event.timestamp);
-        const activityTimestamp = turn?.startTimestamp ?? turn?.firstTimestamp ?? event.timestamp;
-        eventActivityOrder.set(event.eventKey, activityOrder);
-        const projectId = event.projectId ?? UNCLASSIFIED_PROJECT_ID;
-        const key = `${event.client}\u0000${projectId}\u0000${event.sessionId ?? ""}`;
-        const current = entries.get(key);
-        if (!current) {
-            entries.set(key, {
-                value: {
-                    client: event.client,
-                    projectId,
-                    ...(event.sessionId ? { sessionId: event.sessionId } : { unscoped: true }),
-                    eventCount: 1,
-                    lastSeenAt: activityTimestamp,
-                },
-                lastSeenOrder: activityOrder,
-            });
-            continue;
-        }
-        const lastSeenAt = activityOrder >= current.lastSeenOrder
-            ? activityTimestamp
-            : current.value.lastSeenAt;
-        entries.set(key, {
-            value: {
-                ...current.value,
-                eventCount: current.value.eventCount + 1,
-                lastSeenAt,
-            },
-            lastSeenOrder: Math.max(current.lastSeenOrder, activityOrder),
-        });
-    }
-    return {
-        eventActivityOrder,
-        projectSessions: [...entries.values()]
-            .map((entry) => entry.value)
-            .sort((left, right) => (left.projectId.localeCompare(right.projectId)
-            || left.client.localeCompare(right.client)
-            || timestampOrder(right.lastSeenAt) - timestampOrder(left.lastSeenAt)
-            || (left.sessionId ?? "").localeCompare(right.sessionId ?? ""))),
-    };
-}
-function timestampOrder(value) {
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;
-}

package/lib/memorax-code-backend/dist/viewer/projection/cache.js

@@ -1,69 +0,0 @@
-export const MEMORY_VIEWER_DATA_PROJECTION_CAPACITY = 64;
-const dataProjections = new Map();
-const sharedDataProjections = new Map();
-const projectionHistories = new Map();
-export function prepareMemoryViewerDataProjectionHistory(projectionKey, historical) {
-    if (projectionHistories.get(projectionKey) === historical)
-        return;
-    dataProjections.delete(projectionKey);
-    sharedDataProjections.delete(projectionKey);
-    projectionHistories.set(projectionKey, historical);
-}
-export function shareMemoryViewerDataProjectionValue(projectionKey, valueKey, historical, liveVersion, create) {
-    let projections = sharedDataProjections.get(projectionKey);
-    if (!projections) {
-        projections = new Map();
-        sharedDataProjections.set(projectionKey, projections);
-    }
-    const cached = projections.get(valueKey);
-    if (cached && cached.historical === historical && cached.liveVersion === liveVersion)
-        return cached.value;
-    const value = create();
-    projections.set(valueKey, { historical, liveVersion, value });
-    return value;
-}
-export function readMemoryViewerDataProjection(projectionKey, filterKey, historical, liveVersion) {
-    const projections = dataProjections.get(projectionKey);
-    const cached = projections?.get(filterKey);
-    if (!cached || cached.historical !== historical || cached.liveVersion !== liveVersion)
-        return undefined;
-    projections?.delete(filterKey);
-    projections?.set(filterKey, cached);
-    return cached.data;
-}
-export function writeMemoryViewerDataProjection(projectionKey, filterKey, historical, liveVersion, data) {
-    let projections = dataProjections.get(projectionKey);
-    if (!projections) {
-        projections = new Map();
-        dataProjections.set(projectionKey, projections);
-    }
-    projections.set(filterKey, { historical, liveVersion, data });
-    while (projections.size > MEMORY_VIEWER_DATA_PROJECTION_CAPACITY) {
-        const oldestKey = projections.keys().next().value;
-        if (!oldestKey)
-            break;
-        projections.delete(oldestKey);
-    }
-}
-export function clearMemoryViewerDataProjections() {
-    dataProjections.clear();
-    sharedDataProjections.clear();
-}
-export function clearMemoryViewerDataProjectionCache() {
-    dataProjections.clear();
-    sharedDataProjections.clear();
-    projectionHistories.clear();
-}
-export function memoryViewerDataProjectionCacheSize(projectionKey) {
-    return dataProjections.get(projectionKey)?.size ?? 0;
-}
-export function memoryViewerSharedDataProjectionCacheSize(projectionKey) {
-    return sharedDataProjections.get(projectionKey)?.size ?? 0;
-}
-export function shouldCacheMemoryViewerDataProjection(filter, data) {
-    if (filter.sessionId && !data.projectSessions.some((entry) => entry.sessionId === filter.sessionId))
-        return false;
-    if (filter.projectId && data.projectFilterStatus !== "resolved")
-        return false;
-    return true;
-}

package/lib/memorax-code-backend/dist/viewer/projection/event-identity.js

@@ -1,3 +0,0 @@
-export function memoryViewerEventKey(event) {
-    return JSON.stringify([event.client ?? "codex", event.sessionId ?? "", event.id]);
-}

package/lib/memorax-code-backend/dist/viewer/projection/history.js

@@ -1,79 +0,0 @@
-import { memoryViewerEventKey } from "./event-identity.js";
-/**
- * Marks a retained start without an end as interrupted only when a different
- * Turn demonstrably started later in the same client session.
- *
- * This is a Viewer-only projection. It does not synthesize a trace event or
- * change transcript and writeback authority.
- */
-export function foldMemoryViewerSupersededTurnStarts(allEvents) {
-    const endedTurns = new Set();
-    const startsBySession = new Map();
-    for (const event of allEvents) {
-        if (!event.sessionId || !event.turnId)
-            continue;
-        const turnKey = viewerTurnKey(event);
-        if (event.type === "turn_end") {
-            endedTurns.add(turnKey);
-            continue;
-        }
-        if (event.type !== "turn_start")
-            continue;
-        const startedAt = Date.parse(event.timestamp);
-        if (!Number.isFinite(startedAt))
-            continue;
-        const sessionKey = JSON.stringify([event.client, event.sessionId]);
-        const starts = startsBySession.get(sessionKey) ?? new Map();
-        const current = starts.get(turnKey);
-        if (current === undefined || startedAt < current)
-            starts.set(turnKey, startedAt);
-        startsBySession.set(sessionKey, starts);
-    }
-    const interruptedTurns = new Set();
-    for (const starts of startsBySession.values()) {
-        const latestStartedAt = Math.max(...starts.values());
-        for (const [turnKey, startedAt] of starts) {
-            if (!endedTurns.has(turnKey) && startedAt < latestStartedAt) {
-                interruptedTurns.add(turnKey);
-            }
-        }
-    }
-    if (interruptedTurns.size === 0)
-        return [...allEvents];
-    return allEvents.map((event) => (event.type === "turn_start"
-        && !event.turnOutcome
-        && interruptedTurns.has(viewerTurnKey(event))
-        ? { ...event, turnOutcome: "interrupted" }
-        : event));
-}
-export function foldMemoryViewerTurnMaterializations(allEvents) {
-    const byOriginalEventKey = new Map();
-    for (const event of allEvents) {
-        if (event.type === "turn_materialized" && event.originalEventId) {
-            byOriginalEventKey.set(memoryViewerEventKey({
-                id: event.originalEventId,
-                client: event.client,
-                ...(event.sessionId ? { sessionId: event.sessionId } : {}),
-            }), event);
-        }
-    }
-    return allEvents
-        .filter((event) => event.type !== "turn_materialized")
-        .map((event) => {
-        if (event.type !== "turn_end")
-            return event;
-        const materialized = byOriginalEventKey.get(event.eventKey);
-        if (!materialized)
-            return event;
-        const answer = materialized.answer ?? event.answer;
-        return {
-            ...event,
-            ...(materialized.turnOutcome ? { turnOutcome: materialized.turnOutcome } : {}),
-            ...(answer ? { answer, content: answer } : {}),
-            ...(materialized.details === undefined ? {} : { details: materialized.details }),
-        };
-    });
-}
-function viewerTurnKey(event) {
-    return JSON.stringify([event.client, event.sessionId, event.turnId]);
-}

package/lib/memorax-code-backend/dist/viewer/projection/observability.js

@@ -1,8 +0,0 @@
-import { recordMemoryViewerEvent } from "../store.js";
-export function memoryViewerObservabilityHook() {
-    return {
-        recordEvent(event) {
-            recordMemoryViewerEvent(event);
-        },
-    };
-}

package/lib/memorax-code-backend/dist/viewer/projection/redaction.js

@@ -1,52 +0,0 @@
-export function sanitizeMemoryViewerDetails(value, depth = 0) {
-    if (depth > 5)
-        return "[truncated]";
-    if (typeof value === "string")
-        return redactViewerPaths(value.slice(0, 12_000));
-    if (value === null || typeof value !== "object")
-        return value;
-    if (Array.isArray(value)) {
-        return value.slice(0, 50).map((item) => sanitizeMemoryViewerDetails(item, depth + 1));
-    }
-    const output = {};
-    for (const [key, item] of Object.entries(value)) {
-        if (/authorization|api[-_]?key|token|secret/i.test(key))
-            continue;
-        if (key.toLowerCase() === "route"
-            && typeof item === "string"
-            && /^\/api(?:\/[^/\s?#]+)*\/?$/.test(item)) {
-            output[key] = item;
-            continue;
-        }
-        if (viewerPathLikeKey(key)) {
-            output[key] = "[REDACTED]";
-            continue;
-        }
-        output[key] = sanitizeMemoryViewerDetails(item, depth + 1);
-    }
-    return output;
-}
-function viewerPathLikeKey(key) {
-    const normalized = key.replace(/[^a-z0-9]/gi, "").toLowerCase();
-    return normalized === "cwd"
-        || normalized === "path"
-        || normalized.endsWith("path")
-        || normalized === "root"
-        || normalized.endsWith("root")
-        || normalized === "workspace"
-        || normalized === "workingdirectory";
-}
-export function redactViewerPaths(value) {
-    return value
-        .split(/(\bhttps?:\/\/[^\s)'"`]+)/gi)
-        .map((segment) => {
-        if (/^https?:\/\//i.test(segment))
-            return segment;
-        return segment
-            .replace(/\bfile:\/\/[^\s)'"`]+/gi, "[REDACTED]")
-            .replace(/(^|[\s('"`])\\\\[^\\/\s)'"`]+[\\/][^\s)'"`]+/g, "$1[REDACTED]")
-            .replace(/\b[A-Za-z]:[\\/][^\s)'"`]+/g, "[REDACTED]")
-            .replace(/(^|[\s('"`])\/(?!\/)[^\s)'"`]+/g, "$1[REDACTED]");
-    })
-        .join("");
-}

package/lib/memorax-code-backend/dist/viewer/projection/turn-reference.js

@@ -1,12 +0,0 @@
-export function memoryViewerEventTurnIds(event) {
-    return [...new Set([
-            safeTurnId(event.turnId),
-            ...(event.turnReferences ?? []).map((reference) => safeTurnId(reference.turnId)),
-        ].filter(Boolean))];
-}
-function safeTurnId(value) {
-    const candidate = typeof value === "string" ? value.trim() : "";
-    if (!candidate || candidate.length > 512 || /[\u0000-\u001f\u007f\\/]/.test(candidate))
-        return "";
-    return candidate;
-}