@ngis/plugin-sdk 0.4.0 → 0.4.1

package/dist/src/domain/map/types.d.ts

@@ -99,6 +99,8 @@ export interface SceneLayerHighlight {
     allFeatures?: boolean;
     /** Only meaningful with `allFeatures`; rows unchecked after select-all. */
     excludedFeatureIds?: string[];
+    /** Optional MapLibre predicate narrowing an all-matching table selection. */
+    attributeFilter?: HighlightFilterExpression;
 }
 export type SceneLayerStyle = Record<string, unknown>;
 export type SceneLayerRenderMode = "maplibre" | "custom-raster-color" | "custom-flow-field";

package/dist/src/domain/models/crs.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Stage 25 (F25.1) — the frontend's CRS domain model.
+ *
+ * **Authored by the W1 kickoff: TYPES AND CONSTANTS ONLY. Read-only to every W1 session
+ * except S25-13, which owns this file and adds the function bodies below.**
+ *
+ * This is the TypeScript leg of the Stage 25 twin triple. The other two are `CrsDto`
+ * (ngis-file, `io.ngis.file.dto`) and `crs_ref.py` (ngis-geoanalysis). All three mirror
+ * `ngis-protos/crs.proto`'s `CrsRef` and the fixtures in `__fixtures__/crs/`, which are
+ * byte-identical across four copies (F25.14 — compare with `diff --strip-trailing-cr`,
+ * never an on-disk hash: the two repos normalise line endings differently).
+ *
+ * ## G-CRS lives here
+ *
+ * `key` is the identity and the only field a caller must round-trip. An absent CRS is
+ * `null` — never `key: ""`, never `epsg: 0`. Zero is not "unknown", it is absent. The whole
+ * stage exists because `crs.py:78` silently turned an undetectable vector CRS into 4326 and
+ * nothing downstream could tell the difference.
+ *
+ * @see docs/projection_management_stage/README.md — F25.1, F25.13 (frozen names)
+ */
+/** How a CRS came to be attached to a dataset. Never absent on a stored CRS (G-CRS). */
+export type NgisCrsSource = "DETECTED" | "SPEC_DEFAULT" | "USER_ASSIGNED" | "DERIVED";
+/**
+ * The display accessor over `NgisCrsRef.geographic`. The boolean is right on the wire, but
+ * `!ref.geographic` reads as a double negative at every UI call site (F25.13).
+ */
+export type NgisCrsKind = "geographic" | "projected";
+/**
+ * What a tool requires of its inputs' CRS.
+ *
+ * `"uniform"` is **not** a member — D25-5 struck it. `"geographic"` is hand-authored only.
+ */
+export type NgisCrsRequirement = "any" | "projected" | "geographic";
+/**
+ * Where a tool's `crsRequirement` came from. A `CLASSIFIER` requirement may only ever raise
+ * an **advisory** issue (R10 / D25-5 as amended): no classifier rule measured better than
+ * 0.800 precision, and a false `"projected"` refuses a run the user is entitled to make.
+ */
+export type NgisCrsRequirementSource = "HAND_AUTHORED" | "CLASSIFIER";
+/** One coordinate reference system. `key` is `"EPSG:<code>"` or `"custom:<ulid>"`. */
+export interface NgisCrsRef {
+    /** The identity, and the only field a caller must round-trip. */
+    readonly key: string;
+    /** Set iff `key` is an `EPSG:` ref. Never `0` — an absent CRS is a `null` ref. */
+    readonly epsg?: number;
+    /** Always on a resolved custom ref; on an EPSG ref only when asked. */
+    readonly wkt2?: string;
+    /** e.g. `"WGS 84 / UTM zone 50N"`. Present iff the oracle has resolved the ref. */
+    readonly name?: string;
+    readonly geographic?: boolean;
+    /** `"metre"` | `"degree"` | `"foot"` | `"us-foot"` | … */
+    readonly unit?: string;
+    readonly source?: NgisCrsSource;
+}
+/** Blocking refuses the submit with 400; advisory never gates Run (R9). */
+export type NgisValidationIssueSeverity = "blocking" | "advisory";
+/**
+ * Open by design — a later stage may add a code, and an unknown code must render as its
+ * `messageKey` rather than being dropped (the `ExtensionSettingsForm` rule, F14.9).
+ */
+export type NgisCrsIssueCode = "CRS_UNKNOWN" | "CRS_PROJECTED_REQUIRED" | "CRS_GEOGRAPHIC_REQUIRED" | "CRS_REPROJECT_NOTICE" | "CRS_UNSUPPORTED_BY_PROVIDER" | (string & {});
+/** The one-click remedy attached to a blocking issue. Carries the `NgisPickerNotice.action`. */
+export interface NgisValidationIssueFix {
+    /** The parameter the fix sets — e.g. `"ngis:outputCrs"`. */
+    readonly param: string;
+    readonly value: string;
+    /** Client-localised under `Crs.issues.fix.*`. */
+    readonly labelKey: string;
+    readonly params?: Readonly<Record<string, string | number>>;
+}
+/**
+ * A typed, per-parameter validation issue (F25.6). **Additive** to F14.9's string arrays:
+ * `missingParameters` / `parameterErrors` / `outputErrors` / `warnings` keep their meaning.
+ *
+ * `param` routes it to that field's `notices`; `port` routes it to that input port.
+ */
+export interface NgisValidationIssue {
+    readonly code: NgisCrsIssueCode;
+    readonly severity: NgisValidationIssueSeverity;
+    /** Client-localised under `Crs.issues.*`. */
+    readonly messageKey: string;
+    readonly params?: Readonly<Record<string, string | number>>;
+    readonly param?: string;
+    readonly port?: string;
+    readonly fix?: NgisValidationIssueFix;
+    readonly crs?: {
+        readonly input?: NgisCrsRef;
+        readonly suggested?: NgisCrsRef;
+        readonly compute?: NgisCrsRef;
+    };
+}
+/** One input as the compiled plan sees it. */
+export interface NgisCrsPlanInput {
+    readonly port: string;
+    /** The CRS the stored dataset is in. */
+    readonly from: string;
+    /** The CRS it is staged into for this run. Equal to `from` when no staging is needed. */
+    readonly to: string;
+    /** Written back as a cached export variant above `STAGING_CACHE_MIN_BYTES` (20 MiB). */
+    readonly cacheable?: boolean;
+}
+/**
+ * The server-compiled CRS plan (F25.4). Every executor path executes **this** rather than
+ * re-deriving a CRS from dataset metadata or a fallback — that is G-U.
+ *
+ * `null` whenever a blocking issue was raised (R9).
+ */
+export interface NgisCrsPlan {
+    /** The CRS the run computes in. */
+    readonly computeCrs: string;
+    /**
+     * The integer that reaches the PostGIS SQL, the `-t_srs` of ogr2ogr/gdalwarp and the
+     * iObjects `inputSrids`: the EPSG code, or the registry's `spatial_ref_sys` srid
+     * (>= 900001) for a custom CRS. No executor re-derives it (R7).
+     */
+    readonly pgSrid: number;
+    /** The CRS the result is registered in. */
+    readonly resultCrs: string;
+    /** Always `"DERIVED"` when present (R6). */
+    readonly resultCrsSource?: NgisCrsSource;
+    /** One entry per input that had to be reprojected for the run. Staging never mutates storage. */
+    readonly stage: readonly NgisCrsPlanInput[];
+}
+/** The one platform projection parameter, injected into every tool's UI schema (F25.4). */
+export declare const NGIS_OUTPUT_CRS_PARAM = "ngis:outputCrs";
+/** `x-role` of a synthetic platform parameter. `w2-fixture.test.ts:252` excludes these. */
+export declare const NGIS_PLATFORM_ROLE = "platform";
+/**
+ * The identifier half of the chip, alone — `"EPSG:32650"`, `"Custom"`, or the
+ * NEEDS_CRS text. It exists so the chip, the table cell and the picker footer
+ * cannot drift: `formatCrs` is this plus the name, never a second spelling.
+ *
+ * **G-CRS.** A bare integer is never returned. A key that *is* a bare integer —
+ * which is what a server still on the old numeric `srid` would send — is
+ * rendered `EPSG:<n>`, because the one thing the user must never see is a naked
+ * number they cannot tell from a feature count.
+ */
+export declare function formatCrsKey(key: string | null, needsCrsText?: string): string;
+/**
+ * The full chip string — `"EPSG:32650 · WGS 84 / UTM zone 50N"`, `"Custom · <name>"`.
+ *
+ * **This is where G-CRS lives on the client.** It never prints a bare integer,
+ * and `formatCrs(null)` returns the NEEDS_CRS text — never `"-"`, and never
+ * `"EPSG:4326"`, which is the silent default the whole stage exists to remove.
+ * A ref whose oracle lookup has not happened yet has no `name`, and renders as
+ * its identifier alone rather than borrowing one.
+ */
+export declare function formatCrs(ref: NgisCrsRef | null, needsCrsText?: string): string;
+/**
+ * `true` only for a ref the oracle has resolved *and* reported as projected.
+ *
+ * An **unresolved** ref (no `geographic`) is `false` here, exactly as
+ * `crs_ref.py`'s `.projected` is — but it is never `true`, so "we have not asked
+ * yet" can never read as "this is safe to measure distance in". That asymmetry
+ * is G-U, restated in one predicate.
+ */
+export declare function isProjectedCrs(ref: NgisCrsRef | null): boolean;
+/**
+ * The display accessor over `NgisCrsRef.geographic` (F25.13). The boolean is
+ * right on the wire; `!ref.geographic` reads as a double negative at every UI
+ * call site, and a UI that has to negate to say "projected" eventually forgets to.
+ *
+ * Reports `"projected"` on exactly the refs {@link isProjectedCrs} accepts, so
+ * the two cannot drift. An unresolved ref reports `"geographic"` — the
+ * conservative half — and the chip draws it with the unknown sigil instead,
+ * because {@link crsUnitGlyph} has no unit to show.
+ */
+export declare function crsKind(ref: NgisCrsRef): NgisCrsKind;
+/**
+ * The unit sigil's glyph: `°` · `m` · `ft` · `?`.
+ *
+ * Exported because the sigil is drawn in five places (full chip, compact chip,
+ * picker trigger, list row, "needs projection" filter) and an inlined map would
+ * drift between them. `"?"` is the honest answer for both an absent ref and a
+ * unit no client mapping knows — a guessed glyph on an unknown unit is exactly
+ * the silent default this stage removes.
+ */
+export declare function crsUnitGlyph(ref: NgisCrsRef | null): string;
+/**
+ * The wire value — the ref's `key`, or `null`. This is what the `crs` widget
+ * puts in the params payload and what `PUT /api/datasets/{id}/crs` echoes.
+ *
+ * An empty-string key is `null`, not `""`: `key: ""` is not a CRS, and letting
+ * it through is how an absent CRS gets laundered into a present one.
+ */
+export declare function crsKeyOf(ref: NgisCrsRef | null): string | null;

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/domain/models/scene-layer-type.d.ts

@@ -1,10 +1,35 @@
-export declare const SCENE_LAYER_TYPE_IDS: readonly ["MAPLIBRE_FILL", "MAPLIBRE_LINE", "MAPLIBRE_CIRCLE", "MAPLIBRE_RASTER", "CUSTOM_FLOW_FIELD", "DECK_MVT_POLYGON", "DECK_MVT_EXTRUDED_POLYGON", "DECK_COLUMN", "DECK_HEATMAP", "DECK_HEXAGON", "DECK_MVT_LINE", "DECK_MVT_POINT", "SYMBOL_POINT", "SYMBOL_LINE", "SYMBOL_POLYGON"];
+import type { sceneLayerResourceKindOfDatasetKind } from "./dataset-kind";
+export declare const SCENE_LAYER_TYPE_IDS: readonly ["MAPLIBRE_FILL", "MAPLIBRE_LINE", "MAPLIBRE_CIRCLE", "MAPLIBRE_RASTER", "CUSTOM_FLOW_FIELD", "DECK_MVT_POLYGON", "DECK_MVT_EXTRUDED_POLYGON", "DECK_COLUMN", "DECK_HEATMAP", "DECK_HEXAGON", "DECK_MVT_LINE", "DECK_MVT_POINT", "SYMBOL_POINT", "SYMBOL_LINE", "SYMBOL_POLYGON", "PLOTTING_SYMBOL", "DYNAMIC_LINE"];
 export type SceneLayerTypeId = (typeof SCENE_LAYER_TYPE_IDS)[number];
 export type LegacySceneLayerTypeId = "VECTOR" | "RASTER";
 export type SceneLayerRendererKind = "maplibre" | "deck" | "custom";
-export type SceneLayerResourceKind = "vector" | "raster";
+/**
+ * **RETIRED as an independent vocabulary (F29.1 row 6).**
+ *
+ * It was one of the seven spellings of a dataset's kind, and the worst-founded
+ * of them: nothing declared it, it was *reached* by `geometry.includes("raster")`
+ * — a substring match on a geometry string — so a resource whose geometry string
+ * was merely non-empty classified as `"vector"`. The spine now carries the
+ * answer, and the one projection from it lives in
+ * {@link sceneLayerResourceKindOfDatasetKind}.
+ *
+ * The **name and the two lowercase values stay**, because this is the vocabulary
+ * the layer-type table below is written in and renaming it is out of contract
+ * (F29.1's rule for row 1 applies equally here). What is retired is its
+ * *derivation*: it is now defined as the return of the one projection, so it can
+ * never again drift from {@link NgisDatasetKind} by being re-typed by hand, and
+ * widening it is a change to that function and nowhere else.
+ *
+ * It is a **layer-compatibility** vocabulary, not a kind: it answers *"which
+ * renderers can draw this"*, which is why it is deliberately narrower than the
+ * open kind union — a kind registered tomorrow projects to `null` here and the
+ * caller must decide what that means, rather than being handed `"vector"`.
+ */
+export type SceneLayerResourceKind = NonNullable<ReturnType<typeof sceneLayerResourceKindOfDatasetKind>>;
 export type SceneLayerGeometryFamily = "point" | "line" | "polygon" | "raster";
-export type SceneLayerStyleKind = "maplibre-fill" | "maplibre-line" | "maplibre-circle" | "maplibre-raster" | "custom-flow-field" | "deck-mvt-polygon" | "deck-mvt-extruded-polygon" | "deck-column" | "deck-heatmap" | "deck-hexagon" | "deck-mvt-line" | "deck-mvt-point" | "symbol";
+export type SceneLayerStyleKind = "maplibre-fill" | "maplibre-line" | "maplibre-circle" | "maplibre-raster" | "custom-flow-field" | "deck-mvt-polygon" | "deck-mvt-extruded-polygon" | "deck-column" | "deck-heatmap" | "deck-hexagon" | "deck-mvt-line" | "deck-mvt-point" | "symbol"
+/** S28: no-resource Canvas runtime, deliberately not a Stage 25 symbol style. */
+ | "plotting" | "dynamic-line";
 export interface SceneLayerTypeDefinition {
     id: SceneLayerTypeId;
     label: string;

package/dist/src/sdk/context/publishers.d.ts

@@ -17,6 +17,7 @@
  * unrelated store write (a loading flag, a style draft) costs one reference
  * compare rather than a re-derivation and a notification.
  */
+import { type NgisDatasetKind } from "../../domain/models/dataset-kind";
 import type { NgisUnsubscribe } from "../map-api";
 import { type NgisContextValue, type NgisResourceType } from "./keys";
 import type { NgisContextStore } from "./store";
@@ -41,8 +42,23 @@ export interface SceneContextResource {
      * `"Raster"` for a RASTER dataset, the vector geometry type for a VECTOR
      * one, and `null` for everything else — which is the signal
      * `classifySceneResourceType` reads.
+     *
+     * **Stage 29 (F29.1 row 6):** it is no longer the *first* signal. See
+     * {@link SceneContextResource.datasetType}.
      */
     geometryType?: string | null;
+    /**
+     * `SceneResourceDto.datasetType` — the registered kind id, and **the answer
+     * this publisher should be reading** (F29.1 row 6).
+     *
+     * Optional because the producer is `createSceneStore()`
+     * (`src/store/scene-store.ts`), which `S29-15` owns and which does not carry it
+     * onto this slice yet. Until it does, {@link classifySceneResourceType} falls
+     * back to the geometry-string guess — absent is *"the store has not said"*, not
+     * *"this resource has no kind"*, so the fallback is a third state and not a
+     * default.
+     */
+    datasetType?: NgisDatasetKind | null;
 }
 export interface SceneContextScene {
     id: string;
@@ -79,6 +95,27 @@ export interface AuthContextSlice {
  * → `"vector"`, absent → `"file"` (which covers `GENERIC` and a dataset whose
  * metadata fetch failed). The authoritative join lives in X2's
  * `host.resources` facet; wiring this publisher to it is backlog row **V-21**.
+ *
+ * ## Classifier disposition (F29.1 row 6): DELEGATES, with a fallback
+ *
+ * The `geometry.includes("raster")` line below is **the substring match F29.1
+ * retires** — a guess about a dataset's kind made from a geometry string, which
+ * answered `"vector"` for anything non-empty that did not contain the letters
+ * `raster`. The kind id now answers first, through
+ * {@link sceneLayerResourceKindOfDatasetKind}, which is the one place the
+ * projection lives.
+ *
+ * The guess survives **only** as the `datasetType`-absent arm, because the
+ * producer of this slice is `src/store/scene-store.ts` — `S29-15`'s file, not
+ * this session's — so the field cannot be populated here. When `S29-15` carries
+ * it onto the slice, every branch below the first becomes unreachable for an
+ * enriched scene and the guess can be deleted outright. Carried as `S29-V108`.
+ *
+ * A kind that projects to neither `vector` nor `raster` — including a kind
+ * registered after this client shipped — falls through to the geometry arm
+ * rather than to `"file"`, because an unregistered *kind* is not evidence that
+ * the resource has no *geometry*; that is the same absent-is-not-false rule
+ * F29.4 states for capability flags.
  */
 export declare function classifySceneResourceType(resource: SceneContextResource): NgisResourceType;
 /**