nucleus-core-ts 0.9.910 → 0.9.912

package/dist/.build-ok

@@ -1 +1 @@
-0.9.910
+0.9.912

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

@@ -30,7 +30,8 @@ import { Notice } from './Primitives';
  * is a confusing half hour otherwise.
  */ /** A filename somebody can still recognise a week later. */ const fileNameFor = (slug)=>`integration-${slug || 'connection'}.json`;
 export function ConnectionExport({ actions, source }) {
-    const t = useLabels().transfer;
+    const labels = useLabels();
+    const t = labels.transfer;
     const store = useIntegrationsStore();
     const [busy, setBusy] = useState(false);
     const [note, setNote] = useState(null);
@@ -88,12 +89,12 @@ export function ConnectionExport({ actions, source }) {
                 children: [
                     /*#__PURE__*/ _jsx("p", {
                         className: theme.field.hint,
-                        children: "One file holding this connection, its calls and its mappings — enough to rebuild the whole integration in another installation. Bring it in there with Import, on the connections screen."
+                        children: labels.explain.exportBundleRebuildsIntegration
                     }),
                     /*#__PURE__*/ _jsx(Notice, {
                         title: t.noSecretsTitle,
                         tone: "info",
-                        children: "Tokens, passwords and keys are left out on purpose. Whatever this connection authenticates with has to be entered again wherever the file lands."
+                        children: labels.explain.exportOmitsCredentials
                     }),
                     note ? /*#__PURE__*/ _jsx("p", {
                         className: theme.field.hint,

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

@@ -153,12 +153,12 @@ export function CredentialFields({ actions, source, loading = false }) {
                         title: labels.auth.writeOnlyTitle,
                         tone: "info",
                         children: /*#__PURE__*/ _jsx("p", {
-                            children: "A value typed here is stored and from then on only ever sent to the service. It is not returned to this screen, or to any other, no matter who asks — all that comes back is a masked hint. Leave a box empty to keep whatever is already stored."
+                            children: labels.explain.credentialsWriteOnlyBody
                         })
                     }),
                     slots.length === 0 ? /*#__PURE__*/ _jsx("p", {
                         className: theme.list.empty,
-                        children: "This connection is set to no authentication, so there is no secret to store. Pick an auth type above to see the fields it needs."
+                        children: labels.explain.credentialsNoAuthNothingToStore
                     }) : null,
                     slots.map((slot)=>/*#__PURE__*/ _jsx(CredentialSlotRow, {
                             disabled: busy,

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

@@ -132,7 +132,7 @@ export function EndpointSample({ endpoint, actions }) {
                             }),
                             /*#__PURE__*/ _jsx("p", {
                                 className: theme.field.hint,
-                                children: "Used for this one request only. During a run each parameter takes its value from the binding configured for it."
+                                children: labels.endpoints.samplePathValuesHint
                             }),
                             /*#__PURE__*/ _jsx("div", {
                                 className: "grid grid-cols-1 gap-3 sm:grid-cols-2",
@@ -192,14 +192,14 @@ export function EndpointSample({ endpoint, actions }) {
                             }) : null,
                             sample.recordCount > 0 ? /*#__PURE__*/ _jsx("p", {
                                 className: theme.field.hint,
-                                children: `This is one request. The source answered it with ${sample.recordCount} record(s)${sample.recordCount > sample.sample.length ? `, of which the first ${sample.sample.length} are printed below` : ''} — not the whole table. If the endpoint pages, this is one page of it. Preview on the Run step walks every page and reports the real total.`
+                                children: `${labels.explain.sampleOneRequestLead}${sample.recordCount}${labels.explain.sampleOneRequestRecords}${sample.recordCount > sample.sample.length ? `${labels.explain.sampleFirstPrintedLead}${sample.sample.length}${labels.explain.sampleFirstPrintedTail}` : ''}${labels.explain.sampleOneRequestTail}`
                             }) : null,
                             sample.recordCount === 0 ? /*#__PURE__*/ _jsxs(Notice, {
                                 title: labels.endpoints.sampleNoRecords,
                                 tone: "warning",
                                 children: [
                                     /*#__PURE__*/ _jsx("p", {
-                                        children: "These are the top-level keys of the body the source returned. Set the response root path to whichever holds the list."
+                                        children: labels.explain.sampleBodyKeysAreTopLevel
                                     }),
                                     sample.bodyKeys.length > 0 ? /*#__PURE__*/ _jsx("ul", {
                                         className: "mt-2 flex flex-wrap gap-1.5",
@@ -211,7 +211,7 @@ export function EndpointSample({ endpoint, actions }) {
                                             }, key))
                                     }) : /*#__PURE__*/ _jsx("p", {
                                         className: "mt-2",
-                                        children: "The body has no top-level keys at all: it is empty, or it is a bare value rather than an object."
+                                        children: labels.explain.sampleBodyHasNoTopLevelKeys
                                     }),
                                     sample.bodyPreview ? /*#__PURE__*/ _jsx("div", {
                                         className: "mt-2",
@@ -255,7 +255,7 @@ export function EndpointSample({ endpoint, actions }) {
                     }) : null,
                     !store.sampling && !sample ? /*#__PURE__*/ _jsx("p", {
                         className: theme.field.hint,
-                        children: "Nothing has been sampled yet. One request is sent, read-only, and the shape it comes back with is what the field mapping is built from."
+                        children: labels.endpoints.sampleNothingYet
                     }) : null
                 ]
             })

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

@@ -23,7 +23,8 @@ import { Field, Notice, Section } from './Primitives';
 /** Columns that plausibly hold a password, so the guess is a good one. */ const PASSWORD_LIKE = /password|passwd|sifre|şifre|parola/i;
 /** Columns that plausibly point at the account row. */ const LINK_LIKE = /^(user_?id|account_?id|login_?id)$/i;
 export function MappingAccountFields({ value, targetFields, targets, disabled, onChange }) {
-    const t = useLabels().account;
+    const labels = useLabels();
+    const t = labels.account;
     const uid = useId();
     const accountEntity = targets.find((target)=>target.entity === value?.entity);
     const accountFields = accountEntity?.fields ?? [];
@@ -96,7 +97,7 @@ export function MappingAccountFields({ value, targetFields, targets, disabled, o
                             })
                         }),
                         /*#__PURE__*/ _jsx(Field, {
-                            hint: "The column on the account that identifies it.",
+                            hint: labels.explain.accountMatchColumnIdentifies,
                             htmlFor: `${uid}-match-column`,
                             label: t.identifiedBy,
                             children: /*#__PURE__*/ _jsxs("select", {
@@ -120,7 +121,7 @@ export function MappingAccountFields({ value, targetFields, targets, disabled, o
                             })
                         }),
                         /*#__PURE__*/ _jsx(Field, {
-                            hint: "Where the run's shared password is written.",
+                            hint: labels.explain.accountPasswordColumnReceives,
                             htmlFor: `${uid}-password`,
                             label: t.passwordInto,
                             children: /*#__PURE__*/ _jsxs("select", {
@@ -151,7 +152,7 @@ export function MappingAccountFields({ value, targetFields, targets, disabled, o
                             })
                         }),
                         /*#__PURE__*/ _jsx(Field, {
-                            hint: "The imported record's column carrying that same value.",
+                            hint: labels.explain.accountMatchFromCarriesValue,
                             htmlFor: `${uid}-match-from`,
                             label: t.matchedFrom,
                             children: /*#__PURE__*/ _jsxs("select", {
@@ -175,7 +176,7 @@ export function MappingAccountFields({ value, targetFields, targets, disabled, o
                             })
                         }),
                         /*#__PURE__*/ _jsx(Field, {
-                            hint: "Used only when the column above came back EMPTY, so nobody is left without a login. Name the record's own columns in braces — {firstName}.{sicilNo}@acme.com. Leave it blank to go on skipping those records.",
+                            hint: labels.explain.accountFallbackWhenIdentifierEmpty,
                             htmlFor: `${uid}-email-format`,
                             label: t.identifierFallback,
                             children: /*#__PURE__*/ _jsx("input", {
@@ -190,7 +191,7 @@ export function MappingAccountFields({ value, targetFields, targets, disabled, o
                             })
                         }),
                         /*#__PURE__*/ _jsx(Field, {
-                            hint: "Filled with the new account's id, so the record and its login know each other.",
+                            hint: labels.explain.accountIdColumnLinksBack,
                             htmlFor: `${uid}-id-column`,
                             label: t.accountIdInto,
                             children: /*#__PURE__*/ _jsxs("select", {
@@ -245,7 +246,7 @@ export function MappingAccountFields({ value, targetFields, targets, disabled, o
                         }),
                         (value.joins ?? []).length === 0 ? /*#__PURE__*/ _jsx("p", {
                             className: theme.field.hint,
-                            children: "Nothing. An account with no role can sign in and do nothing — every screen it reaches refuses it. A role usually lives in its own table, joined to the account, which is what this adds."
+                            children: labels.explain.accountNoMembershipsYet
                         }) : null,
                         (value.joins ?? []).map((join, joinIndex)=>{
                             const joinEntity = targets.find((target)=>target.entity === join.entity);
@@ -348,12 +349,12 @@ export function MappingAccountFields({ value, targetFields, targets, disabled, o
                 /*#__PURE__*/ _jsx(Notice, {
                     title: t.sharedPasswordTitle,
                     tone: "info",
-                    children: "Every account this run creates is given the same opening password — asked for once, when the import is started, and stored nowhere. People change it themselves afterwards. A record whose value already has an account is linked to that one instead, so running this import again does not create a second."
+                    children: labels.explain.accountSharedPasswordPerRun
                 })
             ]
         }) : /*#__PURE__*/ _jsx("p", {
             className: theme.list.empty,
-            children: "Off. Records are imported without a login — useful for a directory, not for people who have to sign in."
+            children: labels.explain.accountCreationOff
         })
     });
 }

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

@@ -188,7 +188,7 @@ export function MappingList({ actions, sourceId, selectedId, reloadToken, onSele
                                                 children: [
                                                     /*#__PURE__*/ _jsx(Badge, {
                                                         tone: WRITE_MODE_TONE[mapping.writeMode],
-                                                        children: mapping.writeMode
+                                                        children: labels.writeModeFull[mapping.writeMode]
                                                     }),
                                                     mapping.enabled === false ? /*#__PURE__*/ _jsx(Badge, {
                                                         tone: "neutral",

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

@@ -46,7 +46,8 @@ import { Field, Notice, Section } from './Primitives';
         }
     ];
 export function MappingScheduleFields({ enabled, cron, timezone, needsPassword, disabled, onChange }) {
-    const t = useLabels().schedule;
+    const labels = useLabels();
+    const t = labels.schedule;
     const presets = presetsOf(t.presets);
     const uid = useId();
     const parsed = cron.trim() === '' ? null : parseCron(cron);
@@ -102,7 +103,7 @@ export function MappingScheduleFields({ enabled, cron, timezone, needsPassword,
                             })
                         }),
                         /*#__PURE__*/ _jsx(Field, {
-                            hint: "The company's own clock, so 02:00 stays 02:00 across a daylight-saving change.",
+                            hint: labels.explain.scheduleTimezoneIsCompanyClock,
                             htmlFor: `${uid}-timezone`,
                             label: t.timezone,
                             children: /*#__PURE__*/ _jsx("input", {
@@ -133,16 +134,16 @@ export function MappingScheduleFields({ enabled, cron, timezone, needsPassword,
                 needsPassword ? /*#__PURE__*/ _jsx(Notice, {
                     title: t.cannotRunTitle,
                     tone: "warning",
-                    children: "It creates a login for every new record, and a login needs a password — which there is nobody to type at that hour. Either start this import by hand, or turn the login off and give people their accounts another way."
+                    children: labels.explain.scheduleCannotRunUnattended
                 }) : null,
                 /*#__PURE__*/ _jsx("p", {
                     className: theme.field.hint,
-                    children: "Every server running this app checks the schedule, and exactly one of them takes the import — the same lock that stops two people running it at once."
+                    children: labels.explain.scheduleOneServerTakesTheRun
                 })
             ]
         }) : /*#__PURE__*/ _jsx("p", {
             className: theme.list.empty,
-            children: "Off. This import runs when somebody asks for it, and at no other time."
+            children: labels.explain.scheduleOffUntilAskedFor
         })
     });
 }

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

@@ -70,7 +70,7 @@ export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolic
                 tone: "danger",
                 children: [
                     /*#__PURE__*/ _jsx("p", {
-                        children: "Every existing row is dropped and written again, so row ids change. Foreign keys, saved links, exports, report filters and anything else holding one of those ids breaks, and no amount of re-running repairs it."
+                        children: labels.explain.writeModeReplaceRebuildsTable
                     }),
                     /*#__PURE__*/ _jsx("p", {
                         className: "mt-1",
@@ -98,7 +98,7 @@ export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolic
             missingRecordPolicy === 'delete' ? /*#__PURE__*/ _jsx(Notice, {
                 title: labels.mappings.deleteWarnTitle,
                 tone: "warning",
-                children: "A source that answers with a short page — a filter left on, a timeout, an expired token honoured with an empty list — looks exactly like records that went away."
+                children: labels.explain.writeModeDeleteTrustsShortPage
             }) : null,
             missingRecordPolicy === 'deactivate' ? /*#__PURE__*/ _jsxs("div", {
                 className: "grid grid-cols-1 gap-3 sm:grid-cols-2",

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

@@ -178,7 +178,7 @@ export function PaginationFields({ idPrefix, value, disabled, onChange }) {
             /*#__PURE__*/ _jsx(Notice, {
                 title: labels.endpoints.paginationTitle,
                 tone: "warning",
-                children: "Nothing here is detected for you. Pick the wrong style and the import still succeeds — it reads the first page and never asks for the rest. In a destructive write mode the records it never saw count as missing, so the run deletes or deactivates them."
+                children: labels.explain.paginationWrongStyleSilentlySucceeds
             }),
             /*#__PURE__*/ _jsx(Field, {
                 hint: labels.endpoints.paginationHint,

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

@@ -24,7 +24,7 @@ export function RunConfirmStep({ lines, counted, working, onConfirm, onDismiss }
             }),
             counted ? null : /*#__PURE__*/ _jsx("p", {
                 className: "mt-2",
-                children: "These counts are unknown because nothing was previewed. Run a preview first if you want to know how many rows this removes before it removes them."
+                children: labels.explain.runConfirmCountsUnknown
             }),
             /*#__PURE__*/ _jsxs("div", {
                 className: "mt-3 flex flex-wrap items-center gap-2",
@@ -41,7 +41,7 @@ export function RunConfirmStep({ lines, counted, working, onConfirm, onDismiss }
                         disabled: working,
                         onClick: onDismiss,
                         type: "button",
-                        children: "Keep them, do not run"
+                        children: labels.explain.runConfirmKeepThem
                     })
                 ]
             })

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

@@ -118,7 +118,7 @@ export function RunHistory({ actions, mappingId, refreshKey, onRefresh }) {
                     }) : null,
                     !firstPagePending && list.items.length === 0 && !list.error ? /*#__PURE__*/ _jsx("p", {
                         className: theme.list.empty,
-                        children: "Nothing has run yet. A preview writes nothing; the first entry appears here once an import is started."
+                        children: labels.explain.runHistoryNothingRunYet
                     }) : null,
                     list.items.length > 0 ? /*#__PURE__*/ _jsx("ul", {
                         className: theme.list.wrapper,

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

@@ -16,7 +16,8 @@ import { countersLine, errorText, formatDuration, formatMoment, RUN_STATUS_TONE,
  * a button that quietly disappears reads as a bug rather than as an expiry.
  */ const theme = integrationsPageTheme;
 export function RunHistoryRow({ run, actions, onReverted }) {
-    const t = useLabels().errors;
+    const labels = useLabels();
+    const t = labels.errors;
     const store = useIntegrationsStore();
     const [reverting, setReverting] = useState(false);
     const [conflicts, setConflicts] = useState(null);
@@ -72,23 +73,23 @@ export function RunHistoryRow({ run, actions, onReverted }) {
                 children: [
                     /*#__PURE__*/ _jsx(Badge, {
                         tone: RUN_STATUS_TONE[run.status],
-                        children: run.status
+                        children: labels.runStatusFull[run.status]
                     }),
                     /*#__PURE__*/ _jsx("span", {
                         className: theme.card.title,
-                        children: run.targetEntity ?? 'unknown target'
+                        children: run.targetEntity ?? labels.badges.unknownTarget
                     }),
                     run.writeMode ? /*#__PURE__*/ _jsx(Badge, {
                         tone: "neutral",
-                        children: run.writeMode
+                        children: labels.writeModeFull[run.writeMode] ?? run.writeMode
                     }) : null,
                     run.trigger ? /*#__PURE__*/ _jsx(Badge, {
                         tone: "neutral",
-                        children: run.trigger
+                        children: labels.triggerFull[run.trigger] ?? run.trigger
                     }) : null,
                     mismatch ? /*#__PURE__*/ _jsx(Badge, {
                         tone: "warning",
-                        children: `read ${run.totalFetched} of ${reportedTotal}`
+                        children: labels.badges.readOf(run.totalFetched ?? 0, reportedTotal ?? 0)
                     }) : null
                 ]
             }),

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

@@ -279,7 +279,7 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
                     !(store.planning || plan || activeRunId) ? /*#__PURE__*/ _jsx(Notice, {
                         tone: "info",
                         title: labels.runs.previewExplainTitle,
-                        children: "A preview reads the source without writing anything, and reports how many rows would be created, updated, skipped, and how many rows in the target the source no longer returns."
+                        children: labels.explain.runPreviewWritesNothing
                     }) : null
                 ]
             })

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

@@ -1,5 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { Notice } from './Primitives';
 /**
@@ -36,6 +37,7 @@ import { Notice } from './Primitives';
     ].sort((a, b)=>b.records - a.records);
 }
 export function RunPlanReferences({ plan, busy, onCreateAndRun, onSkipAndRun }) {
+    const labels = useLabels();
     const missing = missingReferenceValues(plan);
     const planned = plan.referenceInserts ?? [];
     if (missing.length === 0 && planned.length === 0) return null;
@@ -43,15 +45,11 @@ export function RunPlanReferences({ plan, busy, onCreateAndRun, onSkipAndRun })
         className: "flex flex-col gap-3",
         children: [
             missing.length > 0 ? /*#__PURE__*/ _jsxs(Notice, {
-                title: `${missing.length} value(s) this import refers to are not here yet`,
+                title: labels.explain.missingReferencesTitle(missing.length),
                 tone: "warning",
                 children: [
-                    /*#__PURE__*/ _jsxs("p", {
-                        children: [
-                            "As it stands the records that carry them are left out — ",
-                            plan.toSkip,
-                            " record(s) in total. Either add the values first, or import without those records."
-                        ]
+                    /*#__PURE__*/ _jsx("p", {
+                        children: labels.explain.missingReferencesRecordsLeftOut(plan.toSkip)
                     }),
                     /*#__PURE__*/ _jsx("ul", {
                         className: "mt-2 flex flex-col gap-1",
@@ -61,7 +59,7 @@ export function RunPlanReferences({ plan, busy, onCreateAndRun, onSkipAndRun })
                                     /*#__PURE__*/ _jsx("strong", {
                                         children: entry.value
                                     }),
-                                    ` — missing from ${entry.entity}.${entry.entityColumn}, needed by ${entry.records} record(s)`
+                                    labels.explain.missingReferenceRow(`${entry.entity}.${entry.entityColumn}`, entry.records)
                                 ]
                             }, entry.key))
                     }),
@@ -73,25 +71,25 @@ export function RunPlanReferences({ plan, busy, onCreateAndRun, onSkipAndRun })
                                 disabled: busy,
                                 onClick: onCreateAndRun,
                                 type: "button",
-                                children: `Create these ${missing.length} value(s) and import everything`
+                                children: labels.explain.missingReferencesCreateAndRun(missing.length)
                             }),
                             /*#__PURE__*/ _jsx("button", {
                                 className: theme.button.secondary,
                                 disabled: busy,
                                 onClick: onSkipAndRun,
                                 type: "button",
-                                children: "Import without those records"
+                                children: labels.explain.missingReferencesRunWithoutThem
                             })
                         ]
                     })
                 ]
             }) : null,
             planned.length > 0 ? /*#__PURE__*/ _jsxs(Notice, {
-                title: `${planned.length} value(s) will be added first`,
+                title: labels.explain.plannedReferencesTitle(planned.length),
                 tone: "info",
                 children: [
                     /*#__PURE__*/ _jsx("p", {
-                        children: "These are created in the same import, before the records that point at them, so nothing is written pointing at nothing. They carry only the value itself — rename them afterwards."
+                        children: labels.explain.plannedReferencesCreatedBefore
                     }),
                     /*#__PURE__*/ _jsx("ul", {
                         className: "mt-2 flex flex-col gap-1",
@@ -112,7 +110,7 @@ export function RunPlanReferences({ plan, busy, onCreateAndRun, onSkipAndRun })
                             disabled: busy,
                             onClick: onSkipAndRun,
                             type: "button",
-                            children: "Do not create them — leave those records out"
+                            children: labels.explain.plannedReferencesLeaveRecordsOut
                         })
                     })
                 ]

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

@@ -35,22 +35,22 @@ export function RunPlanSummary({ plan }) {
                     }),
                     /*#__PURE__*/ _jsx(Badge, {
                         tone: "info",
-                        children: plan.writeMode
+                        children: labels.writeModeFull[plan.writeMode]
                     }),
                     /*#__PURE__*/ _jsx(Badge, {
                         tone: plan.dedupConfigured ? 'neutral' : 'warning',
-                        children: plan.dedupConfigured ? 'dedup key set' : 'no dedup key'
+                        children: plan.dedupConfigured ? labels.badges.dedupSet : labels.badges.dedupMissing
                     }),
                     /*#__PURE__*/ _jsx(Badge, {
                         tone: "neutral",
-                        children: `missing rows: ${plan.missingPolicy}`
+                        children: labels.badges.missingRows(labels.missingPolicyFull[plan.missingPolicy])
                     })
                 ]
             }),
             countMismatch ? /*#__PURE__*/ _jsx(Notice, {
                 tone: "danger",
                 title: labels.runExtras.countMismatchTitle,
-                children: `The source reports ${plan.reportedTotal} record(s); ${plan.totalFetched} were actually read. Check the endpoint's pagination profile before running: a wrong profile reads one page, and every record it never saw counts as missing.`
+                children: labels.explain.runPlanCountMismatchBody(plan.reportedTotal, plan.totalFetched)
             }) : null,
             /*#__PURE__*/ _jsxs("div", {
                 className: theme.stat.grid,
@@ -83,9 +83,9 @@ export function RunPlanSummary({ plan }) {
                 ]
             }),
             plan.accountsToCreate > 0 ? /*#__PURE__*/ _jsx(Notice, {
-                title: `${plan.accountsToCreate} login(s) will be created, with the password typed above`,
+                title: labels.explain.runPlanAccountsToCreateTitle(plan.accountsToCreate),
                 tone: "info",
-                children: "Each new record gets an account in the same import — one password for all of them, which people change themselves afterwards. Anyone whose value already has an account is linked to it instead."
+                children: labels.explain.runPlanAccountsSharePassword
             }) : null,
             plan.warnings.map((warning, index)=>/*#__PURE__*/ _jsx(Notice, {
                     title: warning,

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

@@ -319,6 +319,33 @@ export type IntegrationsLabels = {
         deactivate: string;
         delete: string;
     };
+    /**
+     * The words on the badges.
+     *
+     * A run said "succeeded" and a mapping said "upsert" — the value out of the
+     * column, printed as-is. They are the first thing read on both screens, and
+     * they were the last thing left in English.
+     */
+    runStatusFull: {
+        queued: string;
+        running: string;
+        succeeded: string;
+        failed: string;
+        cancelled: string;
+        reverted: string;
+    };
+    triggerFull: {
+        manual: string;
+        schedule: string;
+        api: string;
+    };
+    badges: {
+        unknownTarget: string;
+        dedupSet: string;
+        dedupMissing: string;
+        missingRows: (policy: string) => string;
+        readOf: (fetched: string | number, reported: string | number) => string;
+    };
     missingPolicyHint: {
         ignore: string;
         deactivate: string;
@@ -527,6 +554,58 @@ export type IntegrationsLabels = {
         dismiss: string;
         remove: string;
     };
+    /**
+     * The sentences that explain a consequence rather than name a control.
+     *
+     * They used to be written into the components, which meant a Turkish
+     * installation read English paragraphs in the middle of a Turkish screen —
+     * and these are exactly the paragraphs somebody reads before doing something
+     * irreversible. The short labels were always translatable; the reasoning was
+     * not, which is backwards.
+     */
+    explain: {
+        exportBundleRebuildsIntegration: string;
+        exportOmitsCredentials: string;
+        credentialsWriteOnlyBody: string;
+        credentialsNoAuthNothingToStore: string;
+        sampleOneRequestLead: string;
+        sampleOneRequestRecords: string;
+        sampleFirstPrintedLead: string;
+        sampleFirstPrintedTail: string;
+        sampleOneRequestTail: string;
+        sampleBodyKeysAreTopLevel: string;
+        sampleBodyHasNoTopLevelKeys: string;
+        accountMatchColumnIdentifies: string;
+        accountPasswordColumnReceives: string;
+        accountMatchFromCarriesValue: string;
+        accountFallbackWhenIdentifierEmpty: string;
+        accountIdColumnLinksBack: string;
+        accountNoMembershipsYet: string;
+        accountSharedPasswordPerRun: string;
+        accountCreationOff: string;
+        scheduleTimezoneIsCompanyClock: string;
+        scheduleCannotRunUnattended: string;
+        scheduleOneServerTakesTheRun: string;
+        scheduleOffUntilAskedFor: string;
+        writeModeReplaceRebuildsTable: string;
+        writeModeDeleteTrustsShortPage: string;
+        paginationWrongStyleSilentlySucceeds: string;
+        runConfirmCountsUnknown: string;
+        runConfirmKeepThem: string;
+        runHistoryNothingRunYet: string;
+        runPreviewWritesNothing: string;
+        missingReferencesTitle: (count: string | number) => string;
+        missingReferencesRecordsLeftOut: (count: string | number) => string;
+        missingReferenceRow: (target: string | number, count: string | number) => string;
+        missingReferencesCreateAndRun: (count: string | number) => string;
+        missingReferencesRunWithoutThem: string;
+        plannedReferencesTitle: (count: string | number) => string;
+        plannedReferencesCreatedBefore: string;
+        plannedReferencesLeaveRecordsOut: string;
+        runPlanCountMismatchBody: (reportedTotal: string | number | null, totalFetched: string | number) => string;
+        runPlanAccountsToCreateTitle: (accountsToCreate: string | number) => string;
+        runPlanAccountsSharePassword: string;
+    };
 };
 /** What every app gets before it says otherwise. */
 export declare const defaultIntegrationsLabels: IntegrationsLabels;

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

@@ -298,6 +298,26 @@
         append: 'Nothing is matched, so running this import twice stores every record twice.',
         replace: 'The table is emptied and refilled on every run.'
     },
+    runStatusFull: {
+        queued: 'queued',
+        running: 'running',
+        succeeded: 'succeeded',
+        failed: 'failed',
+        cancelled: 'cancelled',
+        reverted: 'reverted'
+    },
+    triggerFull: {
+        manual: 'manual',
+        schedule: 'scheduled',
+        api: 'API'
+    },
+    badges: {
+        unknownTarget: 'unknown target',
+        dedupSet: 'dedup key set',
+        dedupMissing: 'no dedup key',
+        missingRows: (policy)=>`missing rows: ${policy}`,
+        readOf: (fetched, reported)=>`read ${fetched} of ${reported}`
+    },
     missingPolicyFull: {
         ignore: 'Ignore — leave them exactly as they are',
         deactivate: 'Deactivate — mark them with a column value',
@@ -488,6 +508,49 @@
         somethingWentWrong: 'Something went wrong',
         dismiss: 'Dismiss error',
         remove: 'Remove'
+    },
+    explain: {
+        exportBundleRebuildsIntegration: 'One file holding this connection, its calls and its mappings — enough to rebuild the whole integration in another installation. Bring it in there with Import, on the connections screen.',
+        exportOmitsCredentials: 'Tokens, passwords and keys are left out on purpose. Whatever this connection authenticates with has to be entered again wherever the file lands.',
+        credentialsWriteOnlyBody: 'A value typed here is stored and from then on only ever sent to the service. It is not returned to this screen, or to any other, no matter who asks — all that comes back is a masked hint. Leave a box empty to keep whatever is already stored.',
+        credentialsNoAuthNothingToStore: 'This connection is set to no authentication, so there is no secret to store. Pick an auth type above to see the fields it needs.',
+        sampleOneRequestLead: 'This is one request. The source answered it with ',
+        sampleOneRequestRecords: ' record(s)',
+        sampleFirstPrintedLead: ', of which the first ',
+        sampleFirstPrintedTail: ' are printed below',
+        sampleOneRequestTail: ' — not the whole table. If the endpoint pages, this is one page of it. Preview on the Run step walks every page and reports the real total.',
+        sampleBodyKeysAreTopLevel: 'These are the top-level keys of the body the source returned. Set the response root path to whichever holds the list.',
+        sampleBodyHasNoTopLevelKeys: 'The body has no top-level keys at all: it is empty, or it is a bare value rather than an object.',
+        accountMatchColumnIdentifies: 'The column on the account that identifies it.',
+        accountPasswordColumnReceives: "Where the run's shared password is written.",
+        accountMatchFromCarriesValue: "The imported record's column carrying that same value.",
+        accountFallbackWhenIdentifierEmpty: "Used only when the column above came back EMPTY, so nobody is left without a login. Name the record's own columns in braces — {firstName}.{sicilNo}@acme.com. Leave it blank to go on skipping those records.",
+        accountIdColumnLinksBack: "Filled with the new account's id, so the record and its login know each other.",
+        accountNoMembershipsYet: 'Nothing. An account with no role can sign in and do nothing — every screen it reaches refuses it. A role usually lives in its own table, joined to the account, which is what this adds.',
+        accountSharedPasswordPerRun: 'Every account this run creates is given the same opening password — asked for once, when the import is started, and stored nowhere. People change it themselves afterwards. A record whose value already has an account is linked to that one instead, so running this import again does not create a second.',
+        accountCreationOff: 'Off. Records are imported without a login — useful for a directory, not for people who have to sign in.',
+        scheduleTimezoneIsCompanyClock: "The company's own clock, so 02:00 stays 02:00 across a daylight-saving change.",
+        scheduleCannotRunUnattended: 'It creates a login for every new record, and a login needs a password — which there is nobody to type at that hour. Either start this import by hand, or turn the login off and give people their accounts another way.',
+        scheduleOneServerTakesTheRun: 'Every server running this app checks the schedule, and exactly one of them takes the import — the same lock that stops two people running it at once.',
+        scheduleOffUntilAskedFor: 'Off. This import runs when somebody asks for it, and at no other time.',
+        writeModeReplaceRebuildsTable: 'Every existing row is dropped and written again, so row ids change. Foreign keys, saved links, exports, report filters and anything else holding one of those ids breaks, and no amount of re-running repairs it.',
+        writeModeDeleteTrustsShortPage: 'A source that answers with a short page — a filter left on, a timeout, an expired token honoured with an empty list — looks exactly like records that went away.',
+        paginationWrongStyleSilentlySucceeds: 'Nothing here is detected for you. Pick the wrong style and the import still succeeds — it reads the first page and never asks for the rest. In a destructive write mode the records it never saw count as missing, so the run deletes or deactivates them.',
+        runConfirmCountsUnknown: 'These counts are unknown because nothing was previewed. Run a preview first if you want to know how many rows this removes before it removes them.',
+        runConfirmKeepThem: 'Keep them, do not run',
+        runHistoryNothingRunYet: 'Nothing has run yet. A preview writes nothing; the first entry appears here once an import is started.',
+        runPreviewWritesNothing: 'A preview reads the source without writing anything, and reports how many rows would be created, updated, skipped, and how many rows in the target the source no longer returns.',
+        missingReferencesTitle: (count)=>`$${count} value(s) this import refers to are not here yet`,
+        missingReferencesRecordsLeftOut: (count)=>`As it stands the records that carry them are left out — $${count} record(s) in total. Either add the values first, or import without those records.`,
+        missingReferenceRow: (target, count)=>` — missing from $${target}, needed by $${count} record(s)`,
+        missingReferencesCreateAndRun: (count)=>`Create these $${count} value(s) and import everything`,
+        missingReferencesRunWithoutThem: 'Import without those records',
+        plannedReferencesTitle: (count)=>`$${count} value(s) will be added first`,
+        plannedReferencesCreatedBefore: 'These are created in the same import, before the records that point at them, so nothing is written pointing at nothing. They carry only the value itself — rename them afterwards.',
+        plannedReferencesLeaveRecordsOut: 'Do not create them — leave those records out',
+        runPlanCountMismatchBody: (reportedTotal, totalFetched)=>`The source reports ${reportedTotal} record(s); ${totalFetched} were actually read. Check the endpoint's pagination profile before running: a wrong profile reads one page, and every record it never saw counts as missing.`,
+        runPlanAccountsToCreateTitle: (accountsToCreate)=>`${accountsToCreate} login(s) will be created, with the password typed above`,
+        runPlanAccountsSharePassword: 'Each new record gets an account in the same import — one password for all of them, which people change themselves afterwards. Anyone whose value already has an account is linked to it instead.'
     }
 };
 /**