diff --git a/wiki/Architecture.md b/wiki/Architecture.md
index 7b0f85bf..dfd922b9 100644
--- a/wiki/Architecture.md
+++ b/wiki/Architecture.md
@@ -1,3 +1,5 @@
+<!-- AUTO-GENERATED from source code by scripts/generate_wiki.py — do not edit manually -->
+
 # Architecture
 
 ## Overview
@@ -12,13 +14,16 @@ FastPlot/
 ├── libs/
 │   ├── FastSense/                 # Core plotting engine
 │   │   ├── FastSense.m            # Main class
-│   │   ├── FastSenseGrid.m       # Dashboard layout
-│   │   ├── FastSenseDock.m         # Tabbed container
-│   │   ├── FastSenseToolbar.m      # Interactive toolbar
-│   │   ├── FastSenseTheme.m        # Theme system
-│   │   ├── FastSenseDataStore.m    # SQLite-backed chunked storage
+│   │   ├── FastSenseGrid.m        # Dashboard layout
+│   │   ├── FastSenseDock.m        # Tabbed container
+│   │   ├── FastSenseToolbar.m     # Interactive toolbar
+│   │   ├── FastSenseTheme.m       # Theme system
+│   │   ├── FastSenseDataStore.m   # SQLite-backed chunked storage
 │   │   ├── SensorDetailPlot.m     # Sensor detail view with state bands
 │   │   ├── NavigatorOverlay.m     # Minimap zoom navigator
+│   │   ├── ConsoleProgressBar.m   # Progress indication
+│   │   ├── binary_search.m        # Binary search utility
+│   │   ├── build_mex.m            # MEX compilation script
 │   │   ├── mksqlite.c             # SQLite3 MEX interface
 │   │   └── private/               # Internal algorithms + MEX sources
 │   ├── SensorThreshold/           # Sensor and threshold system
@@ -33,7 +38,14 @@ FastPlot/
 │   │   ├── EventViewer.m
 │   │   ├── LiveEventPipeline.m
 │   │   ├── NotificationService.m
-│   │   └── private/               # Violation grouping
+│   │   ├── EventStore.m
+│   │   ├── EventConfig.m
+│   │   ├── IncrementalEventDetector.m
+│   │   ├── DataSource.m           # Abstract data source
+│   │   ├── MatFileDataSource.m    # File-based data source
+│   │   ├── MockDataSource.m       # Test data generation
+│   │   ├── NotificationRule.m     # Email notification rules
+│   │   └── private/               # Event grouping algorithms
 │   ├── Dashboard/                 # Dashboard engine (serializable)
 │   │   ├── DashboardEngine.m
 │   │   ├── DashboardBuilder.m
@@ -128,6 +140,28 @@ Optional C MEX functions with SIMD intrinsics (AVX2 on x86_64, NEON on arm64):
 
 All share a common `simd_utils.h` abstraction layer. If MEX is unavailable, pure-MATLAB implementations are used with identical behavior.
 
+## Data Flow Architecture
+
+### Core Data Path
+```
+Raw Data (X, Y arrays)
+    ↓
+FastSenseDataStore (optional, for large datasets)
+    ↓
+Downsampling Engine (MinMax/LTTB)
+    ↓
+Pyramid Cache (lazy multi-resolution)
+    ↓
+Graphics Objects (line handles)
+    ↓
+Interactive Display
+```
+
+### Storage Modes
+- **Memory mode**: X/Y arrays held in MATLAB workspace
+- **Disk mode**: Data chunked into SQLite database via `FastSenseDataStore`
+- **Auto mode**: Switches to disk when data exceeds `MemoryLimit` (default 500MB)
+
 ## Sensor Threshold Resolution
 
 The `Sensor.resolve()` algorithm is segment-based:
@@ -139,7 +173,7 @@ The `Sensor.resolve()` algorithm is segment-based:
 3. Assign threshold values per segment
 4. Detect violations using SIMD-accelerated comparison
 
-Complexity: O(S x R) where S = state segments and R = rules, instead of O(N x R) per-point evaluation.
+Complexity: O(S × R) where S = state segments and R = rules, instead of O(N × R) per-point evaluation.
 
 ## Disk-Backed Data Storage
 
@@ -221,6 +255,44 @@ Clicking "Edit" in the toolbar creates a `DashboardBuilder` instance:
 - **Load:** JSON is decoded, widgets array is normalized to cell, and `configToWidgets()` dispatches to each widget class's `fromStruct()` static method. An optional `SensorResolver` function handle re-binds Sensor objects by name.
 - **Export script:** generates a `.m` file with `DashboardEngine` constructor calls and `addWidget` calls for each widget.
 
+## Event Detection Architecture
+
+The event detection system provides real-time threshold violation monitoring with configurable notifications and data persistence.
+
+### Core Components
+
+```
+LiveEventPipeline
+├── DataSourceMap          — Maps sensor keys to data sources
+├── IncrementalEventDetector — Tracks per-sensor state and open events
+├── EventStore            — Thread-safe .mat file persistence
+├── NotificationService   — Rule-based email alerts
+└── EventViewer          — Interactive Gantt chart + filterable table
+```
+
+### Data Sources
+
+- **MatFileDataSource**: Polls .mat files for new data
+- **MockDataSource**: Generates realistic test signals with violations
+- **Custom sources**: Implement `DataSource.fetchNew()` interface
+
+### Event Detection Flow
+
+1. `LiveEventPipeline.runCycle()` polls all data sources
+2. New data is passed to `IncrementalEventDetector.process()`
+3. Sensor state is evaluated via `Sensor.resolve()`
+4. Violations are grouped into events with debouncing (`MinDuration`)
+5. Events are stored via `EventStore.append()` (atomic .mat writes)
+6. `NotificationService` sends rule-based email alerts with plot snapshots
+7. Active `EventViewer` instances auto-refresh to show new events
+
+### Escalation Logic
+
+When `EscalateSeverity` is enabled, events are promoted to the highest violated threshold:
+- A violation starts at "Warning" level
+- If "Alarm" threshold is also crossed, the event is escalated to "Alarm"
+- The event retains the highest severity level encountered
+
 ## WebBridge Architecture
 
 The `WebBridge` class provides a TCP server that bridges MATLAB dashboards to web-based visualization. It uses NDJSON (newline-delimited JSON) for message framing over TCP.
@@ -231,14 +303,14 @@ All messages are JSON objects terminated by a newline character. The protocol is
 
 | Message Type | Direction | Description |
 |-------------|-----------|-------------|
-| `init` | MATLAB -> Bridge | Initial handshake with signal list, dashboard config, and registered actions |
-| `data_changed` | MATLAB -> Bridge | Notify that signal data has been updated |
-| `config_changed` | MATLAB -> Bridge | Dashboard layout/theme has changed |
-| `actions_changed` | MATLAB -> Bridge | Available custom actions have changed |
-| `action` | Bridge -> MATLAB | Execute a registered action (with optional args) |
-| `action_result` | MATLAB -> Bridge | Result of action execution (ok/error) |
-| `bridge_ready` | Bridge -> MATLAB | Bridge reports its HTTP port |
-| `shutdown` | MATLAB -> Bridge | Graceful shutdown signal |
+| `init` | MATLAB → Bridge | Initial handshake with signal list, dashboard config, and registered actions |
+| `data_changed` | MATLAB → Bridge | Notify that signal data has been updated |
+| `config_changed` | MATLAB → Bridge | Dashboard layout/theme has changed |
+| `actions_changed` | MATLAB → Bridge | Available custom actions have changed |
+| `action` | Bridge → MATLAB | Execute a registered action (with optional args) |
+| `action_result` | MATLAB → Bridge | Result of action execution (ok/error) |
+| `bridge_ready` | Bridge → MATLAB | Bridge reports its HTTP port |
+| `shutdown` | MATLAB → Bridge | Graceful shutdown signal |
 
 ### Data Flow
 
@@ -266,3 +338,19 @@ MATLAB (DashboardEngine)
 - **Custom actions:** MATLAB callbacks registered via `registerAction(name, callback)` are exposed to the web UI and invoked over TCP
 - **Config polling:** a timer periodically hashes the dashboard config JSON and sends `config_changed` when the layout changes
 - **WAL mode:** SQLite DataStore databases are switched to WAL (Write-Ahead Logging) mode during serving for concurrent MATLAB writes and bridge reads
+
+## Interactive Features
+
+### Progress Indication
+`ConsoleProgressBar` provides hierarchical progress feedback:
+- Single-line ASCII/Unicode bars with backspace-based updates
+- Indentation support for nested operations (e.g., dock → tabs → tiles)
+- Freeze/finish modes for permanent status lines
+
+### Toolbars and Navigation
+- **FastSenseToolbar**: Data cursor, crosshair, grid toggle, autoscale, export, live mode
+- **DashboardToolbar**: Live toggle, edit mode, save/export, name editing
+- **NavigatorOverlay**: Minimap with draggable zoom rectangle for `SensorDetailPlot`
+
+### Link Groups
+Multiple FastSense instances can share synchronized zoom/pan via `LinkGroup` strings. When one plot's XLim changes, all plots in the same group update automatically.
diff --git a/wiki/Datetime-Guide.md b/wiki/Datetime-Guide.md
index f25b7afe..42fb893b 100644
--- a/wiki/Datetime-Guide.md
+++ b/wiki/Datetime-Guide.md
@@ -1,6 +1,8 @@
+<!-- AUTO-GENERATED from source code by scripts/generate_wiki.py — do not edit manually -->
+
 # Datetime Guide
 
-FastPlot supports time series data with datetime X-axes. Both datenum values and MATLAB datetime objects are supported.
+FastSense supports time series data with datetime X-axes. Both datenum values and MATLAB datetime objects are supported.
 
 ---
 
@@ -77,11 +79,11 @@ fig = FastSenseGrid(2, 1, 'Theme', 'dark');
 
 fp1 = fig.tile(1);
 fp1.addLine(x, sin(2*pi*(1:1e6)/86400)*20+50, 'XType', 'datenum', 'DisplayName', 'Pressure');
-fig.tileTitle(1, 'Pressure');
+fig.setTileTitle(1, 'Pressure');
 
 fp2 = fig.tile(2);
 fp2.addLine(x, cos(2*pi*(1:1e6)/86400)*10+25, 'XType', 'datenum', 'DisplayName', 'Temperature');
-fig.tileTitle(2, 'Temperature');
+fig.setTileTitle(2, 'Temperature');
 
 fig.renderAll();
 ```
@@ -146,6 +148,31 @@ fp.render();
 
 ---
 
+## SensorDetailPlot with Datetime
+
+The `SensorDetailPlot` component supports datetime X-axes through the `'XType'` parameter:
+
+```matlab
+% Create sensor with datenum timestamps
+tStart = datetime(2024, 3, 11, 8, 0, 0);
+tEnd = datetime(2024, 3, 11, 10, 0, 0);
+tDatetime = linspace(tStart, tEnd, 72000);
+tNum = datenum(tDatetime);
+
+s = Sensor('pressure', 'Name', 'Line Pressure');
+s.X = tNum;
+s.Y = 4.2 + 0.6*sin(2*pi*tNum*24/1.5) + 0.15*randn(1, 72000);
+s.resolve();
+
+% Create detail plot with datetime formatting
+sdp = SensorDetailPlot(s, 'XType', 'datenum', 'Theme', 'light');
+sdp.render();
+```
+
+The navigator and main plot both show human-readable time labels.
+
+---
+
 ## GNU Octave Notes
 
 - Octave does not support MATLAB's `datetime` class
diff --git a/wiki/Event-Detection-Guide.md b/wiki/Event-Detection-Guide.md
new file mode 100644
index 00000000..7e1ff841
--- /dev/null
+++ b/wiki/Event-Detection-Guide.md
@@ -0,0 +1,410 @@
+<!-- AUTO-GENERATED from source code by scripts/generate_wiki.py — do not edit manually -->
+
+# Event Detection Guide
+
+The Event Detection system in FastSense provides comprehensive threshold-based monitoring with live detection, notification services, and visual event management. It bridges the [[Sensors]] library for threshold analysis with real-time event pipelines, storage, and notifications.
+
+## When to Use Event Detection
+
+- **Real-time monitoring**: Detect threshold violations as they occur in live data streams
+- **Historical analysis**: Analyze events from recorded sensor data with statistical summaries
+- **Alert systems**: Configure rule-based notifications with email and snapshot generation
+- **Event visualization**: View events in Gantt timelines and filterable tables
+- **Data archival**: Store events with automatic backup rotation and atomic file operations
+
+## Core Workflow
+
+The event detection workflow follows these steps:
+
+1. **Configure sensors** with thresholds using the [[Sensors]] library
+2. **Set up data sources** to fetch new sensor data (live files, mock data, etc.)
+3. **Configure event detection** with minimum duration, callbacks, and escalation
+4. **Run detection** to find threshold violations and generate Event objects
+5. **Store and visualize** events using EventStore and EventViewer
+
+## Basic Event Detection
+
+### Quick Start Example
+
+```matlab
+% Create a sensor with threshold
+sensor = Sensor('temperature');
+sensor.X = 1:100;
+sensor.Y = 70 + 10*sin((1:100)/10) + randn(1,100);
+sensor.addThresholdRule(struct(), 85, 'Direction', 'upper', 'Label', 'temp high');
+
+% Configure and run detection
+cfg = EventConfig();
+cfg.MinDuration = 2;  % 2-second minimum
+cfg.addSensor(sensor);
+events = cfg.runDetection();
+
+% Print summary
+printEventSummary(events);
+```
+
+### EventConfig - Central Configuration
+
+The [[Event Detection|EventConfig]] class orchestrates all event detection:
+
+```matlab
+cfg = EventConfig();
+cfg.MinDuration = 1.5;              % Debounce short violations
+cfg.MaxCallsPerEvent = 2;           % Limit callback invocations
+cfg.EscalateSeverity = true;        % H -> HH when peak exceeds
+cfg.AutoOpenViewer = true;          % Open EventViewer after detection
+cfg.OnEventStart = eventLogger();   % Console logging callback
+
+% Auto-save events to file with backup rotation
+cfg.EventFile = 'my_events.mat';
+cfg.MaxBackups = 5;
+
+% Add sensors
+cfg.addSensor(temperatureSensor);
+cfg.addSensor(pressureSensor);
+
+% Set threshold colors for visualization
+cfg.setColor('temp warning', [1 0.8 0]);
+cfg.setColor('temp critical', [1 0.2 0]);
+
+% Run detection
+events = cfg.runDetection();
+```
+
+### Event Objects
+
+Each detected event is represented by an [[Event Detection|Event]] object:
+
+```matlab
+% Event properties (read-only after creation)
+event.StartTime       % datenum of violation start
+event.EndTime         % datenum of violation end  
+event.Duration        % duration in days
+event.SensorName      % sensor identifier
+event.ThresholdLabel  % threshold name
+event.ThresholdValue  % threshold numeric value
+event.Direction       % 'upper' or 'lower'
+
+% Statistical properties (set by detector)
+event.PeakValue      % most extreme value during violation
+event.NumPoints      % number of data points in violation
+event.MinValue       % minimum value during violation
+event.MaxValue       % maximum value during violation
+event.MeanValue      % mean value during violation
+event.RmsValue       % RMS value during violation
+event.StdValue       % standard deviation during violation
+```
+
+## Live Event Detection
+
+### Data Sources
+
+Data sources provide the interface between your data and the event detection system:
+
+```matlab
+% Mock data source for testing
+mockDS = MockDataSource('BaseValue', 100, 'NoiseStd', 2, ...
+    'ViolationProbability', 0.001, 'ViolationAmplitude', 25);
+
+% File-based data source for live monitoring
+fileDS = MatFileDataSource('sensors/temp.mat', 'XVar', 'time', 'YVar', 'temp');
+
+% Map sensors to data sources
+dsMap = DataSourceMap();
+dsMap.add('temperature', mockDS);
+dsMap.add('pressure', fileDS);
+```
+
+### Live Pipeline
+
+The [[Event Detection|LiveEventPipeline]] orchestrates continuous monitoring:
+
+```matlab
+% Create pipeline
+pipeline = LiveEventPipeline(sensors, dsMap, ...
+    'EventFile', 'live_events.mat', ...
+    'Interval', 15, ...              % 15-second polling
+    'MinDuration', 5, ...            % 5-second minimum events
+    'EscalateSeverity', true);       % H -> HH escalation
+
+% Configure notifications
+notifService = NotificationService('DryRun', true);
+pipeline.NotificationService = notifService;
+
+% Start/stop live monitoring
+pipeline.start();   % begins timer-driven cycles
+pipeline.stop();    % stops timer
+```
+
+### Incremental Detection
+
+For live scenarios, use [[Event Detection|IncrementalEventDetector]] to maintain state between updates:
+
+```matlab
+detector = IncrementalEventDetector('MinDuration', 2, ...
+    'EscalateSeverity', true);
+
+% Process incremental updates
+newEvents = detector.process('temp_01', sensor, newX, newY, [], []);
+
+% Check for ongoing events
+if detector.hasOpenEvent('temp_01')
+    state = detector.getSensorState('temp_01');
+    fprintf('Open event since %.2f\n', state.openEventStart);
+end
+```
+
+## Event Storage and Persistence
+
+### EventStore - Atomic File Operations
+
+The [[Event Detection|EventStore]] provides thread-safe event persistence:
+
+```matlab
+% Create event store
+store = EventStore('events.mat', 'MaxBackups', 3);
+
+% Configure metadata for EventViewer
+store.SensorData = cfg.SensorData;           % for click-to-plot
+store.ThresholdColors = cfg.ThresholdColors; % for color consistency
+
+% Append new events (atomic operation)
+store.append(newEvents);
+store.save();
+
+% Load from file (static method)
+[events, metadata, changed] = EventStore.loadFile('events.mat');
+```
+
+### Auto-Save Configuration
+
+EventConfig can automatically save events to a file:
+
+```matlab
+cfg.EventFile = 'auto_events.mat';  % Enable auto-save
+cfg.MaxBackups = 5;                  % Backup rotation
+
+% Events saved automatically after cfg.runDetection()
+events = cfg.runDetection();
+```
+
+## Event Visualization
+
+### EventViewer - Interactive Timeline
+
+The [[Event Detection|EventViewer]] provides a Gantt timeline and filterable table:
+
+```matlab
+% Create viewer with full context
+viewer = EventViewer(events, sensorData, thresholdColors);
+
+% Or load from saved file
+viewer = EventViewer.fromFile('events.mat');
+
+% Auto-refresh from file
+viewer.startAutoRefresh(10);  % refresh every 10 seconds
+viewer.stopAutoRefresh();
+
+% Manual refresh
+viewer.refreshFromFile();
+
+% Update with new events
+viewer.update(newEvents);
+```
+
+The EventViewer features:
+- **Gantt timeline**: Visual event bars colored by threshold
+- **Filterable table**: Filter by sensor, threshold, date range
+- **Click interaction**: Click Gantt bars to highlight table rows
+- **Auto-refresh**: Polls the source file for live updates
+- **Export**: Context menu options for data export
+
+## Notification System
+
+### Notification Rules
+
+Configure rule-based notifications with priority matching:
+
+```matlab
+% Default rule (catches all events)
+defaultRule = NotificationRule('Recipients', {{'ops@company.com'}}, ...
+    'Subject', 'Event: {sensor} - {threshold}', ...
+    'IncludeSnapshot', false);
+
+% Sensor-specific rule (higher priority)
+tempRule = NotificationRule('SensorKey', 'temperature', ...
+    'Recipients', {{'thermal@company.com'}}, ...
+    'Subject', 'Temperature Event: {threshold}', ...
+    'IncludeSnapshot', true, ...
+    'ContextHours', 2);
+
+% Exact match rule (highest priority)  
+criticalRule = NotificationRule('SensorKey', 'temperature', ...
+    'ThresholdLabel', 'critical', ...
+    'Recipients', {{'safety@company.com', 'manager@company.com'}}, ...
+    'Subject', 'CRITICAL: {sensor} {threshold}!');
+```
+
+### NotificationService
+
+The [[Event Detection|NotificationService]] manages rule-based notifications:
+
+```matlab
+notif = NotificationService('DryRun', true, ... % test mode
+    'SnapshotDir', 'snapshots/', ...
+    'SmtpServer', 'mail.company.com');
+
+notif.setDefaultRule(defaultRule);
+notif.addRule(tempRule);
+notif.addRule(criticalRule);
+
+% Notify on event (called by pipeline)
+notif.notify(event, sensorData);
+```
+
+### Email Templates
+
+Notification templates support variable substitution:
+
+```matlab
+rule = NotificationRule( ...
+    'Subject', 'Alert: {sensor} exceeded {threshold}', ...
+    'Message', ['Sensor: {sensor}\n' ...
+               'Threshold: {threshold} ({direction})\n' ...
+               'Time: {startTime} to {endTime}\n' ...
+               'Duration: {duration}\n' ...
+               'Peak: {peak}\n' ...
+               'Statistics: mean={mean}, std={std}']);
+```
+
+Available template variables:
+- `{sensor}`, `{threshold}`, `{direction}`, `{peak}`
+- `{startTime}`, `{endTime}`, `{duration}`
+- `{mean}`, `{std}`, `{min}`, `{max}`, `{rms}`
+
+### Event Snapshots
+
+Generate PNG snapshots showing event context:
+
+```matlab
+% Generate detail and context plots
+files = generateEventSnapshot(event, sensorData, ...
+    'OutputDir', 'snapshots/', ...
+    'SnapshotSize', [800, 400], ...
+    'Padding', 0.1, ...          % 10% padding around event
+    'ContextHours', 2);          % 2 hours before event
+
+% Returns: {detailFile, contextFile}
+```
+
+## Severity Escalation
+
+Events can escalate to higher severity levels when peaks exceed multiple thresholds:
+
+```matlab
+% Configure escalation
+detector = EventDetector('EscalateSeverity', true);
+
+% Sensor with multiple thresholds
+sensor.addThresholdRule(struct(), 85, 'Label', 'H Warning');
+sensor.addThresholdRule(struct(), 95, 'Label', 'HH Alarm');
+
+% If violation starts at 87 (H Warning) but peaks at 97:
+% 1. Initial event: "H Warning" 
+% 2. Escalated event: "HH Alarm" (same time span, higher severity)
+events = detectEventsFromSensor(sensor, detector);
+```
+
+## Utility Functions
+
+### Event Logging
+
+Simple console logging for development:
+
+```matlab
+cfg.OnEventStart = eventLogger();
+
+% Logs: [EVENT] Temperature | temp high | UPPER | 123.45 -> 125.67 (dur=0.02) | peak=126.83
+```
+
+### Event Summary
+
+Formatted console output for analysis:
+
+```matlab
+printEventSummary(events);
+
+% Outputs table with columns:
+% Start | End | Duration | Sensor | Threshold | Dir | Peak | #Pts | Mean | Std
+```
+
+### Bridging with Sensors
+
+Convert from sensor violations to events:
+
+```matlab
+% Uses sensor.ResolvedViolations and sensor.ResolvedThresholds
+events = detectEventsFromSensor(sensor);
+events = detectEventsFromSensor(sensor, customDetector);
+```
+
+## Performance Considerations
+
+- **MinDuration**: Use appropriate debounce times to filter noise
+- **MaxCallsPerEvent**: Limit callback overhead in high-frequency scenarios  
+- **Backup rotation**: Configure MaxBackups to manage disk usage
+- **Incremental detection**: Use IncrementalEventDetector for live scenarios to avoid reprocessing
+- **File polling**: Balance refresh intervals with system load
+- **Snapshot generation**: PNG creation can be expensive; use sparingly
+
+## Common Patterns
+
+### Multi-Sensor Dashboard with Events
+
+```matlab
+% Configure multiple sensors
+cfg = EventConfig();
+cfg.addSensor(temperatureSensor);
+cfg.addSensor(pressureSensor);  
+cfg.addSensor(vibrationSensor);
+cfg.AutoOpenViewer = true;
+
+% Run detection and view results
+events = cfg.runDetection();
+```
+
+### Live Monitoring with Notifications
+
+```matlab
+% Set up complete live pipeline
+pipeline = LiveEventPipeline(sensors, dataSourceMap, ...
+    'EventFile', 'monitoring.mat', ...
+    'Interval', 30);
+
+% Configure notifications
+pipeline.NotificationService = notificationService;
+
+% Start monitoring
+pipeline.start();
+```
+
+### Event Analysis Workflow
+
+```matlab
+% Load saved events
+viewer = EventViewer.fromFile('historical_events.mat');
+
+% Analyze programmatically
+[events, meta] = EventStore.loadFile('historical_events.mat');
+tempEvents = events(strcmp({events.SensorName}, 'Temperature'));
+criticalEvents = events(strcmp({events.ThresholdLabel}, 'critical'));
+
+printEventSummary(criticalEvents);
+```
+
+## See Also
+
+- [[Sensors]] - Configure thresholds and violations
+- [[Live Mode Guide]] - Real-time data streaming patterns
+- [[Dashboard Engine Guide]] - Multi-plot coordination
+- [[Examples]] - Complete working examples
diff --git a/wiki/Getting-Started.md b/wiki/Getting-Started.md
index 11231ef3..fa2ad769 100644
--- a/wiki/Getting-Started.md
+++ b/wiki/Getting-Started.md
@@ -1,12 +1,17 @@
+<!-- AUTO-GENERATED from source code by scripts/generate_wiki.py — do not edit manually -->
+
 # Getting Started
 
-A step-by-step tutorial introducing FastPlot's core features.
+A step-by-step tutorial introducing FastSense's core features for ultra-fast time series plotting.
 
 ## 1. Your First Plot
 
 ```matlab
-setup;
+% Set up the library
+projectRoot = fileparts(fileparts(mfilename('fullpath')));
+run(fullfile(projectRoot, 'install.m'));
 
+% Create a 10 million point dataset
 fp = FastSense();
 x = linspace(0, 100, 1e7);  % 10 million points
 y = sin(x) + 0.1 * randn(size(x));
@@ -14,7 +19,7 @@ fp.addLine(x, y, 'DisplayName', 'Noisy Sine');
 fp.render();
 ```
 
-Try zooming and panning — FastSense re-downsamples in real time, keeping the display responsive regardless of dataset size.
+Try zooming and panning — FastSense automatically downsamples data to screen resolution in real time, keeping the display responsive regardless of dataset size.
 
 ## 2. Themes
 
@@ -24,7 +29,7 @@ fp.addLine(x, y, 'DisplayName', 'Sensor');
 fp.render();
 ```
 
-Available presets: 'default', 'dark', 'light', 'industrial', 'scientific', 'ocean'. See [[API Reference: Themes]] for customization.
+Available presets: 'default', 'dark', 'light', 'industrial', 'scientific', 'ocean'. See [[API Reference: Themes]] for customization options.
 
 ## 3. Thresholds and Violations
 
@@ -48,26 +53,26 @@ fp.addLine(x, sin(2*x) * 0.5, 'DisplayName', 'Channel C');
 fp.render();
 ```
 
-Colors auto-cycle from the theme's palette.
+Colors auto-cycle from the theme's palette. Use `resetColorIndex()` to restart the color sequence.
 
 ## 5. Visual Annotations
 
-### Bands (horizontal alarm zones)
+### Horizontal Bands (alarm zones)
 ```matlab
 fp.addBand(0.8, 1.0, 'FaceColor', [1 0.3 0.3], 'FaceAlpha', 0.15, 'Label', 'High Alarm');
 ```
 
-### Shaded regions (between curves)
+### Shaded Regions (between curves)
 ```matlab
 fp.addShaded(x, y+0.5, y-0.5, 'FaceColor', [0.3 0.7 1], 'FaceAlpha', 0.2, 'DisplayName', 'Envelope');
 ```
 
-### Area fills
+### Area Fills
 ```matlab
 fp.addFill(x, abs(y), 'FaceColor', [0 0.5 1], 'Baseline', 0, 'DisplayName', 'Energy');
 ```
 
-### Event markers
+### Event Markers
 ```matlab
 fp.addMarker([10 30 70], [0.9 0.9 0.9], 'Marker', 'v', 'MarkerSize', 10, 'Color', [1 0 0], 'Label', 'Events');
 ```
@@ -81,15 +86,15 @@ fig.setTileSpan(1, [1 2]);  % top tile spans full width
 fp1 = fig.tile(1);
 fp1.addLine(x, sin(x)*50+50, 'DisplayName', 'Pressure');
 fp1.addBand(90, 100, 'FaceColor', [1 0 0], 'FaceAlpha', 0.12, 'Label', 'Alarm');
-fig.tileTitle(1, 'Pressure');
+fig.setTileTitle(1, 'Pressure');
 
 fp2 = fig.tile(2);
 fp2.addLine(x, cos(x)*20+60, 'DisplayName', 'Temperature');
-fig.tileTitle(2, 'Temperature');
+fig.setTileTitle(2, 'Temperature');
 
 fp3 = fig.tile(3);
 fp3.addLine(x, randn(size(x)), 'DisplayName', 'Vibration');
-fig.tileTitle(3, 'Vibration');
+fig.setTileTitle(3, 'Vibration');
 
 fig.renderAll();
 ```
@@ -129,34 +134,28 @@ fp.addLine(x, y, 'XType', 'datenum', 'DisplayName', 'Daily Cycle');
 fp.render();
 ```
 
-## 10. Sensor System
+## 10. Logarithmic Axes
 
 ```matlab
-s = Sensor('pressure', 'Name', 'Chamber Pressure');
-s.X = linspace(0, 100, 1e6);
-s.Y = randn(1, 1e6) * 10 + 50;
-
-sc = StateChannel('machine');
-sc.X = [0 30 60 80]; sc.Y = [0 1 2 1];
-s.addStateChannel(sc);
-s.addThresholdRule(struct('machine', 1), 70, 'Direction', 'upper', 'Label', 'Run HI');
-s.addThresholdRule(struct('machine', 2), 55, 'Direction', 'upper', 'Label', 'Boost HI');
-s.resolve();
+% Exponential growth data
+n2 = 1e6;
+x2 = linspace(1, 1000, n2);
+y2 = exp(x2 / 200) .* (1 + 0.1 * randn(1, n2));
 
-fp = FastSense('Theme', 'industrial');
-fp.addSensor(s, 'ShowThresholds', true);
-fp.render();
+fp2 = FastSense();
+fp2.addLine(x2, y2, 'DisplayName', 'Exponential Growth');
+fp2.setScale('YScale', 'log');
+fp2.render();
 ```
 
-## 11. Event Detection
+Use `setScale('XScale', 'log')` for logarithmic X-axis or both together.
 
-```matlab
-det = EventDetector('MinDuration', 0.5);
-events = detectEventsFromSensor(s, det);
-printEventSummary(events);
+## 11. Updating Data
 
-sensorData = struct('name', 'pressure', 't', s.X, 'y', s.Y);
-viewer = EventViewer(events, sensorData);
+```matlab
+% Replace line data on an already-rendered plot
+newY = cos(x * 2*pi/15) + 0.4*randn(size(x));
+fp.updateData(1, x, newY);
 ```
 
 ## 12. Downsampling Methods
@@ -175,12 +174,31 @@ fp.addLine(x, y1, 'DownsampleMethod', 'minmax', 'DisplayName', 'MinMax');
 fp.addLine(x, y2, 'DownsampleMethod', 'lttb', 'DisplayName', 'LTTB');
 ```
 
+## 13. Live Mode
+
+```matlab
+% Start live mode to auto-refresh from a .mat file
+fp.startLive('data.mat', @(fp, s) fp.updateData(1, s.x, s.y), 'Interval', 1);
+```
+
+The callback is triggered whenever the file's modification date changes.
+
+## 14. Figure Distribution
+
+```matlab
+% Auto-arrange all open figures on screen
+FastSense.distFig();
+
+% Or use specific grid dimensions
+FastSense.distFig('Rows', 2, 'Cols', 3);
+```
+
 ## Next Steps
 
-- [[API Reference: FastPlot]] — full constructor options, properties, methods
-- [[API Reference: Dashboard]] — tiled and tabbed layouts
-- [[API Reference: Sensors]] — state-dependent thresholds
-- [[API Reference: Event Detection]] — event detection and viewer
+- [[FastPlot|API Reference: FastPlot]] — full constructor options, properties, methods
+- [[Dashboard|API Reference: Dashboard]] — tiled and tabbed layouts
+- [[Sensors|API Reference: Sensors]] — state-dependent thresholds
+- [[Event Detection|API Reference: Event Detection]] — event detection and viewer
 - [[Live Mode Guide]] — live data polling
 - [[Datetime Guide]] — datetime axes
 - [[Dashboard Engine Guide]] — DashboardEngine + DashboardBuilder
diff --git a/wiki/Home.md b/wiki/Home.md
index 947e7f7d..979623a5 100644
--- a/wiki/Home.md
+++ b/wiki/Home.md
@@ -1,8 +1,8 @@
-# FastPlot
+<!-- AUTO-GENERATED from source code by scripts/generate_wiki.py — do not edit manually -->
 
-Ultra-fast time series plotting for MATLAB and GNU Octave.
+# FastPlot
 
-FastPlot enables fluid interactive visualization of massive datasets (1K to 100M+ points). It dynamically downsamples data to screen resolution on every zoom/pan interaction, rendering only ~4,000 points regardless of dataset size. This eliminates GPU memory bottlenecks and keeps the UI responsive at 200+ FPS.
+Ultra-fast time series plotting for MATLAB and GNU Octave with dynamic downsampling, sensor monitoring, and dashboard layouts.
 
 ## Key Metrics
 
@@ -13,25 +13,31 @@ FastPlot enables fluid interactive visualization of massive datasets (1K to 100M
 | GPU memory (10M pts) | 0.06 MB vs 153 MB for plot() |
 | Implementation | Pure MATLAB + optional C MEX (AVX2/NEON SIMD) |
 
+## Library Components
+
+FastPlot consists of five integrated libraries:
+
+| Library | Description |
+|---------|-------------|
+| **FastSense** | Core plotting engine with dynamic downsampling, dashboard layouts (FastSenseGrid, FastSenseDock), interactive toolbar, themes, and disk-backed storage via FastSenseDataStore |
+| **SensorThreshold** | Sensor data containers with state-dependent threshold rules, violation detection, and SensorRegistry catalog |
+| **EventDetection** | Event detection from threshold violations, EventViewer with Gantt timeline, live pipeline with notifications |
+| **Dashboard** | Widget-based dashboard engine with 8 widget types, 24-column responsive grid, edit mode, and JSON persistence |
+| **WebBridge** | TCP server for web-based visualization with NDJSON protocol |
+
 ## Features
 
 - **Smart downsampling** — per-pixel MinMax and LTTB algorithms, auto-selected per zoom level
-- **Lazy pyramid cache** — multi-resolution pre-computation for instant zoom-out on 50M+ datasets
+- **Pyramid cache** — multi-resolution pre-computation for instant zoom-out on 50M+ datasets  
 - **MEX acceleration** — optional C with SIMD (AVX2/NEON), auto-fallback to pure MATLAB
 - **Dashboard layouts** — tiled grids (FastSenseGrid) and tabbed containers (FastSenseDock)
 - **Interactive toolbar** — data cursor, crosshair, grid/legend toggle, autoscale, PNG export
-- **6 built-in themes** — default, dark, light, industrial, scientific, ocean (with colorblind palette)
+- **6 built-in themes** — default, dark, light, industrial, scientific, ocean
 - **Linked axes** — synchronized zoom/pan across subplots
-- **Datetime support** — datenum and MATLAB datetime with auto-formatting tick labels
-- **NaN gap handling** — seamless visualization of missing data regions
-- **Uneven sampling** — works with any monotonically increasing X (no uniform spacing required)
 - **Sensor system** — state-dependent thresholds with condition-based rules and violation markers
 - **Event detection** — group violations into events with statistics, Gantt viewer, click-to-plot
 - **Live mode** — file polling with auto-refresh (preserve/follow/reset view modes)
-- **Console progress bars** — hierarchical progress display during batch rendering
-- **Disk-backed storage** — SQLite-backed chunked DataStore for 100M+ point datasets that exceed memory
-- **Navigator overlay** — minimap zoom navigator for quick orientation
-- **Sensor detail view** — specialized plot with state bands and threshold context
+- **Disk-backed storage** — SQLite-backed chunked DataStore for 100M+ point datasets
 
 ## Quick Start
 
@@ -55,11 +61,11 @@ fig.setTileSpan(1, [1 2]);
 fp1 = fig.tile(1);
 fp1.addLine(x, sin(x), 'DisplayName', 'Pressure');
 fp1.addBand(0.8, 1.0, 'FaceColor', [1 0.3 0.3], 'FaceAlpha', 0.15, 'Label', 'Alarm');
-fig.tileTitle(1, 'Pressure Monitor');
+fig.setTileTitle(1, 'Pressure Monitor');
 
 fp2 = fig.tile(2);
 fp2.addLine(x, cos(x), 'DisplayName', 'Temperature');
-fig.tileTitle(2, 'Temperature');
+fig.setTileTitle(2, 'Temperature');
 
 fig.renderAll();
 ```
@@ -87,39 +93,22 @@ fp.render();
 - C compiler (optional) for MEX acceleration
 - No toolbox dependencies
 
-## Libraries
-
-FastPlot consists of five libraries:
+## Getting Started
 
-| Library | Path | Description |
-|---------|------|-------------|
-| FastPlot | `libs/FastPlot/` | Core plotting engine, dashboard layouts, toolbar, themes, disk-backed storage |
-| SensorThreshold | `libs/SensorThreshold/` | Sensor data containers, state channels, threshold rules |
-| EventDetection | `libs/EventDetection/` | Event detection, viewer UI, live pipeline, notifications |
-| Dashboard | `libs/Dashboard/` | Serializable dashboard engine with JSON persistence |
-| WebBridge | `libs/WebBridge/` | TCP server for web-based visualization |
+Start with the [[Installation]] guide to set up FastPlot and compile MEX acceleration. Then follow the [[Getting Started]] tutorial for step-by-step examples covering basic plotting, dashboards, sensors, and live mode.
 
-## Wiki Navigation
+## API Reference
 
-**Getting Started**
-- [[Installation]] — setup, MEX compilation, verification
-- [[Getting Started]] — tutorial with code examples
-
-**API Reference**
-- [[FastPlot|API Reference: FastPlot]] — core plotting class
+**Core Classes**
+- [[FastPlot|API Reference: FastPlot]] — main plotting engine with dynamic downsampling
 - [[Dashboard|API Reference: Dashboard]] — FastSenseGrid, FastSenseDock, FastSenseToolbar
+- [[Sensors|API Reference: Sensors]] — Sensor, StateChannel, ThresholdRule, SensorRegistry
+- [[Event Detection|API Reference: Event Detection]] — EventDetector, EventViewer, LiveEventPipeline
 - [[Themes|API Reference: Themes]] — theme presets, customization, color palettes
-- [[Sensors|API Reference: Sensors]] — Sensor, StateChannel, ThresholdRule, SensorRegistry (with printTable and viewer)
-- [[Event Detection|API Reference: Event Detection]] — EventDetector, Event, EventConfig, EventViewer (with Gantt hover tooltips)
 - [[Utilities|API Reference: Utilities]] — ConsoleProgressBar, FastSenseDefaults
 
-**Guides**
+**Specialized Guides**
 - [[Live Mode Guide]] — file polling, view modes, live dashboards
+- [[Dashboard Engine Guide]] — DashboardEngine with widget-based dashboards
 - [[Datetime Guide]] — working with time series data
-- [[Dashboard Engine Guide]] — DashboardEngine + DashboardBuilder usage
-
-**Internals**
-- [[Architecture]] — render pipeline, zoom callback, data flow
-- [[MEX Acceleration]] — SIMD details, build, fallback
-- [[Performance]] — benchmarks and optimization tips
-- [[Examples]] — categorized guide to 40+ runnable examples
+- [[Examples]] — 40+ categorized runnable examples
diff --git a/wiki/Live-Mode-Guide.md b/wiki/Live-Mode-Guide.md
index c9dad5d0..647be3f7 100644
--- a/wiki/Live-Mode-Guide.md
+++ b/wiki/Live-Mode-Guide.md
@@ -1,6 +1,8 @@
+<!-- AUTO-GENERATED from source code by scripts/generate_wiki.py — do not edit manually -->
+
 # Live Mode Guide
 
-FastPlot supports live data visualization by polling a .mat file for updates and auto-refreshing the display. Live mode works with single plots, tiled dashboards, and tabbed docks.
+FastSense supports live data visualization by polling a .mat file for updates and auto-refreshing the display. Live mode works with single plots, tiled dashboards, and tabbed docks.
 
 ---
 
@@ -110,35 +112,43 @@ fp.startLive('data.mat', @updateFcn, ...
     'MetadataVars', {'units', 'calibration'});
 ```
 
+The metadata is loaded from a separate file and attached to the specified line and tile:
+
+```matlab
+fig.MetadataFile = 'metadata.mat';
+fig.MetadataVars = {'sensor_id', 'location', 'units'};
+fig.MetadataLineIndex = 1;   % which line within the tile
+fig.MetadataTileIndex = 1;   % which tile to attach to
+```
+
 ---
 
 ## Live Event Detection
 
-Combine live mode with event detection for real-time monitoring:
+Combine live mode with event detection for real-time monitoring using the LiveEventPipeline:
 
 ```matlab
-% Create sensor and resolve
-s = Sensor('pressure', 'Name', 'Pressure');
-s.X = x; s.Y = y;
-sc = StateChannel('machine');
-sc.X = [0 30 60]; sc.Y = [0 1 2];
-s.addStateChannel(sc);
-s.addThresholdRule(struct('machine', 1), 70, 'Direction', 'upper', 'Label', 'Run HI');
-s.resolve();
-
-% Configure event detection with live logging
-cfg = EventConfig();
-cfg.MinDuration = 0.5;
-cfg.OnEventStart = eventLogger();
-cfg.addSensor(s);
-
-% Plot
-fp = FastSense('Theme', 'dark');
-fp.addSensor(s, 'ShowThresholds', true);
-fp.render();
-
-% Start live polling
-fp.startLive('pressure_data.mat', @(fp, data) updateWithDetection(fp, data, cfg));
+% Create sensors with thresholds
+tempSensor = Sensor('temperature', 'Name', 'Temperature');
+tempSensor.addThresholdRule(struct(), 78, 'Direction', 'upper', 'Label', 'Hi Warn');
+tempSensor.addThresholdRule(struct(), 82, 'Direction', 'upper', 'Label', 'Hi Alarm');
+tempSensor.resolve();
+
+sensors = containers.Map();
+sensors('temperature') = tempSensor;
+
+% Configure data sources
+dsMap = DataSourceMap();
+dsMap.add('temperature', MockDataSource('BaseValue', 70, 'NoiseStd', 2));
+
+% Set up pipeline with event store
+pipeline = LiveEventPipeline(sensors, dsMap, ...
+    'EventFile', 'events.mat', ...
+    'Interval', 15, ...
+    'MinDuration', 0.5);
+
+% Start live event detection
+pipeline.start();
 ```
 
 ---
@@ -179,7 +189,7 @@ fig.refresh();
 
 ## Toolbar Integration
 
-The FastSenseToolbar provides a Live Mode button:
+The [[FastSenseToolbar|API Reference: FastSenseToolbar]] provides a Live Mode button:
 
 ```matlab
 tb = FastSenseToolbar(fp);
@@ -195,6 +205,22 @@ tb.refresh();
 
 ---
 
+## Console Progress Bars
+
+Use ConsoleProgressBar for visual feedback during long operations:
+
+```matlab
+pb = ConsoleProgressBar(2);   % 2-space indent
+pb.start();
+for k = 1:8
+    pb.update(k, 8, 'Tile 1');
+    pause(0.1);
+end
+pb.freeze();   % becomes permanent line
+```
+
+---
+
 ## Tips
 
 - Set `'ViewMode', 'follow'` for monitoring use cases where you always want to see the latest data
@@ -202,6 +228,7 @@ tb.refresh();
 - Keep polling interval reasonable (1-5 seconds) to avoid overwhelming the file system
 - The .mat file should be written atomically (write to temp file, then rename) to avoid partial reads
 - Live mode works with linked axes — all linked plots update together
+- Use `DeferDraw = true` to skip drawnow during batch render for better performance
 
 ---
 
@@ -210,4 +237,4 @@ tb.refresh();
 - [[API Reference: FastPlot]] — startLive(), stopLive(), updateData() methods
 - [[API Reference: Dashboard]] — Dashboard live mode
 - [[API Reference: Event Detection]] — Live event detection
-- [[Examples]] — example_event_detection_live.m
+- [[Examples]] — example_dashboard_live.m, example_live_pipeline.m
diff --git a/wiki/MEX-Acceleration.md b/wiki/MEX-Acceleration.md
index e0b2b8dc..9a0439c4 100644
--- a/wiki/MEX-Acceleration.md
+++ b/wiki/MEX-Acceleration.md
@@ -1,15 +1,17 @@
+<!-- AUTO-GENERATED from source code by scripts/generate_wiki.py — do not edit manually -->
+
 # MEX Acceleration
 
-FastPlot includes optional C MEX functions with SIMD intrinsics for maximum performance. All MEX functions have pure-MATLAB fallbacks — behavior is identical.
+FastSense includes optional C MEX functions with SIMD intrinsics for maximum performance. All MEX functions have pure-MATLAB fallbacks — behavior is identical.
 
 ## Building MEX Files
 
 ```matlab
-cd libs/FastPlot
+cd libs/FastSense
 build_mex();
 ```
 
-The build script auto-detects your architecture and compiles all MEX functions.
+The build script auto-detects your architecture and compiles all MEX functions with appropriate SIMD optimizations.
 
 ### Requirements
 
@@ -19,98 +21,91 @@ The build script auto-detects your architecture and compiles all MEX functions.
 | Linux | GCC |
 | Windows | MSVC |
 
-For SQLite-backed features (DataStore, disk-based resolve), `libsqlite3` is also needed:
+SQLite3 is bundled as an amalgamation and compiled directly into MEX files that need it — no system installation required.
 
-| Platform | Install |
-|----------|---------|
-| macOS | `brew install sqlite3` (usually pre-installed) |
-| Ubuntu/Debian | `sudo apt install libsqlite3-dev` |
-| Windows | Download from [sqlite.org](https://sqlite.org/download.html) |
+## Architecture Support
 
-## Accelerated Functions
+All MEX functions include a common SIMD abstraction layer that adapts to your CPU:
 
-### binary_search_mex
+| Architecture | SIMD Instructions | Fallback |
+|-------------|------------------|----------|
+| x86_64 | AVX2 + FMA | SSE2 |
+| ARM64 (Apple Silicon) | NEON | - |
+| Other | Scalar operations | - |
 
-O(log n) binary search for the visible data range within sorted X arrays.
+If AVX2 compilation fails on x86_64, the build script automatically retries with SSE2.
 
-- **Speedup**: 10-20x over MATLAB's `find`
-- **Used by**: Zoom/pan callback to locate visible data indices
+## Accelerated Functions
 
-### minmax_core_mex
+### Core Downsampling
 
-Per-pixel MinMax reduction with SIMD vectorization.
+**binary_search_mex** — O(log n) binary search for visible data range
+- **Speedup**: 10-20x over MATLAB's `find`
+- **Used by**: Zoom/pan callbacks to locate visible indices
 
-- **Speedup**: 3-10x
+**minmax_core_mex** — Per-pixel MinMax reduction with SIMD vectorization
+- **Speedup**: 3-10x over pure MATLAB
 - **SIMD**: Processes 4 doubles (AVX2) or 2 doubles (NEON) per cycle
-- **Used by**: Default downsampling algorithm
+- **Used by**: Default downsampling algorithm in [[FastPlot|API Reference: FastPlot]]
 
-### lttb_core_mex
-
-Largest Triangle Three Buckets downsampling with SIMD-accelerated triangle area computation.
-
-- **Speedup**: 10-50x
+**lttb_core_mex** — Largest Triangle Three Buckets with SIMD triangle area computation
+- **Speedup**: 10-50x over MATLAB implementation
 - **Used by**: LTTB downsampling method
 
-### violation_cull_mex
-
-Fused threshold violation detection and pixel-space culling in a single pass.
-
-- **Speedup**: Significant (avoids two-pass MATLAB approach)
-- **Used by**: Violation marker rendering on zoom/pan
-
-### compute_violations_mex
+### Threshold Processing
 
-Batch threshold violation detection for `Sensor.resolve()`.
+**violation_cull_mex** — Fused threshold violation detection and pixel culling
+- **Speedup**: Significant (single-pass vs two-pass MATLAB)
+- **Used by**: Violation marker rendering during zoom/pan
 
+**compute_violations_mex** — Batch threshold violation detection
 - **Speedup**: Significant over per-point MATLAB comparison
-- **Used by**: Sensor resolution pipeline
+- **Used by**: [[Sensors|API Reference: Sensors]] resolution pipeline
 
-### resolve_disk_mex
+### Data Storage
 
-SQLite disk-based sensor resolution — reads chunks from the database and computes violations without loading full datasets into memory.
-
-- **Used by**: `Sensor.resolve()` with disk-backed storage
-
-### build_store_mex
-
-Bulk SQLite writer that creates the DataStore database in a single C call, replacing ~20K mksqlite round-trips.
-
-- **Speedup**: 2-3x (eliminates MATLAB-to-MEX overhead per chunk)
+**build_store_mex** — Bulk SQLite writer for DataStore initialization
+- **Speedup**: 2-3x (eliminates ~20K MATLAB-to-MEX round-trips)
 - **SIMD**: Accelerated Y min/max computation per chunk
-- **Used by**: `FastSenseDataStore` initialization
+- **Used by**: `FastSenseDataStore` construction
 
-### mksqlite
+**resolve_disk_mex** — SQLite disk-based sensor resolution
+- **Used by**: `Sensor.resolve()` with disk-backed storage
+- **Benefit**: Reads chunks from database without loading full datasets
 
-SQLite3 MEX interface with typed BLOB support (serializes MATLAB arrays into SQLite BLOBs preserving type and shape).
+**mksqlite** — SQLite3 MEX interface with typed BLOB support
+- **Used by**: DataStore, disk-backed sensor resolution
+- **Features**: Serializes MATLAB arrays preserving type and shape
 
-- **Used by**: DataStore, disk-backed Sensor resolution
-- **Requires**: `libsqlite3`
+## Fallback Behavior
 
-## SIMD Architecture
+When MEX files are unavailable:
 
-All MEX functions share a common `simd_utils.h` abstraction layer:
+- Each function has a pure-MATLAB equivalent in `libs/FastSense/private/`
+- Runtime auto-detection switches between MEX and MATLAB seamlessly
+- Identical numerical results and API
+- Performance remains excellent for datasets under ~10M points
 
-| Architecture | Instructions |
-|-------------|-------------|
-| x86_64 | AVX2 (with SSE2 fallback) |
-| arm64 (Apple Silicon) | NEON |
+## Compilation Process
 
-The abstraction provides platform-independent load, store, min, max, and comparison operations.
+The `build_mex()` function:
 
-## Fallback Behavior
+1. **Detects architecture** — normalizes platform strings (`maca64`, `aarch64`, etc.) into canonical labels
+2. **Selects compiler** — prefers GCC on Octave for better auto-vectorization; uses MATLAB's default on MATLAB
+3. **Sets SIMD flags** — chooses instruction sets based on detected CPU architecture
+4. **Compiles sources** — builds all MEX files with bundled SQLite3 amalgamation
+5. **Handles failures** — automatically retries x86_64 builds with SSE2 if AVX2 fails
+6. **Copies shared files** — distributes MEX binaries to other library directories
 
-If MEX files are not compiled:
+## Verifying Installation
 
-- Each function has a pure-MATLAB equivalent in `libs/FastPlot/private/`
-- The MATLAB code auto-detects MEX availability at runtime
-- Zero behavior change — same numerical results, same API
-- Performance is still excellent for datasets under ~10M points
-
-## Verifying MEX Installation
+Test that MEX functions produce identical results to MATLAB fallbacks:
 
 ```matlab
 setup;
 addpath('tests');
 test_mex_parity;      % Verify MEX matches MATLAB output
-test_mex_edge_cases;  % Test edge cases (empty arrays, single points, NaN)
+test_mex_edge_cases;  % Test edge cases (empty arrays, NaN, etc.)
 ```
+
+The test suite validates numerical accuracy across all MEX functions and handles edge cases like empty arrays, single points, and NaN values.
diff --git a/wiki/Performance.md b/wiki/Performance.md
index b2f7ee4c..351f43b6 100644
--- a/wiki/Performance.md
+++ b/wiki/Performance.md
@@ -1,31 +1,37 @@
+<!-- AUTO-GENERATED from source code by scripts/generate_wiki.py — do not edit manually -->
+
 # Performance
 
-Benchmarks measured on Apple M4 with GNU Octave 11.
+FastSense achieves dramatic performance improvements over MATLAB's built-in `plot()` function through intelligent downsampling, multi-level caching, and optimized MEX kernels. Here's what you can expect and how to measure it yourself.
+
+## Key Performance Metrics
+
+Based on benchmarks with 10M data points on Apple M4 with GNU Octave 11:
 
-## Key Metrics
+| Metric | Value | Description |
+|--------|-------|-------------|
+| Zoom cycle time | 4.7 ms | Time to re-downsample and redraw on zoom/pan |
+| Effective zoom FPS | 212 FPS | Interactive frames per second during zoom |
+| Point reduction | 99.96% | 10M points → ~4K rendered points |
+| GPU memory usage | 0.06 MB | vs 153 MB for equivalent `plot()` |
 
-| Metric | Value |
-|--------|-------|
-| 10M point zoom cycle | 4.7 ms |
-| Effective zoom FPS | 212 FPS |
-| Point reduction | 99.96% (10M to ~4K) |
-| GPU memory (10M points) | 0.06 MB vs 153 MB for plot() |
+The key advantage isn't just initial render time — it's maintaining fluid interactivity. With `plot()`, 10M points make zoom/pan unusable, while FastSense maintains sub-5ms response times.
 
-## FastPlot vs plot()
+## FastSense vs plot() Performance
 
-| Points | plot() render | FastPlot render | Speedup |
-|--------|--------------|----------------|---------|
-| 10K | instant | instant | - |
-| 100K | moderate | instant | ~5x |
+| Points | plot() render | FastSense render | Speedup |
+|--------|---------------|------------------|---------|
+| 10K | instant | instant | ~1x |
+| 100K | moderate lag | instant | ~5x |
 | 1M | slow | fast | ~10x |
 | 10M | very slow | 0.19 s | ~50x |
-| 100M | often fails | works | - |
+| 100M | often fails | works | ∞ |
 
-The key advantage is not just initial render time but interactive performance — plot() with 10M points makes zoom/pan unusable, while FastPlot maintains sub-5ms response.
+At 100M+ points, `plot()` frequently runs out of memory or becomes completely unresponsive, while FastSense handles it gracefully.
 
 ## Dashboard Performance
 
-With 10M points per tile:
+Multi-tile dashboards show increasing advantage as tile count grows:
 
 | Layout | subplot() | FastSenseGrid | Speedup |
 |--------|-----------|---------------|---------|
@@ -33,41 +39,137 @@ With 10M points per tile:
 | 2x2 | 0.451 s | 0.377 s | 1.2x |
 | 3x3 | 0.964 s | 0.709 s | 1.4x |
 
-Advantage grows with tile count — downsampled rendering cost stays flat while subplot() scales linearly with total points.
+Each FastSenseGrid tile downsamples independently to ~4K points regardless of raw data size, so rendering cost stays nearly flat. Traditional approaches scale linearly with total point count.
 
 ## MEX vs Pure MATLAB
 
+Compiled MEX kernels provide substantial acceleration for core operations:
+
 | Operation (10M points) | MATLAB | MEX | Speedup |
 |------------------------|--------|-----|---------|
 | Binary search | ~1 ms | ~0.05 ms | 20x |
 | MinMax downsample | ~25 ms | ~7 ms | 3.5x |
 | LTTB downsample | ~200 ms | ~4 ms | 50x |
+| Violation detection | ~50 ms | ~2 ms | 25x |
+
+MEX kernels use SIMD instructions (AVX2/NEON) to process 4 doubles per CPU cycle when possible.
+
+## Running Your Own Benchmarks
 
-## Running Benchmarks
+FastSense includes several benchmark scripts to measure performance on your system:
 
 ```matlab
 setup;
 cd examples
 
-% FastPlot vs plot() comparison
+% Compare FastSense vs plot() across different data sizes
 benchmark;
 
-% Per-frame zoom latency
+% Measure zoom/pan latency frame-by-frame
 benchmark_zoom;
 
-% Feature-specific benchmarks
+% Test specific features (downsampling, violations, etc.)
 benchmark_features;
 
-% Sensor.resolve() performance
+% Benchmark Sensor.resolve() with thresholds
 benchmark_resolve;
 ```
 
-## Why It's Fast
+The stress test example creates a realistic large-scale scenario:
+
+```matlab
+example_stress_test;  % 5 tabs, 26 sensors, 86M points, 104 thresholds
+```
+
+## Why FastSense is Fast
+
+### 1. Downsample to Screen Resolution
+Only renders ~4,000 points regardless of dataset size. A 100M point dataset uses the same GPU memory as a 4K dataset once downsampled.
+
+### 2. Binary Search for Range Queries
+Uses O(log N) binary search instead of O(N) linear scanning to find visible data ranges on zoom/pan.
+
+### 3. Lazy Multi-Level Pyramid
+Pre-computes downsampled levels (100:1, 10000:1, etc.) so zooming out never touches raw data. Cache is built incrementally as needed.
+
+### 4. SIMD-Optimized MEX Kernels
+C implementations use vectorized instructions to process multiple data points per CPU cycle:
+- **AVX2** on x86_64: processes 4 doubles simultaneously
+- **NEON** on ARM64: processes 2-4 elements per cycle
+
+### 5. Fused Operations
+Combines multiple operations in single passes:
+- Violation detection + pixel coordinate culling
+- Downsampling + threshold line intersection
+- Range lookup + metadata forwarding
+
+### 6. Direct Graphics Updates
+Updates line data via direct XData/YData assignment — the fastest path through MATLAB's graphics system. Avoids object recreation or property listeners.
+
+### 7. Frame Rate Limiting
+Uses `drawnow limitrate` to cap display refresh at 20 FPS, preventing GPU thrashing during rapid zoom/pan sequences.
+
+## Performance Tuning Options
+
+Several properties control the performance vs. quality trade-off:
+
+```matlab
+fp = FastSense();
+
+% Increase points per pixel for denser traces (default: 2)
+fp.DownsampleFactor = 4;
+
+% Adjust pyramid compression (default: 100)
+fp.PyramidReduction = 50;  % more levels, finer granularity
+
+% Switch algorithms for different data characteristics
+fp.DefaultDownsampleMethod = 'lttb';  % vs 'minmax'
+
+% Control when downsampling kicks in (default: 5000)
+fp.MinPointsForDownsample = 10000;
+```
+
+## Memory Management
 
-1. **Downsample to screen resolution**: Only ~4,000 points rendered regardless of dataset size
-2. **Binary search**: O(log N) visible range lookup instead of scanning
-3. **Lazy pyramid**: Pre-computed multi-resolution cache avoids touching raw data at zoom-out
-4. **SIMD MEX**: Vectorized C code processes 4 doubles per CPU cycle
-5. **Fused operations**: Violation detection + pixel culling in single pass
-6. **Dot notation updates**: Direct XData/YData assignment (fastest MATLAB path)
-7. **drawnow limitrate**: Caps display refresh at 20 FPS to prevent GPU thrashing
+FastSense automatically switches between in-memory and disk-backed storage:
+
+```matlab
+fp = FastSense();
+
+% Force storage mode (default: 'auto')
+fp.StorageMode = 'memory';  % always RAM
+fp.StorageMode = 'disk';    % always SQLite
+
+% Adjust memory threshold (default: 500 MB)
+fp.MemoryLimit = 1e9;  % 1 GB threshold
+```
+
+The `'auto'` mode uses [[FastSenseDataStore|API Reference: FastSenseDataStore]] for lines exceeding the memory limit, seamlessly providing disk-based storage without performance degradation.
+
+## Monitoring Performance
+
+Enable verbose output to see detailed timing information:
+
+```matlab
+fp = FastSense('Verbose', true);
+fp.addLine(x, y);
+fp.render();
+
+% Output:
+% [FastSense] Line 1: 10000000 points → 3847 (MinMax, 23.4 ms)
+% [FastSense] Pyramid L1: 100000 points (7.8 ms)  
+% [FastSense] Pyramid L2: 1000 points (0.3 ms)
+% [FastSense] Total render: 187.2 ms
+```
+
+The [[ConsoleProgressBar]] class (used internally) is also available for your own batch operations:
+
+```matlab
+pb = ConsoleProgressBar();
+pb.start();
+for k = 1:1000
+    % your processing
+    pb.update(k, 1000, 'Processing');
+end
+pb.finish();
+```
diff --git a/wiki/Use-Case:-Multi-Sensor-Shared-Threshold.md b/wiki/Use-Case:-Multi-Sensor-Shared-Threshold.md
index 16ce6f32..1ccdb160 100644
--- a/wiki/Use-Case:-Multi-Sensor-Shared-Threshold.md
+++ b/wiki/Use-Case:-Multi-Sensor-Shared-Threshold.md
@@ -1,3 +1,5 @@
+<!-- AUTO-GENERATED from source code by scripts/generate_wiki.py — do not edit manually -->
+
 # Use Case: Multi-Sensor Shared Threshold
 
 Plot multiple sensors on a single tile with one shared threshold, see violation markers for all sensors, and run event detection.
@@ -101,7 +103,8 @@ The shared threshold can also be state-dependent. Attach the same `StateChannel`
 ```matlab
 for i = 1:numel(sensors)
     sc = StateChannel('mode');
-    sc.setData(modeX, modeValues);   % same state for all
+    sc.X = modeX;
+    sc.Y = modeValues;   % same state for all sensors
     sensors{i}.addStateChannel(sc);
 
     % Threshold only active during 'run' mode
@@ -111,17 +114,70 @@ for i = 1:numel(sensors)
 end
 ```
 
----
+Each sensor evaluates the same state conditions independently, so thresholds activate/deactivate synchronously across all sensors while maintaining individual violation tracking.
 
-## With EventViewer
+---
 
-Display all events in the Gantt-style EventViewer:
+## Complete Multi-Zone Example
 
 ```matlab
-viewer = EventViewer(allEvents);
-```
+%% Multi-zone temperature monitoring with shared alarm level
+sensors = cell(1, 3);
+zones = {'North', 'Central', 'South'};
+t = linspace(0, 120, 50000);
+
+% Create state channel for system mode
+modeX = [0, 30, 60, 90];
+modeY = [0, 1, 1, 0];  % 0=idle, 1=active
+
+for i = 1:3
+    s = Sensor(sprintf('temp_zone_%d', i), 'Name', sprintf('Zone %s', zones{i}));
+    s.X = t;
+    
+    % Each zone has different baseline but similar patterns
+    baseline = 20 + i * 2;
+    s.Y = baseline + 5*sin(2*pi*t/40) + 2*randn(1, numel(t));
+    
+    % Add state channel
+    sc = StateChannel('system_mode');
+    sc.X = modeX;
+    sc.Y = modeY;
+    s.addStateChannel(sc);
+    
+    % Shared threshold rules
+    s.addThresholdRule(struct(), 30, 'Direction', 'upper', 'Label', 'Max Temp (any mode)');
+    s.addThresholdRule(struct('system_mode', 1), 28, 'Direction', 'upper', 'Label', 'Max Temp (active)');
+    s.resolve();
+    
+    sensors{i} = s;
+end
 
-Each event row shows the sensor name, threshold label, and time span. Click any event to drill down into the data.
+%% Plot with shared thresholds
+fp = FastSense();
+for i = 1:numel(sensors)
+    fp.addSensor(sensors{i}, 'ShowThresholds', (i == 1));
+end
+fp.render();
+title('Multi-Zone Temperature Monitoring');
+xlabel('Time (s)');
+ylabel('Temperature (°C)');
+legend('show');
+
+%% Event detection
+detector = EventDetector('MinDuration', 2.0);
+allEvents = [];
+for i = 1:numel(sensors)
+    evts = detectEventsFromSensor(sensors{i}, detector);
+    allEvents = [allEvents, evts];
+end
+
+fprintf('\n=== Event Summary ===\n');
+for i = 1:numel(allEvents)
+    fprintf('%s: %s violation at %.1f-%.1fs (peak %.2f°C)\n', ...
+        allEvents(i).SensorName, allEvents(i).ThresholdLabel, ...
+        allEvents(i).StartTime, allEvents(i).EndTime, allEvents(i).PeakValue);
+end
+```
 
 ---
 
@@ -139,4 +195,4 @@ Each event row shows the sensor name, threshold label, and time span. Click any
 
 - [[Sensors|API Reference: Sensors]] — `Sensor`, `ThresholdRule`, `StateChannel`
 - [[Event Detection|API Reference: Event Detection]] — `EventDetector`, `detectEventsFromSensor`, `EventViewer`
-- [[Examples]] — `example_multi`, `example_sensor_dashboard`, `example_event_detection_live`
+- [[Examples]] — `example_multi_sensor_linked`, `example_sensor_threshold`, `example_sensor_multi_state`
diff --git a/wiki/WebBridge-Guide.md b/wiki/WebBridge-Guide.md
new file mode 100644
index 00000000..f0c1e2df
--- /dev/null
+++ b/wiki/WebBridge-Guide.md
@@ -0,0 +1,242 @@
+<!-- AUTO-GENERATED from source code by scripts/generate_wiki.py — do not edit manually -->
+
+# WebBridge Guide
+
+WebBridge provides a powerful system for integrating FastPlot with web applications through a TCP-based communication protocol. It enables real-time data streaming, dashboard configuration synchronization, and remote control capabilities.
+
+## Overview
+
+WebBridge serves as a communication bridge between MATLAB/FastPlot and web clients, using NDJSON (Newline Delimited JSON) messages over TCP. This architecture allows:
+
+- Real-time streaming of sensor data to web applications
+- Bidirectional dashboard configuration synchronization
+- Remote action execution from web interfaces
+- Multiple concurrent client connections
+
+## Basic Usage
+
+### Setting Up WebBridge
+
+```matlab
+% Create a dashboard with some data
+dashboard = Dashboard();
+dashboard.addSensor('temperature', randn(1000, 1), 'units', '°C');
+
+% Create and start WebBridge
+bridge = WebBridge(dashboard);
+bridge.serve();  % Starts both TCP server and data polling
+```
+
+### Configuration Options
+
+```matlab
+% Customize polling interval for configuration changes
+bridge = WebBridge(dashboard, 'ConfigPollInterval', 0.5);  % Poll every 500ms
+
+% Manual control over TCP server
+bridge = WebBridge(dashboard);
+bridge.startTcp();  % Start TCP server only
+% ... later ...
+bridge.stop();      % Stop all services
+```
+
+## Protocol Messages
+
+WebBridge uses a structured message protocol for communication:
+
+### Initialization Messages
+
+When a client connects, WebBridge sends initialization data:
+
+```matlab
+% The bridge automatically sends:
+% - Signal definitions (names, units, data types)
+% - Dashboard configuration (layouts, themes, etc.)
+% - Available actions list
+```
+
+### Data Update Messages
+
+As data changes, WebBridge streams updates:
+
+```matlab
+% Manually trigger data change notifications
+bridge.notifyDataChanged('temperature');  % Single signal
+bridge.notifyDataChanged({'temp', 'pressure'});  % Multiple signals
+```
+
+### Configuration Synchronization
+
+Dashboard configuration changes are automatically detected and broadcast:
+
+```matlab
+% Any changes to dashboard properties trigger config updates
+dashboard.Title = 'Updated Dashboard';
+% WebBridge automatically detects and broadcasts this change
+```
+
+## Remote Actions
+
+### Registering Actions
+
+Register callback functions that can be invoked from web clients:
+
+```matlab
+% Register a simple action
+bridge.registerAction('reset_data', @() resetSensorData());
+
+% Register an action with parameters
+bridge.registerAction('set_threshold', @(params) setThreshold(params.value));
+
+% Register an action that returns results
+bridge.registerAction('get_stats', @() struct('mean', mean(data), 'std', std(data)));
+```
+
+### Action Management
+
+```matlab
+% Check if an action exists
+if bridge.hasAction('reset_data')
+    disp('Reset action is available');
+end
+
+% Actions are automatically broadcast to clients when registered
+```
+
+## Advanced Integration Patterns
+
+### Live Data Streaming
+
+```matlab
+dashboard = Dashboard();
+sensor = dashboard.addSensor('live_data', []);
+bridge = WebBridge(dashboard);
+bridge.serve();
+
+% Simulate live data updates
+timer_obj = timer('ExecutionMode', 'fixedRate', 'Period', 0.1, ...
+    'TimerFcn', @(~,~) updateLiveData());
+
+    function updateLiveData()
+        new_data = randn(10, 1);
+        sensor.appendData(new_data);
+        bridge.notifyDataChanged('live_data');
+    end
+
+start(timer_obj);
+```
+
+### Multi-Dashboard Broadcasting
+
+```matlab
+% WebBridge can handle complex dashboard configurations
+dashboard = Dashboard();
+dashboard.addSensor('sensor1', data1);
+dashboard.addSensor('sensor2', data2);
+
+% All sensors and their configurations are automatically synchronized
+bridge = WebBridge(dashboard);
+bridge.serve();
+```
+
+### Custom Action Handlers
+
+```matlab
+% Register actions with error handling
+bridge.registerAction('process_data', @processDataHandler);
+
+function result = processDataHandler(params)
+    try
+        % Process the request
+        result = struct('success', true, 'data', processedData);
+    catch ME
+        result = struct('success', false, 'error', ME.message);
+    end
+end
+```
+
+## Protocol Details
+
+### Message Format
+
+All messages use NDJSON format (one JSON object per line):
+
+```matlab
+% Example message types sent by WebBridge:
+% {"type": "init", "signals": [...], "dashboard": {...}, "actions": [...]}
+% {"type": "data_changed", "signalIds": ["sensor1", "sensor2"]}
+% {"type": "config_changed", "dashboard": {...}}
+% {"type": "actions_changed", "actionNames": ["action1", "action2"]}
+% {"type": "action_result", "requestId": "123", "name": "action1", "ok": true, "data": {...}}
+```
+
+### Client Integration
+
+Web clients should handle these message types:
+
+- `init`: Initial data and configuration
+- `data_changed`: Signal data updates
+- `config_changed`: Dashboard configuration updates
+- `actions_changed`: Available actions list updates
+- `action_result`: Results from action execution
+
+## Performance Considerations
+
+### Efficient Data Updates
+
+```matlab
+% Batch multiple signal updates
+bridge.notifyDataChanged({'temp', 'pressure', 'humidity'});
+
+% Rather than individual notifications:
+% bridge.notifyDataChanged('temp');
+% bridge.notifyDataChanged('pressure');
+% bridge.notifyDataChanged('humidity');
+```
+
+### Configuration Polling
+
+```matlab
+% Adjust polling frequency based on needs
+bridge.ConfigPollInterval = 2.0;  % Less frequent for stable configurations
+bridge.ConfigPollInterval = 0.1;  % More frequent for dynamic dashboards
+```
+
+## Error Handling
+
+### Connection Management
+
+```matlab
+% WebBridge handles client connections automatically
+% Multiple clients can connect simultaneously
+% Disconnected clients are automatically cleaned up
+```
+
+### Action Error Reporting
+
+```matlab
+% Action errors are automatically captured and sent to clients
+bridge.registerAction('failing_action', @() error('Something went wrong'));
+% Client receives: {"ok": false, "error": "Something went wrong"}
+```
+
+## Integration with Dashboard Engine
+
+WebBridge works seamlessly with the [[Dashboard Engine Guide]]:
+
+```matlab
+% Dashboard engine changes are automatically synchronized
+dashboard.Theme = 'dark';
+dashboard.Layout = 'grid';
+% WebBridge detects and broadcasts these changes
+```
+
+## Best Practices
+
+1. **Register all actions before starting the server** to ensure clients receive the complete actions list
+2. **Use batch notifications** for multiple simultaneous data updates
+3. **Handle action errors gracefully** with try-catch blocks
+4. **Set appropriate polling intervals** based on configuration change frequency
+5. **Clean up resources** by calling `stop()` when shutting down
+
+For more information on dashboard configuration, see the [[Dashboard|API Reference: Dashboard]] page.