@manta-eu/react 0.1.0 → 0.1.1

package/dist/routes/memories/hooks/useConflictCheck.d.ts

@@ -0,0 +1,18 @@
+import { GQLMemoryScope, type GQLConflictingMemory } from "@manta-eu/client";
+export type ConflictCheckInput = {
+    label: string;
+    description: string;
+    scope: GQLMemoryScope;
+    teams?: string[];
+    excludeIri?: string;
+};
+export type ConflictCheckResult = {
+    conflicts: GQLConflictingMemory[];
+    timedOut: boolean;
+};
+export type UseConflictCheckResult = {
+    check: (input: ConflictCheckInput) => Promise<ConflictCheckResult>;
+    isChecking: boolean;
+};
+export declare function useConflictCheck(): UseConflictCheckResult;
+//# sourceMappingURL=useConflictCheck.d.ts.map

package/dist/routes/memories/hooks/useConflictCheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConflictCheck.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/hooks/useConflictCheck.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,cAAc,EACd,KAAK,oBAAoB,EAG1B,MAAM,kBAAkB,CAAC;AAM1B,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,cAAc,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,oBAAoB,EAAE,CAAC;IAClC,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACnE,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,wBAAgB,gBAAgB,IAAI,sBAAsB,CAmCzD"}

package/dist/routes/memories/hooks/useConflictCheck.js

@@ -0,0 +1,35 @@
+import { DetectMemoryConflictsDocument, GQLMemoryScope, } from "@manta-eu/client";
+import { useCallback, useState } from "react";
+import { useMantaClient } from "#providers/index";
+const conflictCheckTimeoutMs = 15_000;
+export function useConflictCheck() {
+    const { mantaClient } = useMantaClient();
+    const [isChecking, setIsChecking] = useState(false);
+    const check = useCallback(async (input) => {
+        setIsChecking(true);
+        try {
+            const result = await mantaClient.request({
+                document: DetectMemoryConflictsDocument,
+                variables: {
+                    input: {
+                        label: input.label,
+                        description: input.description,
+                        scope: input.scope,
+                        teams: input.scope === GQLMemoryScope.Team ? (input.teams ?? []) : undefined,
+                        excludeIri: input.excludeIri ?? undefined,
+                        wantToStopAfterMs: conflictCheckTimeoutMs,
+                    },
+                },
+                signal: AbortSignal.timeout(conflictCheckTimeoutMs + 5_000),
+            });
+            return result.detectMemoryConflicts;
+        }
+        catch {
+            return { conflicts: [], timedOut: false };
+        }
+        finally {
+            setIsChecking(false);
+        }
+    }, [mantaClient]);
+    return { check, isChecking };
+}

package/dist/routes/memories/hooks/useDuplicateDetection.d.ts

@@ -0,0 +1,11 @@
+import type { GQLConflictingMemory, GQLMemory } from "@manta-eu/client";
+export type DuplicateMatches = Map<string, GQLConflictingMemory[]>;
+export declare function pickDuplicateTargets(memories: GQLMemory[], max?: number): GQLMemory[];
+export declare function useDuplicateDetection(memories: GQLMemory[], options?: {
+    enabled?: boolean;
+    max?: number;
+}): {
+    duplicates: DuplicateMatches;
+    isDetecting: boolean;
+};
+//# sourceMappingURL=useDuplicateDetection.d.ts.map

package/dist/routes/memories/hooks/useDuplicateDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDuplicateDetection.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/hooks/useDuplicateDetection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAKxE,MAAM,MAAM,gBAAgB,GAAG,GAAG,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;AAOnE,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,SAAS,EAAE,EAAE,GAAG,GAAE,MAAyB,GAAG,SAAS,EAAE,CAEvG;AAeD,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,SAAS,EAAE,EACrB,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAChD;IAAE,UAAU,EAAE,gBAAgB,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAyDxD"}

package/dist/routes/memories/hooks/useDuplicateDetection.js

@@ -0,0 +1,73 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useConflictCheck } from "./useConflictCheck.js";
+// Caps how many memories run semantic detection in one pass, so a large unreviewed queue
+// cannot fan out into an unbounded number of detection calls.
+const defaultMaxChecks = 25;
+// Only memories with a description carry enough signal for semantic comparison.
+export function pickDuplicateTargets(memories, max = defaultMaxChecks) {
+    return memories.filter((m) => isPresent(m.description)).slice(0, max);
+}
+function buildMemoryKey(memory) {
+    return `${memory.iri}:${memory.scope}:${memory.label}:${memory.description ?? ""}`;
+}
+function targetSignature(memories) {
+    return memories.map(buildMemoryKey).join("|");
+}
+// Runs the existing semantic conflict check (SEMSIM recall pre-filter + LLM precision judge)
+// across a set of memories and returns, per memory IRI, the existing memories it likely
+// duplicates. Results are cached by IRI+label+description so re-renders and tab switches do
+// not re-issue detection for unchanged memories. Nothing is mutated — this only surfaces
+// candidates; the user still confirms any supersession in the review dialog.
+export function useDuplicateDetection(memories, options = {}) {
+    const { enabled = true, max = defaultMaxChecks } = options;
+    const { check } = useConflictCheck();
+    const targets = useMemo(() => (enabled ? pickDuplicateTargets(memories, max) : []), [memories, enabled, max]);
+    const signature = useMemo(() => targetSignature(targets), [targets]);
+    const [duplicates, setDuplicates] = useState(new Map());
+    const [isDetecting, setIsDetecting] = useState(false);
+    const cacheRef = useRef(new Map());
+    const checkRef = useRef(check);
+    checkRef.current = check;
+    const targetsRef = useRef(targets);
+    targetsRef.current = targets;
+    useEffect(() => {
+        const current = targetsRef.current;
+        if (!isPresent(current)) {
+            setDuplicates(new Map());
+            setIsDetecting(false);
+            return;
+        }
+        let cancelled = false;
+        setIsDetecting(true);
+        void (async () => {
+            const next = new Map();
+            for (const memory of current) {
+                const key = buildMemoryKey(memory);
+                let conflicts = cacheRef.current.get(key);
+                if (conflicts == null) {
+                    const result = await checkRef.current({
+                        label: memory.label,
+                        description: memory.description ?? "",
+                        scope: memory.scope,
+                        excludeIri: memory.iri,
+                    });
+                    if (cancelled)
+                        return;
+                    conflicts = result.conflicts;
+                    cacheRef.current.set(key, conflicts);
+                }
+                if (isPresent(conflicts))
+                    next.set(memory.iri, conflicts);
+            }
+            if (!cancelled) {
+                setDuplicates(next);
+                setIsDetecting(false);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [signature]);
+    return { duplicates, isDetecting };
+}

package/dist/routes/memories/hooks/useLiveContext.d.ts

@@ -0,0 +1,23 @@
+import { type SparqlJsonResults } from "@manta-eu/client/types/sparql-types";
+export declare const liveContextSelectQuery = "SELECT ?entity ?property ?value WHERE {\n  :LiveContext_Chat :includes ?entity .\n  ?entity ?property ?value .\n  FILTER NOT EXISTS {\n        ?entity a :Memory .\n        {\n          ?entity :memoryTrustedUntil ?horizon .\n          FILTER(?horizon <= NOW())\n        } UNION {\n          ?entity :memoryValidUntil ?expiry .\n          FILTER(?expiry <= NOW())\n        } UNION {\n          ?entity :memoryValidFrom ?validFrom .\n          FILTER(?validFrom > NOW())\n        }\n      }\n}";
+export type EntityProperty = {
+    predicate: string;
+    value: string;
+    isUri: boolean;
+    datatype?: string;
+};
+export type LiveContextEntity = {
+    iri: string;
+    compactedIri: string;
+    types: string[];
+    properties: EntityProperty[];
+};
+export type LiveContextGroup = {
+    type: string;
+    typeLabel: string;
+    entities: LiveContextEntity[];
+};
+export declare function parseLiveContext(data: SparqlJsonResults): LiveContextGroup[];
+export declare const liveContextQueryKey: readonly ["live-context"];
+export declare function useLiveContext(): import("@tanstack/react-query").UseQueryResult<LiveContextGroup[], Error>;
+//# sourceMappingURL=useLiveContext.d.ts.map

package/dist/routes/memories/hooks/useLiveContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLiveContext.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/hooks/useLiveContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAA2C,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAOtH,eAAO,MAAM,sBAAsB,gfAIjC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,EAAE,cAAc,EAAE,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B,CAAC;AAkBF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,GAAG,gBAAgB,EAAE,CA+D5E;AAED,eAAO,MAAM,mBAAmB,2BAA4B,CAAC;AAE7D,wBAAgB,cAAc,8EAwB7B"}

package/dist/routes/memories/hooks/useLiveContext.js

@@ -0,0 +1,102 @@
+import { liveContextMemoryDateFilter } from "@manta-eu/client/shared/live-context";
+import { compactUri, prependMissingSparqlPrefixes } from "@manta-eu/client/shared/rdf-namespaces";
+import { isSparqlJsonResults } from "@manta-eu/client/types/sparql-types";
+import { useQuery } from "@tanstack/react-query";
+import { useMantaClient } from "#providers/index";
+const rdfTypeIri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+const trivialTypePrefixes = ["rdf:", "rdfs:", "owl:", "xsd:"];
+export const liveContextSelectQuery = `SELECT ?entity ?property ?value WHERE {
+  :LiveContext_Chat :includes ?entity .
+  ?entity ?property ?value .
+  ${liveContextMemoryDateFilter}
+}`;
+function formatTypeLabel(compacted) {
+    const localName = compacted.includes(":") ? (compacted.split(":")[1] ?? compacted) : compacted;
+    return localName.replace(/([A-Z])/g, " $1").trim();
+}
+function sparqlValueIsUri(node) {
+    return node.type === "uri";
+}
+function sparqlValueDatatype(node) {
+    if ("datatype" in node && typeof node.datatype === "string") {
+        return node.datatype;
+    }
+    return undefined;
+}
+export function parseLiveContext(data) {
+    const entityMap = new Map();
+    for (const binding of data.results.bindings) {
+        const entityNode = binding["entity"];
+        const propertyNode = binding["property"];
+        const valueNode = binding["value"];
+        if (!entityNode || !propertyNode || !valueNode)
+            continue;
+        const entityIri = entityNode.value;
+        const propertyIri = propertyNode.value;
+        if (!entityMap.has(entityIri)) {
+            entityMap.set(entityIri, { types: [], properties: [] });
+        }
+        const entry = entityMap.get(entityIri);
+        if (!entry)
+            continue;
+        if (propertyIri === rdfTypeIri) {
+            const compacted = compactUri(valueNode.value);
+            if (!trivialTypePrefixes.some((p) => compacted.startsWith(p))) {
+                if (!entry.types.includes(compacted)) {
+                    entry.types.push(compacted);
+                }
+            }
+        }
+        else {
+            const isUri = sparqlValueIsUri(valueNode);
+            entry.properties.push({
+                predicate: compactUri(propertyIri),
+                value: isUri ? compactUri(valueNode.value) : valueNode.value,
+                isUri,
+                datatype: sparqlValueDatatype(valueNode),
+            });
+        }
+    }
+    const groupMap = new Map();
+    for (const [iri, { types, properties }] of entityMap) {
+        const primaryType = types[0] ?? "Unknown";
+        if (!groupMap.has(primaryType)) {
+            groupMap.set(primaryType, {
+                type: primaryType,
+                typeLabel: formatTypeLabel(primaryType),
+                entities: [],
+            });
+        }
+        const group = groupMap.get(primaryType);
+        if (!group)
+            continue;
+        group.entities.push({
+            iri,
+            compactedIri: compactUri(iri),
+            types,
+            properties: [...properties].sort((a, b) => a.predicate.localeCompare(b.predicate)),
+        });
+    }
+    return [...groupMap.values()].sort((a, b) => a.typeLabel.localeCompare(b.typeLabel));
+}
+export const liveContextQueryKey = ["live-context"];
+export function useLiveContext() {
+    const { sparqlFetch, onUnauthorized } = useMantaClient();
+    return useQuery({
+        queryKey: liveContextQueryKey,
+        queryFn: async () => {
+            const response = await sparqlFetch(prependMissingSparqlPrefixes(liveContextSelectQuery));
+            if (!response.ok) {
+                if (response.status === 401) {
+                    onUnauthorized();
+                }
+                throw new Error(`SPARQL query failed: ${response.status}`);
+            }
+            const raw = await response.json();
+            if (!isSparqlJsonResults(raw)) {
+                throw new Error("Invalid SPARQL results format");
+            }
+            return parseLiveContext(raw);
+        },
+    });
+}

package/dist/routes/memories/hooks/useMemoryColumns.d.ts

@@ -0,0 +1,33 @@
+import { type GQLConflictingMemory, type GQLMemory, type GQLMemorySchema } from "@manta-eu/client";
+import type { ColumnDef } from "@tanstack/react-table";
+export declare const memoryColumnIds: {
+    readonly label: "label";
+    readonly description: "description";
+    readonly kind: "kind";
+    readonly teams: "teams";
+    readonly used: "used";
+    readonly actions: "actions";
+};
+export type MemoryColumnId = (typeof memoryColumnIds)[keyof typeof memoryColumnIds];
+export declare const memoryColumnLabels: {
+    label: string;
+    description: string;
+    kind: string;
+    teams: string;
+    used: string;
+};
+export declare const defaultColumnOrder: string[];
+type UseMemoryColumnsArgs = {
+    isOperator?: boolean;
+    userId: string;
+    schemas?: GQLMemorySchema[];
+    onEdit: (memory: GQLMemory) => void;
+    onDelete: (iri: string) => void;
+    onMove?: (memory: GQLMemory) => void;
+    onRestore?: (iri: string) => void;
+    onReconfirm?: (iri: string) => void;
+    duplicates?: Map<string, GQLConflictingMemory[]>;
+};
+export declare function useMemoryColumns(args: UseMemoryColumnsArgs): ColumnDef<GQLMemory>[];
+export {};
+//# sourceMappingURL=useMemoryColumns.d.ts.map

package/dist/routes/memories/hooks/useMemoryColumns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMemoryColumns.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/hooks/useMemoryColumns.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAInG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AA2BvD,eAAO,MAAM,eAAe;;;;;;;CAOlB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAGpF,eAAO,MAAM,kBAAkB;;;;;;CAMkB,CAAC;AAElD,eAAO,MAAM,kBAAkB,UAW9B,CAAC;AAyBF,KAAK,oBAAoB,GAAG;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,MAAM,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC;IACpC,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;CAClD,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,SAAS,CAAC,SAAS,CAAC,EAAE,CA8PnF"}

package/dist/routes/memories/hooks/useMemoryColumns.js

@@ -0,0 +1,188 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { isTrustedUntilExpiringSoon } from "@manta-eu/client/shared/memory-preload-gate";
+import { formatEntityName } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { addDays, format, formatDistanceToNow, isBefore } from "date-fns";
+import { ChevronDown, Clock } from "lucide-react";
+import { useMemo } from "react";
+import { AutoCapturedBadge, DuplicateBadge, KindBadge, MemoryAbout, MemoryEvidence, OutOfWindowBadge, PreloadedBadge, SchemaBadge, } from "../components/badges.js";
+import { ImportanceIcon } from "../components/ImportanceSlider.js";
+import { MemoryActions } from "../components/MemoryActions.js";
+import { compareMemoryHorizons, formatHorizonDate, formatHorizonTooltip, memoryHorizon, memoryWindowState, shouldShowValidFrom, } from "../expiry-utils.js";
+import { Tooltip, TooltipContent, TooltipTrigger } from "#components/tooltip/index";
+export const memoryColumnIds = {
+    label: "label",
+    description: "description",
+    kind: "kind",
+    teams: "teams",
+    used: "used",
+    actions: "actions",
+};
+export const memoryColumnLabels = {
+    [memoryColumnIds.label]: "Label",
+    [memoryColumnIds.description]: "Description",
+    [memoryColumnIds.kind]: "Type",
+    [memoryColumnIds.teams]: "Teams",
+    [memoryColumnIds.used]: "Used",
+};
+export const defaultColumnOrder = [
+    memoryColumnIds.label,
+    memoryColumnIds.description,
+    memoryColumnIds.kind,
+    memoryColumnIds.teams,
+    "importance",
+    "memoryValidUntil",
+    "createdBy",
+    "extractedAt",
+    memoryColumnIds.used,
+    memoryColumnIds.actions,
+];
+function getTeamName(path) {
+    return path.split("/").filter(Boolean).pop() ?? path;
+}
+function formatCreatedBy(createdBy, currentUserId) {
+    if (!createdBy)
+        return "Manta";
+    if (createdBy === currentUserId)
+        return "You";
+    return "Another user";
+}
+function MaybeTooltip(props) {
+    const { tooltip, children } = props;
+    if (tooltip == null)
+        return children;
+    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: children }), _jsx(TooltipContent, { children: tooltip })] }));
+}
+export function useMemoryColumns(args) {
+    const { isOperator, userId, schemas, onEdit, onDelete, onMove, onRestore, onReconfirm, duplicates } = args;
+    return useMemo(() => {
+        const schemaByIri = new Map(schemas?.map((s) => [s.iri, s]) ?? []);
+        return [
+            {
+                id: memoryColumnIds.label,
+                accessorKey: "label",
+                header: "Label",
+                enableSorting: false,
+                meta: { className: "max-w-72" },
+                cell: ({ row }) => {
+                    const windowState = memoryWindowState(row.original.memoryValidFrom, row.original.memoryValidUntil);
+                    return (_jsxs("span", { className: "flex min-w-48 flex-wrap items-start gap-1.5 whitespace-normal typography-caption-medium text-default-foreground", children: [_jsx("span", { className: "line-clamp-2 min-w-24 max-w-full break-words", children: row.original.label }), row.original.supersededBy != null && (_jsx("span", { className: "inline-flex items-center rounded-full px-2 py-0.5 typography-tiny bg-faint text-muted-foreground border border-muted-border", children: "Archived" })), windowState === "active" ? (_jsx(PreloadedBadge, { memory: row.original })) : (_jsx(OutOfWindowBadge, { state: windowState })), row.original.confidence != null && row.original.confidence < 1 && (_jsx(AutoCapturedBadge, { confidence: row.original.confidence })), duplicates?.get(row.original.iri) != null && (_jsx(DuplicateBadge, { matches: (duplicates.get(row.original.iri) ?? []).map((c) => ({ label: c.label, reason: c.reason })) }))] }));
+                },
+            },
+            {
+                id: memoryColumnIds.description,
+                accessorKey: "description",
+                header: "Description",
+                enableSorting: false,
+                meta: { className: "max-w-96" },
+                cell: ({ row }) => (_jsxs("span", { className: "flex w-full min-w-56 flex-col", children: [_jsx("span", { className: "text-muted-foreground line-clamp-5 whitespace-normal break-words", children: row.original.description }), _jsx(MemoryAbout, { aboutEntityIris: row.original.aboutEntityIris }), _jsx(MemoryEvidence, { evidence: row.original.memoryEvidence })] })),
+            },
+            {
+                id: memoryColumnIds.kind,
+                accessorKey: "kind",
+                header: "Type",
+                enableSorting: true,
+                meta: { className: "max-w-52" },
+                filterFn: (row, _columnId, filterValue) => row.original.memorySubclass === filterValue || row.original.kind === filterValue,
+                cell: ({ row }) => {
+                    const props = row.original.customProperties;
+                    const filledEntries = props ? Object.entries(props).filter(([, v]) => isPresent(v)) : [];
+                    const schema = row.original.memorySubclass ? schemaByIri.get(row.original.memorySubclass) : undefined;
+                    const schemaLabel = row.original.memorySubclass
+                        ? (schema?.label ?? formatEntityName(row.original.memorySubclass))
+                        : null;
+                    const badges = (_jsxs(_Fragment, { children: [_jsx(KindBadge, { kind: row.original.kind }), _jsx(SchemaBadge, { label: schemaLabel })] }));
+                    if (!isPresent(filledEntries)) {
+                        return _jsx("div", { className: "flex min-w-36 flex-wrap items-center gap-1.5", children: badges });
+                    }
+                    return (_jsx("div", { className: "flex min-w-36 flex-wrap items-center gap-1.5", children: _jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsxs("div", { className: "inline-flex w-fit flex-wrap items-center gap-1.5", children: [badges, _jsxs("span", { className: "inline-flex items-center gap-0.5 rounded-full px-2 py-0.5 typography-tiny bg-faint border border-muted-border text-muted-foreground", children: [filledEntries.length, _jsx(ChevronDown, { className: "size-3" })] })] }) }), _jsx(TooltipContent, { className: "typography-small text-left max-w-sm", children: _jsx("div", { className: "flex flex-col gap-1", children: filledEntries.map(([path, value]) => {
+                                            const propDef = schema?.properties.find((p) => p.path === path);
+                                            const label = propDef?.label ?? formatEntityName(path);
+                                            return (_jsxs("div", { className: "flex items-center gap-1.5", children: [_jsxs("span", { className: "text-muted-foreground shrink-0 whitespace-nowrap", children: [label, ":"] }), _jsx("span", { className: "min-w-0 truncate", children: value })] }, path));
+                                        }) }) })] }) }));
+                },
+            },
+            {
+                id: memoryColumnIds.teams,
+                accessorKey: "teams",
+                header: "Teams",
+                enableSorting: false,
+                cell: ({ row }) => {
+                    const teams = row.original.teams;
+                    if (!isPresent(teams))
+                        return _jsx("span", { className: "typography-small text-muted-foreground", children: "-" });
+                    if (teams.length === 1) {
+                        return _jsx("span", { className: "typography-small text-muted-foreground", children: getTeamName(teams[0] ?? "") });
+                    }
+                    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsxs("span", { className: "typography-small text-muted-foreground cursor-default", children: [teams.length, " teams"] }) }), _jsx(TooltipContent, { children: _jsx("div", { className: "flex flex-col gap-1", children: teams.map((path) => (_jsx("span", { children: getTeamName(path) }, path))) }) })] }));
+                },
+            },
+            {
+                id: "importance",
+                accessorKey: "importance",
+                header: "Importance",
+                enableSorting: true,
+                cell: ({ row }) => _jsx(ImportanceIcon, { value: row.original.importance }),
+            },
+            {
+                id: "memoryValidUntil",
+                accessorKey: "memoryValidUntil",
+                header: "Expires",
+                enableSorting: true,
+                sortingFn: (a, b) => compareMemoryHorizons(memoryHorizon(a.original.memoryValidUntil, a.original.memoryTrustedUntil), memoryHorizon(b.original.memoryValidUntil, b.original.memoryTrustedUntil)),
+                cell: ({ row }) => {
+                    const horizon = memoryHorizon(row.original.memoryValidUntil, row.original.memoryTrustedUntil);
+                    const expiresSoon = horizon.kind === "expiry"
+                        ? isBefore(new Date(horizon.at), addDays(new Date(), 7))
+                        : horizon.kind === "trust" && isTrustedUntilExpiringSoon(horizon.at, new Date());
+                    return (_jsx(MaybeTooltip, { tooltip: horizon.kind === "none" ? null : formatHorizonTooltip(horizon), children: _jsxs("span", { className: `inline-flex items-center gap-1 typography-small ${expiresSoon ? "text-warning-foreground" : "text-muted-foreground"}`, children: [_jsx(Clock, { className: "size-3 shrink-0" }), formatHorizonDate(horizon)] }) }));
+                },
+            },
+            {
+                id: "createdBy",
+                accessorKey: "createdBy",
+                header: "Owner",
+                enableSorting: false,
+                cell: ({ row }) => (_jsx("span", { className: "typography-small text-muted-foreground", children: formatCreatedBy(row.original.createdBy, userId) })),
+            },
+            {
+                id: memoryColumnIds.used,
+                accessorFn: (memory) => memory.memoryUseCount + memory.memoryCiteCount,
+                header: "Used",
+                enableSorting: true,
+                cell: ({ row }) => {
+                    const preloaded = row.original.memoryUseCount;
+                    const cited = row.original.memoryCiteCount;
+                    const count = preloaded + cited;
+                    const lastUsedAt = row.original.memoryLastUsedAt;
+                    if (!count) {
+                        return _jsx("span", { className: "typography-small text-muted-foreground whitespace-nowrap", children: "Never" });
+                    }
+                    const lastUsedLine = lastUsedAt
+                        ? `Last used ${formatDistanceToNow(new Date(lastUsedAt), { addSuffix: true })}`
+                        : null;
+                    return (_jsx(MaybeTooltip, { tooltip: _jsxs(_Fragment, { children: [_jsxs("div", { children: [preloaded, "\u00D7 pre-loaded, ", cited, "\u00D7 cited"] }), lastUsedLine ? _jsx("div", { children: lastUsedLine }) : null] }), children: _jsxs("span", { className: "typography-small whitespace-nowrap", children: [count, "\u00D7"] }) }));
+                },
+            },
+            {
+                id: "extractedAt",
+                accessorKey: "updatedAt",
+                header: "Updated",
+                enableSorting: true,
+                cell: ({ row }) => {
+                    const validFrom = row.original.memoryValidFrom;
+                    const tooltip = validFrom && shouldShowValidFrom(row.original.updatedAt, validFrom)
+                        ? `True since ${format(new Date(validFrom), "MMM d, yyyy")} — older than this record`
+                        : null;
+                    return (_jsx(MaybeTooltip, { tooltip: tooltip, children: _jsx("span", { className: "typography-small text-muted-foreground whitespace-nowrap", children: formatDistanceToNow(new Date(row.original.updatedAt), { addSuffix: true }) }) }));
+                },
+            },
+            {
+                id: memoryColumnIds.actions,
+                enableHiding: false,
+                enableSorting: false,
+                cell: ({ row }) => (_jsx(MemoryActions, { memory: row.original, isOperator: isOperator, onEdit: onEdit, onDelete: onDelete, onMove: onMove, onRestore: onRestore, onReconfirm: onReconfirm })),
+            },
+        ];
+    }, [isOperator, userId, schemas, onEdit, onDelete, onMove, onRestore, onReconfirm, duplicates]);
+}

package/dist/routes/memories/hooks/useMemoryTable.d.ts

@@ -0,0 +1,33 @@
+import type { GQLMemory } from "@manta-eu/client";
+import type { ColumnDef, SortingState, Table } from "@tanstack/react-table";
+import type { KindFilter, SchemaFilter } from "../components/MemoriesFilters.js";
+export type { KindFilter, SchemaFilter };
+export type ImportanceFilter = 0 | 1 | 2 | 3 | 4 | 5;
+export type StatusFilterKey = "autoCaptured" | "hideStale" | "promotion" | "deadWeight" | "unused" | "needsReview";
+export type MemoryFilterCriteria = {
+    search: string;
+    importance: ImportanceFilter;
+    autoCaptured: boolean;
+    hideStale: boolean;
+    promotion: boolean;
+    deadWeight: boolean;
+    unused: boolean;
+    needsReview: boolean;
+    schema: SchemaFilter;
+};
+export declare function filterMemories(data: GQLMemory[], criteria: MemoryFilterCriteria, now?: Date): GQLMemory[];
+export type UseMemoryTableResult = {
+    table: Table<GQLMemory>;
+    kindFilter: KindFilter;
+    onKindFilterChange: (kind: KindFilter) => void;
+    schemaFilter: SchemaFilter;
+    onSchemaFilterChange: (iri: SchemaFilter) => void;
+    searchQuery: string;
+    onSearchQueryChange: (query: string) => void;
+    importanceFilter: ImportanceFilter;
+    onImportanceFilterChange: (importance: ImportanceFilter) => void;
+    statusFilters: Record<StatusFilterKey, boolean>;
+    onStatusFilterChange: (key: StatusFilterKey, value: boolean) => void;
+};
+export declare function useMemoryTable(tableKey: string, data: GQLMemory[], columns: ColumnDef<GQLMemory>[], initialSorting?: SortingState, initialColumnVisibility?: Record<string, boolean>): UseMemoryTableResult;
+//# sourceMappingURL=useMemoryTable.d.ts.map

package/dist/routes/memories/hooks/useMemoryTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMemoryTable.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/hooks/useMemoryTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAOlD,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAmB,MAAM,uBAAuB,CAAC;AAM7F,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAK9E,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;AAEzC,MAAM,MAAM,gBAAgB,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,WAAW,GAAG,WAAW,GAAG,YAAY,GAAG,QAAQ,GAAG,aAAa,CAAC;AA0BnH,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,gBAAgB,CAAC;IAC7B,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,QAAQ,EAAE,oBAAoB,EAAE,GAAG,GAAE,IAAiB,GAAG,SAAS,EAAE,CAgCrH;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IACxB,UAAU,EAAE,UAAU,CAAC;IACvB,kBAAkB,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IAC/C,YAAY,EAAE,YAAY,CAAC;IAC3B,oBAAoB,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,CAAC;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,wBAAwB,EAAE,CAAC,UAAU,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACjE,aAAa,EAAE,MAAM,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;IAChD,oBAAoB,EAAE,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACtE,CAAC;AAEF,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,SAAS,EAAE,EACjB,OAAO,EAAE,SAAS,CAAC,SAAS,CAAC,EAAE,EAC/B,cAAc,GAAE,YAAiB,EACjC,uBAAuB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChD,oBAAoB,CAiGtB"}