@ngis/plugin-ui 0.4.0 → 0.4.1

package/dist/src/api/workflows.d.ts

@@ -1,3 +1,4 @@
+import type { NgisDatasetKind } from "../domain/models/dataset-kind";
 import type { WorkflowDagConfig } from "../types/workflow";
 export type { WorkflowDagConfig, WorkflowDagEdge, WorkflowDagGraph, WorkflowDagNode, WorkflowDagScriptConfig, WorkflowDagScriptPort, WorkflowDagView, WorkflowDagViewEdge, WorkflowDagViewNode, WorkflowDagViewPosition, WorkflowDagViewport, } from "../types/workflow";
 export type WorkflowDefinitionStatus = "DRAFT" | "PUBLISHED";
@@ -37,7 +38,15 @@ export interface WorkflowInstanceOutputDto {
     nodeId: string;
     fileId: string;
     fileName?: string | null;
-    datasetType?: string | null;
+    /**
+     * **Stage 29 (F29.1).** The registered kind id of the dataset this node
+     * produced — the same wire fact as `DatasetInfo.datasetType`, so it is typed
+     * from the one type rather than as a bare `string`. `null` means *no kind
+     * resolved*; `"GENERIC"` is gone. The union is **open** — a workflow may
+     * produce a kind registered after this client shipped, and the output row must
+     * still render.
+     */
+    datasetType?: NgisDatasetKind | null;
     primary?: boolean | null;
     extracted?: boolean | null;
     extractTarget?: WorkflowOutputTarget | null;

package/dist/src/components/plugin-ui/ChartCanvas.d.ts

@@ -1,5 +1,8 @@
+import * as echarts from "echarts/core";
 import type { NgisChartSpec } from "../../sdk/host-api";
 import { type NgisChartTheme } from "./stat-chart-model";
+/** Shared, modular ECharts runtime for host-controlled chart canvases. */
+export { echarts as ngisEcharts };
 export interface ChartCanvasProps {
     spec: NgisChartSpec;
     theme: NgisChartTheme;

package/dist/src/components/plugin-ui/ParamForm.d.ts

@@ -8,7 +8,24 @@ export interface NgisParamFormChange {
     readonly submission: NgisRunSubmission | null;
     /** Client rules (F14.9) refuse the submit. */
     readonly blockedByClient: boolean;
-    /** The server's blocking messages, if it has answered. */
+    /**
+     * **Stage 25 (F25.6/F25.7), additive.** The server's verdict refuses the
+     * submit — `isSubmitBlocked` over the last answer it gave.
+     *
+     * It exists because a blocking **issue** can arrive with every F14.9 string
+     * array empty (the frozen `validate-execution-issues.json` is exactly that
+     * shape), so a caller gating on {@link blockingMessages}` .length` alone would
+     * leave Run live on a run the server had already refused. `validateBeforeSubmit`
+     * still refuses at press time either way; this is what lets a caller disable
+     * the control *with the reason*, which is F25.7 flow 1's second half.
+     */
+    readonly blockedByServer: boolean;
+    /**
+     * The server's blocking messages, if it has answered — F14.9's string arrays
+     * **and**, since F25.6, the localised text of every blocking issue. An issue
+     * and a string are the same thing to a reader; keeping them in one list is
+     * what stops a caller having to know which channel a refusal came down.
+     */
     readonly blockingMessages: readonly string[];
     /** `warnings` — never blocks (F14.9). */
     readonly advisoryMessages: readonly string[];
@@ -19,15 +36,13 @@ export interface NgisParamFormChange {
      */
     readonly validateBeforeSubmit: () => Promise<boolean>;
 }
-export interface ParamFormProps {
+export interface ParamFormBaseProps {
     /** The 0.4 facade — always the one `createGisPluginHostFactory` minted. */
     host: NgisHostAPI;
     /** The flow port id (F14.5, `record` out port). Also seeds the field DOM ids. */
     id?: string;
     /** Plugin-authored; rendered **literally** (F13.11). */
     label?: string;
-    /** The tool whose UI schema this form is generated from. */
-    toolId: string;
     /**
      * Param names the form does not render — already bound by a flow port
      * (F14.22's `hide={["ELEV"]}`). **An unknown name survives and is surfaced**,
@@ -60,4 +75,51 @@ export interface ParamFormProps {
     /** Reports the exact layer chosen from a duplicate-named resource option. */
     onSameNamedLayerSelect?: (layerId: string) => void;
 }
-export declare function ParamForm({ host, id, label, toolId, hide, inputs, widgets, values: seed, onChange, sceneId, className, contentClassName, onSameNamedLayerSelect, }: ParamFormProps): import("react/jsx-runtime").JSX.Element;
+/** Bind either an implementation id (host-owned code) or a manifest alias (a bundle). */
+export type ParamFormProps = (ParamFormBaseProps & {
+    /** Legacy host-owned spelling. Third-party bundles should use `dependency`. */
+    toolId: string;
+    dependency?: never;
+}) | (ParamFormBaseProps & {
+    /** Locally unique `manifest.toolDependencies[].alias`. */
+    dependency: string;
+    toolId?: never;
+});
+export declare function ParamForm(props: ParamFormProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * **F25.4's fixed "Platform" register, above the vendor parameters.**
+ *
+ * The problem this solves is not decoration: `ngis:outputCrs` appears on *every*
+ * tool form and belongs to none of them. Left inline among the tool's own
+ * parameters it reads as one of them — a buffer setting the tool author chose —
+ * and the user has no way to learn that the same control is on the next form
+ * too, in the same place, meaning the same thing.
+ *
+ * ## A register change, not a box
+ *
+ * The device is a **caption with a rule running off it**, the way a bench sheet
+ * separates the instrument's settings from the bench's. A card, a tinted panel
+ * or an accent bar would all read as *alert* — the visual grammar this app
+ * already uses for a warning — and would announce something on every form
+ * forever that is only ever ordinary.
+ *
+ * So the boundary is one hairline, and it closes below the group as well as
+ * opening above it: the vendor list resumes with **no caption at all**, because
+ * it is the default register and naming it would imply a symmetry that does not
+ * exist. The eyebrow is `text-muted-foreground`, i.e. **quieter than the field
+ * labels beneath it**, which inverts the usual section-header hierarchy on
+ * purpose. Persistent chrome earns less emphasis than the thing it frames, and
+ * the boldness this stage has to spend is already spent — on `CrsChip`'s unit
+ * sigil, where round means degrees and square means metres.
+ *
+ * **Exported for one reason only:** this repo has no DOM in tests
+ * (`S25-V127`), so a server render cannot drive `ParamForm` past its
+ * `loadToolUiSchema` effect into the field list — the group's markup is
+ * unreachable through the form. Exporting the section makes it assertable
+ * directly. It is **not** on `plugin-ui`'s barrel (`index.ts` names its exports
+ * one by one) and therefore not on any published surface.
+ */
+export declare function PlatformGroup({ title, children, }: {
+    title: string;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/plugin-ui/PickerField.d.ts

@@ -22,6 +22,23 @@ export interface NgisPickerNotice {
     /** Already-translated host text. */
     text: string;
     tone: NgisPickerNoticeTone;
+    /**
+     * **Stage 25 (F25.6), additive — no existing caller breaks.**
+     *
+     * The one-click remedy attached to a validation issue: F25.7's *"Use
+     * EPSG:32650"* and *"Set projection…"*. It is a field on the notice rather
+     * than a widening of `text`, and that choice is the contract:
+     *
+     * `text` stays a `string`, so this component still cannot invent copy the
+     * caller did not ask for. Widening `text` to `ReactNode` was **considered and
+     * rejected** at S25-02 — a smaller diff, but it reopens the rule in this
+     * file's own header that everything in `notices` is a host-translated string.
+     * A `{label, onClick}` pair keeps both halves owned by the caller.
+     */
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
 }
 export interface PickerFieldProps {
     /** Control id; also `<label for>`. */

package/dist/src/components/plugin-ui/RunButton.d.ts

@@ -34,16 +34,24 @@ export type RunButtonProps = (RunButtonBaseProps & {
      */
     submission: NgisRunSubmission | null;
     toolId?: never;
+    dependency?: never;
     inputs?: never;
 }) | (RunButtonBaseProps & {
     submission?: never;
     /** The tool to run; its UI schema supplies each bound input's role,
      *  requiredness and label — F14.10's provenance chain, unaltered. */
     toolId: string;
+    dependency?: never;
     /**
      * F14.4's bindings, keyed by tool parameter name, plus any number of
      * `...ngisFlowSpread("@ref")` directives. Needs an enclosing `<Flow>`.
      */
     inputs: Readonly<Record<string, NgisInputBinding>>;
+}) | (RunButtonBaseProps & {
+    submission?: never;
+    /** Locally unique `manifest.toolDependencies[].alias`. */
+    dependency: string;
+    toolId?: never;
+    inputs: Readonly<Record<string, NgisInputBinding>>;
 });
 export declare function RunButton(props: RunButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/plugin-ui/crs-issue-messages.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Where a server verdict becomes a **field's** notice, and where a UI schema
+ * splits into the platform's parameters and the tool's (Stage 25, **F25.4 /
+ * F25.6**).
+ *
+ * `ParamForm.tsx` is the wiring and the chrome. Everything it *decides* about an
+ * issue or about a parameter's group lives here, pure and React-free, for the
+ * reason `w2-contracts.ts` and `param-form-model.ts` are: this repo has no DOM
+ * in tests (`S25-V127`), so a rule that lives inside a component render is a
+ * rule no test can reach. The three flows in design §5.3 are asserted against
+ * these functions **and** against the real form that calls them — which is only
+ * possible because the two are the same code.
+ *
+ * ## What this module deliberately does not do
+ *
+ * It never re-classifies. `severity` is the server's, decided from the
+ * requirement's *provenance* — only the 119 hand-authored seeds may block, and a
+ * classifier-derived requirement is advisory forever (F25.6, D25-5 as amended on
+ * the user's ruling). There is no branch on `code` here and no branch on
+ * `crsRequirementSource`, because a client that upgraded or downgraded one would
+ * reopen exactly what S25-01 measured: no classifier rule beat 0.800 precision,
+ * and a false refusal is strictly worse than a false permit (**G-U**).
+ *
+ * It also never *drops* one. An issue naming neither a `param` nor a `port` has
+ * no field to belong to and comes back from {@link unroutedIssues} for the
+ * form-level list. Silence would be the client deciding a refusal did not count.
+ *
+ * ## The name
+ *
+ * The W2 dispatch table carved this session a file called
+ * `plugin-ui/validation-messages.ts`. **Stage 25 has no such file and never had
+ * one** — the name was read off the cross-stage diff, where it is a file *Stage
+ * 24* creates (+44). Two stages independently creating the same path is a
+ * head-on collision at the `main` merge rather than the textual one D25-0 plans
+ * for, so this module carries a name only Stage 25 uses. Recorded as a
+ * correction of record against the dispatch table (`S25-V233`), not resolved
+ * silently.
+ */
+import { type NgisValidationIssue } from "../../domain/models/crs";
+import type { NgisToolUiParam } from "../../types/analysis";
+import type { NgisPickerNoticeTone } from "./PickerField";
+/**
+ * Is this parameter the **platform's** rather than the tool's?
+ *
+ * F14.2 normalizes `role` to `"input" | "option" | "output"` — three *data*
+ * roles, and `ngis:outputCrs` is an `option` by that measure like any other
+ * non-port parameter. The platform/vendor distinction is a different axis
+ * entirely and rides on `x-role`, which reaches the client verbatim in
+ * `extensions` (F14.2's escape hatch). Reading it there rather than widening
+ * `NgisParamRole` is deliberate: the two axes are independent, and a fourth
+ * member of `role` would make `ngis:outputCrs` stop being an option, which it
+ * still is.
+ */
+export declare function isPlatformParam(param: NgisToolUiParam): boolean;
+export interface NgisParamGroups {
+    /** `x-role: platform`, in schema order. Rendered **above** the vendor list. */
+    readonly platform: readonly NgisToolUiParam[];
+    /** Everything else, in schema order — the tool's own parameters, unchanged. */
+    readonly vendor: readonly NgisToolUiParam[];
+}
+/**
+ * The form's two groups, **in schema order within each** (F25.4).
+ *
+ * The order between them is fixed and is not a preference: the output CRS
+ * decides what the tool's numbers *mean* — at EPSG:4326 a buffer distance of 500
+ * is 500 degrees — so a user who reads the form top to bottom meets the unit
+ * before the number that carries it. Putting it after the vendor params would
+ * put the consequence after the cause.
+ */
+export declare function splitPlatformParams(params: readonly NgisToolUiParam[]): NgisParamGroups;
+/**
+ * `hide` with every platform parameter removed.
+ *
+ * **F25.4: a platform parameter "is never hidden by an author override".** A
+ * plugin author writes `hide={[…]}` to suppress a param another node already
+ * binds (F14.22); `ngis:outputCrs` is bound by no node and belongs to no tool,
+ * so hiding it can only ever remove the user's one way to say what projection
+ * the run computes in. Filtered here rather than only at render, because `hide`
+ * also drives `toSubmission` — a param hidden there is absent from the payload,
+ * and the form would then submit a run with the CRS decision silently dropped.
+ */
+export declare function effectiveHide(hide: readonly string[], params: readonly NgisToolUiParam[]): readonly string[];
+/**
+ * The issues that belong to one field.
+ *
+ * A field owns an issue when the issue names it as the **parameter that fixes
+ * it** (`param`) or as the **input port it is about** (`port`). Both are matched
+ * against the same name because a UI-schema input parameter *is* the port
+ * (F14.2): `port: "input"` and `param: "input"` address the same field, and a
+ * router that honoured only one of them would drop half the flows — R1's
+ * `CRS_UNKNOWN` and R5's `CRS_REPROJECT_NOTICE` are both per-port.
+ */
+export declare function issuesForField(issues: readonly NgisValidationIssue[], paramName: string): readonly NgisValidationIssue[];
+/**
+ * The issues no field claims — form-level, and **never discarded**.
+ *
+ * An issue naming neither a `param` nor a `port` is about the run as a whole
+ * (R8's `CRS_UNSUPPORTED_BY_PROVIDER` is the shipped example: the provider
+ * cannot compute in that CRS, which is not one field's fault). It renders in the
+ * form's own notice list. The complement of {@link issuesForField} over every
+ * rendered field, so an issue naming a field the form does not render still
+ * surfaces rather than vanishing with it.
+ */
+export declare function unroutedIssues(issues: readonly NgisValidationIssue[], renderedNames: readonly string[]): readonly NgisValidationIssue[];
+/**
+ * The notice tone for a severity — **the server's, rendered as given**.
+ *
+ * Two tones exist (`PickerField` has `info` and `warn`) and there are two
+ * severities, so this is a total map with nothing to decide. It is a named
+ * function anyway so that the mapping has one definition and the G-U rule has
+ * one place to be violated from, rather than an inline ternary at each of the
+ * three call sites.
+ */
+export declare function issueNoticeTone(severity: NgisValidationIssue["severity"]): NgisPickerNoticeTone;
+/**
+ * Is any of these issues a refusal?
+ *
+ * The same rule `isSubmitBlocked` applies to a whole verdict, over an arbitrary
+ * subset — used to ask "does *this field* carry the reason Run is off?" without
+ * re-deciding what blocking means.
+ */
+export declare function hasBlockingIssue(issues: readonly NgisValidationIssue[]): boolean;
+/**
+ * The **last hop** of a server-offered remedy: `fix.labelKey` + `fix.params` →
+ * the words on the button (Stage 25, `S25-V300`).
+ *
+ * S25-30b proved the `fix` reaches the *response boundary* on both the validate
+ * and the submit leg, and recorded that it had **not** been proved to the
+ * button. This is that hop, and it lived inside `ParamForm`'s render until now —
+ * where no gate could reach it, because this repo has no DOM in tests
+ * (`S25-V127`). Extracted for exactly that reason and for no other; the
+ * behaviour is unchanged.
+ *
+ * **A key the client does not carry renders as the key itself**, never as
+ * nothing and never as invented copy. That is the `ExtensionSettingsForm` rule
+ * (F14.9): a later stage may ship a `labelKey` this build has never heard of,
+ * and a button labelled `Crs.issues.fix.useUtm` is ugly but honest, while a
+ * button labelled nothing is a remedy the user cannot see and a sentence the
+ * client made up is worse than both.
+ *
+ * The translator is passed in rather than imported so this stays React-free and
+ * assertable — the `picker-model.ts` discipline. `next-intl`'s root translator
+ * satisfies it as-is.
+ */
+export interface NgisIssueTranslator {
+    has(key: string): boolean;
+    (key: string, params?: Readonly<Record<string, string | number>>): string;
+}
+export declare function issueFixLabel(fix: NonNullable<NgisValidationIssue["fix"]>, translate: NgisIssueTranslator): string;
+/**
+ * The same hop for an issue's own sentence. Paired with {@link issueFixLabel}
+ * because the two must agree about what an unknown key does — one of them
+ * falling back to the key while the other fell back to `""` would put a notice
+ * on screen whose text and whose button disagreed about whether the server had
+ * said anything.
+ */
+export declare function issueText(issue: NgisValidationIssue, translate: NgisIssueTranslator): string;

package/dist/src/components/plugin-ui/flow-ports.d.ts

@@ -48,6 +48,7 @@ import type { NgisPortSpec } from "./w3-contracts";
 export declare const NGIS_PICKER_SLOT = "ngis-picker-field";
 export declare const NGIS_FLOW_SLOTS: {
     readonly resourceSelect: "ngis-picker-field";
+    readonly crsSelect: "crs-picker";
     readonly modelSelect: "ngis-picker-field";
     readonly fieldSelect: "ngis-picker-field";
     readonly extentPicker: "ngis-picker-field";
@@ -89,6 +90,22 @@ export declare function extentPickerPorts(options: {
     readonly nodeId: string;
     readonly label?: string;
 }): readonly NgisPortSpec[];
+/**
+ * `value: crs` (Stage 25, **F25.9**).
+ *
+ * The value form is the ref's **key string** — `"EPSG:32650"` — and not the ref
+ * object, so what leaves this port is exactly what a `crs` widget writes into a
+ * params payload and exactly what reaches `POST /api/analysis/tasks` as
+ * `outputCrs`. One spelling, three layers.
+ *
+ * No `valueType`: that member is `kind: "value"`-only by F14.5, and a `crs` port
+ * is not a `value` port. Its shape is stated by its kind.
+ */
+export declare function crsSelectPorts(options: {
+    readonly nodeId: string;
+    readonly label?: string;
+    readonly required?: boolean;
+}): readonly NgisPortSpec[];
 /**
  * `value: record` out, plus **one `in` port per required UI-schema param not
  * satisfied internally** (F14.5).

package/dist/src/components/plugin-ui/param-widgets.d.ts

@@ -10,13 +10,13 @@
  * control that works, and F14.2 says an unknown widget is a render-time error
  * surfaced in place.
  *
- * YB1 emits only seven of the twelve keys in v1 (`field-select`, `extent`,
+ * YB1 emits only seven of the thirteen keys in v1 (`field-select`, `extent`,
  * `textarea`, `multi-select` and `resource-multi` are never emitted — `V-45`
  * and `src/types/analysis.ts`'s own note). The other five are reachable through
  * an author's `widgets` override and a recipe's promoted inputs, and they are
  * exercised by `src/sdk/__fixtures__/ui-schema/authored/w2-dependency-probe.json`.
  *
- * ## Four of the twelve are Y2's pickers, not new controls
+ * ## Five of the thirteen are pickers, not new controls
  *
  * `resource-select`, `resource-multi`, `field-select` and `extent` delegate to
  * `ResourceSelect` / `FieldSelect` / `ExtentPicker`. Rebuilding those controls

package/dist/src/components/plugin-ui/picker-model.d.ts

@@ -13,6 +13,7 @@
  * extracted from. `@ngis/plugin-ui` re-exports the components from here instead
  * (F14.14 — "the components' runtime lives in the host bundle").
  */
+import type { NgisCrsRef } from "../../domain/models/crs";
 import { type NgisDataType, type NgisModelSearchResult, type NgisModelSummary, type NgisResourceField, type NgisResourceSummary, type NgisResourceType } from "../../sdk/facets/types";
 import type { NgisBounds } from "../../sdk/map-api";
 /** One row of any of the four pickers. Data only — no node, no callback. */
@@ -32,6 +33,26 @@ export interface NgisPickerOption {
     hint: string | null;
     /** Listed but not ready — greyed, still selectable, never hidden. */
     muted: boolean;
+    /**
+     * **Stage 25 (F25.5 / F25.9, `S25-V216`).** The dataset's CRS behind this
+     * row, for the resource picker only. Absent on model and field options, which
+     * have no such thing — an optional member rather than a `null` one, because
+     * "a tool has no CRS" and "this dataset has no projection" are not the same
+     * sentence and a reader of this type should not have to guess which.
+     */
+    crs?: NgisCrsRef | null;
+    /**
+     * **Stage 25 (`S25-V216` / `S25-V236`).** Whether this row is in the
+     * `NEEDS_CRS` state, i.e. whether binding it to a port produces a blocking
+     * `CRS_UNKNOWN`.
+     *
+     * It is a **separate field and not `crs === null`**, because the rule is not
+     * that: `needsProjection` reads the server's status *and* the ref, so a `DONE`
+     * row whose dataset read failed is also in this state. Deriving it at each
+     * call site is how the picker and the library would come to disagree about
+     * which rows carry the ⚠.
+     */
+    needsCrs?: boolean;
     /** A scene layer is currently hidden but remains a valid data input. */
     hidden?: boolean;
     /** Present only when another eligible layer has the same visible name. */
@@ -58,6 +79,34 @@ export declare function widenDataTypes(types?: readonly NgisDataType[]): NgisRes
  * this is a choice rather than a limitation, and it is the contract's choice.
  */
 export declare function resourceOptions(summaries: readonly NgisResourceSummary[]): NgisPickerOption[];
+/**
+ * What `ResourceSelect` has to say about projection, as a decision rather than a
+ * render (Stage 25, **F25.5 / F25.7 flow 2 as the W3 kickoff amended it**).
+ *
+ * Three states, and the difference between the last two is the whole of
+ * `S25-V236`:
+ *
+ * - `"none"` — nothing listed is in `NEEDS_CRS`. Silence, not reassurance.
+ * - `"listed"` — rows exist in that state but the port is bound to none of them.
+ *   The picker **says so and offers nothing**, because there is no dataset to
+ *   attach an action to: "Set projection…" needs a subject.
+ * - `"bound"` — the port is bound to one. *This* is the run that will not start,
+ *   and it is the only case where the affordance has a dataset to act on.
+ *
+ * The rule this encodes is the kickoff's ruling: the remedy is the **picker's**,
+ * because the picker is the one surface that knows which dataset a port carries.
+ * The server's `CRS_UNKNOWN` still arrives through `ParamForm`'s issue routing
+ * and is still what blocks Run — this function never decides that.
+ */
+export type NgisResourceCrsState = {
+    readonly kind: "none";
+} | {
+    readonly kind: "listed";
+} | {
+    readonly kind: "bound";
+    readonly option: NgisPickerOption;
+};
+export declare function resourceCrsState(options: readonly NgisPickerOption[], selected: readonly string[]): NgisResourceCrsState;
 /**
  * Project a file-typed resource input onto the scene layers a person actually
  * recognises. The submitted value remains the resource's `effectiveFileId`;

package/dist/src/components/plugin-ui/run-data.d.ts

@@ -31,17 +31,45 @@ import type { NgisExecutionValidation } from "../../types/analysis";
 import { type NgisRunGate } from "./run-model";
 import { type NgisRunSubmission } from "./w2-contracts";
 /** Run-shaping options a submission does not carry (they are the caller's, not
- *  the generated form's). Mirrors `NgisTaskRunRequest` plus `targetSrid`, which
- *  only the validate leg takes. */
+ *  the generated form's). Mirrors `NgisTaskRunRequest`. */
 export interface NgisRunOptions {
     sceneId?: string;
     /** Lab-scene optimistic fence. Ordinary scene runs leave this absent. */
     expectedSceneGeneration?: number;
     outputMode?: "ADD_LAYER" | "UPDATE_RESOURCE";
     targetResourceId?: string;
-    /** `validate-execution` only — `POST /api/analysis/tasks` has no such field. */
-    targetSrid?: number;
+    /**
+     * **Stage 25 (F25.4), replacing `targetSrid?: number`** (the `S25-V124`
+     * ruling).
+     *
+     * An `NgisCrsRef` key. Two things changed at once and both matter:
+     *
+     * 1. **It is a string, not an integer.** An integer cannot name a custom CRS,
+     *    and `formatCrs` exists because a bare number is not a CRS a user can
+     *    read either.
+     * 2. **It goes on BOTH legs.** `targetSrid` reached `validate-execution` and
+     *    stopped — so a run could validate against one projection decision and
+     *    execute with none. {@link submitRun} now carries it too, which is what
+     *    makes the validate verdict describe the run that actually happens.
+     *
+     * Absent is a real value: compute in the primary input's own CRS (R4).
+     */
+    outputCrs?: string;
 }
+/**
+ * The output CRS a submission itself declares, if any.
+ *
+ * `ngis:outputCrs` is an ordinary parameter in the generated form (F25.4 puts it
+ * in the schema, F25.3 renders it with the `crs` widget), so a filled form
+ * already carries it in `submission.params`. Lifting it here is what makes the
+ * run body carry `outputCrs` **with no author involvement** — a plugin that
+ * never heard of Stage 25 still submits the user's choice.
+ *
+ * An explicit `options.outputCrs` wins, because a caller that passed one is
+ * making the decision on purpose. An empty string is absent, never `""` on the
+ * wire (F14.4's "empty is unbound").
+ */
+export declare function outputCrsOf(submission: NgisRunSubmission, options?: NgisRunOptions): string | undefined;
 /**
  * The `host.models.validate` request for one submission.
  *

package/dist/src/components/plugin-ui/w2-contracts.d.ts

@@ -19,6 +19,7 @@
  * Contract: F14.2 (widget vocabulary), F14.3 (validation DTOs), F14.5 (ports),
  * F14.8 (presets), F14.9 (form lifecycle), F14.10 (no `disabled` prop).
  */
+import type { NgisValidationIssue } from "../../domain/models/crs";
 import type { NgisExecutionValidation, NgisUiSchemaValueType, NgisWidgetKey } from "../../types/analysis";
 /**
  * A single generated-form value. Narrower than `unknown` on purpose: F14.2's
@@ -115,6 +116,66 @@ export type NgisWidgetRegistry<TWidget> = {
  * or `FAIL` port cannot run.
  */
 export declare function blockingValidationMessages(validation: NgisExecutionValidation): readonly string[];
+/**
+ * **Every typed issue the server sent, from both halves of one verdict (F25.6).**
+ *
+ * F25.6 put `issues[]` on `NgisExecutionValidation` **and** on
+ * `NgisBindingValidation`, exactly as F14.9 put its string arrays on both —
+ * an execution-level issue is usually about a *parameter*, a binding-level one is
+ * about a *port*. They are one channel read at two levels, never two channels,
+ * and this function is the single statement of that.
+ *
+ * It exists because they were being read at one level in the gate and at two in
+ * the form (`S29-V234`): `isSubmitBlocked` counted only the execution-level
+ * half while `ParamForm` merged both for display, so a `severity: "blocking"`
+ * issue arriving on the binding half printed the server's refusal and left Run
+ * live beside it. That is the shape G-U forbids — the client does not get to
+ * decline to act on a severity the server declared — and Stage 26's shipped
+ * `unknown_crs_issue` (`binding_validation.py:187`) writes to precisely that
+ * half. Order is execution-first so the compiler's fuller statement of a fact
+ * precedes the binding pass's barer one, matching the server's own `dedupe`.
+ */
+export declare function serverIssues(validation: NgisExecutionValidation): readonly NgisValidationIssue[];
+/**
+ * **AMENDED additively by F25.6 (Stage 25).** F14.9's rule is unchanged and
+ * still counts: a `NOT_EXECUTABLE` verdict or any blocking string blocks the
+ * submit. What is added is a third input — a typed `issues[]` entry whose
+ * `severity` is `"blocking"`, on **either** half of the verdict.
+ *
+ * **`S29-V234` (Stage 29): "either half" was the contract and one half was the
+ * code.** This read `validation.issues` alone, while F25.6 declares `issues[]`
+ * on `NgisBindingValidation` too and the F14.9 rule it amends already reaches
+ * into the binding half for `errors`. It is {@link serverIssues} that is read
+ * now — not a widening of the rule, which was always stated over the channel
+ * rather than over one level of it, but the rule finally reading all of it.
+ *
+ * The client **never suppresses, downgrades or re-classifies a server issue**
+ * (G-U). There is deliberately no branch here on `code`, on provenance, or on
+ * whether the client thinks the situation warrants it: severity is decided
+ * server-side as a function of provenance (a `CLASSIFIER` requirement may only
+ * ever produce `"advisory"`), and a client that second-guessed it would be
+ * re-opening the very defect S25-01 measured — no classifier rule exceeded 0.800
+ * precision, and a false refusal is strictly worse than a false permit.
+ *
+ * **Stage 29 (F29.8), RULED SILENT by the user 2026-09-19 — this function gains
+ * NO second blocking source, and it has never had one.** A kind-`ADAPTABLE`
+ * binding applies its adapter with no confirmation step, so `KIND_ADAPTABLE` is
+ * an `advisory` the form renders and nothing more; the arms below are unchanged
+ * and there is deliberately no branch on `code` or on the `ADAPTABLE` verdict
+ * token. The reason is the same one G-U rests on, one level up: `"ADAPTABLE"` is
+ * the **same** token for Stage 26's CRS adaptation and Stage 29's kind
+ * adaptation, and today's CRS adaptation reprojects without asking — a gate on
+ * one of the two would make the token's meaning depend on which issue code
+ * happened to accompany it. **A session adding a confirm gate here is reopening
+ * a ruling, not fixing an omission**; `ParamForm.kindAdaptable.test.tsx` asserts
+ * this function's body against exactly that.
+ *
+ * What the ruling does **not** cover, stated because silence would look like
+ * coverage: it is about the `ADAPTABLE` verdict's consent model, not about data
+ * conversion generally. An adapter that mutated or replaced a user's
+ * authoritative data would be outside it and would need its own ruling
+ * (`S29-V215`).
+ */
 export declare function isSubmitBlocked(validation: NgisExecutionValidation): boolean;
 /** Advisory only — never blocks (F14.9). */
 export declare function advisoryValidationMessages(validation: NgisExecutionValidation): readonly string[];

package/dist/src/components/plugin-ui/w3-contracts.d.ts

@@ -41,7 +41,22 @@ import type { NgisDataType, NgisTaskOutput } from "../../sdk/facets/types";
 import type { NgisUiSchemaValueType } from "../../types/analysis";
 import type { NgisParamValue } from "./w2-contracts";
 export type NgisPortDirection = "in" | "out";
-export type NgisPortKind = "resource" | "resources" | "field" | "extent" | "task" | "value" | "record";
+export type NgisPortKind = "resource" | "resources" | "field" | "extent" | "task" | "value" | "record" | "crs";
+/**
+ * **Stage 25 (F25.9)** — `crs` is the eighth kind, and its value form is the
+ * ref's **key string** (`"EPSG:32650"`, `"custom:<ulid>"`), never an integer and
+ * never the ref object. That is the same value the `crs` widget puts in a params
+ * payload (F25.3) and the same one `ngis:outputCrs` carries to the submit body,
+ * so a port, a form field and a wire field all speak one spelling.
+ *
+ * It is a kind of its own rather than a `value` port with `valueType: "string"`
+ * for the reason every other kind here exists: the engine's generated reasons
+ * and the `data-port-*` attributes name what a port *is*, and "choose a CRS
+ * first" is not "choose a value first". Compatibility is a separate question,
+ * answered by {@link portKindsCompatible} — where `crs` is string-shaped and so
+ * interoperates with `resource`/`field`/`value`, because its wire form really is
+ * a bare string.
+ */
 /**
  * F14.5's port spec, verbatim but for one clarification.
  *