@focus-reactive/payload-plugin-translator 0.7.2 → 0.8.0

package/README.md

@@ -180,6 +180,22 @@ translatorPlugin({
 });
 ```
 
+### Stale-translation detection
+
+_Since v0.8.0._
+
+With `provenance` enabled, the document translation control shows an **"out of date"** marker (with a
+tooltip naming the affected locales) when a target locale's source content changed after it was
+translated. Open the translation popup to see the per-locale list, where each locale can be
+**re-translated** or its out-of-date notice **dismissed**.
+Staleness is derived on read by comparing the current source fingerprint against the one recorded at
+translation time — no extra configuration, and no write-side hook on your collections. Editing a
+source locale marks its already-translated locales stale on the next panel view; re-translating clears it.
+
+Dismiss acknowledges the drift without re-translating; the marker stays hidden until the source
+changes again. When `provenance` is disabled nothing is shown. Note the fingerprint is text-only, so
+formatting-only edits to rich text do not mark a locale stale.
+
 ### Lifecycle callbacks
 
 _Since v0.7.0._
@@ -382,11 +398,10 @@ Every public API is annotated with `@since x.y.z` in its JSDoc, and features car
 
 ## Roadmap
 
-Planned features building on the v0.7.0 provenance foundation:
+Planned features building on the provenance foundation:
 
-- **Stale-translation detection** — surface which target locales are out of sync with their source, using the recorded provenance fingerprint.
 - **Global translation dashboard** — translate across all collections from one place, with project-wide progress.
-- **Auto-translate on source change** — retranslate automatically when default-locale content changes.
+- **Auto-translate on source change** — retranslate automatically when default-locale content changes, driven by stale-translation detection.
 
 ## License
 

package/dist/client/entities/translation/api/mutations/useDismissStaleness.d.ts

@@ -0,0 +1,12 @@
+import type { CollectionSlug } from "payload";
+type Variables = {
+    collection: CollectionSlug;
+    id: string;
+    target_lng: string;
+};
+/**
+ * Dismisses (acknowledges) staleness of one target locale, then refreshes the staleness query so the
+ * indicator disappears until the source changes again (#50).
+ */
+export declare function useDismissStaleness(): import("@tanstack/react-query").UseMutationResult<void, Error, Variables, unknown>;
+export {};

package/dist/client/entities/translation/api/mutations/useDismissStaleness.js

@@ -0,0 +1,40 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { ofetch } from "ofetch";
+import { useTranslateKitConfig } from "../../../../app/config";
+import { handleNextApiError } from "../../../../shared/lib/errors/handleApiError";
+import { DOCUMENT_STALENESS_QUERY_KEY } from "../queries/useDocumentStaleness";
+/**
+ * Dismisses (acknowledges) staleness of one target locale, then refreshes the staleness query so the
+ * indicator disappears until the source changes again (#50).
+ */ export function useDismissStaleness() {
+    const queryClient = useQueryClient();
+    const { basePath } = useTranslateKitConfig();
+    return useMutation({
+        mutationKey: [
+            "dismiss-staleness"
+        ],
+        mutationFn: async ({ collection, id, target_lng })=>{
+            await handleNextApiError(()=>{
+                return ofetch(`/api${basePath}/stale/dismiss`, {
+                    method: "post",
+                    body: {
+                        collection_slug: collection,
+                        collection_id: id,
+                        target_lng
+                    }
+                });
+            });
+        },
+        onSuccess: (_data, { collection, id })=>{
+            queryClient.invalidateQueries({
+                queryKey: [
+                    DOCUMENT_STALENESS_QUERY_KEY,
+                    collection,
+                    id
+                ]
+            });
+        }
+    });
+}
+
+//# sourceMappingURL=useDismissStaleness.js.map

package/dist/client/entities/translation/api/mutations/useQueueDocumentTranslation.js

@@ -2,6 +2,7 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { ofetch } from "ofetch";
 import { useTranslateKitConfig } from "../../../../app/config";
 import { handleNextApiError } from "../../../../shared/lib/errors/handleApiError";
+import { DOCUMENT_STALENESS_QUERY_KEY } from "../queries/useDocumentStaleness";
 export function useQueueDocumentTranslation() {
     const queryClient = useQueryClient();
     const { basePath } = useTranslateKitConfig();
@@ -26,6 +27,11 @@ export function useQueueDocumentTranslation() {
                     "collection-translation-status"
                 ]
             });
+            queryClient.invalidateQueries({
+                queryKey: [
+                    DOCUMENT_STALENESS_QUERY_KEY
+                ]
+            });
         }
     });
 }

package/dist/client/entities/translation/api/mutations/useRunDocumentTranslation.js

@@ -2,6 +2,7 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { ofetch } from "ofetch";
 import { useTranslateKitConfig } from "../../../../app/config";
 import { handleNextApiError } from "../../../../shared/lib/errors/handleApiError";
+import { DOCUMENT_STALENESS_QUERY_KEY } from "../queries/useDocumentStaleness";
 export function useRunDocumentTranslation() {
     const queryClient = useQueryClient();
     const { basePath } = useTranslateKitConfig();
@@ -20,6 +21,11 @@ export function useRunDocumentTranslation() {
                     "document-translation-status"
                 ]
             });
+            queryClient.invalidateQueries({
+                queryKey: [
+                    DOCUMENT_STALENESS_QUERY_KEY
+                ]
+            });
         }
     });
 }

package/dist/client/entities/translation/api/queries/useDocumentStaleness.d.ts

@@ -0,0 +1,17 @@
+import type { CollectionSlug } from "payload";
+import type { DocumentStaleness } from "../../model/types";
+type Props = {
+    collection: CollectionSlug;
+    id: string;
+};
+type Options = {
+    enabled?: boolean;
+};
+export declare const DOCUMENT_STALENESS_QUERY_KEY = "document-staleness";
+/**
+ * Reads per-locale staleness for a document (#50). Computed lazily on the server, so there is no
+ * polling — it refetches on mount / window focus and whenever the dismiss mutation invalidates its
+ * key. Reports nothing when provenance is disabled.
+ */
+export declare function useDocumentStaleness({ collection, id }: Props, options?: Options): import("@tanstack/react-query").UseQueryResult<NoInfer<DocumentStaleness>, Error>;
+export {};

package/dist/client/entities/translation/api/queries/useDocumentStaleness.js

@@ -0,0 +1,35 @@
+import { useQuery } from "@tanstack/react-query";
+import { ofetch } from "ofetch";
+import { useTranslateKitConfig } from "../../../../app/config";
+import { handleNextApiError } from "../../../../shared/lib/errors/handleApiError";
+export const DOCUMENT_STALENESS_QUERY_KEY = "document-staleness";
+const getQueryKey = ({ collection, id })=>[
+        DOCUMENT_STALENESS_QUERY_KEY,
+        collection,
+        id
+    ];
+/**
+ * Reads per-locale staleness for a document (#50). Computed lazily on the server, so there is no
+ * polling — it refetches on mount / window focus and whenever the dismiss mutation invalidates its
+ * key. Reports nothing when provenance is disabled.
+ */ export function useDocumentStaleness({ collection, id }, options) {
+    const { basePath } = useTranslateKitConfig();
+    return useQuery({
+        queryKey: getQueryKey({
+            collection,
+            id
+        }),
+        queryFn: async ({ signal })=>{
+            return handleNextApiError(async ()=>{
+                const response = await ofetch(`/api${basePath}/stale/${collection}/${id}`, {
+                    method: "get",
+                    signal
+                });
+                return response.data;
+            });
+        },
+        enabled: options?.enabled
+    });
+}
+
+//# sourceMappingURL=useDocumentStaleness.js.map

package/dist/client/entities/translation/api/queries/useDocumentTranslation.js

@@ -1,8 +1,9 @@
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { ofetch } from "ofetch";
-import { useCallback } from "react";
+import { useCallback, useEffect, useRef } from "react";
 import { useTranslateKitConfig } from "../../../../app/config";
 import { handleNextApiError } from "../../../../shared/lib/errors/handleApiError";
+import { DOCUMENT_STALENESS_QUERY_KEY } from "./useDocumentStaleness";
 const getDocumentTranslationQueryKey = ({ collection, id })=>{
     return [
         "document-translation-status",
@@ -45,6 +46,27 @@ export function useDocumentTranslation({ collection, id }, options) {
         id,
         queryClient
     ]);
+    // When a queued (async) translation transitions to "completed" in-session, the provenance
+    // record's sourceFingerprint has just been updated server-side — invalidate staleness so the
+    // "Out of date" notice clears without waiting for the next focus/remount refetch (#50).
+    // Seeded lazily (undefined) and gated on a *defined, non-completed → completed* transition, so a
+    // cold mount of an already-completed document does NOT fire a spurious extra refetch.
+    const previousStatusRef = useRef(undefined);
+    useEffect(()=>{
+        const previousStatus = previousStatusRef.current;
+        const currentStatus = query.data?.status;
+        if (currentStatus === "completed" && previousStatus !== undefined && previousStatus !== "completed") {
+            queryClient.invalidateQueries({
+                queryKey: [
+                    DOCUMENT_STALENESS_QUERY_KEY
+                ]
+            });
+        }
+        previousStatusRef.current = currentStatus;
+    }, [
+        query.data?.status,
+        queryClient
+    ]);
     return {
         ...query,
         invalidate

package/dist/client/entities/translation/index.d.ts

@@ -1,20 +1,27 @@
 import { useCancelCollectionTranslations } from "./api/mutations/useCancelCollectionTranslations";
 import { useCancelDocumentTranslation } from "./api/mutations/useCancelDocumentTranslation";
+import { useDismissStaleness } from "./api/mutations/useDismissStaleness";
 import { useQueueDocumentTranslation } from "./api/mutations/useQueueDocumentTranslation";
 import { useRunDocumentTranslation } from "./api/mutations/useRunDocumentTranslation";
 import { useCollectionTranslationStatus } from "./api/queries/useCollectionTranslationStatus";
+import { useDocumentStaleness } from "./api/queries/useDocumentStaleness";
 import { useDocumentTranslation } from "./api/queries/useDocumentTranslation";
-export { CompletedTranslationStatus } from "./ui/CompletedTranslationStatus";
-export { FailedTranslationStatus } from "./ui/FailedTranslationStatus";
-export { RunningTranslationStatus } from "./ui/RunningTranslationStatus";
+export { TranslationStatusList } from "./ui/TranslationStatusList";
 export declare const TranslationsApi: {
     useRunDocumentTranslation: typeof useRunDocumentTranslation;
     useQueueDocumentTranslation: typeof useQueueDocumentTranslation;
     useDocumentTranslation: typeof useDocumentTranslation;
+    useDocumentStaleness: typeof useDocumentStaleness;
     useCancelDocumentTranslation: typeof useCancelDocumentTranslation;
     useCollectionTranslationStatus: typeof useCollectionTranslationStatus;
     useCancelCollectionTranslations: typeof useCancelCollectionTranslations;
+    useDismissStaleness: typeof useDismissStaleness;
 };
-export { PendingTranslationStatus } from "./ui/PendingTranslationStatus";
-export type { DocumentTranslation, DocumentTranslationCompleted, DocumentTranslationFailed, DocumentTranslationPending, DocumentTranslationRunning, CollectionTranslationStatus, CollectionTranslationStatusItem, GroupedCollectionTranslationStatus, } from "./model/types";
+export type { DocumentTranslation, DocumentTranslationCompleted, DocumentTranslationFailed, DocumentTranslationPending, DocumentTranslationRunning, CollectionTranslationStatus, CollectionTranslationStatusItem, GroupedCollectionTranslationStatus, DocumentStaleness, StalenessLocale, } from "./model/types";
 export { DocumentTranslationStatus } from "./model/enums";
+export { derivePanelStatus, deriveCollectionPanelStatus, describePanelStatus, } from "./model/panelStatus";
+export type { PanelStatus, MarkerTone } from "./model/panelStatus";
+export { PanelStatusMarker } from "./ui/PanelStatusMarker";
+export { ActionButton } from "./ui/ActionButton";
+export { buildTranslationStatusRows } from "./model/statusRows";
+export type { TranslationStatusRow, TranslationRowState } from "./model/statusRows";

package/dist/client/entities/translation/index.js

@@ -1,21 +1,26 @@
 import { useCancelCollectionTranslations } from "./api/mutations/useCancelCollectionTranslations";
 import { useCancelDocumentTranslation } from "./api/mutations/useCancelDocumentTranslation";
+import { useDismissStaleness } from "./api/mutations/useDismissStaleness";
 import { useQueueDocumentTranslation } from "./api/mutations/useQueueDocumentTranslation";
 import { useRunDocumentTranslation } from "./api/mutations/useRunDocumentTranslation";
 import { useCollectionTranslationStatus } from "./api/queries/useCollectionTranslationStatus";
+import { useDocumentStaleness } from "./api/queries/useDocumentStaleness";
 import { useDocumentTranslation } from "./api/queries/useDocumentTranslation";
-export { CompletedTranslationStatus } from "./ui/CompletedTranslationStatus";
-export { FailedTranslationStatus } from "./ui/FailedTranslationStatus";
-export { RunningTranslationStatus } from "./ui/RunningTranslationStatus";
+export { TranslationStatusList } from "./ui/TranslationStatusList";
 export const TranslationsApi = {
     useRunDocumentTranslation,
     useQueueDocumentTranslation,
     useDocumentTranslation,
+    useDocumentStaleness,
     useCancelDocumentTranslation,
     useCollectionTranslationStatus,
-    useCancelCollectionTranslations
+    useCancelCollectionTranslations,
+    useDismissStaleness
 };
-export { PendingTranslationStatus } from "./ui/PendingTranslationStatus";
 export { DocumentTranslationStatus } from "./model/enums";
+export { derivePanelStatus, deriveCollectionPanelStatus, describePanelStatus } from "./model/panelStatus";
+export { PanelStatusMarker } from "./ui/PanelStatusMarker";
+export { ActionButton } from "./ui/ActionButton";
+export { buildTranslationStatusRows } from "./model/statusRows";
 
 //# sourceMappingURL=index.js.map

package/dist/client/entities/translation/model/panelStatus.d.ts

@@ -0,0 +1,60 @@
+import { DocumentTranslationStatus } from "./enums";
+import type { StatusDotColor } from "./statusRows";
+import type { GroupedCollectionTranslationStatus } from "./types";
+/**
+ * The single aggregate signal shown on a translate trigger (document or collection). Detail lives in
+ * the popup; the panel only surfaces the most urgent state at a glance (see the panel-UI design doc).
+ */
+export type PanelStatus = {
+    kind: "failed";
+} | {
+    kind: "running";
+} | {
+    kind: "stale";
+    staleLocales: string[];
+} | {
+    kind: "fresh";
+} | {
+    kind: "none";
+};
+/** The marker tones — every panel state except `none` (which shows no marker). */
+export type MarkerTone = Exclude<PanelStatus["kind"], "none">;
+/**
+ * Dot colour + motion per aggregate marker tone. Mirrors the status list's `STATE_DOT` vocabulary
+ * (failed=red, in-progress=blue+pulse, stale=amber, fresh=green) so the trigger badge and the popup
+ * rows read as one system.
+ */
+export declare const MARKER_DOT: Record<MarkerTone, {
+    color: StatusDotColor;
+    animated?: boolean;
+}>;
+/**
+ * Map an aggregate {@link PanelStatus} to the trigger marker's tone + hover/AT text. Shared by the
+ * document and collection triggers so both name their states the same way. `fallbackTitle` is the
+ * "nothing to signal" label (each surface passes its own, e.g. "Translate this document").
+ */
+export declare function describePanelStatus(status: PanelStatus | undefined, fallbackTitle: string): {
+    tone?: MarkerTone;
+    title: string;
+};
+type PanelStatusInput = {
+    /** Status of the latest translation job, if any. */
+    runStatus?: DocumentTranslationStatus | null;
+    /** Target locales whose translation is out of date (from staleness detection). */
+    staleLocales: string[];
+};
+/**
+ * Collapse the latest run status + per-locale staleness into one panel marker, by priority:
+ * `failed → running → stale → fresh → none`. A more urgent transient state (a failed or in-flight
+ * job) outranks the durable "out of date" signal; `fresh` means a completed translation with nothing
+ * stale; `none` means nothing has been translated yet.
+ */
+export declare function derivePanelStatus({ runStatus, staleLocales }: PanelStatusInput): PanelStatus;
+/**
+ * Collapse a collection's grouped job counts into one trigger marker. Priority:
+ * `in-progress (running/pending) → failed → fresh → none`. In-progress outranks failures because
+ * work is actively happening and self-resolves; once nothing is running, a failure is surfaced.
+ * There is no `stale` here — staleness is a per-document signal, not tracked for the bulk dashboard.
+ */
+export declare function deriveCollectionPanelStatus(status: GroupedCollectionTranslationStatus | undefined): PanelStatus;
+export {};

package/dist/client/entities/translation/model/panelStatus.js

@@ -0,0 +1,101 @@
+import { DocumentTranslationStatus } from "./enums";
+/**
+ * Dot colour + motion per aggregate marker tone. Mirrors the status list's `STATE_DOT` vocabulary
+ * (failed=red, in-progress=blue+pulse, stale=amber, fresh=green) so the trigger badge and the popup
+ * rows read as one system.
+ */ export const MARKER_DOT = {
+    failed: {
+        color: "red"
+    },
+    running: {
+        color: "blue",
+        animated: true
+    },
+    stale: {
+        color: "amber"
+    },
+    fresh: {
+        color: "green"
+    }
+};
+/**
+ * Map an aggregate {@link PanelStatus} to the trigger marker's tone + hover/AT text. Shared by the
+ * document and collection triggers so both name their states the same way. `fallbackTitle` is the
+ * "nothing to signal" label (each surface passes its own, e.g. "Translate this document").
+ */ export function describePanelStatus(status, fallbackTitle) {
+    switch(status?.kind){
+        case "failed":
+            return {
+                tone: "failed",
+                title: "Last translation failed"
+            };
+        case "running":
+            return {
+                tone: "running",
+                title: "Translation in progress…"
+            };
+        case "stale":
+            return {
+                tone: "stale",
+                title: `Out of date: ${status.staleLocales.map((l)=>l.toLowerCase()).join(", ")}`
+            };
+        case "fresh":
+            return {
+                tone: "fresh",
+                title: "Translations up to date"
+            };
+        default:
+            return {
+                title: fallbackTitle
+            };
+    }
+}
+/**
+ * Collapse the latest run status + per-locale staleness into one panel marker, by priority:
+ * `failed → running → stale → fresh → none`. A more urgent transient state (a failed or in-flight
+ * job) outranks the durable "out of date" signal; `fresh` means a completed translation with nothing
+ * stale; `none` means nothing has been translated yet.
+ */ export function derivePanelStatus({ runStatus, staleLocales }) {
+    if (runStatus === DocumentTranslationStatus.FAILED) return {
+        kind: "failed"
+    };
+    if (runStatus === DocumentTranslationStatus.RUNNING || runStatus === DocumentTranslationStatus.PENDING) {
+        return {
+            kind: "running"
+        };
+    }
+    if (staleLocales.length > 0) return {
+        kind: "stale",
+        staleLocales
+    };
+    if (runStatus === DocumentTranslationStatus.COMPLETED) return {
+        kind: "fresh"
+    };
+    return {
+        kind: "none"
+    };
+}
+/**
+ * Collapse a collection's grouped job counts into one trigger marker. Priority:
+ * `in-progress (running/pending) → failed → fresh → none`. In-progress outranks failures because
+ * work is actively happening and self-resolves; once nothing is running, a failure is surfaced.
+ * There is no `stale` here — staleness is a per-document signal, not tracked for the bulk dashboard.
+ */ export function deriveCollectionPanelStatus(status) {
+    if (!status) return {
+        kind: "none"
+    };
+    if (status.running.length > 0 || status.pending.length > 0) return {
+        kind: "running"
+    };
+    if (status.failed.length > 0) return {
+        kind: "failed"
+    };
+    if (status.completed.length > 0) return {
+        kind: "fresh"
+    };
+    return {
+        kind: "none"
+    };
+}
+
+//# sourceMappingURL=panelStatus.js.map

package/dist/client/entities/translation/model/statusRows.d.ts

@@ -0,0 +1,42 @@
+import type { DocumentStaleness, DocumentTranslation } from "./types";
+/**
+ * One row in the unified per-locale STATUS list. Collapses what used to be three separate visual
+ * treatments (the completed chip, the "out of date" list, and the running/pending/failed chips) into
+ * a single consistent shape keyed by target locale.
+ */
+export type TranslationRowState = "failed" | "running" | "pending" | "stale" | "translated";
+export type TranslationStatusRow = {
+    /** Stable key — the target locale (one row per target). */
+    targetLocale: string;
+    sourceLocale: string;
+    state: TranslationRowState;
+    /** ISO timestamp for the row's caption (translation time, or the job's last update). */
+    at?: string;
+    /** Set together with a transient `state` (failed/running/pending) — the job id run/cancel act on. */
+    jobId?: string;
+    /** Failure reason, present only for `state === "failed"`, so the row can surface why it failed. */
+    error?: string;
+};
+/** The status dot vocabulary (a `ColorIndicator` colour), shared by the list badge and the panel marker. */
+export type StatusDotColor = "red" | "green" | "blue" | "gray" | "amber";
+/**
+ * Dot colour + motion per row state. Only the actively-processing state pulses, so motion means
+ * "in progress now". The single source of truth for the status colour vocabulary — the panel
+ * trigger marker mirrors it (see `MARKER_DOT`).
+ */
+export declare const STATE_DOT: Record<TranslationRowState, {
+    color: StatusDotColor;
+    animated?: boolean;
+}>;
+/**
+ * Build the unified status rows from per-locale staleness + the single latest job.
+ *
+ * Rows come from `staleness.locales` (one per translated target: `stale` or `translated`). The latest
+ * job is overlaid onto its target locale: a **transient** job state (failed/running/pending) wins over
+ * the durable signal for that locale, and a job for a target with no provenance row yet adds a row.
+ * Sorted `failed → running → pending → stale → translated`, newest first within a group.
+ */
+export declare function buildTranslationStatusRows(input: {
+    staleness?: DocumentStaleness | null;
+    run?: DocumentTranslation;
+}): TranslationStatusRow[];

package/dist/client/entities/translation/model/statusRows.js

@@ -0,0 +1,79 @@
+/**
+ * Dot colour + motion per row state. Only the actively-processing state pulses, so motion means
+ * "in progress now". The single source of truth for the status colour vocabulary — the panel
+ * trigger marker mirrors it (see `MARKER_DOT`).
+ */ export const STATE_DOT = {
+    failed: {
+        color: "red"
+    },
+    running: {
+        color: "blue",
+        animated: true
+    },
+    pending: {
+        color: "gray"
+    },
+    stale: {
+        color: "amber"
+    },
+    translated: {
+        color: "green"
+    }
+};
+// Most urgent first. Transient job states outrank the durable stale/translated signal.
+const ORDER = {
+    failed: 0,
+    running: 1,
+    pending: 2,
+    stale: 3,
+    translated: 4
+};
+const TRANSIENT = new Set([
+    "failed",
+    "running",
+    "pending"
+]);
+// Maps the closed 4-member job-status set to a row state. "completed" → "translated"; the transient
+// three pass through. If a new DocumentTranslationStatus is ever added, extend this explicitly —
+// otherwise it would silently render as "translated".
+const toRowState = (jobStatus)=>jobStatus === "failed" || jobStatus === "running" || jobStatus === "pending" ? jobStatus : "translated";
+/**
+ * Build the unified status rows from per-locale staleness + the single latest job.
+ *
+ * Rows come from `staleness.locales` (one per translated target: `stale` or `translated`). The latest
+ * job is overlaid onto its target locale: a **transient** job state (failed/running/pending) wins over
+ * the durable signal for that locale, and a job for a target with no provenance row yet adds a row.
+ * Sorted `failed → running → pending → stale → translated`, newest first within a group.
+ */ export function buildTranslationStatusRows(input) {
+    const { staleness, run } = input;
+    const byTarget = new Map();
+    for (const locale of staleness?.locales ?? []){
+        byTarget.set(locale.target_lng, {
+            targetLocale: locale.target_lng,
+            sourceLocale: locale.source_lng,
+            state: locale.is_stale ? "stale" : "translated",
+            at: locale.translated_at
+        });
+    }
+    if (run) {
+        const state = toRowState(run.status);
+        const target = run.input.target_lng;
+        const existing = byTarget.get(target);
+        // Overlay the job only when it adds information: a transient state, or a locale not yet listed.
+        if (TRANSIENT.has(state) || !existing) {
+            byTarget.set(target, {
+                targetLocale: target,
+                sourceLocale: run.input.source_lng,
+                state: existing && !TRANSIENT.has(state) ? existing.state : state,
+                at: run.updated_at,
+                jobId: TRANSIENT.has(state) ? run.id : existing?.jobId,
+                error: run.status === "failed" ? run.error.message : undefined
+            });
+        }
+    }
+    return [
+        ...byTarget.values()
+    ].sort((a, b)=>ORDER[a.state] - ORDER[b.state] || (b.at ?? "").localeCompare(a.at ?? ""));
+}
+
+//# sourceMappingURL=statusRows.js.map

package/dist/client/entities/translation/model/types.d.ts

@@ -44,4 +44,15 @@ export type CollectionTranslationStatus = {
     docs: Array<CollectionTranslationStatusItem>;
 };
 export type GroupedCollectionTranslationStatus = Record<DocumentTranslationStatus, CollectionTranslationStatusItem[]>;
+/** One translated target locale's staleness relative to its source (#50). */
+export type StalenessLocale = {
+    target_lng: string;
+    source_lng: string;
+    is_stale: boolean;
+    translated_at: string;
+};
+/** Per-locale staleness for a single document. */
+export type DocumentStaleness = {
+    locales: StalenessLocale[];
+};
 export {};

package/dist/client/entities/translation/model/types.js

@@ -1,3 +1,3 @@
-export { };
+/** Per-locale staleness for a single document. */ export { };
 
 //# sourceMappingURL=types.js.map

package/dist/client/entities/translation/ui/ActionButton/ActionButton.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+/**
+ * A row action shared by the document and collection status lists: a bordered, neutral icon button
+ * + tooltip. One source of truth so both popovers' actions look identical. The icon gives the
+ * affordance; the tooltip carries the explanation (a bare label can't say "hide until the source
+ * changes again").
+ */
+export declare function ActionButton({ icon, title, onClick, disabled, loading, }: {
+    icon: ReactNode;
+    title: string;
+    onClick: () => void;
+    disabled?: boolean;
+    loading?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/entities/translation/ui/ActionButton/ActionButton.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import Button from "../../../../shared/ui/Button";
+import Tooltip from "../../../../shared/ui/Tooltip";
+import styles from "./styles.module.scss";
+/**
+ * A row action shared by the document and collection status lists: a bordered, neutral icon button
+ * + tooltip. One source of truth so both popovers' actions look identical. The icon gives the
+ * affordance; the tooltip carries the explanation (a bare label can't say "hide until the source
+ * changes again").
+ */ export function ActionButton({ icon, title, onClick, disabled, loading }) {
+    return /*#__PURE__*/ _jsx(Tooltip, {
+        content: title,
+        children: /*#__PURE__*/ _jsx(Button, {
+            type: "button",
+            $variant: "transparent",
+            $size: "sm",
+            $isIconButton: true,
+            className: styles.action,
+            "aria-label": title,
+            onClick: onClick,
+            disabled: disabled,
+            $isLoading: loading,
+            children: icon
+        })
+    });
+}
+
+//# sourceMappingURL=ActionButton.js.map

package/dist/client/entities/translation/ui/ActionButton/index.d.ts

@@ -0,0 +1 @@
+export { ActionButton } from "./ActionButton";

package/dist/client/entities/translation/ui/ActionButton/index.js

@@ -0,0 +1,3 @@
+export { ActionButton } from "./ActionButton";
+
+//# sourceMappingURL=index.js.map