nucleus-core-ts 0.9.804 → 0.9.806

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

@@ -2,6 +2,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useEffectEvent, useState } from 'react';
 import { useIntegrationsStore } from '../store';
+import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { ConnectionAuthFields } from './ConnectionAuthFields';
 import { ConnectionBasicFields } from './ConnectionBasicFields';
@@ -17,6 +18,7 @@ import { CardSkeleton } from './Skeletons';
  * of what was stored and what is being typed.
  */ const theme = integrationsPageTheme;
 export function ConnectionForm({ actions, source, loading = false, onSaved }) {
+    const labels = useLabels();
     const store = useIntegrationsStore();
     const [draft, setDraft] = useState(()=>source ? draftFromSource(source) : emptyConnectionDraft);
     const [errors, setErrors] = useState({});
@@ -73,11 +75,11 @@ export function ConnectionForm({ actions, source, loading = false, onSaved }) {
                 children: [
                     /*#__PURE__*/ _jsx("h2", {
                         className: theme.card.title,
-                        children: source ? 'Edit connection' : 'New connection'
+                        children: source ? labels.connections.editTitle : labels.connections.newTitle
                     }),
                     source ? /*#__PURE__*/ _jsx(Badge, {
                         tone: source.enabled === false ? 'neutral' : 'success',
-                        children: source.enabled === false ? 'Disabled' : 'Enabled'
+                        children: source.enabled === false ? labels.connections.disabledBadge : labels.connections.enabledBadge
                     }) : null
                 ]
             }),

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

@@ -1,5 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useId } from 'react';
 import { cn } from '../../../utils/cn';
 import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
@@ -20,6 +21,14 @@ const METHODS = [
 ];
 export function EndpointFormFields({ draft, disabled, errors, onChange }) {
     const labels = useLabels();
+    /**
+   * Unique per instance.
+   *
+   * These ids were literals — `endpoint-tag`, `endpoint-name` — which is fine
+   * for one form on a page and wrong the moment there are two: every `<label
+   * htmlFor>` binds to whichever rendered first, so clicking a label focuses the
+   * OTHER record's field. `useId` makes that structurally impossible.
+   */ const uid = useId();
     return /*#__PURE__*/ _jsxs(_Fragment, {
         children: [
             /*#__PURE__*/ _jsxs("div", {
@@ -27,13 +36,13 @@ export function EndpointFormFields({ draft, disabled, errors, onChange }) {
                 children: [
                     /*#__PURE__*/ _jsx(Field, {
                         hint: labels.endpoints.tagHint,
-                        htmlFor: "endpoint-tag",
+                        htmlFor: `${uid}-tag`,
                         label: labels.endpoints.tag,
                         children: /*#__PURE__*/ _jsx("input", {
-                            "aria-describedby": "endpoint-tag-hint",
+                            "aria-describedby": `${uid}-tag-hint`,
                             className: theme.field.input,
                             disabled: disabled,
-                            id: "endpoint-tag",
+                            id: `${uid}-tag`,
                             onChange: (event)=>onChange({
                                     tag: event.target.value
                                 }),
@@ -43,12 +52,12 @@ export function EndpointFormFields({ draft, disabled, errors, onChange }) {
                         })
                     }),
                     /*#__PURE__*/ _jsx(Field, {
-                        htmlFor: "endpoint-name",
+                        htmlFor: `${uid}-name`,
                         label: labels.endpoints.name,
                         children: /*#__PURE__*/ _jsx("input", {
                             className: theme.field.input,
                             disabled: disabled,
-                            id: "endpoint-name",
+                            id: `${uid}-name`,
                             onChange: (event)=>onChange({
                                     name: event.target.value
                                 }),
@@ -65,12 +74,12 @@ export function EndpointFormFields({ draft, disabled, errors, onChange }) {
                     /*#__PURE__*/ _jsx("div", {
                         className: "sm:w-32",
                         children: /*#__PURE__*/ _jsx(Field, {
-                            htmlFor: "endpoint-method",
+                            htmlFor: `${uid}-method`,
                             label: labels.endpoints.method,
                             children: /*#__PURE__*/ _jsx("select", {
                                 className: theme.field.input,
                                 disabled: disabled,
-                                id: "endpoint-method",
+                                id: `${uid}-method`,
                                 onChange: (event)=>{
                                     for (const method of METHODS){
                                         if (method === event.target.value) onChange({
@@ -90,13 +99,13 @@ export function EndpointFormFields({ draft, disabled, errors, onChange }) {
                         className: "min-w-0 flex-1",
                         children: /*#__PURE__*/ _jsx(Field, {
                             hint: labels.endpoints.pathHint,
-                            htmlFor: "endpoint-path",
+                            htmlFor: `${uid}-path`,
                             label: labels.endpoints.path,
                             children: /*#__PURE__*/ _jsx("input", {
-                                "aria-describedby": "endpoint-path-hint",
+                                "aria-describedby": `${uid}-path-hint`,
                                 className: theme.field.input,
                                 disabled: disabled,
-                                id: "endpoint-path",
+                                id: `${uid}-path`,
                                 onChange: (event)=>onChange({
                                         path: event.target.value
                                     }),
@@ -110,13 +119,13 @@ export function EndpointFormFields({ draft, disabled, errors, onChange }) {
             }),
             /*#__PURE__*/ _jsx(Field, {
                 hint: labels.endpoints.rootPathHint,
-                htmlFor: "endpoint-root",
+                htmlFor: `${uid}-root`,
                 label: labels.endpoints.rootPath,
                 children: /*#__PURE__*/ _jsx("input", {
-                    "aria-describedby": "endpoint-root-hint",
+                    "aria-describedby": `${uid}-root-hint`,
                     className: theme.field.input,
                     disabled: disabled,
-                    id: "endpoint-root",
+                    id: `${uid}-root`,
                     onChange: (event)=>onChange({
                             responseRootPath: event.target.value
                         }),
@@ -128,13 +137,13 @@ export function EndpointFormFields({ draft, disabled, errors, onChange }) {
             /*#__PURE__*/ _jsx(Field, {
                 error: errors?.queryParams,
                 hint: labels.endpoints.queryParamsHint,
-                htmlFor: "endpoint-query",
+                htmlFor: `${uid}-query`,
                 label: labels.endpoints.queryParams,
                 children: /*#__PURE__*/ _jsx("textarea", {
-                    "aria-describedby": describedBy('endpoint-query', true, Boolean(errors?.queryParams)),
+                    "aria-describedby": describedBy(`${uid}-query`, true, Boolean(errors?.queryParams)),
                     className: cn(theme.field.input, 'h-auto min-h-16 py-2 font-mono text-xs'),
                     disabled: disabled,
-                    id: "endpoint-query",
+                    id: `${uid}-query`,
                     onChange: (event)=>onChange({
                             queryParams: event.target.value
                         }),
@@ -146,13 +155,13 @@ export function EndpointFormFields({ draft, disabled, errors, onChange }) {
             draft.method === 'GET' ? null : /*#__PURE__*/ _jsx(Field, {
                 error: errors?.requestBody,
                 hint: labels.endpoints.requestBodyHint,
-                htmlFor: "endpoint-body",
+                htmlFor: `${uid}-body`,
                 label: labels.endpoints.requestBody,
                 children: /*#__PURE__*/ _jsx("textarea", {
-                    "aria-describedby": describedBy('endpoint-body', true, Boolean(errors?.requestBody)),
+                    "aria-describedby": describedBy(`${uid}-body`, true, Boolean(errors?.requestBody)),
                     className: cn(theme.field.input, 'h-auto min-h-20 py-2 font-mono text-xs'),
                     disabled: disabled,
-                    id: "endpoint-body",
+                    id: `${uid}-body`,
                     onChange: (event)=>onChange({
                             requestBody: event.target.value
                         }),
@@ -162,12 +171,12 @@ export function EndpointFormFields({ draft, disabled, errors, onChange }) {
                 })
             }),
             /*#__PURE__*/ _jsx(Field, {
-                htmlFor: "endpoint-description",
+                htmlFor: `${uid}-description`,
                 label: labels.endpoints.description,
                 children: /*#__PURE__*/ _jsx("textarea", {
                     className: cn(theme.field.input, 'h-auto min-h-20 py-2'),
                     disabled: disabled,
-                    id: "endpoint-description",
+                    id: `${uid}-description`,
                     onChange: (event)=>onChange({
                             description: event.target.value
                         }),
@@ -178,13 +187,13 @@ export function EndpointFormFields({ draft, disabled, errors, onChange }) {
             }),
             /*#__PURE__*/ _jsxs("label", {
                 className: "flex items-center gap-2",
-                htmlFor: "endpoint-enabled",
+                htmlFor: `${uid}-enabled`,
                 children: [
                     /*#__PURE__*/ _jsx("input", {
                         checked: draft.enabled,
                         className: "size-4 shrink-0 accent-sky-600 dark:accent-sky-500",
                         disabled: disabled,
-                        id: "endpoint-enabled",
+                        id: `${uid}-enabled`,
                         onChange: (event)=>onChange({
                                 enabled: event.target.checked
                             }),

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

@@ -1,5 +1,5 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useEffectEvent, useState } from 'react';
 import { useIntegrationsStore } from '../store';
 import { useLabels } from '../text/context';
@@ -18,14 +18,24 @@ export function EndpointsTab({ actions }) {
     const labels = useLabels();
     const store = useIntegrationsStore();
     const sourceId = store.selectedSourceId;
-    const [selected, setSelected] = useState(null);
     const [creating, setCreating] = useState(false);
     const [reloadToken, setReloadToken] = useState(0);
-    // Another connection is another set of endpoints. A form left open across the
+    /**
+   * The selection is the STORE's, and only the store's.
+   *
+   * It used to be kept here as well, and the two were reconciled by comparing
+   * them on every render. Clicking a second call then left the first form on
+   * screen and added the new one under it — two live editors of two different
+   * records, both writing to the same hard-coded field ids, growing by one card
+   * per click. One source of truth, and one keyed container below, is what makes
+   * that impossible rather than unlikely.
+   */ const selectedId = store.selectedEndpointId;
+    const editing = selectedId ? store.endpoints.find((e)=>e.id === selectedId) ?? null : null;
+    // Another connection is another set of calls. A form left open across the
     // change would be editing a record this connection does not own.
     const reset = useEffectEvent(()=>{
-        setSelected(null);
         setCreating(false);
+        store.selectEndpoint(null);
     });
     useEffect(()=>{
         reset();
@@ -33,29 +43,26 @@ export function EndpointsTab({ actions }) {
         sourceId
     ]);
     const handleNew = ()=>{
-        setSelected(null);
+        store.selectEndpoint(null);
         setCreating(true);
     };
     const handleSelect = (endpoint)=>{
-        setSelected(endpoint);
         setCreating(false);
+        store.selectEndpoint(endpoint.id);
     };
     const handleSaved = (saved)=>{
-        setSelected(saved);
         setCreating(false);
-        // Re-selecting drops the old sample: it described the endpoint as it was
+        // Re-selecting drops the old sample: it described the call as it was
         // configured a moment ago, and the mapping would be built from it.
         store.selectEndpoint(saved.id);
         setReloadToken((token)=>token + 1);
     };
     const handleDeleted = ()=>{
-        setSelected(null);
         setCreating(false);
         store.selectEndpoint(null);
         setReloadToken((token)=>token + 1);
     };
     const handleCancel = ()=>{
-        setSelected(null);
         setCreating(false);
         store.selectEndpoint(null);
     };
@@ -65,9 +72,6 @@ export function EndpointsTab({ actions }) {
             children: labels.endpoints.selectConnection
         });
     }
-    // Guarded against the store: the selection is the store's, and a record left
-    // over from the previous one must not be what the form shows.
-    const editing = selected && selected.id === store.selectedEndpointId ? selected : null;
     return /*#__PURE__*/ _jsxs("div", {
         className: "grid grid-cols-1 gap-4 xl:grid-cols-[minmax(0,18rem)_minmax(0,1fr)] xl:gap-5",
         children: [
@@ -78,26 +82,28 @@ export function EndpointsTab({ actions }) {
                 reloadToken: reloadToken,
                 sourceId: sourceId
             }, sourceId),
-            /*#__PURE__*/ _jsxs("div", {
+            /*#__PURE__*/ _jsx("div", {
                 className: theme.layout.main,
-                children: [
-                    editing || creating ? /*#__PURE__*/ _jsx(EndpointForm, {
-                        actions: actions,
-                        endpoint: editing,
-                        onCancel: handleCancel,
-                        onDeleted: handleDeleted,
-                        onSaved: handleSaved,
-                        sourceId: sourceId
-                    }, editing?.id ?? 'new') : /*#__PURE__*/ _jsx("p", {
-                        className: theme.list.empty,
-                        children: "Select an endpoint to edit it, or add one. An endpoint is a single call — a method, a path, and where in the answer the records sit."
-                    }),
-                    editing ? /*#__PURE__*/ _jsx(EndpointSample, {
-                        actions: actions,
-                        endpoint: editing
-                    }, editing.id) : null
-                ]
-            })
+                children: editing || creating ? /*#__PURE__*/ _jsxs(_Fragment, {
+                    children: [
+                        /*#__PURE__*/ _jsx(EndpointForm, {
+                            actions: actions,
+                            endpoint: editing,
+                            onCancel: handleCancel,
+                            onDeleted: handleDeleted,
+                            onSaved: handleSaved,
+                            sourceId: sourceId
+                        }),
+                        editing ? /*#__PURE__*/ _jsx(EndpointSample, {
+                            actions: actions,
+                            endpoint: editing
+                        }) : null
+                    ]
+                }) : /*#__PURE__*/ _jsx("p", {
+                    className: theme.list.empty,
+                    children: labels.endpoints.pickOne
+                })
+            }, editing?.id ?? (creating ? 'new' : 'none'))
         ]
     });
 }

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

@@ -1,6 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { cn } from '../../../utils/cn';
+import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { FIELD_MAPPING_GRID, PARENT_PREFIX, TRANSFORM_LABEL, TRANSFORMS, toTransform } from './fieldMappingOptions';
 /**
@@ -25,6 +26,7 @@ import { FIELD_MAPPING_GRID, PARENT_PREFIX, TRANSFORM_LABEL, TRANSFORMS, toTrans
     });
 }
 export function FieldMappingRow({ row, index, sourceListId, targetFields, isFirst, isLast, disabled, onPatch, onMove, onRemove }) {
+    const labels = useLabels();
     const base = `${sourceListId}-${index}`;
     return /*#__PURE__*/ _jsxs("li", {
         className: cn(theme.card.wrapper, 'p-3'),
@@ -34,7 +36,7 @@ export function FieldMappingRow({ row, index, sourceListId, targetFields, isFirs
                 children: [
                     /*#__PURE__*/ _jsx(Cell, {
                         id: `${base}-source`,
-                        label: "Source",
+                        label: labels.mappings.source,
                         children: /*#__PURE__*/ _jsx("input", {
                             className: theme.field.input,
                             disabled: disabled,
@@ -43,13 +45,13 @@ export function FieldMappingRow({ row, index, sourceListId, targetFields, isFirs
                             onChange: (event)=>onPatch({
                                     source: event.target.value
                                 }),
-                            placeholder: "employeeNo",
+                            placeholder: labels.mappings.sourcePlaceholder,
                             value: row.source
                         })
                     }),
                     /*#__PURE__*/ _jsx(Cell, {
                         id: `${base}-target`,
-                        label: "Target",
+                        label: labels.mappings.targetColumn,
                         children: targetFields.length > 0 ? /*#__PURE__*/ _jsxs("select", {
                             className: theme.field.input,
                             disabled: disabled,
@@ -75,13 +77,13 @@ export function FieldMappingRow({ row, index, sourceListId, targetFields, isFirs
                             onChange: (event)=>onPatch({
                                     target: event.target.value
                                 }),
-                            placeholder: "employee_no",
+                            placeholder: labels.mappings.sourcePlaceholder,
                             value: row.target
                         })
                     }),
                     /*#__PURE__*/ _jsx(Cell, {
                         id: `${base}-transform`,
-                        label: "Transform",
+                        label: labels.mappings.transform,
                         children: /*#__PURE__*/ _jsx("select", {
                             className: theme.field.input,
                             disabled: disabled,
@@ -98,7 +100,7 @@ export function FieldMappingRow({ row, index, sourceListId, targetFields, isFirs
                     }),
                     /*#__PURE__*/ _jsx(Cell, {
                         id: `${base}-constant`,
-                        label: "Constant",
+                        label: labels.mappings.constant,
                         children: /*#__PURE__*/ _jsx("input", {
                             className: theme.field.input,
                             disabled: disabled,
@@ -106,13 +108,13 @@ export function FieldMappingRow({ row, index, sourceListId, targetFields, isFirs
                             onChange: (event)=>onPatch({
                                     constant: event.target.value
                                 }),
-                            placeholder: "Same value on every record",
+                            placeholder: labels.mappings.constantPlaceholder,
                             value: row.constant ?? ''
                         })
                     }),
                     /*#__PURE__*/ _jsx(Cell, {
                         id: `${base}-fallback`,
-                        label: "Fallback",
+                        label: labels.mappings.fallback,
                         children: /*#__PURE__*/ _jsx("input", {
                             className: theme.field.input,
                             disabled: disabled,
@@ -120,7 +122,7 @@ export function FieldMappingRow({ row, index, sourceListId, targetFields, isFirs
                             onChange: (event)=>onPatch({
                                     fallback: event.target.value
                                 }),
-                            placeholder: "Used when the source is empty",
+                            placeholder: labels.mappings.fallbackPlaceholder,
                             value: row.fallback ?? ''
                         })
                     }),

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

@@ -2,6 +2,7 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useId } from 'react';
 import { cn } from '../../../utils/cn';
+import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { FieldMappingRow } from './FieldMappingRow';
 import { EMPTY_FIELD_MAPPING, FIELD_MAPPING_COLUMNS, FIELD_MAPPING_GRID, PARENT_PREFIX } from './fieldMappingOptions';
@@ -14,6 +15,7 @@ import { Notice } from './Primitives';
  * operator can see the order and change it.
  */ const theme = integrationsPageTheme;
 export function FieldMappingRows({ rows, sourceFields, targetFields, disabled, onChange }) {
+    const labels = useLabels();
     const uid = useId();
     const listId = `${uid}-source-fields`;
     const patchRow = (index, patch)=>{
@@ -39,7 +41,7 @@ export function FieldMappingRows({ rows, sourceFields, targetFields, disabled, o
                 children: [
                     /*#__PURE__*/ _jsx("h3", {
                         className: theme.card.title,
-                        children: "Field mappings"
+                        children: labels.mappings.fieldsHeading
                     }),
                     /*#__PURE__*/ _jsx("button", {
                         className: theme.button.secondary,
@@ -54,7 +56,7 @@ export function FieldMappingRows({ rows, sourceFields, targetFields, disabled, o
                 ]
             }),
             sourceFields.length === 0 ? /*#__PURE__*/ _jsx(Notice, {
-                title: "Sample the endpoint first",
+                title: labels.mappings.sampleFirstTitle,
                 tone: "warning",
                 children: "No field names are known yet. Sampling the selected endpoint lists what the response really returns; until then a source has to be typed from memory, and a typo shows up only as an empty column once the import has already run."
             }) : null,

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

@@ -60,7 +60,15 @@ export function IntegrationsPage({ title = 'Integrations', subtitle = 'Connect a
             limit: 1
         };
         const total = (result)=>result.meta?.totalItems ?? 0;
-        actions.listEndpoints(sourceId, one).then((r)=>store.setEndpointsTotal(total(r))).catch(()=>{});
+        // A PAGE of endpoints, not a count. The strip says how many calls have been
+        // tried, and "tried" lives on the row — counting alone reported "5 calls,
+        // 0 tried" for five endpoints that had all been sampled. It also warms the
+        // store for every tab, which is what made the mappings tab depend on having
+        // visited the endpoints tab first.
+        actions.listEndpoints(sourceId, {
+            page: 1,
+            limit: 50
+        }).then((r)=>store.setEndpoints(r.items, r.meta?.totalItems ?? r.items.length)).catch(()=>{});
         actions.listMappings(sourceId, one).then((r)=>store.setMappingsTotal(total(r))).catch(()=>{});
     // Runs are deliberately NOT counted here. A run records the mapping it came
     // from and nothing about the connection, so the only count available is

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

@@ -1,6 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useId, useState } from 'react';
+import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { FieldMappingRows } from './FieldMappingRows';
 import { endpointLabel, fieldsOfStoredSample } from './formSupport';
@@ -19,6 +20,7 @@ import { CardSkeleton } from './Skeletons';
  * draft instead of pouring one mapping's edits into another.
  */ const theme = integrationsPageTheme;
 export function MappingEditor({ mapping, targets, targetsLoading, endpoints, freshSample, saving, deleting, onSave, onDelete, onCancel }) {
+    const labels = useLabels();
     const uid = useId();
     const [draft, setDraft] = useState(mapping);
     const patch = (next)=>{
@@ -57,16 +59,16 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                 className: theme.card.header,
                 children: /*#__PURE__*/ _jsx("h2", {
                     className: theme.card.title,
-                    children: draft.id ? draft.name || 'Mapping' : 'New mapping'
+                    children: draft.id ? draft.name || labels.mappings.editTitle : labels.mappings.newTitle
                 })
             }),
             /*#__PURE__*/ _jsxs("div", {
                 className: theme.card.body,
                 children: [
                     /*#__PURE__*/ _jsx(Field, {
-                        hint: endpoints.length === 0 ? 'This connection has no endpoints yet. Add one on the Endpoints tab.' : readsFrom?.path ?? 'Every mapping reads from exactly one endpoint.',
+                        hint: endpoints.length === 0 ? labels.mappings.noEndpointsBody : readsFrom?.path ?? labels.mappings.readsFromHint,
                         htmlFor: `${uid}-endpoint`,
-                        label: "Reads from",
+                        label: labels.mappings.readsFrom,
                         children: /*#__PURE__*/ _jsxs("select", {
                             className: theme.field.input,
                             disabled: busy || endpoints.length === 0,
@@ -78,7 +80,7 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                             children: [
                                 /*#__PURE__*/ _jsx("option", {
                                     value: "",
-                                    children: "Not set"
+                                    children: labels.mappings.notSet
                                 }),
                                 endpoints.map((endpoint)=>/*#__PURE__*/ _jsx("option", {
                                         value: endpoint.id,
@@ -92,7 +94,7 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                         children: [
                             /*#__PURE__*/ _jsx(Field, {
                                 htmlFor: `${uid}-name`,
-                                label: "Name",
+                                label: labels.mappings.name,
                                 children: /*#__PURE__*/ _jsx("input", {
                                     className: theme.field.input,
                                     disabled: busy,
@@ -100,14 +102,14 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                                     onChange: (event)=>patch({
                                             name: event.target.value
                                         }),
-                                    placeholder: "Staff directory import",
+                                    placeholder: labels.mappings.namePlaceholder,
                                     value: draft.name
                                 })
                             }),
                             /*#__PURE__*/ _jsx(Field, {
-                                hint: targets.length === 0 ? 'This app exposes no writable entities.' : undefined,
+                                hint: targets.length === 0 ? labels.mappings.targetNone : undefined,
                                 htmlFor: `${uid}-target`,
-                                label: "Target entity",
+                                label: labels.mappings.target,
                                 children: /*#__PURE__*/ _jsxs("select", {
                                     className: theme.field.input,
                                     disabled: busy || targets.length === 0,
@@ -117,7 +119,7 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                                     children: [
                                         /*#__PURE__*/ _jsx("option", {
                                             value: "",
-                                            children: "Not set"
+                                            children: labels.mappings.notSet
                                         }),
                                         targets.map((option)=>/*#__PURE__*/ _jsx("option", {
                                                 value: option.entity,
@@ -129,9 +131,9 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                         ]
                     }),
                     /*#__PURE__*/ _jsx(Field, {
-                        hint: targetFields.length === 0 ? 'Choose a target entity to list its columns.' : 'The column an incoming record is matched on. Without it nothing can be updated.',
+                        hint: targetFields.length === 0 ? labels.mappings.dedupHintNoTarget : labels.mappings.dedupHint,
                         htmlFor: `${uid}-dedup`,
-                        label: "Deduplication column",
+                        label: labels.mappings.dedup,
                         children: /*#__PURE__*/ _jsxs("select", {
                             "aria-describedby": `${uid}-dedup-hint`,
                             className: theme.field.input,
@@ -144,7 +146,7 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                             children: [
                                 /*#__PURE__*/ _jsx("option", {
                                     value: "",
-                                    children: "Not set"
+                                    children: labels.mappings.notSet
                                 }),
                                 targetFields.map((field)=>/*#__PURE__*/ _jsx("option", {
                                         value: field,

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

@@ -3,6 +3,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { useEffect, useEffectEvent, useId, useState } from 'react';
 import { cn } from '../../../utils/cn';
 import { useIntegrationsStore } from '../store';
+import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { Badge, Field, Notice } from './Primitives';
 import { ListSkeleton } from './Skeletons';
@@ -27,6 +28,7 @@ function describeLastRun(value) {
     return Number.isNaN(when.getTime()) ? 'Never run' : `Last run ${when.toLocaleString()}`;
 }
 export function MappingList({ actions, sourceId, selectedId, reloadToken, onSelect }) {
+    const labels = useLabels();
     const store = useIntegrationsStore();
     const uid = useId();
     const search = store.mappingsSearch;
@@ -98,18 +100,18 @@ export function MappingList({ actions, sourceId, selectedId, reloadToken, onSele
         children: [
             /*#__PURE__*/ _jsx(Field, {
                 htmlFor: `${uid}-search`,
-                label: "Search mappings",
+                label: labels.mappings.searchLabel,
                 children: /*#__PURE__*/ _jsx("input", {
                     className: theme.field.input,
                     id: `${uid}-search`,
                     onChange: (event)=>setTerm(event.target.value),
-                    placeholder: "Name or target entity",
+                    placeholder: labels.mappings.searchPlaceholder,
                     type: "search",
                     value: term
                 })
             }),
             list.error ? /*#__PURE__*/ _jsxs(Notice, {
-                title: "This list could not be loaded",
+                title: labels.mappings.loadFailed,
                 tone: "danger",
                 children: [
                     list.error,
@@ -184,7 +186,7 @@ export function MappingList({ actions, sourceId, selectedId, reloadToken, onSele
             }),
             list.loading && list.items.length > 0 ? /*#__PURE__*/ _jsx("p", {
                 className: theme.list.itemMeta,
-                children: "Loading more…"
+                children: labels.mappings.loadingMore
             }) : null
         ]
     });

package/dist/fe/components/IntegrationsPage/components/MappingWriteModeFields.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 { Field, Notice } from './Primitives';
 /**
@@ -49,6 +50,7 @@ function toMissingPolicy(value) {
     return policy === 'deactivate' && (column.trim() === '' || value.trim() === '');
 }
 export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolicy, missingRecordColumn, missingRecordValue, dedupConfigured, disabled, onWriteModeChange, onMissingRecordPolicyChange, onMissingRecordColumnChange, onMissingRecordValueChange }) {
+    const labels = useLabels();
     const modeId = `${idPrefix}-write-mode`;
     const policyId = `${idPrefix}-missing-policy`;
     const columnId = `${idPrefix}-missing-column`;
@@ -60,8 +62,8 @@ export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolic
         children: [
             /*#__PURE__*/ _jsx(Field, {
                 htmlFor: modeId,
-                hint: WRITE_MODE_HINT[writeMode],
-                label: "Write mode",
+                hint: labels.writeModeHint[writeMode],
+                label: labels.mappings.writeModeLabel,
                 children: /*#__PURE__*/ _jsx("select", {
                     "aria-describedby": `${modeId}-hint`,
                     className: theme.field.input,
@@ -71,12 +73,12 @@ export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolic
                     value: writeMode,
                     children: WRITE_MODES.map((mode)=>/*#__PURE__*/ _jsx("option", {
                             value: mode,
-                            children: WRITE_MODE_LABEL[mode]
+                            children: labels.writeModeFull[mode]
                         }, mode))
                 })
             }),
             writeMode === 'replace' ? /*#__PURE__*/ _jsxs(Notice, {
-                title: "Replace rebuilds the table on every run",
+                title: labels.mappings.replaceWarnTitle,
                 tone: "danger",
                 children: [
                     /*#__PURE__*/ _jsx("p", {
@@ -90,8 +92,8 @@ export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolic
             }) : null,
             /*#__PURE__*/ _jsx(Field, {
                 htmlFor: policyId,
-                hint: MISSING_POLICY_HINT[missingRecordPolicy],
-                label: "Records the source no longer returns",
+                hint: labels.missingPolicyHint[missingRecordPolicy],
+                label: labels.mappings.missingPolicyLabel,
                 children: /*#__PURE__*/ _jsx("select", {
                     "aria-describedby": `${policyId}-hint`,
                     className: theme.field.input,
@@ -101,12 +103,12 @@ export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolic
                     value: missingRecordPolicy,
                     children: MISSING_POLICIES.map((policy)=>/*#__PURE__*/ _jsx("option", {
                             value: policy,
-                            children: MISSING_POLICY_LABEL[policy]
+                            children: labels.missingPolicyFull[policy]
                         }, policy))
                 })
             }),
             missingRecordPolicy === 'delete' ? /*#__PURE__*/ _jsx(Notice, {
-                title: "Deleting is not reversible",
+                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."
             }) : null,
@@ -115,9 +117,9 @@ export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolic
                 children: [
                     /*#__PURE__*/ _jsx(Field, {
                         error: columnMissing ? 'Required while Deactivate is selected.' : null,
-                        hint: "A column on the target entity.",
+                        hint: labels.mappings.deactivateColumnHint,
                         htmlFor: columnId,
-                        label: "Deactivation column",
+                        label: labels.mappings.deactivateColumn,
                         children: /*#__PURE__*/ _jsx("input", {
                             "aria-describedby": `${columnId}-hint`,
                             className: theme.field.input,
@@ -130,9 +132,9 @@ export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolic
                     }),
                     /*#__PURE__*/ _jsx(Field, {
                         error: valueMissing ? 'Required while Deactivate is selected.' : null,
-                        hint: "Written into that column.",
+                        hint: labels.mappings.deactivateValueHint,
                         htmlFor: valueId,
-                        label: "Deactivation value",
+                        label: labels.mappings.deactivateValue,
                         children: /*#__PURE__*/ _jsx("input", {
                             "aria-describedby": `${valueId}-hint`,
                             className: theme.field.input,

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

@@ -2,6 +2,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useEffectEvent, useState } from 'react';
 import { useIntegrationsStore } from '../store';
+import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { MappingEditor } from './MappingEditor';
 import { MappingList } from './MappingList';
@@ -19,6 +20,7 @@ function messageOf(error) {
     return error instanceof Error ? error.message : 'The request failed.';
 }
 export function MappingsTab({ actions }) {
+    const labels = useLabels();
     const store = useIntegrationsStore();
     const [targets, setTargets] = useState([]);
     const [targetsLoading, setTargetsLoading] = useState(true);
@@ -124,29 +126,23 @@ export function MappingsTab({ actions }) {
     return /*#__PURE__*/ _jsxs("section", {
         className: "flex flex-col gap-4",
         children: [
-            /*#__PURE__*/ _jsxs("div", {
+            /*#__PURE__*/ _jsx("div", {
                 className: theme.header.wrapper,
-                children: [
-                    /*#__PURE__*/ _jsx("p", {
-                        className: theme.header.subtitle,
-                        children: "A mapping turns one endpoint's response into rows of one entity."
-                    }),
-                    /*#__PURE__*/ _jsx("div", {
-                        className: theme.header.actions,
-                        children: /*#__PURE__*/ _jsx("button", {
-                            className: theme.button.primary,
-                            disabled: newMappingEndpointId === '',
-                            onClick: startNew,
-                            type: "button",
-                            children: "New mapping"
-                        })
+                children: /*#__PURE__*/ _jsx("div", {
+                    className: theme.header.actions,
+                    children: /*#__PURE__*/ _jsx("button", {
+                        className: theme.button.primary,
+                        disabled: newMappingEndpointId === '',
+                        onClick: startNew,
+                        type: "button",
+                        children: labels.mappings.create
                     })
-                ]
+                })
             }),
             newMappingEndpointId === '' ? /*#__PURE__*/ _jsx(Notice, {
-                title: "No endpoints to read from",
+                title: labels.mappings.noEndpointsTitle,
                 tone: "info",
-                children: "A mapping turns one endpoint's response into rows, so there has to be an endpoint first. Add one on the Endpoints tab and it becomes selectable here."
+                children: labels.mappings.noEndpointsBody
             }) : null,
             /*#__PURE__*/ _jsxs("div", {
                 className: theme.layout.split,
@@ -176,7 +172,7 @@ export function MappingsTab({ actions }) {
                             targetsLoading: targetsLoading
                         }, draft.id ?? 'new-mapping') : /*#__PURE__*/ _jsx("p", {
                             className: theme.list.empty,
-                            children: "Pick a mapping to edit it, or create one to describe what an import writes."
+                            children: labels.mappings.pickOne
                         })
                     })
                 ]

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

@@ -58,6 +58,10 @@ export type IntegrationsLabels = {
         off: string;
         /** Returns to the chooser once a connection is being worked in. */
         change: string;
+        editTitle: string;
+        newTitle: string;
+        enabledBadge: string;
+        disabledBadge: string;
     };
     runs: {
         /** The one-line summary above the buttons. */
@@ -95,6 +99,7 @@ export type IntegrationsLabels = {
         loadFailed: string;
         loadingMore: string;
         selectConnection: string;
+        pickOne: string;
         editTitle: string;
         newTitle: string;
         tag: string;
@@ -171,6 +176,76 @@ export type IntegrationsLabels = {
         timeout: string;
         timeoutHint: string;
     };
+    /** Step three: which field lands in which column. */
+    mappings: {
+        heading: string;
+        searchLabel: string;
+        searchPlaceholder: string;
+        create: string;
+        loadFailed: string;
+        loadingMore: string;
+        empty: string;
+        noEndpointsTitle: string;
+        noEndpointsBody: string;
+        pickOne: string;
+        editTitle: string;
+        newTitle: string;
+        readsFrom: string;
+        readsFromHint: string;
+        notSet: string;
+        name: string;
+        namePlaceholder: string;
+        target: string;
+        targetNone: string;
+        dedup: string;
+        dedupHintNoTarget: string;
+        dedupHint: string;
+        writeModeLabel: string;
+        missingPolicyLabel: string;
+        replaceWarnTitle: string;
+        deleteWarnTitle: string;
+        deactivateColumn: string;
+        deactivateColumnHint: string;
+        deactivateValue: string;
+        deactivateValueHint: string;
+        fieldsHeading: string;
+        addField: string;
+        sampleFirstTitle: string;
+        sampleFirstBody: string;
+        nothingMapped: string;
+        parentPrefixHint: string;
+        templateHint: string;
+        source: string;
+        sourcePlaceholder: string;
+        targetColumn: string;
+        transform: string;
+        constant: string;
+        constantPlaceholder: string;
+        fallback: string;
+        fallbackPlaceholder: string;
+        save: string;
+    };
+    /** The long form of each write mode, for the picker. */
+    writeModeFull: {
+        upsert: string;
+        append: string;
+        replace: string;
+    };
+    writeModeHint: {
+        upsert: string;
+        append: string;
+        replace: string;
+    };
+    missingPolicyFull: {
+        ignore: string;
+        deactivate: string;
+        delete: string;
+    };
+    missingPolicyHint: {
+        ignore: string;
+        deactivate: string;
+        delete: string;
+    };
     writeMode: {
         upsert: string;
         append: string;

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

@@ -51,7 +51,11 @@
         loadFailed: 'This list could not be loaded',
         retry: 'Try again',
         off: 'Off',
-        change: 'Change'
+        change: 'Change',
+        editTitle: 'Connection',
+        newTitle: 'New connection',
+        enabledBadge: 'Enabled',
+        disabledBadge: 'Off'
     },
     runs: {
         summary: (target, writeMode, missing)=>`Writes into ${target} · ${writeMode} · missing rows: ${missing}`,
@@ -87,6 +91,7 @@
         loadFailed: 'This list could not be loaded',
         loadingMore: 'Loading more…',
         selectConnection: 'Select a connection to see its calls.',
+        pickOne: 'Select a call to edit it, or add one. A call is a single request — a method, a path, and where in the answer the records sit.',
         editTitle: 'Edit call',
         newTitle: 'New call',
         tag: 'Tag',
@@ -162,6 +167,74 @@
         timeout: 'Timeout (ms)',
         timeoutHint: 'How long one request may take before it is given up on. Empty means the server default.'
     },
+    mappings: {
+        heading: 'Mappings',
+        searchLabel: 'Search',
+        searchPlaceholder: 'Name or target table',
+        create: 'New mapping',
+        loadFailed: 'This list could not be loaded',
+        loadingMore: 'Loading more…',
+        empty: 'No mappings match. A mapping is what turns a response into rows.',
+        noEndpointsTitle: 'No calls to read from',
+        noEndpointsBody: "A mapping turns one call's response into rows, so there has to be a call first. Add one on the calls step and it becomes selectable here.",
+        pickOne: 'Pick a mapping to edit it, or create one to describe what an import writes.',
+        editTitle: 'Mapping',
+        newTitle: 'New mapping',
+        readsFrom: 'Reads from',
+        readsFromHint: 'Every mapping reads from exactly one call.',
+        notSet: 'Not set',
+        name: 'Name',
+        namePlaceholder: 'Staff directory import',
+        target: 'Writes into',
+        targetNone: 'This app exposes no writable tables.',
+        dedup: 'Matched on',
+        dedupHintNoTarget: 'Choose a target table to list its columns.',
+        dedupHint: 'The column an incoming record is matched on. Without it nothing can be updated.',
+        writeModeLabel: 'What a run does',
+        missingPolicyLabel: 'Records the source no longer returns',
+        replaceWarnTitle: 'Replace rebuilds the table on every run',
+        deleteWarnTitle: 'Deleting is not reversible',
+        deactivateColumn: 'Deactivation column',
+        deactivateColumnHint: 'A column on the target table.',
+        deactivateValue: 'Deactivation value',
+        deactivateValueHint: 'Written into that column.',
+        fieldsHeading: 'Field mappings',
+        addField: 'Add field',
+        sampleFirstTitle: 'Try the call first',
+        sampleFirstBody: 'No field names are known yet. Trying the selected call lists what the response really returns; until then a source has to be typed from memory, and a typo shows up only as an empty column once the import has already run.',
+        nothingMapped: 'Nothing is mapped yet, so a run would write empty records. Add a field to begin.',
+        parentPrefixHint: 'to take the value from the parent call’s record instead of this one.',
+        templateHint: 'to build one value from several — use it when no single field is unique on its own, which is what the matching column needs.',
+        source: 'Source',
+        sourcePlaceholder: 'employeeNo',
+        targetColumn: 'Target',
+        transform: 'Transform',
+        constant: 'Constant',
+        constantPlaceholder: 'Same value on every record',
+        fallback: 'Fallback',
+        fallbackPlaceholder: 'Used when the source is empty',
+        save: 'Save mapping'
+    },
+    writeModeFull: {
+        upsert: 'Upsert — update what matches, insert the rest',
+        append: 'Append — insert every fetched record',
+        replace: 'Replace — rebuild the table from this response'
+    },
+    writeModeHint: {
+        upsert: 'Rows keep their identity, so whatever points at them keeps working.',
+        append: 'Nothing is matched, so running this import twice stores every record twice.',
+        replace: 'The table is emptied and refilled on every run.'
+    },
+    missingPolicyFull: {
+        ignore: 'Ignore — leave them exactly as they are',
+        deactivate: 'Deactivate — mark them with a column value',
+        delete: 'Delete — remove them from the table'
+    },
+    missingPolicyHint: {
+        ignore: 'Safest. Records removed at the source stay in the table until someone acts.',
+        deactivate: 'Reversible. The row survives and history that refers to it stays readable.',
+        delete: 'Permanent. A source that returns a short page for any reason takes rows with it.'
+    },
     writeMode: {
         upsert: 'update what matches, insert the rest',
         append: 'always insert, never match',

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nucleus-core-ts",
-	"version": "0.9.804",
+	"version": "0.9.806",
 	"description": "Production-ready, enterprise-grade TypeScript framework for building multi-tenant APIs",
 	"author": "Hidayet Can Özcan <hidayetcan@gmail.com>",
 	"license": "SEE LICENSE IN LICENSE",