@zwishing/emap 0.1.0

package/dist/core/interactions.d.ts

@@ -0,0 +1,20 @@
+import { EventDispatcher } from './events';
+export declare class MouseWheel extends EventDispatcher {
+    private _element;
+    private _active;
+    private _timer;
+    private _sustainInterval;
+    private _fadeDelay;
+    private _eventTime;
+    private _getAverageRate;
+    private _getWheelDirection;
+    private _wheelDirection;
+    private _mouseX;
+    private _mouseY;
+    private _wheelHandler;
+    constructor(_element: HTMLElement);
+    destroy(): void;
+    private _updateSustainInterval;
+    private _handleWheel;
+    private _onTick;
+}

package/dist/core/mapshaper-worker-pool.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Worker pool that runs mapshaper commands off-thread.
+ *
+ * Wire protocol matches `src/worker/mapshaper-worker.ts`:
+ *
+ *   main → worker:  { id, type: 'run', cmd, packed, inputFiles? }
+ *   worker → main:  { id, type: 'ok', packed }
+ *                |  { id, type: 'error', message }
+ *
+ * **Concurrency model**: the pool maintains N workers (default 1).
+ * mapshaper itself is not reentrant inside ONE worker — it shares
+ * module-level state (parser tables, internal caches) across calls,
+ * which is why the worker entry serialises via an internal queue.
+ * Across DIFFERENT workers there is no shared state: each worker hosts
+ * its own mapshaper instance, so the pool can run `poolSize` jobs in
+ * true parallel as long as the underlying datasets are independent.
+ *
+ * Dispatch picks the worker with the fewest in-flight requests; ties
+ * break by round-robin index so the load distribution is stable and
+ * predictable.
+ *
+ * Lazy worker spawn: the underlying `Worker`s are constructed on
+ * demand, not at pool construction. Cheap to keep an unused pool
+ * around; useful for callers that toggle `useWorker` at runtime.
+ */
+export interface MapshaperWorkerPoolOptions {
+    /**
+     * URL of the worker bundle (`emap-worker.js`). Resolved by the browser
+     * the same way as any `new Worker(url)` argument — pass the absolute or
+     * page-relative URL where the file is served.
+     */
+    workerUrl: string;
+    /**
+     * Optional override for the `Worker` constructor itself. Used by tests
+     * to inject a `MockWorker`. Defaults to the global `Worker`.
+     */
+    WorkerCtor?: typeof Worker;
+    /**
+     * Number of worker threads to maintain. Each adds its own mapshaper
+     * instance, so peak parallelism = `poolSize`. Default `1` to keep
+     * the historical single-worker semantics; set to e.g.
+     * `navigator.hardwareConcurrency - 1` to scale.
+     *
+     * Workers spawn lazily as load grows; constructing a pool with
+     * `poolSize: 4` does NOT immediately spawn 4 workers — only the
+     * first dispatch creates one, the second creates a second only if
+     * the first is busy, and so on.
+     */
+    poolSize?: number;
+}
+/**
+ * Wire-format ParsedCommand. Mirrors `mapshaper.internal.parseCommands(...)`
+ * output: `{ name: kebab-case, options: snake_case key/values }`. Plain
+ * data, structured-clone friendly.
+ */
+export interface ParsedCommandWire {
+    name: string;
+    options: Record<string, unknown>;
+}
+export declare class MapshaperWorkerPool {
+    private _workerUrl;
+    private _WorkerCtor;
+    private _slots;
+    private _pending;
+    private _nextId;
+    /** Round-robin tie-breaker pointer for dispatch. */
+    private _rrCursor;
+    private _destroyed;
+    constructor(opts: MapshaperWorkerPoolOptions);
+    /**
+     * Send a command + packed dataset to the worker pool and resolve with
+     * the packed result. Each call gets a unique correlation id so multiple
+     * in-flight requests don't cross wires.
+     */
+    run(cmdOrCommands: string | ParsedCommandWire[], packed: any, inputFiles?: Record<string, Uint8Array | string>): Promise<any>;
+    /**
+     * Same as {@link run}, but also surfaces the correlation id synchronously
+     * so the caller can fire an event referencing the id BEFORE the promise
+     * resolves. Used by Emap's `workerjobstart` / `workerjobend` events.
+     *
+     * Even on an immediately-rejecting path (destroyed pool, or environments
+     * lacking a `Worker` constructor), the returned `id` is still drawn from
+     * the same monotonic counter so it never collides with live ids — UI
+     * code can correlate a `workerjobstart` with a synchronously-rejecting
+     * `workerjobend` without aliasing.
+     */
+    runWithId(cmdOrCommands: string | ParsedCommandWire[], packed: any, inputFiles?: Record<string, Uint8Array | string>): {
+        id: number;
+        promise: Promise<any>;
+    };
+    /**
+     * Reserve a correlation id without sending anything. Call {@link dispatchWithId}
+     * with the same id later to actually post the message. Useful when the
+     * caller wants to fire a "started" event with a stable id BEFORE doing
+     * expensive sync work (e.g. dataset packing) that delays the postMessage.
+     */
+    reserveId(): number;
+    /**
+     * Send a message using a previously-reserved id (see {@link reserveId}).
+     * Returns the result promise. Same failure modes as {@link run}: pool
+     * destroyed → rejects; worker spawn fails → rejects.
+     */
+    dispatchWithId(id: number, cmdOrCommands: string | ParsedCommandWire[], packed: any, inputFiles?: Record<string, Uint8Array | string>, 
+    /**
+     * Optional list of `Transferable` objects (typed-array `.buffer`s,
+     * `MessagePort`s, …) handed to `postMessage`. When supplied,
+     * ownership moves to the worker — saves a structured-clone copy
+     * and roughly halves the main-thread memory peak around a
+     * pack/unpack round-trip.
+     *
+     * Callers that share the buffers with main-thread code must NOT
+     * pass them via this list (transfer is destructive on the source
+     * realm).
+     */
+    transferList?: Transferable[]): Promise<any>;
+    /**
+     * Terminate every spawned worker, reject every pending request, and
+     * refuse subsequent `run()` calls. Idempotent.
+     */
+    destroy(): void;
+    /**
+     * Hard-kill every spawned worker and reject every pending request as
+     * `'cancelled'`. Unlike {@link destroy}, the pool stays usable — the
+     * next {@link run} call spawns fresh workers on demand.
+     *
+     * mapshaper isn't interruptible mid-command, so this is the only sound
+     * way to abandon a job that's already running: terminate the whole
+     * worker, lose any other queued jobs as collateral, and start over. A
+     * future iteration could add per-request cancellation tokens; v1 keeps
+     * this honest by exposing only the all-or-nothing semantics.
+     */
+    cancelAll(): void;
+    /** True iff at least one worker has been spawned. Test/diagnostics aid. */
+    isWorkerSpawned(): boolean;
+    /** Number of worker slots configured (NOT the count of currently-spawned workers). */
+    get poolSize(): number;
+    /**
+     * Pick the worker slot to dispatch the next request to.
+     *
+     * Algorithm:
+     *   1. Among slots with the LOWEST `pendingCount`, prefer those that
+     *      are already spawned (avoid paying spawn cost when load is low).
+     *   2. Within that subset, pick by round-robin so the load stays even
+     *      across slots over time. The cursor advances on every dispatch.
+     */
+    private _pickWorker;
+    private _terminateAll;
+    private _ensureWorker;
+    private _onMessage;
+    private _onWorkerError;
+}

package/dist/core/tween.d.ts

@@ -0,0 +1,26 @@
+import { EventDispatcher } from './events';
+export declare class Timer extends EventDispatcher {
+    private _running;
+    private _busy;
+    private _tickTime;
+    private _startTime;
+    private _duration;
+    constructor();
+    start(ms?: number): void;
+    stop(): void;
+    private _startTick;
+    private _onTick;
+}
+export type EaseFunction = (n: number) => number;
+export declare class Tween extends EventDispatcher {
+    private _timer;
+    private _startValue;
+    private _endValue;
+    private _ease;
+    constructor(ease?: EaseFunction);
+    start(a: number, b: number, duration?: number): void;
+    stop(): void;
+    private _onTick;
+    static sineInOut(n: number): number;
+    static quadraticOut(n: number): number;
+}

package/dist/edit/commands/composite.d.ts

@@ -0,0 +1,16 @@
+import type { EditCommand } from '../edit-command';
+/**
+ * Wraps an ordered list of child commands in a single undoable step.
+ *
+ * `do()` invokes the children in their declared order; `undo()` invokes them
+ * in reverse order. This is the building block for every multi-step user
+ * operation (e.g. delete-many, future clip / dissolve / batch attribute
+ * changes) — one logical action becomes one history entry.
+ */
+export declare class CompositeCommand implements EditCommand {
+    private readonly children;
+    readonly label: string | undefined;
+    constructor(children: ReadonlyArray<EditCommand>, label?: string);
+    do(): void;
+    undo(): void;
+}

package/dist/edit/commands/dataset-replace.d.ts

@@ -0,0 +1,43 @@
+import type { EditCommand } from '../edit-command';
+import type { MapshaperDataset } from '../../types/mapshaper-types';
+import type { TopologySource } from '../../source/source';
+export interface DatasetReplaceCommandOptions {
+    /** The source whose dataset is being swapped. */
+    source: TopologySource;
+    /** Snapshot of the dataset BEFORE the operation. Restored by undo. */
+    before: MapshaperDataset;
+    /** Reference to the dataset AFTER the operation. Restored by redo. */
+    after: MapshaperDataset;
+    /** Human-readable label, surfaced via `historychange`. */
+    label: string;
+}
+/**
+ * Reverse a whole-dataset operation (clip / erase / dissolve / future
+ * polygon ops) by holding both the pre- and post-operation dataset
+ * references and swapping which one is active on the `TopologySource`.
+ *
+ * The `before` reference must be a deep copy (typically produced by
+ * `MapshaperAdapter.copyDataset`); the `after` reference is the dataset
+ * mapshaper mutated in place. `setDataset` rebuilds DisplayArcs and fires
+ * `'data'` so the map re-renders.
+ *
+ * Note: this command is a "history barrier" — earlier commands closed over
+ * specific layer / arc references that point at the old dataset, and must
+ * not be replayed across the swap. The `Emap` runner that produces this
+ * command clears the history stack before pushing it.
+ */
+export declare class DatasetReplaceCommand implements EditCommand {
+    private readonly opts;
+    readonly label: string;
+    /**
+     * Pushing a DatasetReplaceCommand marks every prior entry on the undo
+     * stack as `stale`. Their captured dataset / arc references point at
+     * the object this command swapped out, so undoing them post-swap would
+     * write to the wrong place. See `EditCommand.stale` for the full
+     * rationale.
+     */
+    readonly invalidatesPriorCommands = true;
+    constructor(opts: DatasetReplaceCommandOptions);
+    do(): void;
+    undo(): void;
+}

package/dist/edit/commands/feature-affine.d.ts

@@ -0,0 +1,72 @@
+import type { EditCommand } from '../edit-command';
+import { type ArcCollection } from '../../types/mapshaper-types';
+import type { TopologySource } from '../../source/source';
+import type { TranslatedPointFeature } from './feature-translate';
+/**
+ * 2x3 affine matrix in SVG/Canvas convention.
+ *
+ *   x' = a*x + c*y + tx
+ *   y' = b*x + d*y + ty
+ */
+export interface AffineMatrix {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    tx: number;
+    ty: number;
+}
+export interface FeatureAffineCommandOptions {
+    source: TopologySource;
+    /** Shared ArcCollection for path features. Omit for point-only commands. */
+    arcs?: ArcCollection;
+    /** Forward matrix. `do()` applies it; `undo()` applies its inverse. */
+    matrix: AffineMatrix;
+    /** Unique abs-arc-ids referenced by selected path features. */
+    arcIds: number[];
+    /** Selected point features. */
+    pointFeatures: TranslatedPointFeature[];
+    /** Optional human-readable label (defaults to `Transform N features`). */
+    label?: string;
+}
+/**
+ * Apply an affine transform to a fixed set of arcs and point shapes,
+ * reversing it on undo via the analytically-computed inverse matrix.
+ *
+ * Same lightweight in-place semantics as `FeatureTranslateCommand`:
+ * O(touched-vertices), composes freely with other commands in one undo
+ * timeline, no dataset replacement, selection survives.
+ */
+export declare class FeatureAffineCommand implements EditCommand {
+    private readonly opts;
+    readonly label: string;
+    constructor(opts: FeatureAffineCommandOptions);
+    do(): void;
+    undo(): void;
+    private _apply;
+}
+/**
+ * Rotate around `(ox, oy)` by `angleRad`.
+ *
+ * Combined transform: translate(-ox,-oy) → rotate(θ) → translate(ox,oy).
+ */
+export declare function rotateMatrix(angleRad: number, ox?: number, oy?: number): AffineMatrix;
+/**
+ * Scale by `(sx, sy)` around `(ox, oy)`.
+ *
+ * Combined transform: translate(-ox,-oy) → scale(sx,sy) → translate(ox,oy).
+ */
+export declare function scaleMatrix(sx: number, sy: number, ox?: number, oy?: number): AffineMatrix;
+/**
+ * Compose two matrices: result applies `b` first, then `a`. I.e. for vertex
+ * `v`, `compose(a, b)` is equivalent to `a * b * v` — the same convention
+ * as DOMMatrix and CSS `transform`.
+ */
+export declare function composeMatrix(a: AffineMatrix, b: AffineMatrix): AffineMatrix;
+/** Identity matrix — useful as the starting cumulative for `composeMatrix`. */
+export declare const IDENTITY_MATRIX: AffineMatrix;
+/**
+ * Analytical inverse. For a non-degenerate `m`, applying `m` then
+ * `invertMatrix(m)` is the identity (within floating-point epsilon).
+ */
+export declare function invertMatrix(m: AffineMatrix): AffineMatrix;

package/dist/edit/commands/feature-create.d.ts

@@ -0,0 +1,47 @@
+import type { EditCommand } from '../edit-command';
+import { type ArcCollection, type FeatureShape, type MapshaperLayer } from '../../types/mapshaper-types';
+import type { TopologySource } from '../../source/source';
+import { type MapshaperAdapter } from '../../adapter/mapshaper-adapter';
+export type FeatureGeometryType = 'point' | 'polyline' | 'polygon';
+export interface FeatureCreateCommandOptions {
+    geometryType: FeatureGeometryType;
+    /** Layer the feature was appended to. */
+    layer: MapshaperLayer;
+    /** Source so we can refresh DisplayArcs after the mutation. */
+    source: TopologySource;
+    /** The shape value pushed onto `layer.shapes`. */
+    appendedShape: FeatureShape;
+    /** Adapter override for tests; defaults to the process-wide singleton. */
+    adapter?: MapshaperAdapter;
+    /**
+     * The data record pushed onto `layer.data.getRecords()`. `null` when the
+     * layer has no data table.
+     */
+    appendedRecord: Record<string, unknown> | null;
+    /**
+     * Vertex coordinates of the new arc, in original order. Required for path
+     * geometries (polyline / polygon); omitted for points.
+     */
+    arcVertices?: [number, number][];
+    /** The shared ArcCollection for path geometries; omitted for points. */
+    arcs?: ArcCollection;
+}
+/**
+ * Reverse the creation of a drawn feature.
+ *
+ * For path features: the last appended arc is removed via mapshaper's
+ * `internal.deleteLastArc`, and the shape / record are popped. Redo
+ * re-creates the arc using mapshaper's canonical `appendEmptyArc` +
+ * `appendVertex` pattern, so vertex storage and z-values match the original
+ * append exactly.
+ *
+ * For point features: only the shape and (optional) record are popped /
+ * re-pushed.
+ */
+export declare class FeatureCreateCommand implements EditCommand {
+    private readonly opts;
+    readonly label: string;
+    constructor(opts: FeatureCreateCommandOptions);
+    do(): void;
+    undo(): void;
+}

package/dist/edit/commands/feature-delete.d.ts

@@ -0,0 +1,72 @@
+import type { EditCommand } from '../edit-command';
+import type { FeatureShape, MapshaperLayer } from '../../types/mapshaper-types';
+export interface FeatureDeleteCommandOptions {
+    /** The layer object that owns the feature. */
+    layer: MapshaperLayer;
+    /** Index of the feature within `layer.shapes`. Captured at construction. */
+    featureId: number;
+    /** Snapshot of the shape, taken before deletion. Restored by undo. */
+    shape: FeatureShape | null;
+    /**
+     * Snapshot of the data record, taken before deletion. `null` when the
+     * layer has no data table.
+     */
+    record: Record<string, unknown> | null;
+}
+/**
+ * Removes a single feature from a layer by splicing its shape and data
+ * record. Mirrors mapshaper's `gui-drawing-utils.deleteFeature` /
+ * `insertFeature` pair so undo restores the exact prior layout.
+ *
+ * Orphan arcs referenced by deleted path features are intentionally left in
+ * the source's `ArcCollection` — that is mapshaper's convention. Undo
+ * restores the shape, which references the arcs that are still there. To
+ * reclaim space, run a future `clean` / `dissolve` op.
+ *
+ * No `DisplayArcs` refresh: deletion never changes the arc collection.
+ * `DisplayArcs.getScaledArcs` self-heals if `arcs.size()` ever changes for
+ * unrelated reasons (vertex add, addIntersectionCuts), so the only callers
+ * that need to refresh are those that mutate arcs themselves.
+ */
+export declare class FeatureDeleteCommand implements EditCommand {
+    private readonly opts;
+    readonly label = "Delete feature";
+    constructor(opts: FeatureDeleteCommandOptions);
+    do(): void;
+    undo(): void;
+}
+export interface BulkFeatureDeleteCommandOptions {
+    /** The layer being mutated. */
+    layer: MapshaperLayer;
+    /**
+     * Snapshots of every feature being deleted. `id` is the index in the
+     * layer's `shapes` array at the time the command was constructed; the
+     * list need not be sorted but ids must be unique.
+     */
+    snapshots: Array<{
+        id: number;
+        shape: FeatureShape | null;
+        record: Record<string, unknown> | null;
+    }>;
+}
+/**
+ * Layer-scoped bulk delete. Splicing K features one at a time on a layer
+ * with N shapes is O(K·N) — for a 1.5M-vertex topology with K in the
+ * hundreds the main thread freezes for seconds. This command does it in
+ * one O(N) compaction pass instead.
+ *
+ * `do()` rebuilds `layer.shapes` and compacts the data table's records
+ * array IN PLACE so the table's reference stays valid. `undo()` walks the
+ * snapshots in ascending id order and re-inserts via splice — fine because
+ * undo is called once per delete batch, not per feature.
+ *
+ * Like {@link FeatureDeleteCommand}, no `DisplayArcs` refresh is issued;
+ * deletion never changes the arc collection.
+ */
+export declare class BulkFeatureDeleteCommand implements EditCommand {
+    private readonly opts;
+    readonly label: string;
+    constructor(opts: BulkFeatureDeleteCommandOptions);
+    do(): void;
+    undo(): void;
+}

package/dist/edit/commands/feature-property-change.d.ts

@@ -0,0 +1,34 @@
+import type { EditCommand } from '../edit-command';
+import type { MapshaperLayer } from '../../types/mapshaper-types';
+export interface FeaturePropertyChangeCommandOptions {
+    /** Layer that owns the feature. */
+    layer: MapshaperLayer;
+    /** Index of the feature within `layer.shapes`. */
+    featureId: number;
+    /**
+     * Sparse patch of pre-edit values, keyed by field name. The presence of a
+     * key means "the record had this key with this value before the edit"; an
+     * absent key means "the record did not have this key before the edit".
+     */
+    prev: Record<string, unknown>;
+    /**
+     * Sparse patch of post-edit values. Same key-presence semantics as `prev`:
+     * present = "this key should exist with this value", absent = "this key
+     * should not exist".
+     */
+    next: Record<string, unknown>;
+    /** Optional human-readable label for `historychange`. */
+    label?: string;
+}
+/**
+ * Reverse a single-feature attribute edit by walking a sparse `prev` / `next`
+ * patch. Memory cost is proportional to the number of keys that actually
+ * changed, not the size of the record.
+ */
+export declare class FeaturePropertyChangeCommand implements EditCommand {
+    private readonly opts;
+    readonly label: string;
+    constructor(opts: FeaturePropertyChangeCommandOptions);
+    do(): void;
+    undo(): void;
+}

package/dist/edit/commands/feature-translate.d.ts

@@ -0,0 +1,55 @@
+import type { EditCommand } from '../edit-command';
+import { type ArcCollection, type MapshaperLayer } from '../../types/mapshaper-types';
+import type { TopologySource } from '../../source/source';
+/** Point-feature reference within a single source. */
+export interface TranslatedPointFeature {
+    layer: MapshaperLayer;
+    featureId: number;
+}
+export interface FeatureTranslateCommandOptions {
+    source: TopologySource;
+    /** Shared ArcCollection that owns the path-feature arcs. May be omitted if only point features. */
+    arcs?: ArcCollection;
+    /** Offset in source-data coordinates. */
+    dx: number;
+    dy: number;
+    /**
+     * Unique absolute arc ids (post-`absArcId`) referenced by selected path
+     * features in the source. Empty when no path features are selected.
+     */
+    arcIds: number[];
+    /**
+     * Selected point features whose `layer.shapes[featureId]` is offset directly.
+     * Empty when no point features are selected.
+     */
+    pointFeatures: TranslatedPointFeature[];
+}
+/**
+ * Translate a fixed set of arcs and point shapes by `(dx, dy)` in source-data
+ * coordinates. Reverses by negating the offset.
+ *
+ * Lightweight in-place mutation — no dataset replacement, no copy. Cost is
+ * O(vertices in the affected arcs + point coords). The same command class
+ * handles point-only, path-only, and mixed selections within one source.
+ *
+ * Mergeable: consecutive translates of the SAME (source, arcIds,
+ * pointFeatures) tuple within {@link MERGE_WINDOW_MS} accumulate their
+ * deltas into a single entry — useful for arrow-key nudges or any UI
+ * that batches `Emap.translateSelected` per keystroke.
+ *
+ * Known v1 limitation: arcs shared with unselected features are translated
+ * once (correctly per the topology model), which means the unselected
+ * neighbour's geometry follows along. The proper fix requires cutting
+ * shared arcs at the selection boundary first; tracked as a follow-up.
+ */
+export declare class FeatureTranslateCommand implements EditCommand {
+    private readonly opts;
+    readonly label: string;
+    private _mergeAt;
+    constructor(opts: FeatureTranslateCommandOptions);
+    do(): void;
+    undo(): void;
+    mergeable(prev: EditCommand): boolean;
+    merge(next: EditCommand): void;
+    private _apply;
+}

package/dist/edit/commands/field-add.d.ts

@@ -0,0 +1,24 @@
+import type { EditCommand } from '../edit-command';
+import type { MapshaperLayer } from '../../types/mapshaper-types';
+export interface FieldAddCommandOptions {
+    layer: MapshaperLayer;
+    /** Field name to add to every record that does not already have it. */
+    field: string;
+    /** Default value to assign. Defaults to `null` when omitted. */
+    defaultValue?: unknown;
+}
+/**
+ * Add a new column to a layer's data table by setting `field` = `defaultValue`
+ * on every record that does not already have the key. Records that already
+ * carry the key are skipped (and not undone) so the operation is safely
+ * idempotent.
+ */
+export declare class FieldAddCommand implements EditCommand {
+    private readonly opts;
+    readonly label: string;
+    /** Indices of records this command added the key to (used by undo). */
+    private _addedIndices;
+    constructor(opts: FieldAddCommandOptions);
+    do(): void;
+    undo(): void;
+}

package/dist/edit/commands/field-remove.d.ts

@@ -0,0 +1,20 @@
+import type { EditCommand } from '../edit-command';
+import type { MapshaperLayer } from '../../types/mapshaper-types';
+export interface FieldRemoveCommandOptions {
+    layer: MapshaperLayer;
+    /** Field name to drop from every record in the layer. */
+    field: string;
+}
+/**
+ * Drop a column from a layer's data table. Each record's prior value is
+ * snapshotted on `do()` so `undo()` can restore exact contents — including
+ * leaving records that never had the field untouched.
+ */
+export declare class FieldRemoveCommand implements EditCommand {
+    private readonly opts;
+    readonly label: string;
+    private _snapshot;
+    constructor(opts: FieldRemoveCommandOptions);
+    do(): void;
+    undo(): void;
+}

package/dist/edit/commands/field-rename.d.ts

@@ -0,0 +1,19 @@
+import type { EditCommand } from '../edit-command';
+import type { MapshaperLayer } from '../../types/mapshaper-types';
+export interface FieldRenameCommandOptions {
+    layer: MapshaperLayer;
+    from: string;
+    to: string;
+}
+/**
+ * Rename a column on every record in a layer. Each record that has the
+ * `from` key has its value moved to `to` and the old key dropped. Records
+ * without the `from` key are left untouched in both directions.
+ */
+export declare class FieldRenameCommand implements EditCommand {
+    private readonly opts;
+    readonly label: string;
+    constructor(opts: FieldRenameCommandOptions);
+    do(): void;
+    undo(): void;
+}