@feltdb/core 0.5.7 → 0.6.0

package/dist/create/server-source/crates/feltdb-server/src/transaction_recovery.rs

@@ -0,0 +1,461 @@
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+/// Transaction status for idempotency and recovery.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum TransactionStatus {
+    /// Transaction status is unknown (may be in-flight or lost).
+    Unknown,
+    /// Transaction successfully committed.
+    Committed,
+    /// Transaction was rejected (validation failure).
+    Rejected,
+    /// Transaction conflicted (concurrent write or version mismatch).
+    Conflicted,
+}
+
+/// Record of a transaction for idempotency and recovery.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TransactionRecord {
+    /// Unique transaction ID.
+    pub transaction_id: String,
+
+    /// Current status of the transaction.
+    pub status: TransactionStatus,
+
+    /// Hash of the payload for idempotency checking.
+    /// Same ID + same payload = retry is safe
+    /// Same ID + different payload = conflict
+    pub payload_hash: String,
+
+    /// State version after transaction (if committed).
+    pub state_version: u64,
+
+    /// When this transaction was recorded.
+    pub recorded_at: u64,
+
+    /// When the transaction was committed (if successful).
+    pub committed_at: Option<u64>,
+
+    /// Reason for rejection or conflict (if applicable).
+    pub error: Option<String>,
+}
+
+/// Request to check transaction status.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TransactionStatusRequest {
+    pub transaction_id: String,
+    pub payload_hash: Option<String>,
+}
+
+/// Response with transaction status.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TransactionStatusResponse {
+    pub transaction_id: String,
+    pub status: TransactionStatus,
+    pub payload_hash: String,
+    pub state_version: u64,
+    pub committed_at: Option<u64>,
+    pub error: Option<String>,
+}
+
+/// Recoverable transaction store.
+#[derive(Clone)]
+pub struct TransactionRecoveryStore {
+    records: Arc<RwLock<HashMap<String, TransactionRecord>>>,
+}
+
+impl TransactionRecoveryStore {
+    /// Creates a new recovery store.
+    pub fn new() -> Self {
+        Self {
+            records: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    /// Records a transaction being processed.
+    pub fn record_unknown(
+        &self,
+        transaction_id: String,
+        payload_hash: String,
+    ) -> Result<(), String> {
+        let mut records = self
+            .records
+            .write()
+            .map_err(|_| "store lock poisoned".to_string())?;
+
+        let id = transaction_id.clone();
+        records.insert(
+            transaction_id,
+            TransactionRecord {
+                transaction_id: id,
+                status: TransactionStatus::Unknown,
+                payload_hash,
+                state_version: 0,
+                recorded_at: now(),
+                committed_at: None,
+                error: None,
+            },
+        );
+
+        Ok(())
+    }
+
+    /// Records a successful commit.
+    pub fn record_committed(
+        &self,
+        transaction_id: String,
+        payload_hash: String,
+        state_version: u64,
+    ) -> Result<(), String> {
+        let mut records = self
+            .records
+            .write()
+            .map_err(|_| "store lock poisoned".to_string())?;
+
+        let txn_id = transaction_id.clone();
+        records.insert(
+            txn_id.clone(),
+            TransactionRecord {
+                transaction_id: txn_id,
+                status: TransactionStatus::Committed,
+                payload_hash,
+                state_version,
+                recorded_at: now(),
+                committed_at: Some(now()),
+                error: None,
+            },
+        );
+
+        Ok(())
+    }
+
+    /// Records a rejection.
+    pub fn record_rejected(
+        &self,
+        transaction_id: String,
+        payload_hash: String,
+        error: String,
+    ) -> Result<(), String> {
+        let mut records = self
+            .records
+            .write()
+            .map_err(|_| "store lock poisoned".to_string())?;
+
+        let id = transaction_id.clone();
+        records.insert(
+            id.clone(),
+            TransactionRecord {
+                transaction_id: id,
+                status: TransactionStatus::Rejected,
+                payload_hash,
+                state_version: 0,
+                recorded_at: now(),
+                committed_at: None,
+                error: Some(error),
+            },
+        );
+
+        Ok(())
+    }
+
+    /// Records a conflict.
+    pub fn record_conflicted(
+        &self,
+        transaction_id: String,
+        payload_hash: String,
+        error: String,
+    ) -> Result<(), String> {
+        let mut records = self
+            .records
+            .write()
+            .map_err(|_| "store lock poisoned".to_string())?;
+
+        let id = transaction_id.clone();
+        records.insert(
+            id.clone(),
+            TransactionRecord {
+                transaction_id: id,
+                status: TransactionStatus::Conflicted,
+                payload_hash,
+                state_version: 0,
+                recorded_at: now(),
+                committed_at: None,
+                error: Some(error),
+            },
+        );
+
+        Ok(())
+    }
+
+    /// Gets transaction status.
+    pub fn get_status(&self, transaction_id: &str) -> Result<TransactionStatusResponse, String> {
+        let records = self
+            .records
+            .read()
+            .map_err(|_| "store lock poisoned".to_string())?;
+
+        let record = records
+            .get(transaction_id)
+            .ok_or(format!("transaction not found: {}", transaction_id))?;
+
+        Ok(TransactionStatusResponse {
+            transaction_id: record.transaction_id.clone(),
+            status: record.status,
+            payload_hash: record.payload_hash.clone(),
+            state_version: record.state_version,
+            committed_at: record.committed_at,
+            error: record.error.clone(),
+        })
+    }
+
+    /// Checks if a retry is safe (idempotent).
+    pub fn is_retry_safe(&self, transaction_id: &str, payload_hash: &str) -> Result<bool, String> {
+        let records = self
+            .records
+            .read()
+            .map_err(|_| "store lock poisoned".to_string())?;
+
+        let record = records.get(transaction_id);
+
+        match record {
+            None => Ok(true), // Unknown transaction - safe to retry
+            Some(r) => {
+                // Same payload = safe to retry
+                if r.payload_hash == payload_hash {
+                    Ok(r.status == TransactionStatus::Committed || r.status == TransactionStatus::Unknown)
+                } else {
+                    // Different payload = conflict
+                    Ok(false)
+                }
+            }
+        }
+    }
+
+    /// Clears old transaction records (for cleanup).
+    pub fn cleanup_before(&self, cutoff_time: u64) -> Result<usize, String> {
+        let mut records = self
+            .records
+            .write()
+            .map_err(|_| "store lock poisoned".to_string())?;
+
+        let before_len = records.len();
+        records.retain(|_, r| r.recorded_at >= cutoff_time);
+        let after_len = records.len();
+
+        Ok(before_len - after_len)
+    }
+}
+
+impl Default for TransactionRecoveryStore {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Computes payload hash for transaction idempotency.
+pub fn compute_payload_hash(payload: &[u8]) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(payload);
+    format!("{:x}", hasher.finalize())
+}
+
+fn now() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn test_payload_hash() -> String {
+        compute_payload_hash(b"test payload")
+    }
+
+    #[test]
+    fn record_and_retrieve_committed_transaction() {
+        let store = TransactionRecoveryStore::new();
+
+        store
+            .record_committed("txn_123".into(), test_payload_hash(), 42)
+            .expect("record failed");
+
+        let status = store.get_status("txn_123").expect("get failed");
+        assert_eq!(status.status, TransactionStatus::Committed);
+        assert_eq!(status.state_version, 42);
+    }
+
+    #[test]
+    fn unknown_transaction_not_found() {
+        let store = TransactionRecoveryStore::new();
+
+        let result = store.get_status("txn_unknown");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn same_payload_is_safe_to_retry() {
+        let store = TransactionRecoveryStore::new();
+        let hash = test_payload_hash();
+
+        store
+            .record_committed("txn_123".into(), hash.clone(), 42)
+            .expect("record failed");
+
+        let is_safe = store.is_retry_safe("txn_123", &hash).expect("check failed");
+        assert!(is_safe);
+    }
+
+    #[test]
+    fn different_payload_is_conflict() {
+        let store = TransactionRecoveryStore::new();
+        let hash1 = test_payload_hash();
+        let hash2 = compute_payload_hash(b"different payload");
+
+        store
+            .record_committed("txn_123".into(), hash1, 42)
+            .expect("record failed");
+
+        let is_safe = store.is_retry_safe("txn_123", &hash2).expect("check failed");
+        assert!(!is_safe);
+    }
+
+    #[test]
+    fn unknown_transaction_is_safe_to_retry() {
+        let store = TransactionRecoveryStore::new();
+        let hash = test_payload_hash();
+
+        let is_safe = store.is_retry_safe("txn_unknown", &hash).expect("check failed");
+        assert!(is_safe);
+    }
+
+    #[test]
+    fn rejected_transaction_with_same_payload_is_not_safe() {
+        let store = TransactionRecoveryStore::new();
+        let hash = test_payload_hash();
+
+        store
+            .record_rejected("txn_123".into(), hash.clone(), "validation error".into())
+            .expect("record failed");
+
+        let is_safe = store.is_retry_safe("txn_123", &hash).expect("check failed");
+        assert!(!is_safe);
+    }
+
+    #[test]
+    fn conflicted_transaction_with_same_payload_is_not_safe() {
+        let store = TransactionRecoveryStore::new();
+        let hash = test_payload_hash();
+
+        store
+            .record_conflicted("txn_123".into(), hash.clone(), "version mismatch".into())
+            .expect("record failed");
+
+        let is_safe = store.is_retry_safe("txn_123", &hash).expect("check failed");
+        assert!(!is_safe);
+    }
+
+    #[test]
+    fn record_unknown_transaction() {
+        let store = TransactionRecoveryStore::new();
+        let hash = test_payload_hash();
+
+        store
+            .record_unknown("txn_123".into(), hash)
+            .expect("record failed");
+
+        let status = store.get_status("txn_123").expect("get failed");
+        assert_eq!(status.status, TransactionStatus::Unknown);
+    }
+
+    #[test]
+    fn record_rejected_transaction() {
+        let store = TransactionRecoveryStore::new();
+        let hash = test_payload_hash();
+
+        store
+            .record_rejected(
+                "txn_123".into(),
+                hash,
+                "required field missing".into(),
+            )
+            .expect("record failed");
+
+        let status = store.get_status("txn_123").expect("get failed");
+        assert_eq!(status.status, TransactionStatus::Rejected);
+        assert!(status.error.is_some());
+    }
+
+    #[test]
+    fn record_conflicted_transaction() {
+        let store = TransactionRecoveryStore::new();
+        let hash = test_payload_hash();
+
+        store
+            .record_conflicted("txn_123".into(), hash, "concurrent write".into())
+            .expect("record failed");
+
+        let status = store.get_status("txn_123").expect("get failed");
+        assert_eq!(status.status, TransactionStatus::Conflicted);
+    }
+
+    #[test]
+    fn cleanup_removes_old_records() {
+        let store = TransactionRecoveryStore::new();
+        let hash = test_payload_hash();
+        let old_time = now() - 86400; // 1 day ago
+
+        store
+            .record_committed("txn_old".into(), hash.clone(), 1)
+            .expect("record failed");
+
+        // Manually insert an old record (normally would be done by recovery mechanism)
+        {
+            let mut records = store.records.write().unwrap();
+            if let Some(r) = records.get_mut("txn_old") {
+                r.recorded_at = old_time;
+            }
+        }
+
+        let cutoff = now() - 3600; // 1 hour ago
+        let deleted = store.cleanup_before(cutoff).expect("cleanup failed");
+        assert_eq!(deleted, 1);
+
+        // Old record should be gone
+        assert!(store.get_status("txn_old").is_err());
+    }
+
+    #[test]
+    fn payload_hash_is_deterministic() {
+        let hash1 = compute_payload_hash(b"test payload");
+        let hash2 = compute_payload_hash(b"test payload");
+        assert_eq!(hash1, hash2);
+
+        let hash3 = compute_payload_hash(b"different");
+        assert_ne!(hash1, hash3);
+    }
+
+    #[test]
+    fn transaction_record_includes_timestamps() {
+        let store = TransactionRecoveryStore::new();
+        let hash = test_payload_hash();
+
+        let before = now();
+        store
+            .record_committed("txn_123".into(), hash, 42)
+            .expect("record failed");
+        let after = now();
+
+        let status = store.get_status("txn_123").expect("get failed");
+        assert!(status.committed_at.is_some());
+        let committed = status.committed_at.unwrap();
+        assert!(committed >= before && committed <= after + 1);
+    }
+}

package/dist/create/template/dot-feltdb-README.md

@@ -0,0 +1,58 @@
+# FeltDB Development Workspace
+
+This directory contains the development workspace configuration for your FeltDB project.
+
+## workspace.json
+
+**Purpose:** Durable pairing identity for your project's development workspace.
+
+**Contents:**
+- `workspaceId` — Unique identifier for this workspace (format: `ws_*`)
+- `projectId` — Your project name
+- `version` — Configuration version
+
+**Usage:**
+- Committed to version control (this is your project's identity)
+- Used by CLI, IDE, agents, and browser extensions to discover the workspace
+- DO NOT edit manually unless you know what you're doing
+
+**Discovery:**
+When any FeltDB tool (VS Code, Claude agent, CLI, browser extension) opens your project, it reads this file to automatically connect to the correct workspace.
+
+## Runtime Files (not committed)
+
+- `pairing.json` — Short-lived pairing token for browser discovery (gitignored)
+- `state.json` — Local workspace state (gitignored)
+- `*.log` — Development logs (gitignored)
+
+## Commands
+
+```bash
+# Check workspace status
+npm run feltdb:status
+
+# Or use the CLI directly
+feltdb workspace status
+
+# Launch development environment (includes workspace authority)
+npm run dev
+```
+
+## Development Workspace Architecture
+
+```
+Your Project
+    ↓
+.feltdb/workspace.json  (pairing identity)
+    ↓
+feltdb dev (workspace authority)
+    ↓
+Browser, IDE, Agent clients
+```
+
+All tools automatically discover your workspace using `workspace.json` and connect to the local development environment started by `npm run dev`.
+
+## Learn More
+
+- [Development Workspaces Documentation](https://github.com/rkendel1/feltdb/blob/main/packages/core/docs/development-workspaces.md)
+- [FeltDB Documentation](https://github.com/rkendel1/feltdb)

package/dist/create/workspace-initialization.js

@@ -0,0 +1,77 @@
+/**
+ * Workspace Initialization
+ *
+ * Initializes a FeltDB Development Workspace for newly created projects.
+ * This is the bootstrap mechanism that enables all FeltDB-aware tools
+ * to discover and connect to the same workspace.
+ */
+import fs from 'fs';
+import path from 'path';
+/**
+ * Generate a unique workspace ID
+ * Format: ws_<projectId>_<timestamp>_<random>
+ */
+export function generateWorkspaceId(projectId) {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 9);
+    return `ws_${projectId}_${timestamp}_${random}`;
+}
+/**
+ * Initialize development workspace for a new project
+ *
+ * Creates .feltdb/workspace.json with the workspace discovery information.
+ * This file is committed to the repository and used by all development tools
+ * (CLI, IDE, agents, browser extensions) to discover and connect to the
+ * same workspace.
+ */
+export function initializeWorkspace(projectDir, projectId) {
+    const feltdbDir = path.join(projectDir, '.feltdb');
+    // Ensure .feltdb directory exists
+    if (!fs.existsSync(feltdbDir)) {
+        fs.mkdirSync(feltdbDir, { recursive: true });
+    }
+    // Create workspace discovery
+    const workspaceId = generateWorkspaceId(projectId);
+    const discovery = {
+        workspaceId,
+        projectId,
+        version: 1,
+    };
+    // Write workspace.json
+    const workspacePath = path.join(feltdbDir, 'workspace.json');
+    fs.writeFileSync(workspacePath, JSON.stringify(discovery, null, 2) + '\n');
+    return discovery;
+}
+/**
+ * Create .gitignore entry for workspace runtime files
+ *
+ * The .feltdb/workspace.json is committed (pairing identity).
+ * But runtime files like pairing tokens should not be committed.
+ */
+export function appendWorkspaceGitignore(projectDir) {
+    const gitignorePath = path.join(projectDir, '.gitignore');
+    const workspaceGitignoreEntries = [
+        '',
+        '# FeltDB Development Workspace',
+        '.feltdb/pairing.json',
+        '.feltdb/state.json',
+        '.feltdb/*.log',
+        '',
+    ].join('\n');
+    if (fs.existsSync(gitignorePath)) {
+        const existing = fs.readFileSync(gitignorePath, 'utf-8');
+        if (!existing.includes('.feltdb/pairing.json')) {
+            fs.appendFileSync(gitignorePath, workspaceGitignoreEntries);
+        }
+    }
+    else {
+        const content = [
+            'node_modules/',
+            'dist/',
+            'build/',
+            '.env.local',
+            workspaceGitignoreEntries,
+        ].join('\n');
+        fs.writeFileSync(gitignorePath, content);
+    }
+}

package/dist/index.d.ts

@@ -65,4 +65,10 @@ export type { TelemetryEvent, TelemetryEventType } from './telemetry.js';
  * Observability and inspection APIs
  */
 export type { ProvenanceGraph, ProvenanceNode, ProvenanceEdge, ProvenanceEdgeType, RuntimeDiagnostics, } from './db.js';
+/**
+ * Development Workspace APIs
+ *
+ * Shared development state for coordinating Browser, IDE, and Agent clients.
+ */
+export * from './workspace/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EACL,eAAe,EACf,KAAK,OAAO,EACZ,KAAK,SAAS,IAAI,iBAAiB,EACnC,KAAK,QAAQ,IAAI,gBAAgB,GAClC,MAAM,eAAe,CAAC;AAEvB;;GAEG;AACH,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AAEnC;;GAEG;AACH,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACnE,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzE;;GAEG;AACH,YAAY,EACV,eAAe,EACf,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EACL,eAAe,EACf,KAAK,OAAO,EACZ,KAAK,SAAS,IAAI,iBAAiB,EACnC,KAAK,QAAQ,IAAI,gBAAgB,GAClC,MAAM,eAAe,CAAC;AAEvB;;GAEG;AACH,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AAEnC;;GAEG;AACH,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACnE,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzE;;GAEG;AACH,YAAY,EACV,eAAe,EACf,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAEjB;;;;GAIG;AACH,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -60,3 +60,9 @@ export * from './agent-runtime.js';
  * Telemetry APIs
  */
 export { emitTelemetry, getTelemetryClient } from './telemetry.js';
+/**
+ * Development Workspace APIs
+ *
+ * Shared development state for coordinating Browser, IDE, and Agent clients.
+ */
+export * from './workspace/index.js';