@geolibre/core 3.1.0 → 3.2.0

package/dist/index.d.mts

@@ -1947,6 +1947,12 @@ export interface RuntimeEnvironmentVariable {
   key: string;
   value: string;
   enabled: boolean;
+  /**
+   * Absent or `true`: the value is a secret (desktop keeps it in the OS
+   * keychain; every egress removes it). `false`: an ordinary value saved in the
+   * project and kept on share/export.
+   */
+  secret?: boolean;
 }
 declare global {
   interface Window {
@@ -2532,8 +2538,32 @@ export interface GeoLibreProject {
   styleLibrary?: StyleLibraryEntry[];
   /** Anchored review comments on map points or features (issue #1518). */
   comments?: ProjectComment[];
+  /**
+   * Interaction state applied when the project opens: the Identify target and
+   * which map controls and toolbar panels start shown (issue #2688). Written by
+   * the Python `geolibre` package from `set_identify` / `show_control`, so a
+   * saved or HTML-exported notebook map opens the way it was set up. Omitted
+   * by default; the app keeps what it loaded and writes it back unchanged.
+   */
+  interaction?: ProjectInteraction;
   metadata: Record<string, unknown>;
 }
+/**
+ * Startup interaction state carried by a project (see
+ * {@link GeoLibreProject.interaction}).
+ */
+export interface ProjectInteraction {
+  /**
+   * Identify target on open: a layer id, `"all"` for every visible queryable
+   * layer, a list of layer ids to identify only those, or `null` for off.
+   */
+  identify?: string | string[] | null;
+  /**
+   * Map control or toolbar panel name (`"search"`, `"bookmark"`, `"globe"`,
+   * ...) to whether it starts shown. Unknown names are ignored on open.
+   */
+  controls?: Record<string, boolean>;
+}
 export type CommentAnchor = {
   type: "point";
   lngLat: [number, number];
@@ -4259,6 +4289,47 @@ export declare function inferFieldTypes(features: ReadonlyArray<{
   properties?: Record<string, unknown> | null;
 }>, names: string[]): Record<string, ExpressionFieldType>;
 //#endregion
+//#region src/style-layer-evaluator.d.ts
+/** The geometry kinds a MapLibre style expression tells apart (`["geometry-type"]`). */
+export type StyleGeometryKind = "Point" | "LineString" | "Polygon";
+/** A feature as a style layer's expressions read it. */
+export interface StyleFeatureInput {
+  id?: string | number;
+  properties: Record<string, unknown> | null | undefined;
+  kind: StyleGeometryKind;
+}
+/** A style layer's filter and property values, evaluated as MapLibre would. */
+export interface StyleLayerEvaluator {
+  /** Whether the layer's `filter` keeps the feature at `zoom`. */
+  passes: (zoom: number, feature: StyleFeatureInput) => boolean;
+  /**
+   * A paint or layout property's value for a feature at `zoom`: the layer's
+   * value (a literal, a legacy function or an expression) or the spec's
+   * default. A color comes back as `[r, g, b, a]` with channels 0-255 and
+   * alpha 0-1; formatted text as its plain string. `undefined` for a property
+   * the spec does not know or an expression that does not compile.
+   */
+  value: (group: "paint" | "layout", name: string, zoom: number, feature: StyleFeatureInput) => unknown;
+}
+interface StyleLayerInput {
+  id?: string;
+  type: string;
+  filter?: unknown;
+  paint?: Record<string, unknown>;
+  layout?: Record<string, unknown>;
+}
+/**
+ * Compile a MapLibre style layer's filter and properties for evaluation
+ * outside MapLibre, for a renderer that draws the layer itself (the ArcGIS
+ * renderer drawing a plugin's own GeoJSON overlay, say). Uses the style spec's
+ * own evaluator, so data-driven and zoom expressions, legacy functions and
+ * defaults behave as they do on MapLibre. Each property compiles once.
+ *
+ * @param layer - The style layer (its `type`, `filter`, `paint`, `layout`).
+ * @returns The layer's evaluator.
+ */
+export declare function createStyleLayerEvaluator(layer: StyleLayerInput): StyleLayerEvaluator;
+//#endregion
 //#region src/document-locale.d.ts
 /**
  * The document language, so formatted numbers and dates follow the UI locale.
@@ -4447,6 +4518,21 @@ export declare function supportsBridgedOpacity(layerId: string): boolean;
 export declare function rendererAppliesOpacity(layer: {
   type: string;
 }, renderer: string | undefined): boolean;
+/**
+ * Whether `layer` is an Add Vector Layer layer GeoLibre adopted
+ * (`maplibre-gl-vector-adopted`, ADOPTED_VECTOR_SOURCE_KIND in
+ * @geolibre/plugins) that has no features yet. A project saves a URL- or
+ * path-backed adopted layer without them, and the vector control reads them
+ * again on reopen. Until then its `source.url` may name GeoParquet or
+ * GeoPackage, so a renderer must wait rather than load that URL as GeoJSON.
+ *
+ * @param layer - A store layer.
+ * @returns True while the adopted layer awaits its features.
+ */
+export declare function isAdoptedVectorAwaitingFeatures(layer: {
+  metadata: Record<string, unknown>;
+  geojson?: unknown;
+}): boolean;
 //#endregion
 //#region src/attribute-form.d.ts
 /** Options threaded to expression evaluation (constraints, visibility). */
@@ -5141,14 +5227,23 @@ export declare class ElevationFetchError extends Error {
 }
 /** A `fetch`-compatible function, so tests can inject a stub. */
 export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
+/**
+ * Normalize longitude into [-180, 180] degrees (handles unwrapped coordinates
+ * from antimeridian cross-overs and world-copy pannings).
+ */
+export declare function normalizeLongitude(lng: number): number;
+/**
+ * Clamp latitude into [-90, 90] degrees.
+ */
+export declare function clampLatitude(lat: number): number;
 /**
  * Fetch elevations (in meters) for an ordered list of coordinates.
  *
  * @param points - Coordinates as `[lng, lat]`, at most {@link MAX_POINTS_PER_REQUEST}
  * @param fetchImpl - Optional `fetch` implementation; defaults to the global `fetch`
  * @returns The elevation in meters for each input coordinate, in the same order
- * @throws {ElevationFetchError} On too many points, a network error, a non-2xx
- *   response, a malformed body, or a length mismatch
+ * @throws {ElevationFetchError} On too many points, a non-finite coordinate, a
+ *   network error, a non-2xx response, a malformed body, or a length mismatch
  */
 export declare function fetchElevations(points: LngLat[], fetchImpl?: FetchLike): Promise<number[]>;
 /** The slice of the MapLibre map the terrain sampler needs (stubbed in tests). */
@@ -5426,6 +5521,18 @@ export declare function normalizeWidgets(value: unknown): DashboardWidget[] | nu
  * @returns An integer column count within [MIN, MAX].
  */
 export declare function normalizeDashboardColumns(value: unknown): number;
+/**
+ * Coerce an untrusted `interaction` block into a {@link ProjectInteraction}.
+ *
+ * Layer ids are kept even when no such layer exists: the block is replayed
+ * against whatever layers the project has when it opens, and the loader drops
+ * the ones it cannot find. Control names are kept as written for the same
+ * reason; the app ignores names it does not know.
+ *
+ * @param value - Raw `interaction` value from the project JSON or the store.
+ * @returns The normalized block, or null when it carries nothing to apply.
+ */
+export declare function normalizeProjectInteraction(value: unknown): ProjectInteraction | null;
 export declare function isAllowedPluginManifestUrl(url: string): boolean;
 export declare function normalizeProjectComments(rawComments: unknown): ProjectComment[];
 export declare function projectFromStore(state: {
@@ -5454,6 +5561,8 @@ export declare function projectFromStore(state: {
   /** Project-scoped Style Manager entries (the store's `projectStyleLibrary`). */
   styleLibrary?: StyleLibraryEntry[] | null;
   comments?: ProjectComment[] | null;
+  /** Startup interaction state loaded with the project, written back as-is. */
+  interaction?: ProjectInteraction | null;
   metadata: Record<string, unknown>;
 }): GeoLibreProject;
 /**
@@ -5490,6 +5599,7 @@ export declare function applyProjectToStore(project: GeoLibreProject): {
   primaryRenderer: MapRendererKind;
   projectStyleLibrary: StyleLibraryEntry[];
   comments: ProjectComment[];
+  projectInteraction: ProjectInteraction | null;
   metadata: Record<string, unknown>;
 };
 /**
@@ -6032,6 +6142,101 @@ export declare function extractCopiedLayerStyle(layer: GeoLibreLayer): CopiedLay
  */
 export declare function applyCopiedLayerStyle(target: GeoLibreLayer, copied: CopiedLayerStyle): Partial<GeoLibreLayer> | null;
 //#endregion
+//#region src/layer-style-file.d.ts
+/** `type` tag identifying a layer styles file. */
+export declare const LAYER_STYLES_FILE_TYPE = "geolibre-layer-styles";
+/** Format version written by {@link serializeLayerStylesFile}. */
+export declare const LAYER_STYLES_FILE_VERSION = 1;
+/** One layer's style in a layer styles file, keyed by the layer's name. */
+export type LayerStyleFileEntry = {
+  /** Name of the layer the style was exported from; the match key. */
+  layerName: string;
+  kind: "vector";
+  /** The full vector {@link LayerStyle} bag. */
+  style: LayerStyle;
+} | {
+  layerName: string;
+  kind: "raster";
+  /** Raster visualization state (`metadata.rasterState`). */
+  rasterState?: Record<string, unknown>;
+  /** Raster classification symbology (`metadata.rasterSymbology`). */
+  rasterSymbology?: Record<string, unknown>;
+};
+/** The on-disk layer styles document. */
+export interface LayerStylesFile {
+  type: typeof LAYER_STYLES_FILE_TYPE;
+  version: typeof LAYER_STYLES_FILE_VERSION;
+  styles: LayerStyleFileEntry[];
+}
+/**
+ * Capture the style of every layer that has one. Layers without copyable
+ * symbology (basemap tiles, 3D tiles, ...) are skipped. Layers that share a
+ * name are all written, in stack order; the first one wins when the file is
+ * applied (see {@link findLayerStyleEntryIndex}).
+ *
+ * @param layers - The layers to export, in store (bottom-to-top) order.
+ * @returns The style entries.
+ */
+export declare function extractLayerStyleEntries(layers: readonly GeoLibreLayer[]): LayerStyleFileEntry[];
+/**
+ * Serialize style entries into the JSON written by Export Layer Styles.
+ *
+ * @param entries - The entries to write.
+ * @returns Pretty-printed file content.
+ */
+export declare function serializeLayerStylesFile(entries: readonly LayerStyleFileEntry[]): string;
+/**
+ * Coerce untrusted entries (a hand-edited file, or a copy kept in settings)
+ * into clean ones. An entry without a name or a known kind is dropped; a
+ * vector style is sanitized and completed against the default style, and a
+ * raster state keeps only well-typed appearance keys, so applying an entry
+ * never hands a renderer an unknown, missing or wrong-typed field.
+ *
+ * @param value - The raw `styles` array.
+ * @returns The usable entries.
+ */
+export declare function normalizeLayerStyleEntries(value: unknown): LayerStyleFileEntry[];
+/**
+ * Parse a file written by {@link serializeLayerStylesFile}.
+ *
+ * @param json - The file content.
+ * @returns The normalized entries.
+ * @throws Error when the content is not a layer styles file, comes from a
+ *   newer format version, or holds no usable entries.
+ */
+export declare function parseLayerStylesFile(json: string): LayerStyleFileEntry[];
+/**
+ * Find the entry for a layer name: an exact match first, then one that differs
+ * only in case or surrounding whitespace, so `Roads` still picks up a style
+ * saved for `roads`. The first match in file order wins.
+ *
+ * @param entries - The style entries.
+ * @param layerName - The layer name to look up.
+ * @param kind - When given, only entries of this style family are considered,
+ *   so a raster style saved under a shared name does not shadow the vector one.
+ * @returns The matching entry's index in `entries`, or -1.
+ */
+export declare function findLayerStyleEntryIndex(entries: readonly LayerStyleFileEntry[], layerName: string, kind?: LayerStyleClipboardKind): number;
+/** A layer restyled from a style entry, and the entry it took. */
+export interface LayerStyleMatch {
+  /** Index of the applied entry in the entries array. */
+  entryIndex: number;
+  /** The patch that applies it. */
+  patch: Partial<GeoLibreLayer>;
+}
+/**
+ * Build the patch that restyles a layer from the entry matching its name, with
+ * the same semantics as pasting a copied style: a vector style replaces the
+ * whole style bag, a raster style merges its appearance keys and keeps the
+ * layer's own band selection, and layer opacity is left alone.
+ *
+ * @param layer - The layer to restyle.
+ * @param entries - The style entries.
+ * @returns The matched entry and patch, or `null` when no entry of the layer's
+ *   style family matches its name (or the layer has no stylable symbology).
+ */
+export declare function matchLayerStyleEntry(layer: GeoLibreLayer, entries: readonly LayerStyleFileEntry[]): LayerStyleMatch | null;
+//#endregion
 //#region src/layer-groups.d.ts
 /** Opacity a freshly created {@link LayerGroup} starts at (fully opaque). */
 export declare const DEFAULT_LAYER_GROUP_OPACITY = 1;
@@ -6323,6 +6528,236 @@ export declare function layerGroupSortability(layers: GeoLibreLayer[], groups: L
  */
 export declare function formatPixelValue(value: number): string;
 //#endregion
+//#region src/s3.d.ts
+/**
+ * Amazon S3 (and S3-compatible) object URLs: parsing, public HTTPS mapping,
+ * SigV4 query-string presigning, and the registry the app uses to plug
+ * credentialed signing into every reader.
+ *
+ * Readers in GeoLibre take a plain HTTPS URL (geotiff.js, cog-tiler-wasm,
+ * pmtiles, DuckDB-WASM's HTTP reader, the vector control). A presigned URL is
+ * the one form of authenticated S3 access all of them accept without a custom
+ * fetch hook, so private objects are read by signing the URL first and handing
+ * the reader the result. Layers keep the unsigned source URL (`s3://…` or the
+ * plain object URL); the signed one is minted again on every load, so a saved
+ * project never carries a signature or a session token.
+ */
+/** A bucket and object key, with the endpoint the URL named, if any. */
+export interface S3ObjectLocation {
+  bucket: string;
+  /** The raw (decoded) object key, without a leading slash. */
+  key: string;
+  /** The region an AWS HTTPS URL named in its host, when it named one. */
+  region?: string;
+}
+/** Where and how a bucket is addressed. */
+export interface S3EndpointConfig {
+  /** Signing region, e.g. `us-east-1`. S3-compatible stores often accept `auto`. */
+  region: string;
+  /**
+   * Custom endpoint origin for S3-compatible stores (MinIO, Cloudflare R2,
+   * Wasabi, Ceph), e.g. `https://minio.example.com:9000`. Empty for AWS.
+   */
+  endpoint?: string;
+  /** Address the bucket in the path instead of the host name. */
+  pathStyle?: boolean;
+}
+/** AWS credentials used to sign a request. */
+export interface S3Credentials {
+  accessKeyId: string;
+  secretAccessKey: string;
+  sessionToken?: string;
+  /** Epoch milliseconds at which temporary credentials stop working. */
+  expiresAt?: number;
+}
+/** A presigned URL and the moment it stops working. */
+export interface S3SignedUrl {
+  href: string;
+  /** Epoch milliseconds. */
+  expiresAt: number;
+}
+/** SigV4 allows a presigned URL to live at most seven days. */
+export declare const S3_MAX_PRESIGN_SECONDS: number;
+/**
+ * Parses an `s3://bucket/key` URI or an AWS S3 HTTPS object URL
+ * (virtual-hosted or path-style, any region) into its bucket and key.
+ * Query strings and fragments are ignored, so a presigned URL parses to the
+ * object it signs.
+ *
+ * @param url The URL to parse.
+ * @returns The bucket and key, or null when the URL is not an S3 object URL.
+ */
+export declare function parseS3Url(url: string): S3ObjectLocation | null;
+/** Whether `url` is an `s3://` URI (as opposed to an HTTPS object URL). */
+export declare function isS3Uri(url: string): boolean;
+/** Formats a location as an `s3://bucket/key` URI. */
+export declare function formatS3Uri(location: S3ObjectLocation): string;
+/**
+ * URI-encodes a key the way SigV4 canonicalizes an S3 path: every byte except
+ * the unreserved set and `/` is percent-encoded, once.
+ */
+export declare function encodeS3Key(key: string): string;
+/**
+ * Builds the HTTPS URL of an object.
+ *
+ * AWS buckets whose name contains a dot are addressed path-style, since the
+ * `*.s3.amazonaws.com` wildcard certificate covers one label only.
+ *
+ * @param location The bucket and key.
+ * @param config The endpoint; without one the global AWS endpoint is used.
+ * @returns The unsigned object URL.
+ */
+export declare function s3ObjectHttpsUrl(location: S3ObjectLocation, config?: Partial<S3EndpointConfig>): string;
+export interface PresignS3Options {
+  /** The unsigned HTTPS object URL (see {@link s3ObjectHttpsUrl}). */
+  url: string;
+  region: string;
+  credentials: S3Credentials;
+  /** Lifetime in seconds, clamped to 1…{@link S3_MAX_PRESIGN_SECONDS}. */
+  expiresIn: number;
+  /** HTTP method the URL authorizes. Defaults to GET. */
+  method?: string;
+  /** Signing time; defaults to now. Exposed for tests. */
+  now?: Date;
+}
+/**
+ * Presigns an S3 request with AWS Signature Version 4 in the query string.
+ * Runs on WebCrypto, so it works in the browser, the Tauri webview, and Node.
+ *
+ * The URL authorizes exactly one method: a GET URL cannot answer a HEAD, so
+ * readers that probe with HEAD need a GET range request instead.
+ *
+ * @param options The object URL, region, credentials, and lifetime.
+ * @returns The presigned URL.
+ */
+export declare function presignS3Url(options: PresignS3Options): Promise<string>;
+/** One signed S3 GET: an object read, or a bucket-level call such as ListObjectsV2. */
+export interface S3PresignRequest {
+  bucket: string;
+  /** Object key; empty for a bucket-level request. */
+  key: string;
+  /** Extra query parameters to sign (e.g. `list-type=2`). */
+  query?: Record<string, string>;
+  /** Region an AWS URL named, used ahead of the connection's default. */
+  region?: string;
+  /**
+   * Sign with this connection instead of the one matched by bucket name (the
+   * S3 browser listing a chosen connection's buckets, where `bucket` is empty).
+   */
+  connectionId?: string;
+}
+/** A configured connection, as the S3 browser lists it. No secrets. */
+export interface S3ConnectionSummary {
+  id: string;
+  name: string;
+  /** Bucket patterns the connection covers; empty means every bucket. */
+  buckets: string[];
+}
+/**
+ * Presigns S3 requests with the app's configured credentials. `presign`
+ * resolves to null when no configured connection covers the bucket, in which
+ * case the object is read anonymously.
+ */
+export interface S3UrlSigner {
+  /** Whether a configured connection covers `bucket`. Must be synchronous. */
+  covers(bucket: string): boolean;
+  /** Presigns a GET; rejects when the connection's credentials cannot be resolved. */
+  presign(request: S3PresignRequest, signal?: AbortSignal): Promise<S3SignedUrl | null>;
+  /** The configured connections, for pickers. */
+  connections(): S3ConnectionSummary[];
+  /**
+   * Fetches a presigned bucket-level URL (listing). The desktop app routes it
+   * through its native HTTP client, which needs no bucket CORS rule.
+   */
+  fetchText?(url: string, signal?: AbortSignal): Promise<{
+    status: number;
+    body: string;
+  }>;
+  /** The persisted location (`s3://bucket/prefix/`) the S3 browser opens at, or "". */
+  defaultLocation?(): string;
+  /** Persists the S3 browser's default location; "" clears it. */
+  setDefaultLocation?(location: string): void;
+}
+/** Installs (or with null, removes) the app's S3 signer. */
+export declare function registerS3UrlSigner(signer: S3UrlSigner | null): void;
+/**
+ * Whether reading `url` needs the S3 signer: it names an S3 object in a bucket
+ * a configured connection covers.
+ */
+export declare function isCredentialedS3Url(url: string): boolean;
+/**
+ * The unsigned URL a presigned one was minted for by
+ * {@link resolveReadableUrl}, or `url` itself. Layer sync runs every URL a
+ * control reports through this, so the store (and a saved project) keeps the
+ * `s3://` source rather than an expiring signature.
+ */
+export declare function unsignedSourceUrl(url: string): string;
+export declare function unsignedSourceUrl(url: string | undefined): string | undefined;
+/**
+ * Resolves a data URL into one a plain HTTP reader can fetch:
+ *
+ * - an S3 object in a bucket a configured connection covers → a presigned URL;
+ * - any other `s3://` URI → the public HTTPS object URL (anonymous read);
+ * - anything else → unchanged.
+ *
+ * @param url The URL a layer or query names.
+ * @param signal Aborts a pending credential lookup.
+ * @returns The URL to hand the reader.
+ * @throws When the bucket is covered but its credentials cannot be resolved.
+ */
+export declare function resolveReadableUrl(url: string, signal?: AbortSignal): Promise<string>;
+/** The installed signer, for the S3 browser. */
+export declare function getS3UrlSigner(): S3UrlSigner | null;
+/** One page of a ListObjectsV2 response. */
+export interface S3ListPage {
+  /** Common prefixes ("folders") under the requested prefix. */
+  prefixes: string[];
+  objects: Array<{
+    key: string;
+    size: number;
+    lastModified?: string;
+  }>;
+  /** Present when more results follow. */
+  nextContinuationToken?: string;
+}
+/**
+ * Parses a ListObjectsV2 XML body. S3's listing XML is flat and predictable,
+ * so this reads it with patterns rather than an XML DOM, which keeps it usable
+ * in workers and Node tests.
+ */
+export declare function parseS3ListObjects(xml: string): S3ListPage;
+/** The error code and message of an S3 XML error body, when it is one. */
+export declare function parseS3Error(xml: string): {
+  code: string;
+  message: string;
+  region?: string;
+} | null;
+/** Bucket names from a ListBuckets (`GET /` on the service) XML body. */
+export declare function parseS3BucketList(xml: string): string[];
+/** A read the bucket's CORS configuration blocked. */
+export declare class S3CorsError extends Error {
+  readonly bucket: string;
+  readonly origin: string;
+  constructor(message: string, bucket: string, origin: string, cause: unknown);
+}
+/** Translates `key`, falling back to `defaultValue` (an app API's `translate`). */
+export type S3ErrorTranslate = (key: string, defaultValue: string, params?: Record<string, string | number>) => string;
+/**
+ * Explains why reading an S3 object failed when the browser only said
+ * "Failed to fetch". A browser reports a request the bucket's CORS rules
+ * blocked exactly like a network outage, so this repeats the request twice:
+ * normally, where success means the failure was transient; then in `no-cors`
+ * mode, which CORS cannot block. Only when the first fails and the second gets
+ * an answer is the bucket's CORS configuration the cause.
+ *
+ * @param url The `s3://` URI or object URL that was being read.
+ * @param error What the reader threw.
+ * @param translate Turns the message into the UI language.
+ * @returns An {@link S3CorsError} naming the bucket and the origin to allow,
+ *   or `error` unchanged when it is not a CORS refusal of an S3 read.
+ */
+export declare function explainS3ReadError(url: string, error: unknown, translate?: S3ErrorTranslate): Promise<unknown>;
+//#endregion
 //#region src/storymap-sample.d.ts
 /**
  * Build a ready-to-play sample story map.
@@ -6566,6 +7001,22 @@ interface LayersSlice {
    * style was applied, so callers can skip the confirmation on a no-op.
    */
   pasteLayerStyle: (id: string) => boolean;
+  /**
+   * Restyle layers from layer styles file entries matched by layer name
+   * (Import Layer Styles, and the Startup setting's auto-apply). Each matched
+   * layer is patched the way {@link pasteLayerStyle} would patch it, all in a
+   * single store update so the import is one undo step.
+   *
+   * @param entries - The parsed style entries.
+   * @param layerIds - Restrict the restyle to these layers; every layer when
+   *   omitted.
+   * @returns Each restyled layer's id with the index of the entry it took, in
+   *   stack order.
+   */
+  applyLayerStyleEntries: (entries: readonly LayerStyleFileEntry[], layerIds?: readonly string[]) => {
+    layerId: string;
+    entryIndex: number;
+  }[];
   /**
    * Replace a layer's persistent attribute joins and immediately re-derive its
    * joined columns (strip what the previous joins added, apply the new list).
@@ -6827,6 +7278,12 @@ interface ProjectContentSlice {
   dashboardColumns: number;
   /** Anchored review comments on map points or features (issue #1518). */
   comments: ProjectComment[];
+  /**
+   * The loaded project's startup `interaction` block (issue #2688). Applied
+   * once on load and written back unchanged on save; live Identify and control
+   * changes do not edit it.
+   */
+  projectInteraction: ProjectInteraction | null;
   /** Append a new dashboard widget. */
   addWidget: (widget: DashboardWidget) => void;
   /** Patch an existing dashboard widget by id (no-op if absent). Merges, so an
@@ -6915,7 +7372,45 @@ interface GpsStatusFix {
 }
 /** Reserved Identify target for querying every visible queryable layer at once. */
 export declare const IDENTIFY_ALL_LAYERS_ID = "__geolibre_identify_all_layers__";
+/** The Identify fields of the store, as set together by an Identify change. */
+interface IdentifyState {
+  identifyLayerId: string | null;
+  identifyLayerIds: string[] | null;
+}
+/**
+ * Resolve an Identify target against the layers that exist.
+ *
+ * Shared by the scripting `setIdentify` command and by project load, which
+ * applies a project's saved `interaction.identify` (issue #2688).
+ *
+ * @param target - A layer id, `"all"`, a list of layer ids, or null/undefined.
+ * @param layerIds - Ids of the layers currently in the project.
+ * @returns The store fields to set. Ids that name no layer are dropped; a list
+ *   that keeps one id becomes a single-layer target, and one that keeps several
+ *   becomes the all-layers mode restricted to those ids.
+ */
+export declare function resolveIdentifyTarget(target: string | readonly string[] | null | undefined, layerIds: Iterable<string>): IdentifyState;
+/**
+ * Whether the all-layers Identify mode may query a layer.
+ *
+ * @param layerId - The candidate layer's id.
+ * @param identifyLayerIds - The store's `identifyLayerIds` restriction.
+ * @returns True when there is no restriction or the layer is in it.
+ */
+export declare function identifyAllIncludes(layerId: string, identifyLayerIds: readonly string[] | null | undefined): boolean;
+/**
+ * Drop removed layers from the Identify state.
+ *
+ * @param state - The current Identify fields.
+ * @param removed - Ids of the layers being removed.
+ * @returns The Identify fields with those layers gone. A restricted all-layers
+ *   mode left with one layer narrows to it, and with none turns Identify off.
+ */
+export declare function identifyStateWithoutLayers(state: IdentifyState, removed: ReadonlySet<string>): IdentifyState;
 interface SessionSlice {
+  /** Local viewing switch; saved layer popup settings are left untouched. */
+  hoverTooltipsEnabled: boolean;
+  setHoverTooltipsEnabled: (enabled: boolean) => void;
   selectedLayerId: string | null;
   selectedFeatureId: string | null;
   /**
@@ -6932,6 +7427,14 @@ interface SessionSlice {
    * DuckDB query, WMS, COG, NetCDF image and time-slider raster alike.
    */
   identifyLayerId: string | null;
+  /**
+   * Layers the all-layers Identify mode is limited to, or null for every
+   * visible queryable layer. Set only alongside {@link IDENTIFY_ALL_LAYERS_ID},
+   * by a script or project that names several layers (issue #2688), and
+   * cleared by every `setIdentifyLayer` call so the in-app buttons keep their
+   * plain meaning.
+   */
+  identifyLayerIds: string[] | null;
   pointerCoords: [number, number] | null;
   /**
    * Ground elevation in true metres under the pointer, for the status bar
@@ -6965,6 +7468,8 @@ interface SessionSlice {
    */
   selectFeatures: (ids: string[], anchorId?: string | null) => void;
   setIdentifyLayer: (id: string | null) => void;
+  /** Set both Identify fields at once (see {@link resolveIdentifyTarget}). */
+  setIdentifyState: (state: IdentifyState) => void;
   setAttributeFilter: (filter: string) => void;
 }
 //#endregion
@@ -7944,6 +8449,89 @@ export declare function resolveThreeDTilesRequestHeaders(url: string, headers: R
  */
 export declare function persistedThreeDTilesRequestHeaders(url: string, headers: Record<string, string> | undefined): Record<string, string> | undefined;
 //#endregion
+//#region src/project-credential-refs.d.ts
+export declare function geocodingApiKeyAccount(providerId: string): string;
+export declare function environmentVariableAccount(key: string): string;
+/** Rows are secret unless explicitly marked `secret: false`. */
+export declare function isSecretEnvironmentVariable(variable: RuntimeEnvironmentVariable): boolean;
+type ProjectCredentialLookup = (account: string) => string | undefined;
+/** Install (or clear, with `null`) the source of stored project credentials. */
+export declare function setProjectCredentialLookup(lookup: ProjectCredentialLookup | null): void;
+/** The stored value for `account`, or `undefined` when none (or no lookup). */
+export declare function lookupProjectCredential(account: string): string | undefined;
+/** Fill empty geocoding API keys from the stored ones. */
+export declare function overlayStoredGeocodingApiKeys(geocoding: GeocodingPreferences): GeocodingPreferences;
+/** Fill empty secret environment variable values from the stored ones. */
+export declare function overlayStoredEnvironmentVariables(variables: RuntimeEnvironmentVariable[]): RuntimeEnvironmentVariable[];
+/** Preferences with every empty stored credential filled in. */
+export declare function overlayStoredPreferenceCredentials(preferences: ProjectPreferences): ProjectPreferences;
+/**
+ * The credential changes an edited Settings draft makes, keyed by account
+ * (`""` deletes).
+ *
+ * - `seeded`: the overlaid preferences the dialog opened with.
+ * - `next`: the normalized draft being saved.
+ *
+ * Only values the user changed are returned, so an untouched session override
+ * (plaintext from the opened file) stays out of the keychain and opening a
+ * file never writes it. Removing, renaming, or un-secreting a variable never
+ * deletes its stored value: names are shared by every project on the device.
+ * Clearing a field deletes the stored value only when the field showed that
+ * stored value; clearing a file override that differed from it just drops the
+ * override, so the shared value applies again and other projects keep it.
+ */
+export declare function changedPreferenceCredentials(seeded: ProjectPreferences, next: ProjectPreferences): Record<string, string>;
+/**
+ * Move unambiguous geocoding API keys and secret environment variable values
+ * out of `project` (a copy; the input is untouched) into `secrets`, keyed by
+ * account. Secret environment rows that have no unique name remain in the
+ * project for an explicit keep/strip choice. Layers pass through: their
+ * request headers reference variables as `${NAME}` rather than holding
+ * secrets that need moving.
+ */
+export declare function splitProjectCredentials(project: GeoLibreProject): {
+  project: GeoLibreProject;
+  secrets: Record<string, string>;
+};
+/**
+ * `headers` with every `${NAME}` resolved from the project's enabled
+ * Environment Variables (stored secret values filled in). Only those rows
+ * count, not the OS environment or build-time values that share the runtime
+ * env. A header referencing an unset variable is dropped.
+ */
+export declare function resolveProjectHeaderReferences(headers: Record<string, string> | undefined): Record<string, string> | undefined;
+//#endregion
+//#region src/header-references.d.ts
+/**
+ * `${NAME}` references in request header values.
+ *
+ * A header such as `Authorization: Bearer ${TILES_TOKEN}` is saved as typed
+ * and resolved from the project's Environment Variables when a request is
+ * made, so the secret itself never sits on the layer. This module is pure (no
+ * store import): `credentials.ts` depends on it, and the store depends on
+ * `credentials.ts`.
+ */
+export declare function hasHeaderReferences(headers: Record<string, string> | undefined): boolean;
+/**
+ * Whether `value` carries no secret of its own: at most a scheme word such as
+ * `Bearer` followed by a single `${NAME}`. Redaction keeps such values.
+ */
+export declare function isHeaderReferenceOnly(value: string): boolean;
+/**
+ * Whether credential-bearing request headers may be sent to `url`: HTTPS, or
+ * plain HTTP to loopback so a local dev server still works. The scheme is read
+ * off a parsed URL, so an unusually cased `HTTPS://` is not misread as
+ * plaintext; a relative or unparseable URL is refused.
+ */
+export declare function allowsCredentialHeaders(url: string): boolean;
+/**
+ * `headers` with every `${NAME}` replaced by `values[NAME]`. A header that
+ * references an unset (or empty) variable is omitted rather than sent with a
+ * hole in it. Returns the input unchanged when nothing references a variable,
+ * and `undefined` when no header remains.
+ */
+export declare function resolveHeaderReferences(headers: Record<string, string> | undefined, values: Readonly<Record<string, string>>): Record<string, string> | undefined;
+//#endregion
 //#region src/credentials.d.ts
 /**
  * Project fields whose values are credentials. Keep this registry as the
@@ -8189,5 +8777,5 @@ export declare function localFileName(path: string): string;
 /** Keep imported layers distinguishable, including within a multi-file import. */
 export declare function uniqueImportedLayerName(name: string, names: Iterable<string>): string;
 //#endregion
-export type { AppState, CesiumIonAssetKind, CesiumIonLayerOptions, CesiumIonQuickPick, CesiumIonQuickPickGroup, CesiumKmlLayerOptions, ConversionToolKind, CredentialRedactionResult, CzmlDocument, CzmlLayerOptions, CzmlPacket, CzmlSource, GeocodeMatch, GeocodeRequest, GeocodeStatus, GeocoderConfig, GeocodingPreferenceInput, GeocodingProvider, GeocodingProviderId, GpsStatusFix, LayerSummary, NetworkToolKind, NominatimForwardResult, NominatimReverseResult, RasterToolKind, ReverseGeocodeDisplay, StatisticsToolKind, VectorToolKind };
+export type { AppState, CesiumIonAssetKind, CesiumIonLayerOptions, CesiumIonQuickPick, CesiumIonQuickPickGroup, CesiumKmlLayerOptions, ConversionToolKind, CredentialRedactionResult, CzmlDocument, CzmlLayerOptions, CzmlPacket, CzmlSource, GeocodeMatch, GeocodeRequest, GeocodeStatus, GeocoderConfig, GeocodingPreferenceInput, GeocodingProvider, GeocodingProviderId, GpsStatusFix, IdentifyState, LayerSummary, NetworkToolKind, NominatimForwardResult, NominatimReverseResult, ProjectCredentialLookup, RasterToolKind, ReverseGeocodeDisplay, StatisticsToolKind, VectorToolKind };
 //# sourceMappingURL=index.d.mts.map