@ethisyscore/plugin-ui 1.93.0 → 1.95.0

package/dist/mappingQueryKeys-BcbA0TGy.d.ts

@@ -0,0 +1,473 @@
+import * as react from 'react';
+
+/**
+ * Per-operation mapping completeness for one connector + module, as returned by the host's
+ * `connectors:mappings:completeness` tool.
+ *
+ * Declared here rather than imported from a plugin's generated contracts because this package sits
+ * BELOW the plugins: every plugin that shows a Tool Mappings page had its own copy of this shape,
+ * and the copies are what let the surfaces drift apart.
+ *
+ * @remarks
+ * The distinction that matters, and the one every copy of the banner got wrong at least once:
+ * `isToolMapped` and `unmappedRequiredCanonicalFields` are INDEPENDENT. An operation can have a tool
+ * mapped and still be incomplete, because the tool's schema does not accept a field the operation
+ * requires. Copy that says "not mapped" when it means "fields not mapped" sends the operator to
+ * auto-match, which maps tools and cannot close a field gap.
+ */
+interface MappingCompletenessItem {
+    /** Canonical operation key, e.g. `list-commits`. */
+    operationKey: string;
+    /** Human label for the operation, as declared by the module's catalogue. */
+    label: string;
+    /**
+     * Whether the module declares this operation as required. Required gaps block the module from
+     * working; optional ones only leave an extra capability switched off.
+     */
+    isRequired: boolean;
+    /**
+     * Whether ANY tool is mapped to the operation. False means the operator has not chosen a tool
+     * yet; true says nothing about whether the mapping is complete.
+     */
+    isToolMapped: boolean;
+    /**
+     * Canonical request fields the operation requires that do not map onto a property the live tool
+     * actually accepts. Non-empty means incomplete, whether or not a tool is mapped.
+     */
+    unmappedRequiredCanonicalFields: string[];
+}
+/** Response envelope for the completeness read, post-unwrap. */
+interface MappingCompletenessResult {
+    operations: MappingCompletenessItem[];
+}
+/**
+ * Type discriminator for a canonical field. Mirrors the backend `CanonicalFieldKind` enum.
+ *
+ * Wire format is the enum member name (e.g. `"String"`, `"StringArray"`); the editor renders the
+ * value verbatim as the field-kind chip, so an unrecognised kind degrades to a label rather than
+ * a blank.
+ */
+type ConnectorCanonicalFieldKind = "String" | "Integer" | "Boolean" | "DateTime" | "Object" | "StringArray";
+/**
+ * A single canonical field on an operation's request or response schema. Carried on the mapping row
+ * so the editor can render an input per field without a separate schema fetch.
+ */
+interface ConnectorCanonicalField {
+    name: string;
+    kind: ConnectorCanonicalFieldKind;
+    isRequired: boolean;
+}
+/**
+ * Arguments the editor hands to the consumer-supplied `onTestMapping` callback. The consumer builds
+ * the full service request from these plus its own `connectorId` / `operationKey` / `toolName` — the
+ * editor owns no network call.
+ */
+interface TestToolMappingRequest {
+    /** Sample values the operator typed — one entry per canonical request field. */
+    sampleArgs: Record<string, unknown>;
+    /** Current unsaved request-field map (empty inputs stripped; `null` if all blank). */
+    requestFieldMap: Record<string, string> | null;
+    /** Current unsaved response-field paths (empty inputs stripped; `null` if all blank). */
+    responseFieldPaths: Record<string, string> | null;
+    /**
+     * Current unsaved static request parameters (blank-key rows dropped; `null` if none). Optional and
+     * backward-compatible: it lets the dry-run exercise the DRAFT static params — a consolidated
+     * tool's `method` discriminator, say — that the operator typed but has not saved yet. A consumer
+     * whose test endpoint does not accept static fields simply ignores it.
+     */
+    staticRequestFields?: Record<string, string> | null;
+}
+/**
+ * Result of extracting one canonical response field from the tool's raw response. Mirrors the
+ * backend `ExtractedFieldResult` DTO.
+ */
+interface TestToolMappingExtractedField {
+    canonicalField: string;
+    /** Extracted value, or `null` when the path matched nothing. */
+    value: string | null;
+    /** `true` when the JSON path resolved to a node in the response. */
+    present: boolean;
+    /**
+     * `true` when the extracted value looks like Base64 content (long string, charset
+     * `[A-Za-z0-9+/=]`, no whitespace). The editor shows a "prefix with base64:" hint so the operator
+     * adjusts the JSON path rather than concluding the mapping is broken.
+     */
+    looksBase64: boolean;
+}
+/** Result the consumer's `onTestMapping` callback resolves with, after the dry-run. */
+interface TestToolMappingResult {
+    success: boolean;
+    /** Error message when `success` is false. */
+    error: string | null;
+    /**
+     * Raw JSON string of the tool's response, shown in a collapsible so the operator can find the
+     * right JSON path.
+     */
+    rawResponseJson: string | null;
+    /** Per-field extraction result. */
+    extractedFields: TestToolMappingExtractedField[];
+}
+/**
+ * Result the consumer's `onSuggestTranslation` callback resolves with. When `success` is true, the
+ * editor merges the two dictionaries over its current inputs so the operator can review the
+ * AI proposal before saving.
+ */
+interface ConnectorMappingSuggestionResult {
+    success: boolean;
+    /** Error message when `success` is false. `null` when `success` is true. */
+    error: string | null;
+    /**
+     * Proposed canonical-request → tool-field-name rewrite. Empty object `{}` when the model found no
+     * request-side rewrites to apply.
+     */
+    requestFieldMap: Record<string, string>;
+    /**
+     * Proposed canonical-response → JSON-path rewrite (e.g. `{ "content": "base64:$.content" }`).
+     * Empty object `{}` when the model found no response-side rewrites.
+     */
+    responseFieldPaths: Record<string, string>;
+}
+
+interface MappingCompletenessBannerProps {
+    /**
+     * Per-operation completeness for the selected connector + module. The banner splits these into
+     * REQUIRED operations with gaps (a blocking warning) and OPTIONAL ones (an informational note);
+     * it renders nothing when neither group has gaps.
+     */
+    operations: MappingCompletenessItem[];
+    /**
+     * Opt-in AI assist. Invoked with the operation the operator chose to fix. The consumer wires this
+     * to the suggest-translation mutation and decides what to do with the result (open the editor
+     * seeded with the suggestion, apply it, and so on).
+     */
+    onSuggestWithAi: (operation: MappingCompletenessItem) => void;
+    /**
+     * Opens the manual mapping editor for an operation. The consumer owns the editor surface and
+     * routing; the banner only raises intent.
+     *
+     * Every known consumer wires this to the request/response translation editor, which is why the
+     * row control is labelled for what it opens rather than for this prop's name. Kept required
+     * because it always was: making it optional would let a consumer render rows with no action.
+     */
+    onOpenMappingEditor: (operation: MappingCompletenessItem) => void;
+    /**
+     * OPTIONAL, and the preferred wiring. Jumps straight to the operation's REQUEST-FIELD
+     * TRANSLATION editor — the "Configure field translation" surface — rather than to whatever general
+     * mapping surface `onOpenMappingEditor` happens to open.
+     *
+     * @remarks
+     * Optional on purpose. This package is pinned independently by every plugin, so a required prop
+     * would break every consumer that has not been updated. When it is absent the row falls back to
+     * `onOpenMappingEditor` with identical rendering, so an un-updated consumer keeps exactly the
+     * behaviour it had and still gains the corrected copy.
+     */
+    onConfigureTranslation?: (operation: MappingCompletenessItem) => void;
+    /**
+     * Operation key currently awaiting an AI suggestion, or `null`. Drives the per-row spinner and
+     * disabled state so a slow suggestion does not lock the whole banner.
+     */
+    suggestingOperationKey?: string | null;
+    /** Disables the AI assist affordance entirely, e.g. AI not configured for the organisation. */
+    disableSuggest?: boolean;
+    /**
+     * `true` when the module has no PROVIDER chosen at all - nobody has said whether it is served by
+     * another installed app or by an external system.
+     *
+     * @remarks
+     * A different gap from everything else this banner reports, and the only one that makes the rest
+     * meaningless: with no provider there is no tool inventory to be complete or incomplete against,
+     * so the two alerts below correctly have nothing to say and the page would otherwise look
+     * configured. This is therefore the one condition that renders the banner when no operation has
+     * a gap.
+     *
+     * Optional, defaulting to `false`, for the reason {@link onConfigureTranslation} is: a consumer
+     * that has not adopted the provider surface keeps exactly its current behaviour.
+     */
+    isProviderUnconfigured?: boolean;
+}
+/**
+ * Connector-setup "mapping completeness" banner, shared by every plugin with a Tool Mappings page.
+ *
+ * Presentational and props-driven: the consumer fetches completeness and owns the editor, so the
+ * same banner serves Repo Monitoring, Timesheets, Error Monitoring and anything added later.
+ *
+ * It separates two cases:
+ *
+ * - **Required** operations with unmapped required fields, a warning the operator must act on
+ *   because the module cannot run them.
+ * - **Optional** operations with unmapped required fields, a calm note. These power extra
+ *   capabilities that stay off until their fields are mapped, and the connector may legitimately
+ *   expose no suitable tool, so they must never read as a blocking error.
+ *
+ * Renders nothing when neither group has gaps.
+ *
+ * @remarks
+ * **The wording is load-bearing, and was wrong in the copy this was promoted from.** Both groups are
+ * selected on `unmappedRequiredCanonicalFields`, which is about FIELD mapping. The original optional
+ * alert was titled "Optional operations not mapped" and said they "stay off until mapped", which
+ * describes TOOL mapping. Auto-match maps tools and cannot close a field gap, so an operator who
+ * pressed auto-match saw the count refuse to move and reported the banner as broken. It was
+ * accurate; the text was not. Every string here therefore says "fields", and both alerts say plainly
+ * that auto-match will not clear them.
+ *
+ * A row without the "No tool mapped" chip already HAS a tool and needs its fields mapped. That chip
+ * is the only thing distinguishing the two states, which is why the prose points at it.
+ *
+ * **The second wording fix, from a production report.** Saying "fields" was necessary but not
+ * sufficient. An operator read "fields that aren't mapped to this connector's tools", concluded the
+ * TOOL was unmapped (it was not), and had no idea which control closed the gap — the text named an
+ * abstraction, "the mapping editor", and never the affordance on screen. So the copy now names the
+ * thing that is missing (the REQUEST-FIELD TRANSLATION, canonical field name → the tool's own
+ * parameter name) and the control that supplies it ("Configure field translation"), and every
+ * listed operation carries that control inline. Their words: "it doesnt really suggest how to fix
+ * it".
+ *
+ * That label is not invented here: it is the verbatim tooltip and aria-label of the per-row gear in
+ * every consumer's `ConnectorMappingView` (host gogo-ui, self-healing, tech, timesheets, sales). The
+ * prose has to name a string the operator can actually find on the page, so a near-miss paraphrase
+ * would reintroduce the defect in a quieter form.
+ */
+declare function MappingCompletenessBanner({ operations, onSuggestWithAi, onOpenMappingEditor, onConfigureTranslation, suggestingOperationKey, disableSuggest, isProviderUnconfigured, }: MappingCompletenessBannerProps): react.JSX.Element | null;
+
+/**
+ * The words the provider controls use, in one place, because two surfaces have to say the same ones.
+ *
+ * ## Why these are constants and not literals at each site
+ *
+ * A "not configured" message has to name the control that resolves it, in that control's own words.
+ * This surface has already paid for the alternative: the completeness banner described a gap in the
+ * abstract ("the mapping editor"), an operator could not find any such thing on the page, and the
+ * report that came back was "it doesnt really suggest how to fix it". The fix was to name the
+ * affordance verbatim - and a verbatim name held as two separate string literals is one rename away
+ * from pointing at nothing again, with both files still compiling and both tests still green.
+ *
+ * So the control renders {@link PROVIDER_CONTROL_LABEL} and the banner quotes it, from here. A test
+ * asserts the banner's text contains the label the view actually renders; it fails if either side
+ * is edited alone.
+ *
+ * Pure strings, no imports. That matters: the mapping HOOKS module value-imports this, and it must
+ * not drag `@mui/material` into a barrel whose consumers may not have installed it.
+ */
+/** Label of the control that chooses what serves a module. */
+declare const PROVIDER_CONTROL_LABEL = "Served by";
+/**
+ * Labels of the two things that can serve a module.
+ *
+ * Phrased from the operator's side rather than the schema's. "Plugin" and "Connector" are the
+ * platform's words for its own internals; an operator choosing where a module's data comes from is
+ * choosing between the applications they already run and something outside.
+ */
+declare const PROVIDER_OPTION_LABEL: {
+    readonly plugin: "This organisation's apps";
+    readonly connector: "External system";
+};
+/** Label of the control that picks WHICH installed application, once "this organisation's apps" is chosen. */
+declare const PLUGIN_PROVIDER_CONTROL_LABEL = "App";
+/** Label of the control that picks WHICH connector, once "external system" is chosen. */
+declare const CONNECTOR_CONTROL_LABEL = "Connector";
+
+interface ConnectorMappingTranslationEditorProps {
+    open: boolean;
+    /**
+     * Human-readable operation label for the dialog title (e.g. "Get File").
+     *
+     * Optional because it is derived from a looked-up operation that may not be found: every caller
+     * passes `string | undefined`. The contract claimed required while reality was optional, so this
+     * states the truth rather than changing any runtime value.
+     */
+    operationLabel?: string;
+    /**
+     * Tool name the mapping currently points at — shown in the dialog header for context.
+     *
+     * Optional and nullable because the editor opens for an operation that may not be mapped yet:
+     * every caller passes `string | null | undefined`.
+     */
+    toolName?: string | null;
+    /**
+     * Canonical request fields the editor renders one input per.
+     *
+     * Optional and nullable: an operation may declare no canonical schema, and the editor already
+     * gates on their presence. See the coalescing note in the component body — this is not cosmetic.
+     */
+    canonicalRequestFields?: ConnectorCanonicalField[] | null;
+    /** Canonical response fields the editor renders one JSON-path input per. Same nullability. */
+    canonicalResponseFields?: ConnectorCanonicalField[] | null;
+    /** Currently-persisted request-field translation, or `null` if the operator hasn't supplied one. */
+    requestFieldMap: Record<string, string> | null;
+    /** Currently-persisted response-field translation, or `null` if the operator hasn't supplied one. */
+    responseFieldPaths: Record<string, string> | null;
+    /**
+     * Currently-persisted static request parameters (tool field name → constant literal value), or
+     * `null` if the operator hasn't supplied any. Seeds the "Static request parameters" rows.
+     */
+    staticRequestFields: Record<string, string> | null;
+    /**
+     * Called with the operator's translation dictionaries when they click Save. Empty inputs are
+     * stripped before this fires; if every input on a side was blank, that side is delivered as `null`
+     * rather than `{}` so the consumer can pass it straight through and the BE writes a NULL column
+     * (which the resolver treats as "no operator override" and falls back to the connector's
+     * vendor-default translation). A populated dictionary means "rewrite these fields explicitly"; the
+     * BE persists it verbatim and the resolver applies it on top of vendor defaults.
+     *
+     * `staticRequestFields` carries the constant tool-request parameters (e.g. `{ method: "get" }`);
+     * same null-vs-populated semantics — `null` when every static row was left blank.
+     */
+    onSave: (requestFieldMap: Record<string, string> | null, responseFieldPaths: Record<string, string> | null, staticRequestFields: Record<string, string> | null) => void;
+    onCancel: () => void;
+    /**
+     * Optional. When provided, the editor renders a Test section below the field tables and a "Test
+     * mapping" button inside it. The consumer supplies this callback so the editor never owns a
+     * network call. Invoked with the sample args and the current (unsaved) field maps — stripped to
+     * `null` when every input is blank, matching `onSave`.
+     */
+    onTestMapping?: (request: TestToolMappingRequest) => Promise<TestToolMappingResult>;
+    /**
+     * Optional. When provided, the editor renders an "Auto-configure" button in the Test section. The
+     * consumer invokes the AI suggestion endpoint with the sample inputs the Test section collects,
+     * then returns the suggested field maps so the editor can populate the request / response inputs.
+     * The operator reviews and clicks Save.
+     *
+     * @param sampleArgs - Sample values the operator typed, one entry per canonical request field.
+     * @returns The suggestion result (success/error + proposed maps).
+     */
+    onSuggestTranslation?: (sampleArgs: Record<string, unknown>) => Promise<ConnectorMappingSuggestionResult>;
+}
+/**
+ * Per-mapping translation editor — surfaced when the operator picks a tool whose schema doesn't
+ * match the operation's canonical request/response field names. Renders two stacked tables
+ * (request / response): left column shows the canonical field's name + kind chip + required
+ * indicator; right column captures the operator-supplied tool field name (request side) or JSON
+ * path (response side).
+ *
+ * <p><b>Identity semantics.</b> An empty input on a field means "identity — pass the canonical name
+ * through unchanged". On Save the editor strips empty values; if every input on a side was blank,
+ * that side is delivered to `onSave` as <code>null</code> (not <code>{}</code>) so the BE writes a
+ * NULL column. The resolver then treats the NULL as "no operator override" and falls back to the
+ * connector's vendor-default translation; a populated dictionary means "rewrite these fields
+ * explicitly" and applies on top of the vendor default.</p>
+ *
+ * <p><b>State seeding.</b> The consumer page mounts/unmounts this dialog every time the editor opens
+ * (the `open` prop is always `true` in practice — the parent gates rendering via conditional mount),
+ * so local state initialises lazily from the props on each mount. This avoids the "setState in
+ * useEffect" pattern the eslint react-hooks ruleset blocks, AND keeps the operator's in-flight edits
+ * sovereign once the dialog is open — a concurrent refresh of the mapping row doesn't clobber what
+ * they're typing.</p>
+ *
+ * <p><b>Promoted, not designed here.</b> This file existed FOUR times — the host's gogo-ui adapter
+ * plus `self-healing`, `tech` and `timesheets` — and the copies had already drifted. Three
+ * differences were adjudicated on the way in, and each is a reason the duplication was expensive:</p>
+ *
+ * <ol>
+ *   <li><b>The Test button is gated on `onTestMapping`.</b> The enclosing block is gated on
+ *       <code>(onTestMapping || onSuggestTranslation)</code>, so without the inner guard a consumer
+ *       supplying only <code>onSuggestTranslation</code> rendered a "Test mapping" button whose
+ *       handler returns immediately — a DEAD CONTROL. `self-healing` shipped that; `tech` and
+ *       `timesheets` had fixed it. Nothing noticed, because there was no single source to notice
+ *       it against.</li>
+ *   <li><b>Backgrounds come from the theme (`action.hover`), never a hardcoded
+ *       <code>rgba()</code>.</b> A literal <code>rgba(0,0,0,0.03)</code> is invisible in dark mode
+ *       and is what `coreconnect/no-hardcoded-colors` exists to stop.</li>
+ *   <li><b>No emoji in chip labels.</b> The chips already carry an icon and a semantic colour, so
+ *       the emoji was a third, untranslatable, screen-reader-hostile encoding of the same state.</li>
+ * </ol>
+ *
+ * <p>The null tolerance below came from the HOST copy, which was the most hardened of the four.
+ * `coreconnect/no-local-mapping-editor` stops a fifth being written.</p>
+ */
+declare function ConnectorMappingTranslationEditorView({ open, operationLabel, toolName, canonicalRequestFields: canonicalRequestFieldsProp, canonicalResponseFields: canonicalResponseFieldsProp, requestFieldMap, responseFieldPaths, staticRequestFields, onSave, onCancel, onTestMapping, onSuggestTranslation, }: ConnectorMappingTranslationEditorProps): react.JSX.Element;
+
+/**
+ * Every operation with a gap, required or optional. Use it to decide whether to mount a banner at
+ * all, without duplicating the predicate.
+ */
+declare function selectIncompleteOperations(operations: MappingCompletenessItem[]): MappingCompletenessItem[];
+/**
+ * REQUIRED operations with a gap. These genuinely block the module: the connector cannot run them.
+ */
+declare function selectRequiredIncompleteOperations(operations: MappingCompletenessItem[]): MappingCompletenessItem[];
+/**
+ * OPTIONAL operations with a gap. Informational only: the operation powers an extra capability that
+ * stays off until its fields are mapped, and the connector may legitimately expose no suitable tool.
+ *
+ * @remarks
+ * Treat these as a note, never a warning. A connector need not expose every operation a module can
+ * use, so a correctly configured connector can sit here indefinitely — and a banner that never
+ * clears is a banner operators learn to ignore, which costs you the required warnings too.
+ */
+declare function selectOptionalIncompleteOperations(operations: MappingCompletenessItem[]): MappingCompletenessItem[];
+/** A module's readiness, counted over REQUIRED operations only. */
+interface MappingReadiness {
+    /** Required operations that are mapped AND have no field gaps. */
+    complete: number;
+    /** Total required operations declared by the module's catalogue. */
+    total: number;
+    /** True when every required operation is mapped and complete. */
+    isReady: boolean;
+}
+/**
+ * Readiness over REQUIRED operations only, for a progress indicator or a "ready" badge.
+ *
+ * @remarks
+ * Optional operations are excluded on purpose. Counting them would leave a properly configured
+ * connector permanently short of 100%, for operations the operator was never expected to map. This
+ * rule came from `ethisyscore-plugin-timesheets`, which had it right while another plugin was
+ * reporting optional field gaps in a standing banner.
+ */
+declare function selectMappingReadiness(operations: MappingCompletenessItem[]): MappingReadiness;
+
+/**
+ * React-query keys for a connector's tool mappings and the completeness read derived from them.
+ *
+ * @remarks
+ * The completeness key is built as a CHILD of the mappings key, and that nesting is the whole point
+ * of shipping these from the SDK rather than letting each plugin declare its own.
+ *
+ * Completeness is derived state: it is the mappings joined against the live tool schemas. Every write
+ * that changes a mapping can change it. When the two keys are siblings, a mutation has to remember to
+ * invalidate both, and one plugin duly invalidated only the mappings key — so its "operations aren't
+ * fully mapped" banner went stale after every save, clear and auto-match, and stayed stale until the
+ * operator navigated away. Nesting means a single `invalidateQueries({ queryKey: mappings })` takes
+ * the completeness read with it, and there is nothing left to forget.
+ *
+ * @example
+ * ```ts
+ * const mappings = connectorMappingsQueryKey(connectorId, moduleKey);
+ *
+ * useQuery({ queryKey: mappings, queryFn: ... });
+ * useQuery({ queryKey: connectorMappingCompletenessQueryKey(connectorId, moduleKey), queryFn: ... });
+ *
+ * // One call. Covers both, and any future query keyed beneath the mappings key.
+ * queryClient.invalidateQueries({ queryKey: mappings });
+ * ```
+ */
+/**
+ * Key for the mappings list of one connector + module.
+ *
+ * `connectorId` is accepted as possibly-undefined because the page renders before a connector is
+ * chosen; pair it with `enabled: !!connectorId` rather than branching on the key.
+ */
+declare function connectorMappingsQueryKey(connectorId: string | undefined, moduleKey: string): readonly ["connector-mappings", string | undefined, string];
+/**
+ * The whole family's prefix, for the one invalidation that has to cross connectors.
+ *
+ * Almost every write is scoped to one connector and should invalidate only that connector's subtree
+ * via {@link connectorMappingsQueryKey}. Changing a module's PROVIDER is the exception: it moves the
+ * module from one provider's rows to another's, so the subtree that must be discarded is the one
+ * being left, which the new scope's key does not name.
+ */
+declare function connectorMappingsRootQueryKey(): readonly ["connector-mappings"];
+/**
+ * Key for the mapping rows of a module served by an installed application.
+ *
+ * A sibling of {@link connectorMappingsQueryKey} rather than a variant of it, because the read
+ * behind it is a different one: the connector list read is scoped by connector id and a
+ * plugin-target row has none. Keyed under the same root so the family invalidation covers it.
+ */
+declare function pluginTargetMappingsQueryKey(moduleKey: string): readonly ["connector-mappings", "plugin-target", string];
+/**
+ * Key for the completeness read, nested UNDER {@link connectorMappingsQueryKey} so invalidating the
+ * mappings prefix always covers it. Do not flatten this into a sibling key.
+ */
+declare function connectorMappingCompletenessQueryKey(connectorId: string | undefined, moduleKey: string): readonly ["connector-mappings", string | undefined, string, "completeness"];
+
+export { type ConnectorCanonicalField as C, MappingCompletenessBanner as M, PLUGIN_PROVIDER_CONTROL_LABEL as P, type TestToolMappingExtractedField as T, CONNECTOR_CONTROL_LABEL as a, type ConnectorCanonicalFieldKind as b, type ConnectorMappingSuggestionResult as c, type ConnectorMappingTranslationEditorProps as d, ConnectorMappingTranslationEditorView as e, type MappingCompletenessBannerProps as f, type MappingCompletenessItem as g, type MappingCompletenessResult as h, type MappingReadiness as i, PROVIDER_CONTROL_LABEL as j, PROVIDER_OPTION_LABEL as k, type TestToolMappingRequest as l, type TestToolMappingResult as m, connectorMappingCompletenessQueryKey as n, connectorMappingsQueryKey as o, connectorMappingsRootQueryKey as p, pluginTargetMappingsQueryKey as q, selectMappingReadiness as r, selectIncompleteOperations as s, selectOptionalIncompleteOperations as t, selectRequiredIncompleteOperations as u };

package/dist/mcpService-4h3sKDpW.d.cts

@@ -0,0 +1,35 @@
+/** Dispatches an MCP tool call by name. The seam a lifted REST service binds to. */
+type ToolInvoker = (toolName: string, args: unknown) => Promise<unknown>;
+/**
+ * Base for service classes lifted from a monolith REST plane onto MCP.
+ *
+ * The monolith versions extend a REST base (`this.get`/`this.post` over axios).
+ * The plugin runtime exposes no imperative MCP transport — only the
+ * `useMcpTool` hook — so a `useXService()` hook composes per-tool invokers (see
+ * {@link useToolInvokerMap}) into a single {@link ToolInvoker} and constructs
+ * the class with it. Method bodies call `this.tool("<tool-name>", args)`.
+ */
+declare abstract class BaseMcpService {
+    private readonly invoker;
+    constructor(invoker: ToolInvoker);
+    protected tool<TRes>(name: string, args?: unknown): Promise<TRes>;
+}
+/**
+ * Thrown by a lifted service method whose monolith REST route has no MCP tool
+ * yet (typically because it needs client-side aggregation over a coarser tool).
+ */
+declare function notViaMcp(serviceName: string, method: string): never;
+/** Imperative invoker for a single MCP tool (the hook's `.invoke`, stable across renders). */
+declare function useToolInvoker<TReq, TRes>(toolName: string): (req: TReq) => Promise<TRes>;
+/**
+ * Composes one {@link ToolInvoker} dispatching over every tool in `tools`, so a
+ * service class can call tools by name.
+ *
+ * Rules of hooks: `tools` MUST be a frozen, constant-length list (e.g. a
+ * module-level `as const` array) so the per-tool `useMcpTool` calls run in a
+ * stable order on every render. Passing a list whose length varies between
+ * renders is a violation and will break.
+ */
+declare function useToolInvokerMap(tools: readonly string[]): ToolInvoker;
+
+export { BaseMcpService as B, type ToolInvoker as T, useToolInvokerMap as a, notViaMcp as n, useToolInvoker as u };

package/dist/mcpService-4h3sKDpW.d.ts

@@ -0,0 +1,35 @@
+/** Dispatches an MCP tool call by name. The seam a lifted REST service binds to. */
+type ToolInvoker = (toolName: string, args: unknown) => Promise<unknown>;
+/**
+ * Base for service classes lifted from a monolith REST plane onto MCP.
+ *
+ * The monolith versions extend a REST base (`this.get`/`this.post` over axios).
+ * The plugin runtime exposes no imperative MCP transport — only the
+ * `useMcpTool` hook — so a `useXService()` hook composes per-tool invokers (see
+ * {@link useToolInvokerMap}) into a single {@link ToolInvoker} and constructs
+ * the class with it. Method bodies call `this.tool("<tool-name>", args)`.
+ */
+declare abstract class BaseMcpService {
+    private readonly invoker;
+    constructor(invoker: ToolInvoker);
+    protected tool<TRes>(name: string, args?: unknown): Promise<TRes>;
+}
+/**
+ * Thrown by a lifted service method whose monolith REST route has no MCP tool
+ * yet (typically because it needs client-side aggregation over a coarser tool).
+ */
+declare function notViaMcp(serviceName: string, method: string): never;
+/** Imperative invoker for a single MCP tool (the hook's `.invoke`, stable across renders). */
+declare function useToolInvoker<TReq, TRes>(toolName: string): (req: TReq) => Promise<TRes>;
+/**
+ * Composes one {@link ToolInvoker} dispatching over every tool in `tools`, so a
+ * service class can call tools by name.
+ *
+ * Rules of hooks: `tools` MUST be a frozen, constant-length list (e.g. a
+ * module-level `as const` array) so the per-tool `useMcpTool` calls run in a
+ * stable order on every render. Passing a list whose length varies between
+ * renders is a violation and will break.
+ */
+declare function useToolInvokerMap(tools: readonly string[]): ToolInvoker;
+
+export { BaseMcpService as B, type ToolInvoker as T, useToolInvokerMap as a, notViaMcp as n, useToolInvoker as u };

package/dist/platform-react/index.cjs

@@ -203,6 +203,50 @@ function useOrgFormatSync() {
     return () => controller.abort();
   }, [transport, organisationId]);
 }
+var warnedAboutMissingAccessor2 = false;
+var useOptionalExtensionRuntimeTransport4 = typeof extensionRuntime__namespace.useOptionalExtensionRuntimeTransport === "function" ? extensionRuntime__namespace.useOptionalExtensionRuntimeTransport : () => {
+  if (!warnedAboutMissingAccessor2) {
+    warnedAboutMissingAccessor2 = true;
+    console.warn(
+      "[plugin-ui] The host realm does not expose useOptionalExtensionRuntimeTransport (host SDK predates 1.88.0). The organisation reporting currency falls back to GBP for this bundle. Bump the host's @ethisyscore/extension-runtime pin to restore it."
+    );
+  }
+  return null;
+};
+var REPORTING_CURRENCY_TOOL = "settings:get-organisation-reporting-currency";
+function useReportingCurrencySync() {
+  const transport = useOptionalExtensionRuntimeTransport4();
+  const organisationId = extensionRuntime__namespace.useHostIdentity()?.organisationId ?? null;
+  const [, bumpVersion] = react.useState(0);
+  const previousOrganisationId = react.useRef(void 0);
+  if (previousOrganisationId.current !== organisationId) {
+    previousOrganisationId.current = organisationId;
+    money.setOrgReportingCurrency(null);
+  }
+  react.useEffect(() => {
+    money.setOrgReportingCurrency(null);
+    bumpVersion((v) => v + 1);
+    if (!transport) return;
+    const controller = new AbortController();
+    transport.invokeTool(
+      REPORTING_CURRENCY_TOOL,
+      {},
+      controller.signal
+    ).then((result) => {
+      if (controller.signal.aborted) return;
+      const currency = result?.currency ?? null;
+      money.setOrgReportingCurrency(
+        currency ? { code: currency.code, decimalPlaces: currency.decimalPlaces } : null
+      );
+      bumpVersion((v) => v + 1);
+    }).catch(() => {
+      if (controller.signal.aborted) return;
+      money.setOrgReportingCurrency(null);
+      bumpVersion((v) => v + 1);
+    });
+    return () => controller.abort();
+  }, [transport, organisationId]);
+}
 
 // src/platform-react/definePlatformReactPluginPage.tsx
 function makeDefaultQueryClient() {
@@ -229,6 +273,7 @@ function definePlatformReactPluginPage(Page, options) {
   } = options;
   function PluginPage(props) {
     useOrgFormatSync();
+    useReportingCurrencySync();
     const page = react.createElement(Page, props);
     const body = wrapPage ? wrapPage(page) : page;
     const surfaceTree = react.createElement(
@@ -390,7 +435,7 @@ function useAuthenticatedQuery(options) {
 function useAuthenticatedQueries(queries) {
   return reactQuery.useQueries({ queries });
 }
-var REPORTING_CURRENCY_TOOL = "settings:get-organisation-reporting-currency";
+var REPORTING_CURRENCY_TOOL2 = "settings:get-organisation-reporting-currency";
 var LIST_CURRENCIES_TOOL = "settings:list-currencies";
 var emptyCatalogue = () => /* @__PURE__ */ new Map();
 var SETTLED_FULFILLED = "fulfilled";
@@ -411,7 +456,7 @@ function useCurrency() {
     const controller = new AbortController();
     Promise.allSettled([
       transport.invokeTool(
-        REPORTING_CURRENCY_TOOL,
+        REPORTING_CURRENCY_TOOL2,
         {},
         controller.signal
       ),
@@ -423,7 +468,8 @@ function useCurrency() {
     ]).then(([reporting, list]) => {
       if (controller.signal.aborted) return;
       if (reporting.status === SETTLED_FULFILLED) {
-        setReportingCurrency(reporting.value?.currency ?? null);
+        const resolved = reporting.value?.currency ?? null;
+        setReportingCurrency(resolved);
       }
       if (list.status === SETTLED_FULFILLED && Array.isArray(list.value)) {
         setCurrencies(new Map(list.value.map((currency) => [currency.id, currency])));
@@ -721,6 +767,7 @@ function definePlatformReactPluginOverlay(Overlay, options) {
   const { rootClassName, styleId, css, manifest = {}, queryClient = defaultQueryClient2, wrapOverlay } = options;
   return function MountedOverlay(props) {
     useOrgFormatSync();
+    useReportingCurrencySync();
     const tree = react.createElement(
       OverlayHostContext.Provider,
       { value: props.overlayHost },
@@ -1057,7 +1104,7 @@ exports.OVERLAY_HOST_CONTRACT_VERSION = OVERLAY_HOST_CONTRACT_VERSION;
 exports.OverlayHostContext = OverlayHostContext;
 exports.PluginPortalScope = PluginPortalScope;
 exports.PluginStyleScope = PluginStyleScope;
-exports.REPORTING_CURRENCY_TOOL = REPORTING_CURRENCY_TOOL;
+exports.REPORTING_CURRENCY_TOOL = REPORTING_CURRENCY_TOOL2;
 exports.SIDEBAR_MODE = SIDEBAR_MODE;
 exports.SurfaceBaseContext = SurfaceBaseContext;
 exports.TemplateContext = TemplateContext;
@@ -1091,6 +1138,7 @@ exports.useMcpUpload = useMcpUpload;
 exports.useOrgFormatSync = useOrgFormatSync;
 exports.useOverlayHost = useOverlayHost;
 exports.usePluginRealtime = usePluginRealtime;
+exports.useReportingCurrencySync = useReportingCurrencySync;
 exports.useSurfaceUrl = useSurfaceUrl;
 exports.useToolInvoker = useToolInvoker;
 exports.useToolInvokerMap = useToolInvokerMap;