@ngis/plugin-ui 0.4.0 → 0.4.1

package/dist/src/domain/models/dataset-kind.d.ts

@@ -0,0 +1,256 @@
+/**
+ * Stage 29 (F29.1 / F29.4 / F29.5 / F29.7 / F29.9) — the frontend's dataset-kind
+ * domain model.
+ *
+ * **This module is the one place in the client that names a dataset kind.** It is
+ * the F25.1 `crs.ts` precedent applied to the second vocabulary this platform
+ * spelled seven ways: a dataset's kind was spelled seven different ways, in three
+ * casings, derived from four different source fields, and no two of the seven had
+ * the same membership. After Stage 29 there is **one** derivation chain — the
+ * server's `datasetType` — and `G-KIND` is the rule that nothing outside a
+ * registry module branches on a kind id.
+ *
+ * Every shape below mirrors the frozen fixtures in
+ * `src/domain/models/__fixtures__/dataset-kind/`, which are byte-identical copies
+ * of `ngis-backend/stages/29-resource-plane/fixtures/` (F29.10 — compare with
+ * `diff --strip-trailing-cr`, never an on-disk hash: the two repos normalise line
+ * endings differently).
+ *
+ * ## The three-state rule lives here
+ *
+ * {@link NgisKindCapabilities} is a `Partial<>` and that is **load-bearing**
+ * (F29.4, inheriting F25.8). A flag **absent** from the block means *the server
+ * has not said*; `{supported: false, reasonKey}` means *this kind cannot*;
+ * `{supported: true, reasonKey: null}` means *it can*. A client that coalesces
+ * absent into `false` has re-introduced exactly the defect Stage 26 paid to
+ * learn — which is why {@link datasetKindCapability} is the only supported way to
+ * read a flag and why it returns `undefined` rather than fabricating a record.
+ *
+ * @see ngis-backend/stages/29-resource-plane/F29-contract.md — F29.1, F29.4,
+ *      F29.5, F29.7, F29.9 (frozen names)
+ * @see docs/resource_plane_stage/README.md — the frontend plan of record
+ */
+/**
+ * **The one client dataset-kind type (F29.1).** The wire field keeps its shipped
+ * name, `datasetType`, and its value is a registered kind id in UPPERCASE
+ * `SNAKE_CASE`.
+ *
+ * **The union is OPEN, and that is the whole point.** `D29-1` makes a kind
+ * *registered data*, so a client shipped today must render a kind registered
+ * tomorrow. The three named members exist for autocomplete and for the
+ * exhaustiveness of *today's* switch statements — they are **not** a membership
+ * assertion, and **no test may assert that the set of kinds equals those three**.
+ * (Stage 15's `Market.*` sub-namespace lesson, which cost a session on three
+ * consecutive waves: a closed-world assertion breaks on every sibling merge.)
+ *
+ * `null` — not a member of this union — keeps exactly one meaning after F29.3:
+ * *no kind resolved* (`status: "NEEDS_KIND"`). `"GENERIC"` is gone from the wire;
+ * a non-geo file reports `datasetType: null` with `status: "N/A"`.
+ */
+export type NgisDatasetKind = "VECTOR" | "RASTER" | "FLOW_FIELD" | (string & {});
+/**
+ * **The six capability flags, frozen (F29.4).**
+ *
+ * `renderable` is deliberately **not** a member, and that is not an oversight:
+ * `renderable` is a server-computed property of a dataset *row*
+ * (`ready && geometryType != null && capabilities.tileable.supported === true`,
+ * F29.6), never a declared capability of a *kind*. Stage 28 ships a
+ * `capabilities.renderable` on a **symbol template**, an unrelated object that
+ * happens to share the field name; keeping `renderable` out of this union is what
+ * stops a symbol payload from satisfying a dataset capability block
+ * (`S29-V073`).
+ */
+export type NgisCapabilityFlag = "tileable" | "analyzable" | "shareable" | "copyable" | "quotaCountable" | "exportable";
+/** The six flags in the F29.4 order. */
+export declare const NGIS_CAPABILITY_FLAGS: readonly NgisCapabilityFlag[];
+/**
+ * One declared capability of a kind (F29.4 / F29.5).
+ *
+ * **A boolean cannot say why a control is greyed**, which is why this is a record
+ * and never a bare boolean. `reasonKey` is an **i18n key the client localises** —
+ * the server never sends display text for a capability refusal — and `params`
+ * carries its interpolation values. The in-repo precedent is shipped:
+ * `ValidationIssue.message_key` / `params_json` and `IssueFix.label_key` /
+ * `params_json` (`ngis-protos/geoanalysis.proto:553-572`); `IssueFix.params_json`
+ * exists *because* a key without its interpolation values made the gRPC and REST
+ * twins of one fixture disagree.
+ */
+export interface NgisCapability {
+    supported: boolean;
+    /** Required when `supported === false`; **must** be `null` when `true`. */
+    reasonKey: string | null;
+    /** Interpolation values for `reasonKey`; `{}` when the key takes none. */
+    params: Record<string, unknown>;
+}
+/**
+ * A kind's declared capability block (F29.4).
+ *
+ * **`Partial<>` is load-bearing — there are three states, not two.** An absent
+ * flag means *the server has not said*, and it must never render as
+ * *this kind cannot*. Read a flag with {@link datasetKindCapability} and nothing
+ * else.
+ *
+ * `{}` is the **empty** block and differs from an absent block: it means *no kind
+ * resolved, therefore no declared capabilities* (`fx-ds-0003`, `status:
+ * "NEEDS_KIND"`). Every flag is then in its third state.
+ *
+ * The block describes the **kind**, not the row's readiness. A `NEEDS_CRS` vector
+ * is still `tileable: true`; it is `ready: false` that stops it rendering.
+ * Conflating the two is how `renderable` came to name three kinds.
+ */
+export type NgisKindCapabilities = Partial<Record<NgisCapabilityFlag, NgisCapability>>;
+/**
+ * Read one declared capability — **the only supported way to read a flag.**
+ *
+ * Returns `undefined` for an absent flag and **never fabricates
+ * `{supported: false}`**. That is F29.4's three-state rule enforced in one
+ * function so no call site can get it wrong; a caller that wants a boolean must
+ * decide, explicitly and at its own site, what *"the server has not said"* means
+ * for the control it is drawing.
+ *
+ * The flag argument is typed {@link NgisCapabilityFlag}, so
+ * `datasetKindCapability(caps, "renderable")` is a **compile error**
+ * (`S29-V073`).
+ */
+export declare function datasetKindCapability(caps: NgisKindCapabilities | null | undefined, flag: NgisCapabilityFlag): NgisCapability | undefined;
+/**
+ * Why a dataset's time axis is or is not known (F29.7, `D29-3` generalised from
+ * CRS).
+ *
+ * There are **four** states, and the fourth is the `temporalExtent` field itself
+ * being `null`, which means *the server has not said* (F25.8) — distinct from
+ * `NOT_APPLICABLE`, which means *this kind has no time axis*.
+ */
+export type NgisTemporalExtentState = "RESOLVED" | "UNRESOLVABLE" | "NOT_APPLICABLE";
+/**
+ * A dataset's temporal extent (F29.7).
+ *
+ * **Never a bare range.** A defaulted range — epoch-to-now, the file's mtime,
+ * anything — is a contract violation, not a fallback (`D29-3`). `fx-ds-0005` is
+ * the fixture that proves it: `start` and `end` are `null` **and** `state` says
+ * why.
+ *
+ * What each state renders as (F29.7, frozen because `D29-3` forbids a default):
+ *
+ * | State | Renders as |
+ * |---|---|
+ * | the field is `null` | the temporal row is **not rendered at all** |
+ * | `NOT_APPLICABLE` | the temporal row is **not rendered at all** |
+ * | `UNRESOLVABLE` | the row renders, with the localised `reasonKey` where the range would be — never a dash, never an empty range |
+ * | `RESOLVED` | the range |
+ *
+ * `null` and `NOT_APPLICABLE` render identically **on purpose**: there is nothing
+ * useful to say to a user in either case. They stay distinct **on the wire**,
+ * because a test must be able to tell them apart and the array stage will need to.
+ */
+export interface NgisTemporalExtent {
+    state: NgisTemporalExtentState;
+    /** ISO 8601; non-null iff `state === "RESOLVED"`. */
+    start: string | null;
+    /** ISO 8601; non-null iff `state === "RESOLVED"`. */
+    end: string | null;
+    /** An i18n key; non-null iff `state === "UNRESOLVABLE"`. */
+    reasonKey: string | null;
+    params: Record<string, unknown>;
+}
+/**
+ * Where a dataset came from (F29.7, `D29-5`).
+ *
+ * `authority` is `AUTHORITY` or `DERIVED`, never both. A `DERIVED` dataset
+ * carries `rebuildableFrom`; an `AUTHORITY` one carries `null` there.
+ *
+ * `sourceFileId` is **not** unique across datasets: `fx-ds-0005` and `fx-ds-0006`
+ * share one. That is `D29-2` — one file, many datasets.
+ */
+export interface NgisDatasetLineage {
+    authority: "AUTHORITY" | "DERIVED";
+    sourceFileId: string | null;
+    derivedFromFileId: string | null;
+    producedByTaskId: string | null;
+    /** Non-null iff `authority === "DERIVED"`. */
+    rebuildableFrom: string | null;
+}
+/**
+ * The array plane's placeholder (F29.7, `D29-S1`).
+ *
+ * **Deliberately typed `null` and nothing else.** `dimensions` is declared on the
+ * wire so the array stage needs no second migration and no second contract
+ * freeze, and it is `null` for every kind Stage 29 registers. Typing it as the
+ * `null` literal makes *"a session that builds a time slider off it is out of
+ * contract"* a compile error rather than a code-review note; widening this alias
+ * is the array stage's job and nobody else's.
+ */
+export type NgisDatasetDimensions = null;
+/**
+ * **The dataset spine (F29.7), as one nominal shape.**
+ *
+ * *Recorded extra export, not in F29.9's table — see the S29-14 session note.*
+ * It exists for `S29-V073`: `renderable` and `ready` are members of a record that
+ * also requires `datasetType`, `status` and `lineage`, so a Stage 28 **symbol
+ * template** — which carries `capabilities.renderable` and none of those — cannot
+ * resolve against the client's **dataset** `renderable`. Two unrelated objects
+ * share one field name; this type and {@link NgisCapabilityFlag}'s exclusion of
+ * `renderable` are the two independent guards that keep them apart.
+ *
+ * `ready` and `renderable` are server-computed and keep their names (F29.6):
+ *
+ * ```
+ * ready      = status ∈ kind.readyStates
+ * renderable = ready && geometryType != null && capabilities.tileable.supported === true
+ * ```
+ *
+ * Both are optional, and `undefined` ("the server has not said") must never render
+ * the same as `false` ("this kind cannot be tiled") — `SceneWorkspaceLayers.tsx`'s
+ * `resolveLayerCrs` is the in-repo precedent and its comment states the rule.
+ */
+export interface NgisDatasetSpine {
+    /** `null` means *no kind resolved* — the only meaning `null` carries (F29.3). */
+    datasetType: NgisDatasetKind | null;
+    /**
+     * **An OPEN vocabulary (F29.7 R2).** A consumer that does not recognise a
+     * status renders the **raw token**, never `UNKNOWN`. The measured hazard is
+     * live: `ngis-file`'s `FileService` normalises a status through a whitelist
+     * whose default arm is `UNKNOWN`, so a `NEEDS_CRS` dataset already reports as
+     * `UNKNOWN` on the library listing — *"we know exactly what is wrong with it"*
+     * collapsed into *"we do not know"*, which is the very thing `D29-3` forbids.
+     */
+    status: string;
+    capabilities?: NgisKindCapabilities;
+    temporalExtent?: NgisTemporalExtent | null;
+    dimensions?: NgisDatasetDimensions;
+    lineage?: NgisDatasetLineage | null;
+    ready?: boolean;
+    renderable?: boolean;
+}
+/** The minimum an issue must carry for {@link isKindAdaptableIssue} to judge it. */
+export interface NgisIssueCodeCarrier {
+    code?: string | null;
+}
+/**
+ * F29.8's rule A1, in one place: is this the **kind** adaptation, or Stage 26's
+ * **CRS** one?
+ *
+ * `"ADAPTABLE"` is the same verdict token for both. **Only the issue code
+ * distinguishes them** — a test that asserts only `verdict === "ADAPTABLE"`
+ * passes on a CRS adaptation and proves Stage 26's code path, not this stage's.
+ *
+ * The client never re-classifies a server verdict or severity (`G-U`): this is a
+ * predicate over a code the server sent, and nothing more.
+ */
+export declare function isKindAdaptableIssue(issue: NgisIssueCodeCarrier | null | undefined): boolean;
+/**
+ * The kind → scene-layer resource-kind projection.
+ *
+ * *Recorded extra export, not in F29.9's table — see the S29-14 session note.*
+ * It is what F29.1 row 6 means by *"S29-14 delegates it to `NgisDatasetKind`"*:
+ * `SceneLayerResourceKind` used to be reached by `geometry.includes("raster")`, a
+ * substring match on a geometry string, and that is a guess. The spine now
+ * carries the answer, and this is the one place the answer is projected onto the
+ * two-value vocabulary the scene-layer type table is written in.
+ *
+ * Returns `null` for a kind that is neither — including an unregistered kind the
+ * client has never seen, which is `NgisDatasetKind` being open — so a caller must
+ * decide what *"I cannot place this kind"* means rather than being handed
+ * `"vector"` by default.
+ */
+export declare function sceneLayerResourceKindOfDatasetKind(kind: NgisDatasetKind | null | undefined): "vector" | "raster" | null;

package/dist/src/domain/models/flow-field-style.d.ts

@@ -0,0 +1,32 @@
+/** Canonical, per-scene-layer presentation state for a FLOW_FIELD resource. */
+export interface FlowFieldColorRamp {
+    /** A UI hint only. `colors` is the renderer authority. */
+    presetId: string;
+    /** Low-speed to high-speed colors. */
+    colors: string[];
+}
+export type FlowFieldSpeedRange = {
+    mode: "data";
+} | {
+    mode: "manual";
+    min: number;
+    max: number;
+};
+export interface FlowFieldStyle {
+    renderer: "flow-field";
+    styleVersion: 1;
+    /** Compatibility-only identity for scenes created before SceneResource links. */
+    flowFieldId?: string;
+    opacity: number;
+    colorRamp: FlowFieldColorRamp;
+    speedRange: FlowFieldSpeedRange;
+    speedFactor: number;
+    particleCount: number;
+    lineWidth: number;
+    trailLength: number;
+    frameDurationMs: number;
+    paused: boolean;
+    maxParticleAge: number;
+    dropRate: number;
+    dropRateBump: number;
+}

package/dist/src/features/gis/components/GisAttributeTable.d.ts

@@ -1,4 +1,4 @@
-import { type DatasetAttributeSelection, type DatasetFeatureRow } from "../../../api/resources";
+import { type DatasetAttributeFilter, type DatasetAttributeSelection, type DatasetFeatureRow } from "../../../api/resources";
 /**
  * **Exported for `@ngis/plugin-ui`'s `<AttributeTable>` (Stage 14 Y4b).** It was
  * file-private while this component had exactly one call site
@@ -30,20 +30,28 @@ export interface GisAttributeTableProps {
     onRunTool: (selection: DatasetAttributeSelection) => Promise<void>;
     /** A selection made with the scene's feature-select tool, keyed by stable row id. */
     mapSelection?: {
-        featureIds: string[];
+        selection: GisAttributeTableSelectionHighlight;
         /** Attribute values present in the selected vector-tile features. */
         rows?: DatasetFeatureRow[];
+        /** Opens this selection in the table's normal “only selected” mode. */
+        showSelectedOnly?: boolean;
         serial: number;
     } | null;
 }
+/** Whether a fresh external selection must keep the selected-only view enabled. */
+export declare function isApplyingMapSelectedOnly(mapSelection: GisAttributeTableProps["mapSelection"], appliedSerial: number | null): boolean;
 /** The table's complete selection meaning, forwarded to the map highlight. */
 export type GisAttributeTableSelectionHighlight = {
     featureIds: string[];
     allFeatures?: false;
+    selectedCount: number;
 } | {
     featureIds: [];
     allFeatures: true;
     excludedFeatureIds: string[];
+    selectedCount: number | null;
+    /** The same API filter that defines this all-matching selection. */
+    filter?: DatasetAttributeFilter;
 };
 /**
  * Attribute table for the selected vector layer's dataset. Server-driven:
@@ -53,4 +61,4 @@ export type GisAttributeTableSelectionHighlight = {
  * a column picker, a filter builder, and dataset-wide selection keyed by the
  * stable feature `id` (so it spans windows that aren't even loaded).
  */
-export declare function GisAttributeTable({ fileId, layerName, active, onHighlight, onSelectionChange, onRunTool, mapSelection, }: GisAttributeTableProps): import("react/jsx-runtime").JSX.Element;
+export declare function GisAttributeTable({ fileId, active, onHighlight, onSelectionChange, onRunTool, mapSelection, }: GisAttributeTableProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/features/gis/hooks/useDatasetFeatureWindow.d.ts

@@ -1,23 +1,19 @@
-import { type DatasetAttributeQueryParams, type DatasetAttributeWhereOp, type DatasetFeatureRow } from "../../../api/resources";
+import { type DatasetAttributeFilter, type DatasetAttributeQueryParams, type DatasetFeatureRow } from "../../../api/resources";
 /** One server-side sort directive (single-column for now). */
 export interface FeatureSort {
     field: string;
     dir: "asc" | "desc";
 }
-/** One server-side filter condition (mirrors the query `where` clause). */
-export interface FeatureFilter {
-    field: string;
-    op: DatasetAttributeWhereOp;
-    value: unknown;
-}
 export interface DatasetFeatureWindowParams {
     fileId: string;
     /** Active sort (null = server default order). */
     sort: FeatureSort | null;
-    /** Active filter conditions (AND-combined). */
-    filters: FeatureFilter[];
+    /** Final API FilterSpec, shared with count and selection actions. */
+    filter?: DatasetAttributeFilter;
     /** Columns to request (empty = all). `id` is always returned regardless. */
     select: string[];
+    /** Enumerated stable ids used by normal attribute queries and pagination. */
+    featureIds?: string[];
     enabled?: boolean;
 }
 export interface DatasetFeatureWindow {

package/dist/src/features/gis/lib/attributeFilters.d.ts

@@ -0,0 +1,24 @@
+import type { DatasetAttributeFilter, DatasetAttributeWhereOp } from "../../../api/resources";
+import type { HighlightFilterExpression } from "../../../domain/map/types";
+/** UI-only `between` expands to the two comparison operators the API supports. */
+export type AttributeFilterOperator = DatasetAttributeWhereOp | "between";
+export interface AttributeFilterCondition {
+    field: string;
+    op: AttributeFilterOperator;
+    value: unknown;
+}
+/** Escape SQL LIKE metacharacters before surrounding a user keyword with `%`. */
+export declare function escapeLikeKeyword(keyword: string): string;
+/**
+ * Converts UI filter conditions into the API's supported, AND-combined where
+ * clauses. This is the sole FilterSpec used by query, count, and all-matching
+ * selection actions.
+ */
+export declare function buildDatasetAttributeFilter(conditions: readonly AttributeFilterCondition[]): DatasetAttributeFilter | undefined;
+/**
+ * Converts the API filter already used for the table query into the equivalent
+ * MapLibre predicate for the attribute-selection overlay. `like` arrives here
+ * in the frontend's deliberate `%escaped keyword%` form, so it maps to a
+ * literal substring match rather than a wildcard expression.
+ */
+export declare function buildAttributeHighlightFilter(filter: DatasetAttributeFilter | undefined): HighlightFilterExpression | undefined;

package/dist/src/sdk/facets/types.d.ts

@@ -32,7 +32,9 @@
  */
 import type { AnalysisToolSchema } from "../../api/analysis";
 import type { SceneType } from "../../api/scenes";
+import type { NgisCrsRef } from "../../domain/models/crs";
 import type { NgisExecutionValidation, NgisToolUiSchema } from "../../types/analysis";
+import type { NgisResolvedToolDependency } from "../../types/extensions";
 import type { NgisBounds, NgisUnsubscribe } from "../map-api";
 export interface NgisSceneInfo {
     id: string;
@@ -59,6 +61,18 @@ export interface NgisSceneFacet {
  * `"table"` would need `NgisFile.fileType`, i.e. a second
  * `GET /api/files/{fileId}` per resource — an N+1 fan-out for a distinction no
  * v1 consumer needs.
+ *
+ * **SURVIVES Stage 29 UNCHANGED (F29.1 row 3).** It is the SDK's v1
+ * plugin-facing classification, frozen by XD7/F13.6 and enforced by two live
+ * gates, and Stage 29 registers **no table dataset model** — so nothing about it
+ * moves (F29.2). It is a *projection* of `NgisDatasetKind` onto the coarser
+ * vocabulary v1 plugins compile against, never a second spelling of it: its
+ * membership is closed because a plugin's `when` expression is, and
+ * `NgisDatasetKind` is open because a kind is registered data. Widening this one
+ * to match would break every shipped plugin fixture.
+ *
+ * *(`GENERIC` no longer reaches the classifier — F29.3 removed it from the wire —
+ * but the "everything else" arm is unchanged and still catches it.)*
  */
 export type NgisResourceType = "vector" | "raster" | "table" | "file";
 /**
@@ -89,6 +103,13 @@ export type NgisResourceType = "vector" | "raster" | "table" | "file";
  * against a builtin node's `"Raster"` and `400`s at workflow save. Y6 applies
  * that column at, and **only** at, the `ngis-workflow` boundary. Nowhere else
  * in either repo is Pascal correct.
+ *
+ * **SURVIVES Stage 29 UNCHANGED (F29.1 row 4).** It is a **tool port** data type
+ * (F14.1), not a dataset kind. The two are related by the compatibility matrix
+ * and **never by equality**: `table` and `pointcloud` are legal port types that
+ * no registered kind emits, and a registered kind the client has never seen binds
+ * to a port through the matrix rather than by name. Renaming or merging them
+ * would assert an identity that does not hold.
  */
 export type NgisDataType = "raster" | "vector" | "table" | "pointcloud" | "raster3d" | "file";
 export declare const NGIS_DATA_TYPES: readonly ["raster", "vector", "table", "pointcloud", "raster3d", "file"];
@@ -130,6 +151,25 @@ export interface NgisResourceSummary {
     geometryType: string | null;
     layerCount: number;
     rendered: boolean;
+    /**
+     * **Stage 25 (F25.1 / F25.9, `S25-V216`).** The dataset's one CRS, or `null`
+     * when the server has none for it (`NEEDS_CRS`).
+     *
+     * It is on the **summary**, not only the detail, and that placement is the
+     * point of the row. `ResourceSelect` lists datasets from `resources.list()`
+     * and must draw each row's projection state at pick time (F25.5); resolving a
+     * ref through `resources.get()` per row is the N+1 XD7 already refused for
+     * `resources.types`. Without this field the picker could draw only the
+     * *absent* state — which is what S25-22 shipped, with the limit recorded
+     * rather than papered over — because a dataset that *has* a projection had
+     * nothing to draw a chip from and inventing one is what G-CRS forbids.
+     *
+     * `null` is a value and not a gap: it is the server saying `NEEDS_CRS`. There
+     * is no `undefined` arm — the facet always answers, and a dataset it could not
+     * read at all reports `datasetStatus: "N/A"` with `crs: null`, which is the
+     * same honest "we cannot say what this is in".
+     */
+    crs: NgisCrsRef | null;
     /**
      * Scene layers that render this resource, when the host can supply them.
      *
@@ -160,7 +200,6 @@ export interface NgisResourceField {
     type: string;
 }
 export interface NgisResourceDetail extends NgisResourceSummary {
-    srid: number | null;
     /** Vector only; `null` otherwise. */
     featureCount: number | null;
     /** Vector only; `[]` otherwise. */
@@ -244,7 +283,21 @@ export interface NgisModelValidateRequest {
     expectedSceneGeneration?: number;
     outputMode?: "ADD_LAYER" | "UPDATE_RESOURCE";
     targetResourceId?: string;
-    targetSrid?: number;
+    /**
+     * **Stage 25 (F25.4, and the `S25-V124` ruling that AMENDS F25.12).**
+     *
+     * Replaces `targetSrid?: number`. It is an {@link NgisCrsRef} **key** — the
+     * string `"EPSG:32650"` or `"custom:<ulid>"` — and never an integer, because
+     * an integer cannot name a custom CRS at all and because a bare number is the
+     * silent-default spelling G-CRS refuses.
+     *
+     * `targetSrid` was typed, forwarded to `validate-execution` and set by no
+     * component: dead plumbing. This member is the live one — `run-data.ts` fills
+     * it from the form's `ngis:outputCrs` parameter and the facade adapter puts it
+     * on the wire as `outputCrs` (the REST leg is camelCase here; the proto
+     * spelling is `output_crs`).
+     */
+    outputCrs?: string;
 }
 export interface NgisModelSearchRequest {
     query?: string;
@@ -300,6 +353,12 @@ export interface NgisModelsFacet {
     /** The one normalized UI schema (F14.2). `null` when the tool or its schema
      *  is absent. Scope `models:read`. */
     uiSchema(toolId: string): Promise<NgisToolUiSchema | null>;
+    /**
+     * Resolves a declared `manifest.toolDependencies[].alias` for this plugin and
+     * viewer. The unavailable arm is a normal, renderable result; it never leaks
+     * implementation UUIDs into plugin manifests. Scope `models:read`.
+     */
+    dependency(alias: string): Promise<NgisResolvedToolDependency>;
     /** REST projection of `ValidateToolExecution`. Returns the response DTO
      *  **verbatim**. Scope `models:read`, **not** `models:run` — it runs nothing,
      *  and returns only registry facts plus dataset metadata the caller can
@@ -324,6 +383,18 @@ export interface NgisTaskRunRequest {
     expectedSceneGeneration?: number;
     outputMode?: "ADD_LAYER" | "UPDATE_RESOURCE";
     targetResourceId?: string;
+    /**
+     * **Stage 25 (F25.4).** The output CRS this run computes in and stores its
+     * result as — an {@link NgisCrsRef} key, never an integer. Absent means
+     * "compute in the primary input's own CRS", which is a real choice and not a
+     * default: the server never substitutes one (G-CRS).
+     *
+     * This is the member that makes exit criterion 6 true. `submitRun` fills it,
+     * the tasks facet spreads the request through to the DIRECT source, and
+     * `createGisTasksSource` hands it to `startTrackedAnalysisTask`, which puts
+     * `outputCrs` in the `POST /api/analysis/tasks` body.
+     */
+    outputCrs?: string;
 }
 export interface NgisTaskHandle {
     /** DIRECT: the analysis task id. WORKFLOW: the workflow instance id. */

package/dist/src/sdk/map-api.d.ts

@@ -38,7 +38,7 @@
 import type { Map as MapLibreMap } from "maplibre-gl";
 import type { SceneLayerHighlight, SceneMapView } from "../domain/map/types";
 import type { GisDrawMode, GisMeasureKind } from "../types/gis";
-import type { WorkspacePanelRegistry } from "./panels";
+import type { WorkspacePanelRegistry } from "@ngis/plugin-sdk";
 /** Current facade contract version — bumped when the frozen surface changes.
  * A plugin's `minNgisVersion` (`docs/frontend-map-sdk.md` §3) is
  * checked against this. Pre-1.0: the surface may still grow (additively).
@@ -73,7 +73,7 @@ import type { WorkspacePanelRegistry } from "./panels";
  * semver compare, **not** by the unknown-capability check: `contributes` and
  * `permissions` are top-level manifest siblings, and a 0.3 runtime inspects
  * only `manifest.capabilities`. */
-export declare const NGIS_MAP_API_VERSION = "0.4.0";
+export declare const NGIS_MAP_API_VERSION = "0.4.1";
 /** A scene layer as the SDK exposes it — a stable projection of the store's
  * `NgisSceneLayer`, so plugins never depend on the store's internal shape. */
 export interface NgisLayerSummary {
@@ -262,6 +262,9 @@ export interface NgisMapAPIBindings {
     /** Raw-map getter for `getMap()`. Usually omitted at construction and wired
      * later via `NgisMapAPIHandle.bindRawMap` (the post-C5 hookup). */
     getRawMap?(): MapLibreMap | null;
+    /** Host hook run before direct raw-map camera commands. Keeps host-owned
+     * temporary camera controllers from racing this SDK escape hatch. */
+    beforeCameraCommand?(map: MapLibreMap): void;
 }
 /**
  * The factory's return value: the public `api` plus the host-side "driver"