@devcabs/folio-engine 0.0.0-stage → 0.1.0

package/dist/services/historyService.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Folio Engine - Unified History Hub Service
+ * Location: src/services/historyService.ts
+ * Specification: docs/tasks/task9_3_unified_school_history_hub.md
+ * Aligned with: docs/00_WORKFLOW.md, docs/03_ARCHITECTURE.md, docs/07_CODING_STANDARDS.md
+ *
+ * Implements:
+ * 1. Full Snapshot Bundling (all 5 nodes + Content DB overrides).
+ * 2. Dual-Tier Timeline (Named Milestones, Rolling Auto-Saves, Safety Backups).
+ * 3. 20-Checkpoint Auto-Save Rotation with Inactivity Debouncing.
+ * 4. Safe Pre-Restore Safety Checkpoint Guarantee.
+ * 5. Full JSON Backup Export & Verified Import.
+ */
+import type { UnifiedPortalSnapshot, HistoryManifest, SnapshotType, PublishedSnapshot } from '../types/history';
+import type { NodeCanvasDocument } from '../types/canvas';
+import { NODE_IDS, type NodeId } from './canvasLayoutService';
+import { getSupabaseConfig, isTableAvailable, markTableMissing, markTableAvailable } from '../utils/supabase-config';
+export { NODE_IDS, type NodeId };
+export declare function getActiveNodeIds(): string[];
+export { getSupabaseConfig, isTableAvailable, markTableMissing, markTableAvailable };
+import { type DraftStalenessCheck } from './draftService';
+export interface EngineSyncBroadcastMessage {
+    type: 'MASID_PUBLISH_BROADCAST';
+    snapshotId: string;
+    timestamp: string;
+    canvases: Record<string, NodeCanvasDocument>;
+    contentOverrides: Record<string, string>;
+    activePublishedId: string;
+}
+export interface HydrationState {
+    isHydrating: boolean;
+    hasConfirmedData: boolean;
+    source: 'cache' | 'cloud' | 'baseline';
+    activePublishedId: string | null;
+}
+export declare const getBroadcastChannelName: (ns?: string) => string;
+export declare const BROADCAST_CHANNEL_NAME: string;
+export declare const getHistoryManifestKey: (ns?: string) => string;
+export declare const STORAGE_KEY_HISTORY_MANIFEST: string;
+export declare const getLiveActivePublishedIdKey: (ns?: string) => string;
+export declare const STORAGE_KEY_LIVE_ACTIVE_PUBLISHED_ID: string;
+export declare const LEGACY_STORAGE_KEY_ACTIVE_PUBLISHED_ID: string;
+export declare const STORAGE_KEY_ACTIVE_PUBLISHED_ID: string;
+export declare const EVENT_HISTORY_CHANGE = "engine-history-change";
+export declare const HISTORY_SCHEMA_VERSION = 1;
+export declare const MAX_AUTOSAVES = 20;
+export declare const AUTOSAVE_DEBOUNCE_MS = 60000;
+/**
+ * Computes scannable metrics summary across all 5 node canvas trees and Content DB.
+ */
+export declare function computeMetricsSummary(canvases: Record<string, NodeCanvasDocument>, contentOverrides: Record<string, string>): UnifiedPortalSnapshot['summary'];
+/**
+ * Retrieves the currently active published snapshot ID.
+ * Reads solely from the canonical key, running a one-time migration from legacy pointers if absent.
+ */
+export declare function getActivePublishedId(): string;
+/**
+ * Sets the active published snapshot ID to the canonical key exclusively.
+ */
+export declare function setActivePublishedId(id: string): void;
+/**
+ * Generates the canonical system factory baseline snapshot.
+ * Serves as the indestructible anchor for the host application.
+ */
+export declare function getDefaultSystemBaselineSnapshot(isActive?: boolean): PublishedSnapshot;
+/**
+ * Lightweight snapshot metadata for localStorage manifest (< 50KB).
+ * Excludes heavy canvas document ASTs and Content DB dictionaries.
+ */
+export interface HistorySnapshotMetadata {
+    id: string;
+    title: string;
+    label?: string;
+    createdAt: string;
+    type: SnapshotType | string;
+    notes?: string;
+    authorSessionId?: string;
+    author?: string;
+    summary?: UnifiedPortalSnapshot['summary'];
+    metricsSummary?: unknown;
+}
+export interface LightweightHistoryManifest {
+    version: number;
+    lastUpdated: string;
+    updatedAt?: string;
+    snapshots: HistorySnapshotMetadata[];
+}
+/**
+ * Hydrates history manifest from persistent IndexedDB store (eliminates localStorage quota wipes).
+ */
+export declare function hydrateHistoryFromIndexedDB(): Promise<HistoryManifest>;
+/**
+ * Retrieves the whole-History manifest from storage.
+ */
+export declare function getHistoryManifest(): HistoryManifest;
+/**
+ * Persists history manifest to storage and notifies subscribers.
+ * Offloads heavy canvas and Content DB payloads exclusively to IndexedDB.
+ * localStorage receives only lightweight metadata (< 50KB for 20+ snapshots).
+ */
+export declare function saveHistoryManifest(manifest: HistoryManifest): void;
+/**
+ * Subscribes to real-time changes in the history manifest.
+ */
+export declare function subscribeToHistoryChange(callback: (manifest: HistoryManifest) => void): () => void;
+/**
+ * Aggregates a complete full snapshot bundle across all 5 nodes and Content DB.
+ */
+export declare function captureCurrentSnapshot(title: string, notes?: string, type?: SnapshotType, sessionId?: string): UnifiedPortalSnapshot;
+/**
+ * Creates and persists a named full milestone.
+ */
+export declare function saveMilestone(title: string, notes?: string, sessionId?: string): UnifiedPortalSnapshot;
+/**
+ * Prunes auto-saves in a list to keep at most MAX_AUTOSAVES (20), preserving all milestones & safety backups.
+ */
+export declare function pruneAutoSaves(snapshots: UnifiedPortalSnapshot[]): UnifiedPortalSnapshot[];
+/**
+ * Triggers an automated snapshot checkpoint.
+ * Debounced to at most once per AUTOSAVE_DEBOUNCE_MS unless forced.
+ */
+export declare function triggerAutoSave(sessionId?: string, force?: boolean): UnifiedPortalSnapshot | null;
+/**
+ * Restores a historical snapshot across all 5 nodes and Content DB.
+ * Automatically takes an immediate safety_backup before applying changes.
+ */
+export declare function restoreUnifiedSnapshot(snapshotId: string): Promise<{
+    success: boolean;
+    safetySnapshotId?: string;
+    error?: string;
+}>;
+/**
+ * Removes a specific snapshot from the manifest.
+ */
+export declare function deleteSnapshot(snapshotId: string): boolean;
+/**
+ * Clears all history checkpoints from the manifest.
+ */
+export declare function clearAllHistory(): void;
+export interface HistoryBackupExport {
+    engineBackupVersion: number;
+    exportedAt: string;
+    tenant: string;
+    manifest: HistoryManifest;
+    activeState: {
+        canvases: Record<string, NodeCanvasDocument>;
+        contentOverrides: Record<string, string>;
+    };
+}
+/**
+ * Generates a full formatted JSON backup string for download.
+ */
+export declare function exportHistoryBackupJson(): string;
+/**
+ * Validates and imports a JSON history backup, merging valid snapshots.
+ */
+export declare function importHistoryBackupJson(jsonString: string): {
+    success: boolean;
+    importedCount: number;
+    error?: string;
+};
+export { initDraftSession, discardDraftSession, } from './draftService';
+/**
+ * Restores a historical snapshot into Developer Mode's draft storage for visual preview before publishing.
+ * Does NOT mutate canonical live storage.
+ */
+export declare function restoreSnapshotToDraft(snapshot: PublishedSnapshot | UnifiedPortalSnapshot): boolean;
+export declare function getLocalFallbackSnapshots(): PublishedSnapshot[];
+/**
+ * Fetches the complete timeline of published snapshots from Supabase cloud (with offline fallback).
+ */
+export declare function fetchPublishedHistoryFromCloud(): Promise<PublishedSnapshot[]>;
+/**
+ * Fetches the current active published version from Supabase cloud.
+ */
+export declare function fetchActivePublishedVersionFromCloud(): Promise<PublishedSnapshot | null>;
+export interface CanPublishDraftResult {
+    canPublish: boolean;
+    reason?: 'NOT_DIRTY' | 'DRAFT_STALE';
+    staleness?: DraftStalenessCheck;
+}
+/**
+ * Checks whether the current draft can be safely published.
+ * Blocks publication if another coordinator has published since draft creation.
+ */
+export declare function canPublishDraft(forcePublish?: boolean): CanPublishDraftResult;
+/**
+ * Commits the current draft state, sets it as the active live version, and syncs to Supabase.
+ */
+export declare function publishNewSnapshot(description: string, title?: string, sessionId?: string, options?: {
+    forcePublish?: boolean;
+} | boolean): Promise<{
+    success: boolean;
+    snapshot: PublishedSnapshot;
+    cloudSynced: boolean;
+    error?: string;
+}>;
+export declare function getSyncBroadcastChannel(): BroadcastChannel | null;
+export declare function closeSyncBroadcastChannel(): void;
+export declare function broadcastLiveSync(message: EngineSyncBroadcastMessage): void;
+export declare function handleIncomingSyncBroadcast(message: EngineSyncBroadcastMessage): void;
+/**
+ * @deprecated Task 11.2.E: Artificial loading gates eliminated.
+ * Baseline documents render immediately on frame 1 with 0 skeleton pop-in.
+ */
+export declare function isInitialHydrationPending(): boolean;
+export declare function isCloudHydrating(): boolean;
+export declare function subscribeToHydration(callback: (isHydrating: boolean) => void): () => void;
+export declare function getHydrationState(): HydrationState;
+export declare function resetHydrationStateForTesting(): void;
+/**
+ * Hydrates local canonical storage from the cloud's active published version on startup.
+ * Memoizes in-flight promise to prevent duplicate concurrent network fetches.
+ */
+export declare function hydrateActiveVersionFromCloud(): Promise<boolean>;

package/dist/services/historyStorage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Folio Engine - Persistent IndexedDB Storage for History Snapshots
+ * Location: src/services/historyStorage.ts
+ * Specification: docs/tasks/task9_7_draft_and_publish_history_system.md
+ *
+ * Provides high-capacity, persistent client-side storage for full
+ * snapshot bundles to eliminate the 5MB localStorage QuotaExceededError.
+ */
+export declare const getHistoryDbName: (ns?: string) => string;
+/**
+ * Persists an item to IndexedDB with zero quota risk.
+ */
+export declare function saveToIndexedDB(key: string, value: unknown): Promise<boolean>;
+/**
+ * Retrieves an item from IndexedDB.
+ */
+export declare function loadFromIndexedDB<T>(key: string): Promise<T | null>;

package/dist/services/mediaService.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Folio Engine - Canonical Cloud Media Upload Service
+ * Location: src/services/mediaService.ts
+ * Specification: docs/tasks/task11_2g_db_draft_and_blob_storage_pipeline.md
+ * Aligned with: docs/00_WORKFLOW.md, docs/03_ARCHITECTURE.md, docs/07_CODING_STANDARDS.md
+ */
+import type { MediaFolder, ImageDownscaleOptions } from '../types/media';
+export declare const MEDIA_BUCKET_ID = "engine-media";
+export declare const DEFAULT_MAX_DIMENSION = 1600;
+export declare const DEFAULT_IMAGE_QUALITY = 0.82;
+/**
+ * Sanitizes a filename, preserving lowercase extension and alphanumeric characters.
+ */
+export declare function sanitizeFilename(filename: string): string;
+/**
+ * Client-side downscaling using an offscreen HTML Canvas.
+ * Scales large camera photos (e.g. 12 MB, 4000x3000) down to max 1600px,
+ * producing crisp, responsive ~120 KB WebP or JPEG binaries.
+ */
+export declare function downscaleImage(file: File | Blob, options?: ImageDownscaleOptions): Promise<Blob>;
+/**
+ * Uploads a binary media asset directly to the Supabase engine-media bucket.
+ * Returns the permanent public CDN URL.
+ */
+export declare function uploadMediaAsset(file: File | Blob, folder?: MediaFolder, originalFilename?: string): Promise<string>;

package/dist/services/sheetsDataService.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Google Sheets Tabular Ingestion & Parsing Service
+ * Document Reference: docs/tasks/task7_1_contracts_d3_math_sanitizer.md
+ *
+ * Slices arbitrary bounding boxes (A5:D12), preserves number purity (nulls for blanks/errors),
+ * automatically filters summary rows (Total/Average), detects multi-series groups,
+ * and pre-bakes sanitized CSV receipts.
+ */
+import type { ChartDataset, ChartSeries, ChartType, ChartVisualConfig } from '../types/chart';
+import type { NodeCode } from '../types/node';
+import { BoundingBoxRange } from '../utils/chartSanitizer';
+export interface ParseTabularParams {
+    chartId: string;
+    title: string;
+    subtitle?: string;
+    unit?: string;
+    asOfDate?: string;
+    chartType?: ChartType;
+    nodeId?: NodeCode;
+    visualConfig?: ChartVisualConfig;
+    rawMatrix?: string[][];
+    csvText?: string;
+}
+/**
+ * Parses raw CSV string into 2D grid preserving RFC 4180 quotes, commas, and line breaks.
+ */
+export declare function parseCsvToMatrix(csvText: string): string[][];
+/**
+ * Crops a 2D matrix according to bounding box range coordinates
+ */
+export declare function cropMatrixToRange(matrix: string[][], range: BoundingBoxRange): string[][];
+/**
+ * Transposes a 2D matrix (swaps rows and columns).
+ * Normalizes jagged rows to the maximum column width.
+ */
+export declare function transposeMatrix<T = string | number | null>(matrix: T[][]): T[][];
+/**
+ * Sorts tabular categories and series data consistently according to the specified sort rule.
+ */
+export declare function sortTabularData(categories: string[], series: ChartSeries[], sortBy?: 'none' | 'asc' | 'desc' | 'category-asc' | 'category-desc'): {
+    categories: string[];
+    series: ChartSeries[];
+};
+/**
+ * Main ingestion function: converts raw matrix or CSV string into a validated ChartDataset.
+ */
+export declare function parseTabularDataset(params: ParseTabularParams): ChartDataset;
+export interface FetchLiveSheetMatrixParams {
+    sheetUrl: string;
+    tabName?: string;
+    sheetGid?: string;
+    range?: string;
+    timeoutMs?: number;
+}
+/**
+ * Fetches real-time tabular data from a public Google Sheet via GViz CSV endpoint.
+ * Returns a 2D string matrix of cell contents without mocking or synthetic placeholders.
+ */
+export declare function fetchLiveSheetMatrix(params: FetchLiveSheetMatrixParams): Promise<string[][]>;

package/dist/services/sheetsVerificationService.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Google Sheets Access Verification & API Discovery Service
+ * Folio Engine
+ * Document Reference: docs/tasks/task7_2_access_verification_sheets_api.md
+ *
+ * Implements:
+ * 1. Pre-flight link access verification: Validates read access against Google endpoints
+ *    and produces tailored sharing guidance.
+ * 2. Automatic Sheet Tab Discovery: Uses Google Sheets API v4 metadata to auto-discover
+ *    tab names and sheet IDs (GIDs).
+ * 3. Fallbacks: Graceful degradation for unconfigured API keys, rate limits, or network errors.
+ */
+export interface SheetMetadataTab {
+    title: string;
+    sheetId: number;
+    index: number;
+}
+export interface SheetAccessCheckResult {
+    accessible: boolean;
+    spreadsheetId: string | null;
+    sheetGid?: string | null;
+    title?: string;
+    error?: string;
+    tabs?: SheetMetadataTab[];
+    modifiedTime?: string;
+}
+/**
+ * Extracts Google Spreadsheet ID from diverse URL patterns:
+ * - https://docs.google.com/spreadsheets/d/{id}/edit#gid=0
+ * - https://docs.google.com/spreadsheets/d/{id}/export?format=csv
+ * - https://docs.google.com/spreadsheets/d/{id}/gviz/tq?tqx=out:csv
+ * - https://docs.google.com/spreadsheets/u/0/d/{id}/view
+ * - Raw spreadsheet ID (25+ alphanumeric characters with dashes/underscores)
+ */
+export declare function extractSpreadsheetId(url: string): string | null;
+/**
+ * Extracts sheet tab GID (numerical identifier) from URL hash or query parameters:
+ * - #gid=123456789
+ * - ?gid=123456789
+ */
+export declare function extractSheetGid(url: string): string | null;
+/**
+ * Retrieves configured Google API key defensively from Vite or Node runtime.
+ */
+export declare function getGoogleApiKey(): string | null;
+/**
+ * Pure parser for Google Sheets API v4 metadata response.
+ */
+export declare function parseSheetsApiMetadata(data: unknown): SheetMetadataTab[];
+/**
+ * Pure parser for tab names and sheet GIDs from public Google Sheets htmlview payload.
+ * Google embeds workbook sheets as:
+ * items.push({name: "Sheet1", pageUrl: "...", gid: "0", ...})
+ */
+export declare function parseHtmlViewTabs(html: string): SheetMetadataTab[];
+/**
+ * Discovers available sheet tabs using:
+ * 1. Google Sheets API v4 metadata endpoint (if key present & enabled).
+ * 2. Public htmlview scraping fallback (no API key required, CORS-enabled).
+ */
+export declare function fetchSheetTabs(spreadsheetIdOrUrl: string, apiKey?: string, options?: {
+    timeoutMs?: number;
+}): Promise<SheetMetadataTab[]>;
+/**
+ * Verifies public readability of a Google Sheet link.
+ *
+ * Checks:
+ * 1. URL pattern validation & spreadsheet ID extraction.
+ * 2. Probe against Google endpoint (Sheets API v4 if API key present, or gviz probe).
+ * 3. Gracefully falls back to GViz probe if Sheets API is disabled or key lacks scope.
+ * 4. Detects restricted access (HTTP 401/403 or HTML login redirect).
+ * 5. Discovers sheet tabs automatically when accessible.
+ */
+export declare function verifySheetAccess(url: string, options?: {
+    apiKey?: string;
+    timeoutMs?: number;
+}): Promise<SheetAccessCheckResult>;
+/**
+ * Formats an ISO 8601 modified timestamp into human-readable academic format (e.g. "Oct 14, 2024").
+ */
+export declare function formatSheetModifiedTime(isoDate?: string | null): string | null;
+/**
+ * Fetches the authentic last modification date of a Google Sheet via Google Drive API v3.
+ */
+export declare function fetchSheetModifiedTime(spreadsheetIdOrUrl: string, apiKey?: string, options?: {
+    timeoutMs?: number;
+}): Promise<string | null>;

package/dist/services/sourceService.d.ts

@@ -0,0 +1,43 @@
+/**
+ * BaaS Data Access Layer & Live Evidence Persistence Service
+ * Folio Engine
+ * Subtask 5.1: Database Schema & BaaS Persistence Engine
+ *
+ * Implements a resilient client service layer with:
+ * 1. PostgREST / Supabase cloud persistence for live coordinator updates.
+ * 2. Multi-tier caching (In-Memory -> LocalStorage snapshot -> Baseline JSON fallback).
+ * 3. Zero-downtime offline and network disconnection resilience.
+ */
+import type { LiveSourceSource, LiveSourceRegistry, UpsertSourcePayload } from '../types/source';
+export declare const getSourceCacheStorageKey: (ns?: string) => string;
+export declare const STORAGE_KEY_SOURCE_CACHE: string;
+export declare const EVENT_SOURCE_SOURCE_CHANGE = "engine-evidence-source-change";
+/**
+ * Sanitizes a LiveSourceSource ensuring any ephemeral /drive-storage/ links
+ * are permanently replaced with stable, non-expiring Google Drive endpoints.
+ */
+export declare function sanitizeLiveSourceSource(source: LiveSourceSource): LiveSourceSource;
+/**
+ * Asynchronously fetches live source sources from the database.
+ * Falls back transparently to localStorage snapshots or baseline JSON.
+ */
+export declare function fetchLiveSourceSources(options?: {
+    forceRefresh?: boolean;
+}): Promise<LiveSourceRegistry>;
+/**
+ * Retrieves a single live source source by pointId with slug normalization.
+ */
+export declare function getLiveSourceSource(pointId: string): Promise<LiveSourceSource | null>;
+/**
+ * Synchronous accessor for fast UI rendering loops without layout shift.
+ * Reads from memory cache, localStorage snapshot, or fallback baseline synchronously.
+ */
+export declare function getSourceSourceSync(pointId: string): LiveSourceSource | null;
+/**
+ * Inserts or updates an source source in the BaaS database and local caches.
+ */
+export declare function upsertLiveSourceSource(payload: UpsertSourcePayload, token?: string): Promise<LiveSourceSource>;
+/**
+ * Resets the in-memory cache and localStorage snapshot back to system defaults.
+ */
+export declare function resetSourceCache(): void;

package/dist/services/undoRedoService.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Folio Engine - Active Session Undo / Redo Service
+ * Location: src/services/undoRedoService.ts
+ * Specification: docs/tasks/task9_2_active_session_undo_redo_engine.md
+ * Aligned with: docs/00_WORKFLOW.md, docs/03_ARCHITECTURE.md, docs/07_CODING_STANDARDS.md
+ *
+ * Implements:
+ * 1. Double-stack command pattern with capped depth (MAX_STACK_DEPTH = 50).
+ * 2. Re-entrancy prevention guard (isExecuting) to prevent nested dispatches during undo/redo.
+ * 3. Forward redo clearance on new user actions.
+ * 4. Keyboard focus detection utility (isTextInput) for shortcut chord isolation.
+ */
+import type { UndoAction, UndoRedoState } from '../types/history';
+export declare const MAX_STACK_DEPTH = 50;
+export declare class UndoRedoManager {
+    private undoStack;
+    private redoStack;
+    private executingLock;
+    /**
+     * Pushes a reversible action onto the undo stack.
+     * Clears the redo stack and enforces the 50-action depth cap.
+     * If an undo/redo action is currently executing, this is a no-op to prevent re-entrant loops.
+     */
+    push(action: Omit<UndoAction, 'id' | 'timestamp'>): UndoAction | null;
+    /**
+     * Pops the most recent action from the undo stack, executes action.undo(),
+     * and pushes it onto the redo stack.
+     */
+    popUndo(): UndoAction | null;
+    /**
+     * Pops the most recent action from the redo stack, executes action.redo(),
+     * and pushes it onto the undo stack.
+     */
+    popRedo(): UndoAction | null;
+    /**
+     * Clears both undo and redo stacks (e.g. on dev mode exit or restore).
+     */
+    clear(): void;
+    /**
+     * Retrieves current immutable state snapshot.
+     */
+    getState(): UndoRedoState;
+    /**
+     * Returns true if an undo/redo operation is currently executing.
+     */
+    isExecuting(): boolean;
+    /**
+     * Diagnostic inspector for testing.
+     */
+    getStacks(): {
+        undo: UndoAction[];
+        redo: UndoAction[];
+    };
+}
+/**
+ * Checks if the target element is an active text input or editable container.
+ * Used to avoid hijacking native cursor undo/redo inside text fields.
+ */
+export declare function isTextInput(target: EventTarget | null): boolean;
+/**
+ * Singleton instance for active session lifetime.
+ */
+export declare const undoRedoService: UndoRedoManager;

package/dist/services/unsavedChangesService.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Folio Engine - Centralized Unsaved / Unpublished Changes Registry Service
+ * Location: src/services/unsavedChangesService.ts
+ * Specification: docs/tasks/task12_0_prevent_refresh_unsaved_changes.md
+ * Aligned with: docs/00_WORKFLOW.md, docs/03_ARCHITECTURE.md, docs/07_CODING_STANDARDS.md
+ *
+ * Implements:
+ * 1. Synchronous in-memory registry of active dirty modal/drawer editors.
+ * 2. Unified dirty status combining active in-flight forms + draft sandbox dirty state.
+ * 3. Canonical beforeunload event guard complying with W3C browser prompt standards.
+ */
+/**
+ * Registers or updates the dirty state of an active editor component.
+ */
+export declare function registerDirtyEditor(editorId: string, isDirty: boolean): void;
+/**
+ * Unregisters an editor upon component unmount or cancellation.
+ */
+export declare function unregisterDirtyEditor(editorId: string): void;
+/**
+ * Clears all active dirty editors (used during tests or whole-session resets).
+ */
+export declare function clearAllDirtyEditors(): void;
+/**
+ * Returns true if there are any active in-flight unsaved form inputs OR unpublished draft changes.
+ */
+export declare function hasAnyUnsavedChanges(): boolean;
+/**
+ * Canonical W3C-compliant beforeunload guard.
+ * Returns empty string and calls preventDefault() if dirty, otherwise does nothing.
+ */
+export declare function handleBeforeUnloadGuard(e: BeforeUnloadEvent): string | undefined;