nucleus-core-ts 0.9.935 → 0.9.936

package/dist/.build-ok

@@ -1 +1 @@
-0.9.935
+0.9.936

package/dist/fe/components/IntegrationsPage/components/MappingEditor.js

@@ -182,6 +182,7 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                             missingRecordColumn: draft.missingRecordColumn ?? '',
                             missingRecordPolicy: draft.missingRecordPolicy,
                             missingRecordValue: draft.missingRecordValue ?? '',
+                            removalScopeColumn: draft.removalScopeColumn ?? '',
                             originColumn: draft.originColumn ?? '',
                             originValue: draft.originValue ?? '',
                             maxRemovalShare: draft.maxRemovalShare ?? 0,
@@ -194,6 +195,9 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                             onMissingRecordValueChange: (value)=>patch({
                                     missingRecordValue: value
                                 }),
+                            onRemovalScopeColumnChange: (value)=>patch({
+                                    removalScopeColumn: value
+                                }),
                             onOriginColumnChange: (value)=>patch({
                                     originColumn: value
                                 }),

package/dist/fe/components/IntegrationsPage/components/MappingList.js

@@ -5,6 +5,7 @@ import { cn } from '../../../utils/cn';
 import { useIntegrationsStore } from '../store';
 import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
+import { mappingStaleness } from './mappingStaleness';
 import { Badge, Field, Notice } from './Primitives';
 import { formatMoment } from './runFormat';
 import { ListSkeleton } from './Skeletons';
@@ -39,6 +40,19 @@ const WRITE_MODE_TONE = {
 export function MappingList({ actions, sourceId, selectedId, reloadToken, onSelect, onRun }) {
     const t = useLabels().errors;
     const labels = useLabels();
+    /*
+   * Read AFTER mount, never during render.
+   *
+   * "How long ago" is a function of the clock, and the clock on the server that
+   * renders this HTML is not the one in the browser that hydrates it. Computing
+   * it in render is what put two different strings in the same row and had React
+   * swap one for the other on mount — the same fault the last-run timestamp was
+   * already fixed for. Null until mounted means the first paint has no age
+   * badges at all, which both renders agree on.
+   */ const [now, setNow] = useState(null);
+    useEffect(()=>{
+        setNow(Date.now());
+    }, []);
     const store = useIntegrationsStore();
     const uid = useId();
     const search = store.mappingsSearch;
@@ -201,7 +215,27 @@ export function MappingList({ actions, sourceId, selectedId, reloadToken, onSele
                                                     /*#__PURE__*/ _jsx("span", {
                                                         className: theme.list.itemMeta,
                                                         children: describeLastRun(mapping.lastRunAt, labels.ui)
-                                                    })
+                                                    }),
+                                                    (()=>{
+                                                        if (now === null) return null;
+                                                        const health = mappingStaleness({
+                                                            lastRunAt: mapping.lastRunAt,
+                                                            scheduleEnabled: mapping.scheduleEnabled,
+                                                            now
+                                                        });
+                                                        return /*#__PURE__*/ _jsxs(_Fragment, {
+                                                            children: [
+                                                                health.unscheduled ? /*#__PURE__*/ _jsx(Badge, {
+                                                                    tone: "warning",
+                                                                    children: labels.ui.unscheduled
+                                                                }) : null,
+                                                                health.tone === 'warning' && health.ageDays !== null ? /*#__PURE__*/ _jsx(Badge, {
+                                                                    tone: "warning",
+                                                                    children: labels.ui.behindByDays(health.ageDays)
+                                                                }) : null
+                                                            ]
+                                                        });
+                                                    })()
                                                 ]
                                             })
                                         ]

package/dist/fe/components/IntegrationsPage/components/MappingWriteModeFields.d.ts

@@ -8,6 +8,13 @@ export type MappingWriteModeFieldsProps = {
     missingRecordPolicy: MissingRecordPolicyValue;
     missingRecordColumn: string;
     missingRecordValue: string;
+    /**
+     * Target column carrying whichever value this mapping's calls vary.
+     *
+     * Set, removal is confined to the values THIS run read, so one call answering
+     * with an error costs that slice its cleanup rather than refusing the run.
+     */
+    removalScopeColumn: string;
     /** The mark this mapping puts on its rows — and the only ones it may remove. */
     originColumn: string;
     originValue: string;
@@ -20,11 +27,12 @@ export type MappingWriteModeFieldsProps = {
     onMissingRecordPolicyChange: (policy: MissingRecordPolicyValue) => void;
     onMissingRecordColumnChange: (value: string) => void;
     onMissingRecordValueChange: (value: string) => void;
+    onRemovalScopeColumnChange: (value: string) => void;
     onOriginColumnChange: (value: string) => void;
     onOriginValueChange: (value: string) => void;
     onMaxRemovalShareChange: (value: number) => void;
 };
-export declare function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolicy, missingRecordColumn, missingRecordValue, originColumn, originValue, maxRemovalShare, dedupConfigured, disabled, onWriteModeChange, onMissingRecordPolicyChange, onMissingRecordColumnChange, onMissingRecordValueChange, onOriginColumnChange, onOriginValueChange, onMaxRemovalShareChange, }: MappingWriteModeFieldsProps): import("react/jsx-runtime").JSX.Element;
+export declare function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolicy, missingRecordColumn, missingRecordValue, originColumn, originValue, maxRemovalShare, dedupConfigured, disabled, onWriteModeChange, onMissingRecordPolicyChange, onMissingRecordColumnChange, onMissingRecordValueChange, removalScopeColumn, onRemovalScopeColumnChange, onOriginColumnChange, onOriginValueChange, onMaxRemovalShareChange, }: MappingWriteModeFieldsProps): import("react/jsx-runtime").JSX.Element;
 /**
  * Stored as a share, typed as a percentage.
  *

package/dist/fe/components/IntegrationsPage/components/MappingWriteModeFields.js

@@ -34,13 +34,14 @@ function toMissingPolicy(value) {
 /** Deactivate has nowhere to write its flag without both of these. */ export function missingRecordFieldsIncomplete(policy, column, value) {
     return policy === 'deactivate' && (column.trim() === '' || value.trim() === '');
 }
-export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolicy, missingRecordColumn, missingRecordValue, originColumn, originValue, maxRemovalShare, dedupConfigured, disabled, onWriteModeChange, onMissingRecordPolicyChange, onMissingRecordColumnChange, onMissingRecordValueChange, onOriginColumnChange, onOriginValueChange, onMaxRemovalShareChange }) {
+export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolicy, missingRecordColumn, missingRecordValue, originColumn, originValue, maxRemovalShare, dedupConfigured, disabled, onWriteModeChange, onMissingRecordPolicyChange, onMissingRecordColumnChange, onMissingRecordValueChange, removalScopeColumn, onRemovalScopeColumnChange, onOriginColumnChange, onOriginValueChange, onMaxRemovalShareChange }) {
     const labels = useLabels();
     const modeId = `${idPrefix}-write-mode`;
     const policyId = `${idPrefix}-missing-policy`;
     const columnId = `${idPrefix}-missing-column`;
     const valueId = `${idPrefix}-missing-value`;
     const originColumnId = `${idPrefix}-origin-column`;
+    const removalScopeColumnId = `${idPrefix}-removal-scope-column`;
     const originValueId = `${idPrefix}-origin-value`;
     const shareId = `${idPrefix}-max-removal-share`;
     const columnMissing = missingRecordPolicy === 'deactivate' && missingRecordColumn.trim() === '';
@@ -171,6 +172,20 @@ export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolic
                             })
                         ]
                     }),
+                    /*#__PURE__*/ _jsx(Field, {
+                        hint: labels.mappings.removalScopeColumnHint,
+                        htmlFor: removalScopeColumnId,
+                        label: labels.mappings.removalScopeColumn,
+                        children: /*#__PURE__*/ _jsx("input", {
+                            "aria-describedby": `${removalScopeColumnId}-hint`,
+                            className: theme.field.input,
+                            disabled: disabled,
+                            id: removalScopeColumnId,
+                            onChange: (event)=>onRemovalScopeColumnChange(event.target.value),
+                            placeholder: "company_code",
+                            value: removalScopeColumn
+                        })
+                    }),
                     originColumn.trim() === '' ? /*#__PURE__*/ _jsx(Notice, {
                         title: labels.mappings.originUnsetTitle,
                         tone: "warning",

package/dist/fe/components/IntegrationsPage/components/mappingDraft.d.ts

@@ -26,6 +26,7 @@ export type MappingDraft = {
     missingRecordColumn?: string | null;
     missingRecordValue?: string | null;
     /** The mark this mapping puts on its rows, and the only ones it may remove. */
+    removalScopeColumn?: string | null;
     originColumn?: string | null;
     originValue?: string | null;
     /** The largest share of existing rows one run may remove; 0 is no ceiling. */

package/dist/fe/components/IntegrationsPage/components/mappingDraft.js

@@ -29,6 +29,7 @@ import { missingRecordFieldsIncomplete } from './MappingWriteModeFields';
         missingRecordPolicy: mapping.missingRecordPolicy,
         missingRecordColumn: mapping.missingRecordColumn,
         missingRecordValue: mapping.missingRecordValue,
+        removalScopeColumn: mapping.removalScopeColumn ?? '',
         originColumn: mapping.originColumn ?? '',
         originValue: mapping.originValue ?? '',
         maxRemovalShare: mapping.maxRemovalShare ?? 0,

package/dist/fe/components/IntegrationsPage/components/mappingStaleness.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Whether a mapping is actually keeping its table up to date.
+ *
+ * The list already said "Last run: 2026-08-02 12:51". Next to four siblings that
+ * all ran the previous night, that line is the difference between a working
+ * integration and a table two days out of date — and it takes arithmetic to see
+ * it, so nobody did. What happened instead: a chief executive was missing from
+ * the directory, a director's title was the one he had held in July, and people
+ * who had left were still listed. All four were the same fact, and the screen
+ * that knew it showed a timestamp.
+ *
+ * The cause underneath was smaller still: that mapping had no schedule. Its
+ * siblings ran nightly; it only ever ran when somebody pressed a button, and
+ * nobody had pressed it since Sunday. Nothing on the screen said so.
+ *
+ * So this answers two questions the timestamp cannot: does anything run this on
+ * its own, and is what it wrote still recent. Both are properties of the row, so
+ * they belong on the row.
+ */
+export type MappingStaleness = {
+    /** Nothing runs this unless a person does. */
+    unscheduled: boolean;
+    /** It has never run at all. */
+    neverRun: boolean;
+    /** Whole days since the last run, null when it has never run. */
+    ageDays: number | null;
+    /** Worth an operator's attention. */
+    tone: 'ok' | 'warning';
+};
+export type StalenessQuestion = {
+    lastRunAt?: string | null;
+    scheduleEnabled?: boolean | null;
+    /** Passed in rather than read, so this is a function of its arguments. */
+    now: number;
+    /**
+     * How old is too old.
+     *
+     * A day, because every schedule in a normal install runs at least nightly, so
+     * a mapping older than that has missed one — and a threshold shorter than the
+     * cadence would flag every mapping every morning, which is how a warning
+     * stops being read.
+     */
+    staleAfterHours?: number;
+};
+export declare function mappingStaleness(question: StalenessQuestion): MappingStaleness;

package/dist/fe/components/IntegrationsPage/components/mappingStaleness.js

@@ -0,0 +1,46 @@
+/**
+ * Whether a mapping is actually keeping its table up to date.
+ *
+ * The list already said "Last run: 2026-08-02 12:51". Next to four siblings that
+ * all ran the previous night, that line is the difference between a working
+ * integration and a table two days out of date — and it takes arithmetic to see
+ * it, so nobody did. What happened instead: a chief executive was missing from
+ * the directory, a director's title was the one he had held in July, and people
+ * who had left were still listed. All four were the same fact, and the screen
+ * that knew it showed a timestamp.
+ *
+ * The cause underneath was smaller still: that mapping had no schedule. Its
+ * siblings ran nightly; it only ever ran when somebody pressed a button, and
+ * nobody had pressed it since Sunday. Nothing on the screen said so.
+ *
+ * So this answers two questions the timestamp cannot: does anything run this on
+ * its own, and is what it wrote still recent. Both are properties of the row, so
+ * they belong on the row.
+ */ const HOUR = 60 * 60 * 1000;
+export function mappingStaleness(question) {
+    const unscheduled = question.scheduleEnabled !== true;
+    const staleAfter = (question.staleAfterHours ?? 24) * HOUR;
+    const parsed = question.lastRunAt ? Date.parse(question.lastRunAt) : Number.NaN;
+    if (!Number.isFinite(parsed)) {
+        /*
+     * Never run is only worth a warning when nothing is going to run it.
+     * A mapping created five minutes ago with a schedule on it is not a
+     * problem — it is a mapping waiting for tonight.
+     */ return {
+            unscheduled,
+            neverRun: true,
+            ageDays: null,
+            tone: unscheduled ? 'warning' : 'ok'
+        };
+    }
+    // A clock skewed forward would otherwise report a negative age and read as
+    // fresh; the floor at zero keeps the answer honest either way.
+    const age = Math.max(0, question.now - parsed);
+    const ageDays = Math.floor(age / (24 * HOUR));
+    return {
+        unscheduled,
+        neverRun: false,
+        ageDays,
+        tone: age > staleAfter ? 'warning' : 'ok'
+    };
+}

package/dist/fe/components/IntegrationsPage/text/index.d.ts

@@ -237,6 +237,8 @@ export type IntegrationsLabels = {
         deactivateColumnHint: string;
         deactivateValue: string;
         deactivateValueHint: string;
+        removalScopeColumn: string;
+        removalScopeColumnHint: string;
         originColumn: string;
         originColumnHint: string;
         originValue: string;
@@ -595,6 +597,10 @@ export type IntegrationsLabels = {
     ui: {
         tryAgain: string;
         neverRun: string;
+        /** Nothing runs this mapping unless somebody presses the button. */
+        unscheduled: string;
+        /** How far behind a mapping's last run is, in whole days. */
+        behindByDays: (days: number) => string;
         lastRun: (moment: string) => string;
         shownOfTotal: (shown: string | number, total: string | number) => string;
         runImport: string;

package/dist/fe/components/IntegrationsPage/text/index.js

@@ -217,6 +217,8 @@
         deactivateColumnHint: 'A column on the target table.',
         deactivateValue: 'Deactivation value',
         deactivateValueHint: 'Written into that column.',
+        removalScopeColumn: 'Removal scope column',
+        removalScopeColumnHint: 'For a source read through several calls — one per company, branch or tenant. Name the target column carrying whichever value the calls vary, and removal is limited to the values this run actually read: a call that answers with an error costs its own slice its cleanup instead of stopping the whole run. Blank means every row is a candidate, and one failing call refuses every removal.',
         originColumn: 'Ownership column',
         originColumnHint: 'A column on the target table that this mapping stamps on every row it writes.',
         originValue: 'Ownership mark',
@@ -522,6 +524,8 @@
     ui: {
         tryAgain: 'Try again',
         neverRun: 'Never run',
+        unscheduled: 'not scheduled',
+        behindByDays: (days)=>days <= 1 ? '1 day behind' : `${days} days behind`,
         lastRun: (moment)=>`Last run ${moment}`,
         shownOfTotal: (shown, total)=>`${shown} of ${total} shown`,
         runImport: 'Import',

package/dist/fe/components/IntegrationsPage/types/records.d.ts

@@ -188,6 +188,13 @@ export type IntegrationMapping = {
     missingRecordPolicy: MissingRecordPolicyValue;
     missingRecordColumn?: string | null;
     missingRecordValue?: string | null;
+    /**
+     * Target column carrying whichever value this mapping's calls vary — a
+     * company code, a branch, a tenant. Set, removal is confined to the values
+     * this run actually read, so one call answering with an error costs that
+     * slice its cleanup instead of refusing the whole run.
+     */
+    removalScopeColumn?: string | null;
     /**
      * The mark this mapping puts on every row it writes, and the only rows it is
      * then allowed to take away. Without it a run that removes missing records