gps-plus-slam-app-framework 1.0.0

package/dist/state/replay-engine.js

@@ -0,0 +1,230 @@
+//#region ../src/state/replay-engine.ts
+/** Default maximum delay between actions in ms (30 seconds real-time) */
+const DEFAULT_MAX_DELAY_MS = 3e4;
+/** Max consecutive dispatch errors before auto-pause (Risk R7) */
+const MAX_CONSECUTIVE_ERRORS = 10;
+/**
+* Extract an absolute epoch-ms timestamp from a Redux action, or null
+* if the action type doesn't carry one.
+*
+* IMPORTANT: depthSample uses performance.now() (relative to page load),
+* NOT epoch ms. Returning it here would mix clock domains and produce
+* garbage delays. It must return null. (Risk R4)
+*
+* @param action - A Redux action with type and optional payload
+* @returns Epoch milliseconds, or null if unavailable/unreliable
+*/
+function extractActionTimestamp(action) {
+	if (!action.payload || typeof action.payload !== "object") return null;
+	const payload = action.payload;
+	switch (action.type) {
+		case "gpsData/recordGpsEvent": {
+			const rawGpsPoint = payload.rawGpsPoint;
+			if (rawGpsPoint && typeof rawGpsPoint.timestamp === "number") return rawGpsPoint.timestamp;
+			const gpsPoint = payload.gpsPoint;
+			if (gpsPoint && typeof gpsPoint.timestamp === "number") return gpsPoint.timestamp;
+			return null;
+		}
+		case "recorder/startSession":
+			if (typeof payload.startTime === "number") return payload.startTime;
+			return null;
+		case "gpsData/markReferencePoint": {
+			if (typeof payload.timestamp === "number") return payload.timestamp;
+			const rawGpsPoint = payload.rawGpsPoint;
+			if (rawGpsPoint && typeof rawGpsPoint.timestamp === "number") return rawGpsPoint.timestamp;
+			const gpsPoint = payload.gpsPoint;
+			if (gpsPoint && typeof gpsPoint.timestamp === "number") return gpsPoint.timestamp;
+			return null;
+		}
+		case "recorder/recordDepthSample": return null;
+		case "recorder/endSession": return null;
+		default: return null;
+	}
+}
+/**
+* Compute the delay in ms between two consecutive actions for replay.
+*
+* @param currentTs - Epoch ms of the current (just-dispatched) action, or null
+* @param nextTs - Epoch ms of the next action, or null
+* @param speedFactor - Playback speed multiplier (1 = real-time)
+* @param maxDelay - Maximum delay in ms (default: DEFAULT_MAX_DELAY_MS)
+* @returns Delay in ms, clamped to [0, maxDelay]
+*/
+function computeInterActionDelay(currentTs, nextTs, speedFactor, maxDelay = DEFAULT_MAX_DELAY_MS) {
+	if (currentTs === null || nextTs === null) return 0;
+	const rawDelay = (nextTs - currentTs) / speedFactor;
+	return Math.min(Math.max(0, rawDelay), maxDelay);
+}
+/**
+* Async controller that dispatches recorded actions with timed delays.
+*
+* Uses AbortController for pause/cancel:
+* - play() starts the async loop
+* - pause() aborts the current controller → loop exits
+* - resume() creates a new controller and restarts from current index
+* - setSpeed() updates a closure variable, picked up on next delay calc
+* - dispose() stops everything and resets state
+*/
+var ReplayEngine = class {
+	state = "idle";
+	currentIndex = 0;
+	actions = [];
+	store = null;
+	speedFactor = 1;
+	abortController = null;
+	progressCallbacks = [];
+	completeCallbacks = [];
+	errorCallbacks = [];
+	currentPlayPromise = null;
+	/** Get the current engine state */
+	getState() {
+		return this.state;
+	}
+	/** Get the current action index (1-based after dispatch, 0 before play) */
+	getCurrentActionIndex() {
+		return this.currentIndex;
+	}
+	/** Register a progress callback: (currentIndex, totalCount) */
+	onProgress(callback) {
+		this.progressCallbacks.push(callback);
+	}
+	/** Register a completion callback */
+	onComplete(callback) {
+		this.completeCallbacks.push(callback);
+	}
+	/**
+	* Register an error callback: (actionIndex, error).
+	* Called when a dispatch throws. Replay continues past the error.
+	* After MAX_CONSECUTIVE_ERRORS consecutive failures, engine auto-pauses (R7).
+	*/
+	onError(callback) {
+		this.errorCallbacks.push(callback);
+	}
+	/** Update playback speed (takes effect on next delay calculation) */
+	setSpeed(factor) {
+		if (!Number.isFinite(factor) || factor <= 0) throw new RangeError(`Speed factor must be a positive finite number, got ${factor}`);
+		this.speedFactor = factor;
+	}
+	/**
+	* Start replaying actions with timed delays.
+	*
+	* @param actions - Array of Redux actions to dispatch
+	* @param store - RecorderStore to dispatch into
+	* @param speedFactor - Initial playback speed (1 = real-time)
+	* @returns Promise that resolves when replay completes or is paused
+	*/
+	play(actions, store, speedFactor) {
+		this.abortController?.abort();
+		this.actions = actions;
+		this.store = store;
+		this.speedFactor = speedFactor;
+		this.currentIndex = 0;
+		this.state = "playing";
+		this.abortController = new AbortController();
+		this.currentPlayPromise = this.runLoop(this.abortController.signal);
+		return this.currentPlayPromise;
+	}
+	/** Pause the replay. Can be resumed later with resume(). */
+	pause() {
+		if (this.state !== "playing") return;
+		this.state = "paused";
+		this.abortController?.abort();
+		this.abortController = null;
+	}
+	/**
+	* Resume from the current action index after a pause.
+	* @returns Promise that resolves when replay completes or is paused again
+	*/
+	resume() {
+		if (this.state !== "paused" || !this.store) return Promise.resolve();
+		this.state = "playing";
+		this.abortController = new AbortController();
+		this.currentPlayPromise = this.runLoop(this.abortController.signal);
+		return this.currentPlayPromise;
+	}
+	/** Stop playback and reset to idle. */
+	dispose() {
+		this.abortController?.abort();
+		this.abortController = null;
+		this.state = "idle";
+		this.currentIndex = 0;
+		this.actions = [];
+		this.store = null;
+		this.currentPlayPromise = null;
+		this.progressCallbacks = [];
+		this.completeCallbacks = [];
+		this.errorCallbacks = [];
+	}
+	async runLoop(signal) {
+		const { actions, store } = this;
+		if (!store) return;
+		const total = actions.length;
+		if (total === 0) {
+			this.state = "completed";
+			this.notifyComplete();
+			return;
+		}
+		let consecutiveErrors = 0;
+		while (this.currentIndex < total) {
+			if (signal.aborted) return;
+			const action = actions[this.currentIndex];
+			try {
+				store.dispatch(action);
+				consecutiveErrors = 0;
+			} catch (err) {
+				consecutiveErrors++;
+				const error = err instanceof Error ? err : new Error(String(err));
+				this.notifyError(this.currentIndex + 1, error);
+				if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+					this.state = "paused";
+					this.abortController?.abort();
+					this.abortController = null;
+					return;
+				}
+			}
+			this.currentIndex++;
+			this.notifyProgress(this.currentIndex, total);
+			if (this.currentIndex >= total) {
+				this.state = "completed";
+				this.notifyComplete();
+				return;
+			}
+			const delay = computeInterActionDelay(extractActionTimestamp(action), extractActionTimestamp(actions[this.currentIndex]), this.speedFactor);
+			if (delay > 0) {
+				if (await this.abortableDelay(delay, signal)) return;
+			}
+		}
+	}
+	/**
+	* Promise-based delay that resolves on timeout or rejects on abort.
+	* Returns true if aborted, false if delay completed normally.
+	*/
+	abortableDelay(ms, signal) {
+		return new Promise((resolve) => {
+			if (signal.aborted) {
+				resolve(true);
+				return;
+			}
+			const timer = setTimeout(() => {
+				signal.removeEventListener("abort", onAbort);
+				resolve(false);
+			}, ms);
+			const onAbort = () => {
+				clearTimeout(timer);
+				resolve(true);
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+		});
+	}
+	notifyProgress(current, total) {
+		for (const cb of this.progressCallbacks) cb(current, total);
+	}
+	notifyComplete() {
+		for (const cb of this.completeCallbacks) cb();
+	}
+	notifyError(actionIndex, error) {
+		for (const cb of this.errorCallbacks) cb(actionIndex, error);
+	}
+};
+//#endregion
+export { DEFAULT_MAX_DELAY_MS, ReplayEngine, computeInterActionDelay, extractActionTimestamp };

package/dist/state/routing-slice.d.ts

@@ -0,0 +1,2 @@
+import { i as routingReducer, n as RoutingState, r as navigateTo, t as AppScreen } from "../routing-slice-BlHTM8eh.js";
+export { AppScreen, RoutingState, navigateTo, routingReducer };

package/dist/state/routing-slice.js

@@ -0,0 +1,13 @@
+import { createSlice } from "@reduxjs/toolkit";
+//#region ../src/state/routing-slice.ts
+const routingSlice = createSlice({
+	name: "routing",
+	initialState: { currentScreen: "setup" },
+	reducers: { navigateTo(state, action) {
+		state.currentScreen = action.payload;
+	} }
+});
+const { navigateTo } = routingSlice.actions;
+const routingReducer = routingSlice.reducer;
+//#endregion
+export { navigateTo, routingReducer };

package/dist/state/store-subscribers.d.ts

@@ -0,0 +1,3 @@
+import { t as SubscribableStore } from "../subscribe-to-selector-UTZ0KkAc.js";
+import { n as wireStoreSubscribers, t as StoreSubscriberDeps } from "../store-subscribers-CuoIzB5T.js";
+export { StoreSubscriberDeps, SubscribableStore, wireStoreSubscribers };

package/dist/state/store-subscribers.js

@@ -0,0 +1,97 @@
+import { fusedGpsFromOdom } from "../utils/fused-path.js";
+import { subscribeToSelector } from "./subscribe-to-selector.js";
+import { selectAlignmentMatrix, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectReferencePoints, selectZeroReference } from "./app-selectors.js";
+import { calcGpsCoords } from "gps-plus-slam-js";
+import { mat4, vec3 } from "gl-matrix";
+//#region ../src/state/store-subscribers.ts
+/**
+* Wire store state-change subscriptions to visualization dependencies.
+*
+* Uses subscribeToSelector to decompose the monolithic subscriber into
+* focused, change-gated callbacks:
+* 1. Alignment matrix changes → apply matrix + capture snapshots
+* 2. GPS position changes → incremental event visualization + map overlay
+* 3. Reference point changes → forward to map overlay
+*
+* Each subscription uses reference equality to detect changes — callbacks
+* only fire when the selector output actually differs between dispatches.
+*
+* Each call creates **fresh subscriptions** — no manual reset needed between
+* sessions. Call the returned unsubscribe function to tear down all.
+*
+* @param store — any object satisfying SubscribableStore (RecorderStore, replay store, mock)
+* @param deps  — visualization dependencies (real singletons or test mocks)
+* @returns An unsubscribe function that removes all listeners from the store.
+*/
+function wireStoreSubscribers(store, deps) {
+	const _odomVec = vec3.create();
+	const _alignedVec = vec3.create();
+	const unsubs = [];
+	unsubs.push(subscribeToSelector(store, selectAlignmentMatrix, (matrix) => {
+		if (!matrix) return;
+		deps.applyAlignmentMatrix(matrix);
+		const state = store.getState();
+		const odomPositions = selectOdometryPositions(state);
+		if (odomPositions.length > 0) {
+			const latestOdom = odomPositions[odomPositions.length - 1];
+			const glMat = mat4.fromValues(...matrix);
+			vec3.set(_odomVec, latestOdom[0], latestOdom[1], latestOdom[2]);
+			vec3.transformMat4(_alignedVec, _odomVec, glMat);
+			const snapshotPos = [
+				_alignedVec[0],
+				_alignedVec[1],
+				_alignedVec[2]
+			];
+			deps.gpsEventVisualizer.addAlignmentSnapshot(snapshotPos);
+			deps.onAlignmentSnapshot?.(snapshotPos);
+			const zeroRef = selectZeroReference(state);
+			if (zeroRef && deps.mapOverlay?.addAlignmentSnapshot) {
+				const gps = calcGpsCoords(zeroRef, _alignedVec);
+				deps.mapOverlay.addAlignmentSnapshot(gps.lat, gps.lon);
+			}
+		}
+	}));
+	unsubs.push(subscribeToSelector(store, selectGpsPositions, (gpsPositions, prevPositions) => {
+		const prevCount = prevPositions?.length ?? 0;
+		const state = store.getState();
+		const zeroRef = selectZeroReference(state);
+		if (zeroRef && !deps.gpsEventVisualizer.getZeroRef()) deps.gpsEventVisualizer.setZeroRef(zeroRef);
+		const odomPositions = selectOdometryPositions(state);
+		const odomRotations = selectOdometryRotations(state);
+		for (let i = prevCount; i < gpsPositions.length; i++) {
+			const gpsPoint = gpsPositions[i];
+			const odomPos = odomPositions[i];
+			if (gpsPoint && odomPos) {
+				deps.gpsEventVisualizer.addGpsEvent(gpsPoint.coordinates, odomPos);
+				deps.onNewGpsPosition?.(gpsPoint.coordinates);
+				deps.onNewGpsLatLng?.(gpsPoint.latitude, gpsPoint.longitude);
+				deps.mapOverlay?.addRawGpsPoint?.(gpsPoint.latitude, gpsPoint.longitude);
+				const alignmentMatrix = selectAlignmentMatrix(state);
+				const zero = selectZeroReference(state);
+				if (alignmentMatrix && zero && deps.mapOverlay?.addFusedPoint) {
+					const fusedGps = fusedGpsFromOdom(alignmentMatrix, odomPos, zero);
+					deps.mapOverlay.addFusedPoint(fusedGps.lat, fusedGps.lon);
+				}
+				const odomRot = odomRotations[i];
+				if (odomRot) deps.onNewOdomPose?.(odomPos, odomRot);
+			}
+		}
+		if (deps.mapOverlay && gpsPositions.length > 0) {
+			const lastGpsPoint = gpsPositions[gpsPositions.length - 1];
+			deps.mapOverlay.setGpsPosition(lastGpsPoint.latitude, lastGpsPoint.longitude);
+		}
+	}));
+	unsubs.push(subscribeToSelector(store, selectReferencePoints, (refPoints, prevPoints) => {
+		const prevCount = prevPoints?.length ?? 0;
+		if (!deps.mapOverlay?.addRefPoint || refPoints.length <= prevCount) return;
+		for (let i = prevCount; i < refPoints.length; i++) {
+			const rp = refPoints[i];
+			deps.mapOverlay.addRefPoint(rp.gpsPoint.latitude, rp.gpsPoint.longitude, rp.id);
+		}
+	}));
+	return () => {
+		for (const unsub of unsubs) unsub();
+	};
+}
+//#endregion
+export { wireStoreSubscribers };

package/dist/state/store.d.ts

@@ -0,0 +1,9 @@
+import { i as DepthSample, r as DepthPoint } from "../ar-types-B-ORgk6Z.js";
+import { s as RecordingOptions } from "../recording-options-BYUFX8iU.js";
+import { n as SessionMetadata } from "../opfs-storage-ChOzF_Wp.js";
+import { t as StorageBackend } from "../storage-backend-BcEItnFr.js";
+import { a as recordWriteFailure, c as startSession, i as recordDepthSample, n as SessionMetadata$1, r as endSession, s as setCurrentScenarioName, t as RecorderState } from "../recorder-slice-fcwAXrsh.js";
+import { a as resetRefPointsState, n as clearSessionRefPointUsage, o as selectCachedKnownRefPoints, r as incrementRefPointUsage, s as setImportedRefPoints, t as RefPointsState } from "../ref-points-slice-tC-Wd6XJ.js";
+import { n as RefPointMark } from "../ref-point-loader-Pt1smgHS.js";
+import { _ as setZeroPos, a as MarkReferencePointPayload, c as RecordGpsEventPayload, d as RootState, f as add2dImage, g as recordGpsEvent, h as markReferencePoint, i as LatLong, l as RecorderStore, m as createRecorderStore, n as CombinedRootState, o as RawDeviceOrientation, p as calcRelativeCoordsInMeters, r as GpsPoint, s as RawGpsPoint, t as AppDispatch, u as RecorderStoreOptions } from "../store-C7PKOj8S.js";
+export { AppDispatch, CombinedRootState, DepthPoint, DepthSample, GpsPoint, LatLong, MarkReferencePointPayload, SessionMetadata as OpfsSessionMetadata, RawDeviceOrientation, RawGpsPoint, RecordGpsEventPayload, RecorderState, RecorderStore, RecorderStoreOptions, RecordingOptions, RefPointMark, RefPointsState, RootState, SessionMetadata$1 as SessionMetadata, StorageBackend, add2dImage, calcRelativeCoordsInMeters, clearSessionRefPointUsage, createRecorderStore, endSession, incrementRefPointUsage, markReferencePoint, recordDepthSample, recordGpsEvent, recordWriteFailure, resetRefPointsState, selectCachedKnownRefPoints, setCurrentScenarioName, setImportedRefPoints, setZeroPos, startSession };

package/dist/state/store.js

@@ -0,0 +1,71 @@
+import { endSession, recordDepthSample, recordWriteFailure, recorderReducer, setCurrentScenarioName, startSession } from "./recorder-slice.js";
+import { clearSessionRefPointUsage, incrementRefPointUsage, refPointsReducer, resetRefPointsState, selectCachedKnownRefPoints, setImportedRefPoints } from "./ref-points-slice.js";
+import { routingReducer } from "./routing-slice.js";
+import { OpfsStorageBackend } from "../storage/opfs-storage-backend.js";
+import { createPersistenceMiddleware } from "./persistence-middleware.js";
+import "../licensing/community-license-key.js";
+import { configureStore } from "@reduxjs/toolkit";
+import { add2dImage, arElementsReducer, calcRelativeCoordsInMeters, gpsDataReducer, gpsElementsReducer, markReferencePoint, recordGpsEvent, sanitizeForDevTools, setZeroPos, validateLicenseKey } from "gps-plus-slam-js";
+//#region ../src/state/store.ts
+/**
+* Redux Store for Recorder App
+*
+* Uses Redux Toolkit's configureStore to combine all reducers (library +
+* app-level) into a single store. Action persistence during recording is
+* handled by the persistence middleware.
+*
+* ARCHITECTURE NOTE: See docs/architecture-ar-gps-pose-separation.md
+* The library's recordGpsEvent action captures paired AR+GPS data
+* that feeds directly into the alignment algorithm.
+*
+* Migration note (§4 — architecture-observations-consolidated.md):
+* Previously the store used a manual wrapper pattern with action.type.startsWith()
+* prefix matching to route actions between a library store and local state
+* variables. This has been replaced with a single configureStore call that
+* combines all 6 reducers declaratively.
+*/
+/**
+* Create the recorder store using Redux Toolkit's configureStore.
+*
+* Combines all 6 reducers (3 library: gpsData, gpsElements, arElements;
+* 3 app: recorder, refPoints, routing) into a single store with the
+* persistence middleware for action recording.
+*
+* @param options - Optional configuration including callbacks
+*/
+function createRecorderStore(options = {}) {
+	const { onWriteFailure } = options;
+	const storageBackend = options.storageBackend ?? new OpfsStorageBackend();
+	const enableDevChecks = options.enableDevChecks ?? true;
+	validateLicenseKey(options.licenseKey ?? "eyJ0eXBlIjoiY29tbXVuaXR5IiwiZXhwIjoxODA4NzcyNDI3fQ.YYNf0IdqniZdMzRXCuvewxsQQ01XNywrKsfL5IpiJotfFJfqtrGg4u9z0QFhXeszPtUhnvgC8_oOnbOkbXPuAw");
+	const store = configureStore({
+		reducer: {
+			gpsData: gpsDataReducer,
+			gpsElements: gpsElementsReducer,
+			arElements: arElementsReducer,
+			recorder: recorderReducer,
+			refPoints: refPointsReducer,
+			routing: routingReducer
+		},
+		middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+			serializableCheck: enableDevChecks,
+			immutableCheck: enableDevChecks
+		}).concat(createPersistenceMiddleware({
+			storageBackend,
+			onWriteFailure
+		})),
+		devTools: {
+			actionSanitizer: sanitizeForDevTools,
+			stateSanitizer: sanitizeForDevTools
+		}
+	});
+	return {
+		getState: () => store.getState(),
+		dispatch: store.dispatch,
+		subscribe: (listener) => store.subscribe(listener),
+		writeFrame: (blob, index) => storageBackend.writeFrame(blob, index),
+		writeSessionMetadata: (metadata) => storageBackend.writeSessionMetadata(metadata)
+	};
+}
+//#endregion
+export { add2dImage, calcRelativeCoordsInMeters, clearSessionRefPointUsage, createRecorderStore, endSession, incrementRefPointUsage, markReferencePoint, recordDepthSample, recordGpsEvent, recordWriteFailure, resetRefPointsState, selectCachedKnownRefPoints, setCurrentScenarioName, setImportedRefPoints, setZeroPos, startSession };

package/dist/state/subscribe-to-selector.d.ts

@@ -0,0 +1,2 @@
+import { n as subscribeToSelector, t as SubscribableStore } from "../subscribe-to-selector-UTZ0KkAc.js";
+export { SubscribableStore, subscribeToSelector };

package/dist/state/subscribe-to-selector.js

@@ -0,0 +1,26 @@
+//#region ../src/state/subscribe-to-selector.ts
+/**
+* Subscribe to a specific derived value from the store, invoking `onChange`
+* only when the selector result changes by strict reference equality (`!==`).
+*
+* This replaces the `let lastX = …; if (current !== lastX) { … }` pattern
+* previously used in store-subscribers.ts.
+*
+* @param store    — subscribable store instance
+* @param selector — pure function extracting a value from state
+* @param onChange — callback receiving (current, previous) when the value changes
+* @returns unsubscribe function
+*/
+function subscribeToSelector(store, selector, onChange) {
+	let previous;
+	return store.subscribe(() => {
+		const current = selector(store.getState());
+		if (current !== previous) {
+			const prev = previous;
+			previous = current;
+			onChange(current, prev);
+		}
+	});
+}
+//#endregion
+export { subscribeToSelector };

package/dist/storage/file-system-utils.d.ts

@@ -0,0 +1,2 @@
+import { n as formatFrameFilename, r as formatTimestamp, t as formatActionFilename } from "../file-system-utils-5cWO8Xyv.js";
+export { formatActionFilename, formatFrameFilename, formatTimestamp };

package/dist/storage/file-system-utils.js

@@ -0,0 +1,31 @@
+//#region ../src/storage/file-system-utils.ts
+/**
+* File System Utilities - Pure Functions
+*
+* These are extracted from file-system.ts so they can be tested
+* without mocking browser APIs.
+*/
+/**
+* Format a Date as a timestamp string for folder names
+* @example "2025-02-28_14-30-11utc"
+*/
+function formatTimestamp(date) {
+	const pad = (n) => String(n).padStart(2, "0");
+	return `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}_${pad(date.getUTCHours())}-${pad(date.getUTCMinutes())}-${pad(date.getUTCSeconds())}utc`;
+}
+/**
+* Format an action file index as a zero-padded filename
+* @example 42 -> "000042.json"
+*/
+function formatActionFilename(index) {
+	return `${String(index).padStart(6, "0")}.json`;
+}
+/**
+* Format a frame index as a zero-padded filename
+* @example 42 -> "frame-000042.jpg"
+*/
+function formatFrameFilename(index) {
+	return `frame-${String(index).padStart(6, "0")}.jpg`;
+}
+//#endregion
+export { formatActionFilename, formatFrameFilename, formatTimestamp };

package/dist/storage/file-system.d.ts

@@ -0,0 +1,2 @@
+import { a as initStorage, c as resetForNewSession, d as startSession, f as verifyWriteAccess, h as writeSessionMetadata, i as getCurrentScenarioHandle, l as resetStorageState, m as writeFrame, n as WriteAccessResult, o as isRefPointAction, p as writeAction, r as ensureScenarioDirectory, s as loadScenarioRefPoints, t as RefPointRecord, u as setCurrentScenario } from "../file-system-BsQgYCU3.js";
+export { RefPointRecord, WriteAccessResult, ensureScenarioDirectory, getCurrentScenarioHandle, initStorage, isRefPointAction, loadScenarioRefPoints, resetForNewSession, resetStorageState, setCurrentScenario, startSession, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata };