@zwishing/emap 0.1.0

package/dist/geo/bounds.d.ts

@@ -0,0 +1,18 @@
+export declare class Bounds {
+    xmin: number;
+    ymin: number;
+    xmax: number;
+    ymax: number;
+    constructor(xmin?: number, ymin?: number, xmax?: number, ymax?: number);
+    static fromArray(arr: [number, number, number, number]): Bounds;
+    get width(): number;
+    get height(): number;
+    get centerX(): number;
+    get centerY(): number;
+    hasBounds(): boolean;
+    clone(): Bounds;
+    mergePoint(x: number, y: number): void;
+    merge(other: Bounds): void;
+    fillOut(aspect: number, focusX?: number, focusY?: number): this;
+    scale(k: number): void;
+}

package/dist/geo/crs-resolver.d.ts

@@ -0,0 +1,35 @@
+import type { MapshaperDataset } from '../types/mapshaper-types';
+/** Default fallback when no metadata identifies a CRS. */
+export declare const DEFAULT_CRS = "EPSG:4326";
+/**
+ * Resolve a canonical CRS identifier (typically `EPSG:NNNN` or a passthrough
+ * label) for a mapshaper dataset.
+ *
+ * Lookup order, first hit wins:
+ *
+ *   1. `info.crs_string` — normalised via {@link normalizeCrsString}.
+ *   2. `info.prj` (raw WKT) — `AUTHORITY["EPSG", "..."]` clause first;
+ *      then Web-Mercator / WGS84 datum heuristics.
+ *   3. `info.crs` (mapshaper's parsed Proj4 descriptor) —
+ *      `is_latlong` ⇒ EPSG:4326; spheroid `merc` + `a=6378137` ⇒ EPSG:3857.
+ *   4. {@link DEFAULT_CRS}.
+ */
+export declare function resolveDatasetCRS(dataset: MapshaperDataset | undefined): string;
+/**
+ * Map a free-text CRS label (`'wgs84'`, `'webmercator'`, `'epsg:4326'`, …)
+ * onto a canonical `EPSG:NNNN` string. Inputs that already look canonical
+ * are upper-cased; everything else passes through upper-cased so callers
+ * still see a stable shape they can branch on.
+ */
+export declare function normalizeCrsString(str: string): string;
+/**
+ * Heuristic-extract a CRS identifier from a raw WKT `.prj` body.
+ * Returns `null` when nothing matches; callers fall through to the next
+ * resolver stage.
+ *
+ * Recognised:
+ *   - `AUTHORITY["EPSG", "<code>"]` anywhere in the body → `EPSG:<code>`.
+ *   - Web-Mercator name fragments → `EPSG:3857`.
+ *   - WGS_1984 datum + GEOGCS top-level → `EPSG:4326`.
+ */
+export declare function inferFromPrj(prj: string): string | null;

package/dist/geo/projection.d.ts

@@ -0,0 +1,28 @@
+import { Bounds } from './bounds';
+import { TopologySource } from '../source/source';
+/**
+ * Projection manages the coordinate reference system and provides
+ * coordinate conversion between CRS-specific units and view-agnostic
+ * representations.
+ */
+export declare class Projection {
+    private _crs;
+    get crs(): string;
+    setCRS(crs: string): void;
+    /**
+     * Compute the map center in geographic coordinates.
+     * For Web Mercator, converts projected coords to lat/lng.
+     */
+    getCenter(cx: number, cy: number): [number, number];
+    /**
+     * Compute a zoom level from the scale factor.
+     * Only meaningful for Web Mercator.
+     */
+    getZoom(mx: number): number;
+    /**
+     * Reproject all sources to a target CRS.
+     * Returns the merged extent of all reprojected layers.
+     */
+    reproject(targetCrs: string, sources: globalThis.Map<string, TopologySource>): Promise<Bounds>;
+    private _webMercatorToLatLng;
+}

package/dist/geo/transform.d.ts

@@ -0,0 +1,19 @@
+import { Bounds } from './bounds';
+/**
+ * Pure affine 2D transformation: scale + translate.
+ * Represents the matrix [mx 0 bx; 0 my by; 0 0 1].
+ */
+export declare class AffineTransform {
+    mx: number;
+    my: number;
+    bx: number;
+    by: number;
+    constructor(mx?: number, my?: number, bx?: number, by?: number);
+    static fromBounds(src: Bounds, dst: Bounds, flipY?: boolean): AffineTransform;
+    project(x: number, y: number): [number, number];
+    unproject(px: number, py: number): [number, number];
+    translate(dx: number, dy: number): void;
+    scale(k: number, px: number, py: number): void;
+    clone(): AffineTransform;
+}
+export { AffineTransform as Transform };

package/dist/geo/viewport.d.ts

@@ -0,0 +1,52 @@
+import { AffineTransform } from './transform';
+import { Bounds } from './bounds';
+/**
+ * Viewport owns the affine transform that maps data coordinates to screen
+ * pixels.  It handles zoom animation, pan constraints, and LOD parameters.
+ */
+export declare class Viewport {
+    private _transform;
+    private _extent;
+    private _width;
+    private _height;
+    private _initialMX;
+    private _initialExtent;
+    private _zoomTween;
+    private _zoomFocus;
+    private _animatingTransform;
+    /** Callback fired whenever the view changes (move / zoom) */
+    onViewChange: (() => void) | null;
+    private _crs;
+    setCRS(crs: string): void;
+    get transform(): AffineTransform;
+    get extent(): Bounds;
+    get width(): number;
+    get height(): number;
+    get initialMX(): number;
+    updateSize(width: number, height: number): void;
+    setExtent(bounds: Bounds): void;
+    reset(): void;
+    clearInitialState(): void;
+    private _updateTransform;
+    pan(dx: number, dy: number): void;
+    cancelZoomAnimation(): void;
+    applyWheelZoom(direction: number, multiplier: number, x: number, y: number): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    private _zoomTo;
+    /** Connect the zoom tween – call once during init */
+    initZoomTween(): void;
+    project(x: number, y: number): [number, number];
+    unproject(px: number, py: number): [number, number];
+    getLineScale(): number;
+    getArcFilter(arcs: {
+        arcIsSmaller?(i: number, minLen: number): boolean;
+        arcIntersectsBBox?(i: number, bbox: number[]): boolean;
+    }): (i: number) => boolean;
+    getViewBounds(): number[] | null;
+    private _getViewBounds;
+    private _applyConstraints;
+    private _getMaxMX;
+    private _getStrictBounds;
+    private _getMinMX;
+}

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+import './shim';
+import 'mapshaper';
+export { Emap } from './map/map';
+export type { ExpressionEvaluationPolicy, QueryFeaturesOptions, QueriedFeature, FeatureRef, HighlightFeatureRef, HighlightStyle, FeatureTranslateSession, FeatureAffineSession, ClipEraseOptions, DissolveOptions, CleanOptions, BufferOptions, ApplyExpressionOptions, ExplodeOptions, InnerlinesOptions, FilterOptions, FilterIslandsOptions, FilterSliversOptions, FilterGeomOptions, AffineLayerOptions, DataFillOptions, SnapOptions, MosaicOptions, UnionOptions, DivideOptions, PointsOptions, PointsMode, LinesOptions, PolygonsOptions, SimplifyOptions, SimplifyMethod, ProjectOptions, RebuildTopologyOptions, RenameLayerOptions, MergeLayersOptions, SplitLayerOptions, DropLayerOptions, SortFeaturesOptions, UniqueFeaturesOptions, FilterFieldsOptions, RenameFieldsOptions, JoinTableOptions, JoinTableData, CheckGeometryOptions, GeometryCheckReport, IntersectionPointsLayerOptions, ExportSnapshotOptions, LoadSnapshotOptions, } from './map/map';
+export type { LayerSpecification, LayerType, LayerPaint, LayerLayout, FillPaint, LinePaint, CirclePaint, } from './map/layer';
+export { resolveStrokeStyle, resolvePointStyle } from './map/layer';
+export { HighlightManager } from './map/highlight-manager';
+export { Selection } from './map/selection';
+export type { SelectMode, SelectionDiff, SelectionSnapshot } from './map/selection';
+export { FeatureQuery } from './map/feature-query';
+export { FeatureAccessor } from './map/feature-accessor';
+export type { Feature } from './map/feature-accessor';
+export { Err, OK, okValue } from './map/op-result';
+export type { OpError, OpResult } from './map/op-result';
+export { quoteCliArg, isValidLayerName, isValidFieldName, findInvalidFieldName, } from './map/command-args';
+export type { ArcCollection, ArcIterator, ArcVertexData, Coord2, DataTable, FeatureShape, GeometryType, LegacyPointShape, MapshaperDataset, MapshaperLayer, PathGeometryType, PathLayer, PathPart, PathShape, PointLayer, PointShape, PointStyle, SignedArcId, StrokeStyle, VertexDotStyle, } from './types/mapshaper-types';
+export { isPathLayer, isPointLayer, bumpEditVersion } from './types/mapshaper-types';
+export { DefaultMapshaperAdapter, getDefaultMapshaperAdapter, setDefaultMapshaperAdapter, } from './adapter/mapshaper-adapter';
+export type { ExportedFile, MapshaperAdapter, MapshaperBBox, PackedSession, RunnerInputFiles, SegmentIntersection, } from './adapter/mapshaper-adapter';
+export { MapshaperWorkerPool } from './core/mapshaper-worker-pool';
+export type { MapshaperWorkerPoolOptions } from './core/mapshaper-worker-pool';
+export { TopologySource } from './source/topology-source';
+export type { TopologySourceData, TopologySourceInput, TopologySourceOptions, ZipExtractionLimits, } from './source/topology-source';
+export type { TopologySource as ITopologySource, ExportFormat, ExportOptions } from './source/source';
+export { Bounds } from './geo/bounds';
+export { AffineTransform, AffineTransform as Transform } from './geo/transform';
+export { Viewport } from './geo/viewport';
+export { Projection } from './geo/projection';
+export { DEFAULT_CRS, inferFromPrj, normalizeCrsString, resolveDatasetCRS, } from './geo/crs-resolver';
+export { CanvasPainter } from './renderer/canvas-painter';
+export { EditOverlayRenderer } from './renderer/edit-overlay-renderer';
+export { EventDispatcher } from './core/events';
+export type { EventListener } from './core/events';
+export { DragPanHandler } from './core/drag-pan-handler';
+export type { EditCommand } from './edit/edit-command';
+export { EditHistory } from './edit/edit-history';
+export type { HistoryStateSnapshot, EditHistoryOptions } from './edit/edit-history';
+export { Transaction } from './edit/transaction';
+export { ValidatorRegistry } from './validation/registry';
+export type { Validator, ValidatorPhase, ValidatorResult, ValidationChange, ValidationIssue, ValidationReport, } from './validation/validator';
+export { topologyValidator } from './validation/builtin/topology';
+export type { TopologyValidatorOptions } from './validation/builtin/topology';
+export { VertexMoveCommand } from './edit/commands/vertex-move';
+export { VertexInsertCommand } from './edit/commands/vertex-insert';
+export { VertexDeleteCommand } from './edit/commands/vertex-delete';
+export { FeatureCreateCommand } from './edit/commands/feature-create';
+export { FeatureDeleteCommand, BulkFeatureDeleteCommand } from './edit/commands/feature-delete';
+export type { FeatureDeleteCommandOptions, BulkFeatureDeleteCommandOptions, } from './edit/commands/feature-delete';
+export { FeatureTranslateCommand } from './edit/commands/feature-translate';
+export type { FeatureTranslateCommandOptions, TranslatedPointFeature, } from './edit/commands/feature-translate';
+export { FeatureAffineCommand, rotateMatrix, scaleMatrix, invertMatrix, composeMatrix, IDENTITY_MATRIX, } from './edit/commands/feature-affine';
+export type { FeatureAffineCommandOptions, AffineMatrix, } from './edit/commands/feature-affine';
+export { SplitSharedArcsCommand, planSharedArcSplit } from './edit/commands/split-shared-arcs';
+export type { SplitSharedArcsCommandOptions, SplitSharedArcsRemap, AppendedArc, } from './edit/commands/split-shared-arcs';
+export { CompositeCommand } from './edit/commands/composite';
+export { DatasetReplaceCommand } from './edit/commands/dataset-replace';
+export type { DatasetReplaceCommandOptions } from './edit/commands/dataset-replace';
+export { FeaturePropertyChangeCommand } from './edit/commands/feature-property-change';
+export type { FeaturePropertyChangeCommandOptions } from './edit/commands/feature-property-change';
+export { FieldAddCommand } from './edit/commands/field-add';
+export type { FieldAddCommandOptions } from './edit/commands/field-add';
+export { FieldRemoveCommand } from './edit/commands/field-remove';
+export type { FieldRemoveCommandOptions } from './edit/commands/field-remove';
+export { FieldRenameCommand } from './edit/commands/field-rename';
+export type { FieldRenameCommandOptions } from './edit/commands/field-rename';
+export type { Control, ControlPosition } from './ui/control';
+export { NavigationControl } from './ui/navigation-control';
+export type { NavigationOptions } from './ui/navigation-control';
+export { StatusControl } from './ui/status-control';
+export type { StatusOptions } from './ui/status-control';
+export { BasemapControl } from './ui/basemap-control';
+export type { BasemapOptions, BasemapStyle } from './ui/basemap-control';
+export { VertexEditControl } from './ui/vertex-edit-control';
+export type { VertexEditControlOptions } from './ui/vertex-edit-control';
+export { EditToolbar } from './ui/edit-toolbar';
+export type { EditToolbarOptions } from './ui/edit-toolbar';
+export { DrawFeatureControl } from './ui/draw-feature-control';
+export type { DrawFeatureControlOptions, DrawGeometryType } from './ui/draw-feature-control';
+export { HistoryControl } from './ui/history-control';
+export type { HistoryControlOptions } from './ui/history-control';
+export { BoxSelectControl } from './ui/box-select-control';
+export type { BoxSelectControlOptions, BoxSelectStyle } from './ui/box-select-control';
+export { LassoSelectControl, pointInPolygon, featureMatchesLasso, } from './ui/lasso-select-control';
+export type { LassoSelectControlOptions, LassoSelectStyle } from './ui/lasso-select-control';
+export { SimplifyControl } from './ui/simplify-control';
+export type { SimplifyControlOptions } from './ui/simplify-control';

package/dist/map/attribute-ops.d.ts

@@ -0,0 +1,61 @@
+import type { FeatureRef } from './types';
+import type { EmapHostInternal } from './emap-host';
+import { type OpResult } from './op-result';
+/**
+ * Attribute-editing manager. Owned by Emap and exposed as `emap.attributes`.
+ * Construction takes the host Emap; the manager calls back into a small
+ * surface of internal helpers (`layers.resolve`, `_history`, ...) on the host.
+ *
+ * Every method returns `OpResult<void>` — `{ ok: true, value: undefined }` on
+ * success, `{ ok: false, error: OpError }` for unresolvable refs or no-op
+ * calls. Errors carry a structured `kind` so UIs can branch on the cause.
+ */
+export declare class AttributeOps {
+    private _emap;
+    constructor(_emap: EmapHostInternal);
+    setFeatureProperty(ref: FeatureRef, key: string, value: unknown): OpResult;
+    /**
+     * Set multiple properties on one feature in a single undo entry.
+     *
+     * Per-key semantics:
+     * - `props[key] === undefined` → delete the key from the record
+     * - any other value → set / overwrite the key
+     *
+     * Returns a `validation` error when every key already has the requested
+     * value (no-op call); no command is pushed and no events fire.
+     */
+    setFeatureProperties(ref: FeatureRef, props: Record<string, unknown>): OpResult;
+    /**
+     * Add a new column to a layer's data table. Records that already carry the
+     * key are skipped (and not rolled back by undo). `defaultValue` defaults to
+     * `null`. Returns a `not-found` error when the source / target / data table
+     * cannot be resolved.
+     */
+    addField(opts: {
+        source: string;
+        target: string;
+        field: string;
+        defaultValue?: unknown;
+    }): OpResult;
+    /**
+     * Drop a column from a layer's data table. Per-record values are
+     * snapshotted for undo so removing the field is fully reversible.
+     */
+    removeField(opts: {
+        source: string;
+        target: string;
+        field: string;
+    }): OpResult;
+    /**
+     * Rename a column on every record in a layer. Refuses with a `validation`
+     * error when any record already carries both `from` and `to` so silent
+     * overwrites are impossible. Use `removeField(to)` first if that is the
+     * intent.
+     */
+    renameField(opts: {
+        source: string;
+        target: string;
+        from: string;
+        to: string;
+    }): OpResult;
+}

package/dist/map/command-args.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Escape a value for embedding inside a double-quoted CLI argument.
+ *
+ * Wraps the result in `"..."`. Inside the quotes:
+ *   - `\` → `\\`
+ *   - `"` → `\"`
+ *   - `\n` / `\r` / `\t` / `\0` → escaped escape sequences. `\n`/`\r`
+ *     would otherwise terminate mapshaper's argument scan; `\0` would
+ *     truncate the C-style strings inside mapshaper-vendor's bundled
+ *     mproj. Other control chars (U+0001..U+001F minus the ones above)
+ *     get rejected by validators upstream so they never reach here.
+ *
+ * The function does NOT validate the argument is identifier-safe — it only
+ * makes whatever you hand it round-trip safely through mapshaper's quote
+ * stripper. Pair it with {@link isValidLayerName} / {@link isValidFieldName}
+ * for inputs that are supposed to be identifiers.
+ */
+export declare function quoteCliArg(value: string): string;
+/** True iff `value` looks like a safe mapshaper layer name. */
+export declare function isValidLayerName(value: unknown): value is string;
+/** True iff `value` looks like a safe mapshaper field name. */
+export declare function isValidFieldName(value: unknown): value is string;
+/**
+ * Validate a list of field names. Returns `null` on success or the FIRST
+ * offending name as a structured-friendly error tuple. Empty arrays are
+ * permitted (caller decides whether to reject).
+ */
+export declare function findInvalidFieldName(values: ReadonlyArray<unknown>): string | null;

package/dist/map/edit-sessions.d.ts

@@ -0,0 +1,97 @@
+import { type TranslatedPointFeature } from '../edit/commands/feature-translate';
+import { type AffineMatrix } from '../edit/commands/feature-affine';
+import { SplitSharedArcsCommand } from '../edit/commands/split-shared-arcs';
+import type { TopologySource } from '../source/source';
+import type { EmapHostInternal } from './emap-host';
+import { type OpResult } from './op-result';
+import type { DragSessionOptions, FeatureTranslateSession, FeatureAffineSession } from './types';
+/**
+ * Selection-editing manager. Owned by Emap and exposed as `emap.editSession`.
+ * Provides translate / rotate / scale operations on the current selection
+ * plus the live "drag" sessions (see {@link FeatureTranslateSession}).
+ */
+export declare class EditSessions {
+    private _emap;
+    constructor(_emap: EmapHostInternal);
+    translateSelected(dx: number, dy: number): OpResult;
+    /**
+     * Begin a translate "drag session" against the current selection.
+     *
+     * The session lets a UI animate a translate (e.g. follow the cursor)
+     * without spamming the undo stack with one entry per mousemove. Geometry
+     * mutates on every `move(dx, dy)`; only `commit()` pushes a single
+     * cumulative `FeatureTranslateCommand` (or `CompositeCommand`) to history.
+     * `cancel()` rolls the geometry back to the pre-session state and
+     * pushes nothing.
+     *
+     * Returns `null` when the selection is empty. The session captures the
+     * selection at start time — concurrent edits to the selection during
+     * a drag are intentionally ignored.
+     */
+    /**
+     * Shared scaffolding for translate/affine sessions: groups the active
+     * selection by source into buckets of `(arcIds, pointFeatures)`, and
+     * (when `splitShared` is true) duplicates any arc shared with an
+     * unselected feature so the drag doesn't drag the neighbour along.
+     *
+     * Returns `null` for an empty / fully-resolved-empty selection. The
+     * returned `splitCmds` have already been `do()`-applied; the caller
+     * must push them onto a composite at commit and call `undo()` on
+     * cancel.
+     */
+    _buildSelectionBuckets(splitShared: boolean): {
+        buckets: Array<{
+            sourceId: string;
+            source: TopologySource;
+            arcIds: number[];
+            pointFeatures: TranslatedPointFeature[];
+        }>;
+        splitCmds: SplitSharedArcsCommand[];
+    } | null;
+    beginTranslateSession(opts?: DragSessionOptions): FeatureTranslateSession | null;
+    /**
+     * Begin a rotate / scale / arbitrary-affine "drag session" against the
+     * current selection. Same one-history-entry-per-drag semantics as
+     * {@link beginTranslateSession}, but the per-frame delta is an arbitrary
+     * affine matrix (typically `rotateMatrix(theta, ox, oy)` or
+     * `scaleMatrix(sx, sy, ox, oy)` with the session's `origin`).
+     *
+     * The pivot is captured at session start: pass `origin` explicitly or let
+     * it default to the selection bbox centroid. Subsequent matrices should
+     * use the same pivot; otherwise the cumulative composed matrix on commit
+     * won't match the visually applied sequence.
+     */
+    beginAffineSession(this: any, origin?: [number, number], opts?: DragSessionOptions): FeatureAffineSession | null;
+    /**
+     * Rotate every selected feature around `origin` by `angleDegrees`.
+     * Default `origin` is the bbox centroid of the affected vertices.
+     *
+     * Lightweight in-place transform on the same path as `translateSelected`:
+     * not a history barrier, selection survives, multi-source selections wrap
+     * in a `CompositeCommand`. Returns `false` for empty selection or zero
+     * angle.
+     */
+    rotateSelected(angleDegrees: number, origin?: [number, number]): OpResult;
+    /**
+     * Scale every selected feature by `(sx, sy)` around `origin`.
+     * `sy` defaults to `sx` (uniform scale). Default `origin` is the bbox
+     * centroid of the affected vertices.
+     */
+    scaleSelected(sx: number, sy?: number, origin?: [number, number]): OpResult;
+    /**
+     * Shared scaffolding for rotate / scale: walks the current selection,
+     * groups by source, computes the bbox centroid (when no origin supplied),
+     * builds one `FeatureAffineCommand` per source, and pushes either the
+     * single command or a `CompositeCommand` wrapping all sources.
+     */
+    _applyAffineToSelection(this: any, matrixForOrigin: (ox: number, oy: number) => AffineMatrix, origin: [number, number] | undefined, labelFor: (totalFeatures: number) => string): OpResult;
+    /**
+     * Compute the bbox centroid of every vertex the bySource buckets reference
+     * (across path-feature arcs and point-feature shapes). Returns `null` when
+     * no vertex was found (e.g., empty arcs).
+     */
+    _computeSelectionCentroid(this: any, bySource: globalThis.Map<string, {
+        arcIdSet: Set<number>;
+        pointFeatures: TranslatedPointFeature[];
+    }>): [number, number] | null;
+}

package/dist/map/edit-state-store.d.ts

@@ -0,0 +1,41 @@
+import type { EditVertexState, EditDrawState } from './types';
+export type EditMode = 'none' | 'vertex' | 'draw';
+export interface EditStateSnapshot {
+    mode: EditMode;
+    vertex: EditVertexState | null;
+    draw: EditDrawState | null;
+}
+export interface EditStateChange {
+    /** Snapshot after the mutation. */
+    current: EditStateSnapshot;
+    /** Mode before the mutation. Equal to `current.mode` for non-mode mutations. */
+    previousMode: EditMode;
+    /** True iff `current.mode !== previousMode`. */
+    modeChanged: boolean;
+}
+/**
+ * Single source of truth for edit-mode state. The owner (Emap) supplies
+ * an `onChange` callback at construction; the store calls it on every
+ * effective mutation so the owner can re-render, toggle the drag-pan
+ * gesture, and emit `editmodechange` exactly once.
+ *
+ * Invariant: vertex/draw state is auto-cleared whenever the mode leaves
+ * the corresponding edit mode, so a stale `setEditMode('none')` no
+ * longer leaks the previous overlay into the next frame.
+ */
+export declare class EditStateStore {
+    private _onChange;
+    private _mode;
+    private _vertex;
+    private _draw;
+    constructor(_onChange: (change: EditStateChange) => void);
+    get mode(): EditMode;
+    get vertex(): EditVertexState | null;
+    get draw(): EditDrawState | null;
+    setMode(mode: EditMode): void;
+    setVertex(state: EditVertexState | null): void;
+    clearVertex(): void;
+    setDraw(state: EditDrawState | null): void;
+    clearDraw(): void;
+    private _fire;
+}

package/dist/map/emap-host.d.ts

@@ -0,0 +1,79 @@
+import type { TopologySource } from '../source/source';
+import type { MapshaperWorkerPool } from '../core/mapshaper-worker-pool';
+import type { EditHistory } from '../edit/edit-history';
+import type { TransactionInternal } from '../edit/transaction';
+import type { Selection } from './selection';
+import type { MapshaperLayer } from '../types/mapshaper-types';
+import type { LayerRegistry } from './layer-registry';
+import type { ValidatorRegistry } from '../validation/registry';
+/**
+ * Sentinel returned by `_runDatasetCommand` callers when the host has
+ * been removed mid-await. Managers interpret this as "drop the result on
+ * the floor, do not mutate state, do not emit events".
+ */
+export declare const HOST_REMOVED: unique symbol;
+export interface EmapHostInternal {
+    /** `true` once `Emap.remove()` has been called. Async ops MUST check
+     *  this before applying results. */
+    readonly _removed: boolean;
+    readonly _sources: globalThis.Map<string, TopologySource>;
+    readonly _history: EditHistory;
+    readonly _selection: Selection;
+    /**
+     * Currently active {@link Transaction}, or `null`. Set by
+     * `Transaction`'s constructor and cleared on commit / rollback. The
+     * runner consults this in `_applyDatasetReplace` to record per-source
+     * first-touch snapshots — kept on the host (rather than threaded
+     * through `OpContext`) so existing op signatures don't have to learn
+     * about transactions.
+     */
+    _activeTransaction: TransactionInternal | null;
+    /**
+     * Validator registry — owns the set of post-commit validators (e.g.
+     * topology checks, attribute schemas). The Emap instance listens to
+     * its own `historychange` event and asks the registry to run every
+     * `'after-commit'` validator; failures fire `validationfailed`.
+     */
+    readonly _validators: ValidatorRegistry;
+    readonly _workerPool: MapshaperWorkerPool | null;
+    readonly _workerMode: boolean | 'auto';
+    readonly _workerThreshold: number;
+    readonly _workerRouting?: import('./worker-routing').WorkerRoutingFn;
+    /**
+     * Single source of truth for `(sourceId, layerId) → MapshaperLayer`
+     * resolution. Replaces the legacy `_resolveLayer` method on the host;
+     * managers should prefer `host.layers.resolve(...)` going forward.
+     */
+    readonly layers: LayerRegistry;
+    /**
+     * @deprecated Use `host.layers.resolve(sourceId, layerId)` instead. Kept
+     * as a thin shim for one release so in-flight refactors don't all need
+     * to land at once.
+     */
+    _resolveLayer(sourceId: string, layerId: string): MapshaperLayer | null;
+    _scheduleRender(): void;
+    _fireHistoryChange(): void;
+    _fireSelectionChange(diff: import('./selection').SelectionDiff): void;
+    _invalidateShapeCachesForSources(sourceIds: Iterable<string>): void;
+    _clearSpatialIndexesForSources(sourceIds: Iterable<string>): void;
+    _allowExpressionEvaluation(values: Array<string | undefined>, operation: string): boolean;
+    fire(type: 'error', payload: {
+        error: unknown;
+    }): void;
+    fire(type: 'workerjobstart', payload: {
+        id: number;
+        cmd: string;
+        label: string;
+        datasetVertexCount: number;
+    }): void;
+    fire(type: 'workerjobend', payload: {
+        id: number;
+        ok: boolean;
+        durationMs: number;
+        errorMessage?: string;
+    }): void;
+    fire(type: 'validationfailed', payload: {
+        results: import('../validation/validator').ValidatorResult[];
+        label: string;
+    }): void;
+}

package/dist/map/feature-accessor.d.ts

@@ -0,0 +1,43 @@
+import type { FeatureRef } from './types';
+import type { PathShape, PointShape, LegacyPointShape } from '../types/mapshaper-types';
+import type { EmapHostInternal } from './emap-host';
+/**
+ * Read-only view of a single feature — geometry + frozen properties.
+ * Returned by every successful {@link FeatureAccessor.get} / `iter`
+ * call. The `properties` object is `Object.freeze`d so accidental
+ * mutation by the caller can't bleed back into the underlying dataset
+ * record.
+ */
+export interface Feature {
+    ref: FeatureRef;
+    /**
+     * Geometry shape for this feature, or `null` when the feature row
+     * exists but has no geometry attached (legal in mapshaper for
+     * data-only layers and for explicit holes in some pipelines).
+     */
+    geometry: PathShape | PointShape | LegacyPointShape | null;
+    /** Frozen view of the row's attribute record (or empty object). */
+    properties: Readonly<Record<string, unknown>>;
+}
+/**
+ * Read-only feature lookups. Hangs off `Emap.features`. Stateless
+ * beyond the host reference; safe to call from any phase.
+ */
+export declare class FeatureAccessor {
+    private readonly _host;
+    constructor(_host: EmapHostInternal);
+    /**
+     * Look up one feature by reference. Returns `null` if the source,
+     * layer, or id can't be resolved (instead of throwing) so call sites
+     * can write `if (!f) skip` ergonomically.
+     */
+    get(ref: FeatureRef): Feature | null;
+    /**
+     * Iterate every feature in `(sourceId, layerId)`. Yields nothing if
+     * the layer doesn't resolve or has no shapes. Each yielded `Feature`
+     * is a fresh allocation — safe to retain across iterations.
+     */
+    iter(sourceId: string, layerId: string): IterableIterator<Feature>;
+    /** Number of features in the layer, or `0` for unresolved layers. */
+    count(sourceId: string, layerId: string): number;
+}

package/dist/map/feature-query.d.ts

@@ -0,0 +1,58 @@
+import { AffineTransform } from '../geo/transform';
+import { TopologySource } from '../source/source';
+import type { QueryFeaturesOptions, QueriedFeature } from './map';
+/**
+ * Handles spatial feature queries (point hit-testing, bbox selection).
+ * Extracted from Emap to keep the map class focused on coordination.
+ */
+export declare class FeatureQuery {
+    private _sources;
+    private _getTransform;
+    private _getSize;
+    private _getInitialMX;
+    private _indexCache;
+    constructor(sources: globalThis.Map<string, TopologySource>, getTransform: () => AffineTransform, getSize: () => {
+        width: number;
+        height: number;
+    }, getInitialMX: () => number);
+    /**
+     * Eagerly build spatial indexes for every layer of one source (or all
+     * sources when omitted). Idempotent — already-cached entries are
+     * skipped. Used by `Emap.prebuildSpatialIndex` to pay the build cost
+     * in idle time before the first user query.
+     */
+    prebuild(sourceId?: string): void;
+    /**
+     * Drop cached spatial indexes for one source (or all). Necessary after
+     * in-place geometry edits (translateSelected, vertex commands) that
+     * mutate arc coordinates without changing shape / arc counts — without
+     * this call, the cache key wouldn't notice and queries would return
+     * prefilter-stale results.
+     */
+    clear(sourceId?: string): void;
+    private _prebuildSource;
+    /**
+     * Lazily build a Flatbush index for one layer, cached by
+     * (sourceId, layerIndex, shapeCount, arcCount). Returns `null` for
+     * shape-less layers — caller falls back to the no-index loop.
+     *
+     * Per-shape bbox: point layers union of their coords; path layers
+     * union of `arcs.getSimpleShapeBbox()` over each part. Same precision
+     * as the existing inline test, just memoized.
+     */
+    private _getOrBuildIndex;
+    query(geometryOrOptions?: [number, number] | [[number, number], [number, number]] | QueryFeaturesOptions, options?: QueryFeaturesOptions, visibleLayers?: Set<string>): QueriedFeature[];
+    private _layerMatchesFilter;
+    private _unproject;
+    private _getHitBuffer;
+    private _getZoomAdjustedHitBuffer;
+    private _findHitCandidates;
+    private _sortByDistance;
+    private _pickNearestCandidates;
+    private _pointTest;
+    private _polylineTest;
+    private _polygonTest;
+    private _polygonVertexTest;
+    private _queryFeaturesAtPoint;
+    private _queryFeaturesInBBox;
+}