editor js bindings scaffold

Cargo.lock

···
 ]
 
 [[package]]
+name = "weaver-editor-js"
+version = "0.1.0"
+dependencies = [
+ "console_error_panic_hook",
+ "js-sys",
+ "serde",
+ "serde-wasm-bindgen 0.6.5",
+ "serde_bytes",
+ "tsify-next",
+ "wasm-bindgen",
+ "weaver-api",
+ "weaver-common",
+ "weaver-editor-browser",
+ "weaver-editor-core",
+ "weaver-editor-crdt",
+ "weaver-embed-worker",
+ "web-sys",
+]
+
+[[package]]
 name = "weaver-embed-worker"
 version = "0.1.0"
 dependencies = [

crates/weaver-editor-js/.gitignore

···
+pkg/
+target/

crates/weaver-editor-js/Cargo.toml

···
+[package]
+name = "weaver-editor-js"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+repository = "https://tangled.org/nonbinary.computer/weaver"
+description = "WASM bindings for the weaver markdown editor"
+
+[lib]
+crate-type = ["cdylib"]
+
+[features]
+default = []
+collab = ["weaver-editor-crdt"]
+
+[dependencies]
+weaver-editor-core = { path = "../weaver-editor-core" }
+weaver-editor-browser = { path = "../weaver-editor-browser" }
+weaver-editor-crdt = { path = "../weaver-editor-crdt", optional = true }
+weaver-embed-worker = { path = "../weaver-embed-worker" }
+weaver-api = { path = "../weaver-api" }
+weaver-common = { path = "../weaver-common" }
+
+wasm-bindgen = "0.2"
+serde = { workspace = true }
+serde_bytes = "0.11"
+serde-wasm-bindgen = "0.6"
+tsify-next = "0.5"
+js-sys = "0.3"
+console_error_panic_hook = "0.1"
+
+[dependencies.web-sys]
+version = "0.3"
+features = [
+    "console",
+    "Document",
+    "Element",
+    "HtmlElement",
+    "HtmlDivElement",
+    "Node",
+    "Window",
+    "Selection",
+    "Range",
+    "InputEvent",
+    "KeyboardEvent",
+    "ClipboardEvent",
+    "CompositionEvent",
+    "DataTransfer",
+    "EventTarget",
+]
+
+[package.metadata.wasm-pack.profile.dev]
+wasm-opt = false
+
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = ['-Oz', '--enable-bulk-memory-opt', '--enable-nontrapping-float-to-int']

crates/weaver-editor-js/build.sh

···
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+PKG_NAME="@weaver.sh/editor"
+PKG_VERSION="0.1.0"
+
+# Targets to build
+TARGETS=(bundler web nodejs deno)
+
+COMMAND="${1:-build}"
+shift || true
+
+# Feature variants
+declare -A VARIANTS=(
+    ["core"]=""
+    ["collab"]="collab"
+)
+
+build() {
+    local target="$1"
+    local variant="$2"
+    local features="$3"
+    local out_dir="pkg/${variant}/${target}"
+
+    echo "Building ${variant}/${target}..."
+
+    local feature_args="--no-default-features"
+    if [[ -n "$features" ]]; then
+        feature_args="$feature_args --features $features"
+    fi
+
+    wasm-pack build \
+        --out-name weaver_editor \
+        --out-dir "$out_dir" \
+        --target "$target" \
+        $feature_args
+
+    # Report size
+    local wasm_file="${out_dir}/weaver_editor_bg.wasm"
+    if [[ -f "$wasm_file" ]]; then
+        local size=$(ls -lh "$wasm_file" | awk '{print $5}')
+        echo "  → ${size}"
+    fi
+}
+
+generate_package_json() {
+    local variant="$1"
+    local out_dir="pkg/${variant}"
+    local pkg_suffix=""
+    local description=""
+
+    if [[ "$variant" == "collab" ]]; then
+        pkg_suffix="-collab"
+        description="Weaver markdown editor with collaborative editing (Loro CRDT + iroh P2P)"
+    else
+        pkg_suffix="-core"
+        description="Weaver markdown editor (local editing, lightweight)"
+    fi
+
+    cat > "${out_dir}/package.json" << EOF
+{
+  "name": "${PKG_NAME}${pkg_suffix}",
+  "version": "${PKG_VERSION}",
+  "description": "${description}",
+  "license": "MPL-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://tangled.org/nonbinary.computer/weaver"
+  },
+  "keywords": ["atproto", "markdown", "editor", "wasm", "weaver"],
+  "main": "nodejs/weaver_editor.js",
+  "module": "bundler/weaver_editor.js",
+  "browser": "web/weaver_editor.js",
+  "types": "bundler/weaver_editor.d.ts",
+  "exports": {
+    ".": {
+      "deno": "./deno/weaver_editor.js",
+      "node": {
+        "import": "./nodejs/weaver_editor.js",
+        "require": "./nodejs/weaver_editor.js"
+      },
+      "browser": {
+        "import": "./web/weaver_editor.js"
+      },
+      "default": "./bundler/weaver_editor.js"
+    },
+    "./bundler": {
+      "import": "./bundler/weaver_editor.js",
+      "types": "./bundler/weaver_editor.d.ts"
+    },
+    "./web": {
+      "import": "./web/weaver_editor.js",
+      "types": "./web/weaver_editor.d.ts"
+    },
+    "./nodejs": {
+      "import": "./nodejs/weaver_editor.js",
+      "require": "./nodejs/weaver_editor.js",
+      "types": "./nodejs/weaver_editor.d.ts"
+    },
+    "./deno": {
+      "import": "./deno/weaver_editor.js",
+      "types": "./deno/weaver_editor.d.ts"
+    }
+  },
+  "files": [
+    "bundler/",
+    "web/",
+    "nodejs/",
+    "deno/",
+    "README.md"
+  ]
+}
+EOF
+}
+
+generate_readme() {
+    local variant="$1"
+    local out_dir="pkg/${variant}"
+
+    cat > "${out_dir}/README.md" << 'EOF'
+# @weaver.sh/editor
+
+WASM-based markdown editor for the weaver.sh ecosystem.
+
+## Installation
+
+```bash
+npm install @weaver.sh/editor-core     # Local editing only
+npm install @weaver.sh/editor-collab   # With collaborative editing
+```
+
+## Usage
+
+### With a bundler (webpack, vite, etc.)
+
+```javascript
+import init, { JsEditor } from '@weaver.sh/editor-core';
+
+await init();
+
+const editor = JsEditor.fromMarkdown('# Hello\n\nWorld');
+console.log(editor.getMarkdown());
+```
+
+### Direct browser usage (no bundler)
+
+```html
+<script type="module">
+  import init, { JsEditor } from '@weaver.sh/editor-core/web';
+  await init();
+  // ...
+</script>
+```
+
+### Node.js
+
+```javascript
+const { JsEditor } = require('@weaver.sh/editor-core/nodejs');
+```
+
+## API
+
+See the TypeScript definitions for full API documentation.
+
+### Core
+
+- `JsEditor.new()` - Create empty editor
+- `JsEditor.fromMarkdown(content)` - Create from markdown
+- `JsEditor.fromSnapshot(entry)` - Create from EntryJson snapshot
+- `editor.getMarkdown()` - Get markdown content
+- `editor.getSnapshot()` - Get EntryJson for drafts
+- `editor.toEntry()` - Get validated EntryJson for publishing
+- `editor.executeAction(action)` - Execute an EditorAction
+- `editor.setTitle(title)` / `editor.setPath(path)` / `editor.setTags(tags)`
+
+### Images
+
+- `editor.addPendingImage(image)` - Track pending upload
+- `editor.finalizeImage(localId, finalized)` - Mark upload complete
+- `editor.getPendingImages()` - Get images awaiting upload
+- `editor.getStagingUris()` - Get staging record URIs for cleanup
+
+### Collab (editor-collab only)
+
+- `JsCollabEditor` - Collaborative editor with Loro CRDT
+- `editor.exportUpdates()` / `editor.importUpdates(bytes)`
+- `editor.addPeer(nodeId)` / `editor.removePeer(nodeId)`
+EOF
+}
+
+do_build() {
+    # Clean previous builds
+    rm -rf pkg
+
+    # Build all combinations
+    for variant in "${!VARIANTS[@]}"; do
+        features="${VARIANTS[$variant]}"
+
+        for target in "${TARGETS[@]}"; do
+            build "$target" "$variant" "$features"
+        done
+
+        generate_package_json "$variant"
+        generate_readme "$variant"
+
+        # Clean up wasm-pack artifacts we don't need
+        find "pkg/${variant}" -name ".gitignore" -delete
+        find "pkg/${variant}" -name "package.json" -path "*/bundler/*" -delete
+        find "pkg/${variant}" -name "package.json" -path "*/web/*" -delete
+        find "pkg/${variant}" -name "package.json" -path "*/nodejs/*" -delete
+        find "pkg/${variant}" -name "package.json" -path "*/deno/*" -delete
+    done
+
+    echo ""
+    echo "Build complete!"
+    echo ""
+    ls -lh pkg/core/web/*.wasm pkg/collab/web/*.wasm 2>/dev/null || true
+    echo ""
+    echo "Packages:"
+    echo "  pkg/core/   - @weaver.sh/editor-core (local editing)"
+    echo "  pkg/collab/ - @weaver.sh/editor-collab (with CRDT collab)"
+}
+
+do_pack() {
+    echo "Packing..."
+    for variant in "${!VARIANTS[@]}"; do
+        echo "  ${variant}..."
+        (cd "pkg/${variant}" && npm pack)
+    done
+    echo ""
+    echo "Tarballs created:"
+    ls -lh pkg/*/*.tgz 2>/dev/null || true
+}
+
+do_publish() {
+    local tag="${1:-}"
+    local tag_arg=""
+    if [[ -n "$tag" ]]; then
+        tag_arg="--tag $tag"
+    fi
+
+    echo "Publishing..."
+    for variant in "${!VARIANTS[@]}"; do
+        echo "  ${variant}..."
+        (cd "pkg/${variant}" && npm publish --access public $tag_arg)
+    done
+    echo ""
+    echo "Published!"
+}
+
+usage() {
+    echo "Usage: $0 [command]"
+    echo ""
+    echo "Commands:"
+    echo "  build    Build all variants and targets (default)"
+    echo "  pack     Create npm tarballs"
+    echo "  publish  Publish to npm registry"
+    echo "  all      Build, pack, and publish"
+    echo ""
+    echo "Options for publish:"
+    echo "  --tag <tag>  Publish with a specific tag (e.g., 'next', 'beta')"
+}
+
+case "$COMMAND" in
+    build)
+        do_build
+        ;;
+    pack)
+        do_pack
+        ;;
+    publish)
+        do_publish "$@"
+        ;;
+    all)
+        do_build
+        do_pack
+        do_publish "$@"
+        ;;
+    -h|--help|help)
+        usage
+        ;;
+    *)
+        echo "Unknown command: $COMMAND"
+        usage
+        exit 1
+        ;;
+esac

crates/weaver-editor-js/src/actions.rs

···
+//! EditorAction conversion for JavaScript.
+
+use serde::{Deserialize, Serialize};
+use tsify_next::Tsify;
+use wasm_bindgen::prelude::*;
+use weaver_editor_core::{EditorAction, FormatAction, Range};
+
+/// JavaScript-friendly editor action.
+///
+/// Mirrors EditorAction from core but with JS-compatible types.
+/// Also includes FormatAction variants for extended formatting.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+#[serde(tag = "type", rename_all = "camelCase")]
+pub enum JsEditorAction {
+    // Text insertion
+    Insert { text: String, start: usize, end: usize },
+    InsertLineBreak { start: usize, end: usize },
+    InsertParagraph { start: usize, end: usize },
+
+    // Deletion
+    DeleteBackward { start: usize, end: usize },
+    DeleteForward { start: usize, end: usize },
+    DeleteWordBackward { start: usize, end: usize },
+    DeleteWordForward { start: usize, end: usize },
+    DeleteToLineStart { start: usize, end: usize },
+    DeleteToLineEnd { start: usize, end: usize },
+    DeleteSoftLineBackward { start: usize, end: usize },
+    DeleteSoftLineForward { start: usize, end: usize },
+
+    // History
+    Undo,
+    Redo,
+
+    // Inline formatting (EditorAction variants)
+    ToggleBold,
+    ToggleItalic,
+    ToggleCode,
+    ToggleStrikethrough,
+    InsertLink,
+
+    // Extended formatting (FormatAction variants)
+    InsertImage,
+    InsertHeading { level: u8 },
+    ToggleBulletList,
+    ToggleNumberedList,
+    ToggleQuote,
+
+    // Clipboard
+    Cut,
+    Copy,
+    Paste { start: usize, end: usize },
+    CopyAsHtml,
+
+    // Selection
+    SelectAll,
+
+    // Cursor
+    MoveCursor { offset: usize },
+    ExtendSelection { offset: usize },
+}
+
+/// Result of converting JsEditorAction.
+pub enum ActionKind {
+    /// Standard EditorAction.
+    Editor(EditorAction),
+    /// FormatAction (needs apply_formatting).
+    Format(FormatAction),
+}
+
+impl JsEditorAction {
+    /// Convert to ActionKind (either EditorAction or FormatAction).
+    pub fn to_action_kind(&self) -> ActionKind {
+        match self {
+            // Text insertion
+            Self::Insert { text, start, end } => ActionKind::Editor(EditorAction::Insert {
+                text: text.clone(),
+                range: Range::new(*start, *end),
+            }),
+            Self::InsertLineBreak { start, end } => ActionKind::Editor(EditorAction::InsertLineBreak {
+                range: Range::new(*start, *end),
+            }),
+            Self::InsertParagraph { start, end } => ActionKind::Editor(EditorAction::InsertParagraph {
+                range: Range::new(*start, *end),
+            }),
+
+            // Deletion
+            Self::DeleteBackward { start, end } => ActionKind::Editor(EditorAction::DeleteBackward {
+                range: Range::new(*start, *end),
+            }),
+            Self::DeleteForward { start, end } => ActionKind::Editor(EditorAction::DeleteForward {
+                range: Range::new(*start, *end),
+            }),
+            Self::DeleteWordBackward { start, end } => ActionKind::Editor(EditorAction::DeleteWordBackward {
+                range: Range::new(*start, *end),
+            }),
+            Self::DeleteWordForward { start, end } => ActionKind::Editor(EditorAction::DeleteWordForward {
+                range: Range::new(*start, *end),
+            }),
+            Self::DeleteToLineStart { start, end } => ActionKind::Editor(EditorAction::DeleteToLineStart {
+                range: Range::new(*start, *end),
+            }),
+            Self::DeleteToLineEnd { start, end } => ActionKind::Editor(EditorAction::DeleteToLineEnd {
+                range: Range::new(*start, *end),
+            }),
+            Self::DeleteSoftLineBackward { start, end } => ActionKind::Editor(EditorAction::DeleteSoftLineBackward {
+                range: Range::new(*start, *end),
+            }),
+            Self::DeleteSoftLineForward { start, end } => ActionKind::Editor(EditorAction::DeleteSoftLineForward {
+                range: Range::new(*start, *end),
+            }),
+
+            // History
+            Self::Undo => ActionKind::Editor(EditorAction::Undo),
+            Self::Redo => ActionKind::Editor(EditorAction::Redo),
+
+            // Inline formatting (EditorAction)
+            Self::ToggleBold => ActionKind::Editor(EditorAction::ToggleBold),
+            Self::ToggleItalic => ActionKind::Editor(EditorAction::ToggleItalic),
+            Self::ToggleCode => ActionKind::Editor(EditorAction::ToggleCode),
+            Self::ToggleStrikethrough => ActionKind::Editor(EditorAction::ToggleStrikethrough),
+            Self::InsertLink => ActionKind::Editor(EditorAction::InsertLink),
+
+            // Extended formatting (FormatAction)
+            Self::InsertImage => ActionKind::Format(FormatAction::Image),
+            Self::InsertHeading { level } => ActionKind::Format(FormatAction::Heading(*level)),
+            Self::ToggleBulletList => ActionKind::Format(FormatAction::BulletList),
+            Self::ToggleNumberedList => ActionKind::Format(FormatAction::NumberedList),
+            Self::ToggleQuote => ActionKind::Format(FormatAction::Quote),
+
+            // Clipboard
+            Self::Cut => ActionKind::Editor(EditorAction::Cut),
+            Self::Copy => ActionKind::Editor(EditorAction::Copy),
+            Self::Paste { start, end } => ActionKind::Editor(EditorAction::Paste {
+                range: Range::new(*start, *end),
+            }),
+            Self::CopyAsHtml => ActionKind::Editor(EditorAction::CopyAsHtml),
+
+            // Selection
+            Self::SelectAll => ActionKind::Editor(EditorAction::SelectAll),
+
+            // Cursor
+            Self::MoveCursor { offset } => ActionKind::Editor(EditorAction::MoveCursor { offset: *offset }),
+            Self::ExtendSelection { offset } => ActionKind::Editor(EditorAction::ExtendSelection { offset: *offset }),
+        }
+    }
+}
+
+/// Parse a JsValue into JsEditorAction.
+pub fn parse_action(value: JsValue) -> Result<JsEditorAction, JsError> {
+    serde_wasm_bindgen::from_value(value)
+        .map_err(|e| JsError::new(&format!("Invalid action: {}", e)))
+}

crates/weaver-editor-js/src/collab.rs

···
+//! JsCollabEditor - collaborative editor with Loro CRDT.
+//!
+//! Only available with the `collab` feature.
+
+use wasm_bindgen::prelude::*;
+
+use weaver_editor_crdt::LoroTextBuffer;
+
+/// Collaborative editor with CRDT sync.
+///
+/// Wraps LoroTextBuffer for collaborative editing with iroh P2P transport.
+#[wasm_bindgen]
+pub struct JsCollabEditor {
+    // TODO: Implement collab editor
+    // - LoroTextBuffer for CRDT-backed text
+    // - iroh node for P2P transport
+    // - Session management callbacks
+    _marker: std::marker::PhantomData<LoroTextBuffer>,
+}
+
+#[wasm_bindgen]
+impl JsCollabEditor {
+    /// Create a new collaborative editor.
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Result<JsCollabEditor, JsError> {
+        Err(JsError::new("CollabEditor not yet implemented"))
+    }
+}
+
+impl Default for JsCollabEditor {
+    fn default() -> Self {
+        Self {
+            _marker: std::marker::PhantomData,
+        }
+    }
+}
+
+// TODO: Implement these when ready:
+// - from_snapshot / from_loro_doc
+// - export_updates / import_updates
+// - get_version
+// - add_peer / remove_peer / get_connected_peers
+// - Session callbacks (onSessionNeeded, onSessionRefresh, onSessionEnd, onPeersNeeded)

crates/weaver-editor-js/src/editor.rs

···
+//! JsEditor - the main editor wrapper for JavaScript.
+
+use std::collections::HashMap;
+
+use wasm_bindgen::prelude::*;
+use web_sys::HtmlElement;
+
+use weaver_editor_browser::BrowserClipboard;
+use weaver_editor_core::{
+    EditorDocument, EditorRope, PlainEditor, RenderCache, UndoableBuffer, apply_formatting,
+    execute_action_with_clipboard,
+};
+
+use crate::actions::{ActionKind, parse_action};
+use crate::types::{EntryEmbeds, EntryJson, FinalizedImage, JsResolvedContent, PendingImage};
+
+type InnerEditor = PlainEditor<UndoableBuffer<EditorRope>>;
+
+/// The main editor instance exposed to JavaScript.
+///
+/// Wraps the core editor with WASM bindings for browser use.
+#[wasm_bindgen]
+pub struct JsEditor {
+    doc: InnerEditor,
+    cache: RenderCache,
+    resolved_content: weaver_common::ResolvedContent,
+
+    // Metadata
+    title: String,
+    path: String,
+    tags: Vec<String>,
+    created_at: String,
+
+    // Image tracking
+    pending_images: HashMap<String, PendingImage>,
+    finalized_images: HashMap<String, FinalizedImage>,
+}
+
+#[wasm_bindgen]
+impl JsEditor {
+    /// Create a new empty editor.
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        let rope = EditorRope::new();
+        let buffer = UndoableBuffer::new(rope, 100);
+        let doc = PlainEditor::new(buffer);
+
+        Self {
+            doc,
+            cache: RenderCache::default(),
+            resolved_content: weaver_common::ResolvedContent::new(),
+            title: String::new(),
+            path: String::new(),
+            tags: Vec::new(),
+            created_at: now_iso(),
+            pending_images: HashMap::new(),
+            finalized_images: HashMap::new(),
+        }
+    }
+
+    /// Create an editor from markdown content.
+    #[wasm_bindgen(js_name = fromMarkdown)]
+    pub fn from_markdown(content: &str) -> Self {
+        let rope = EditorRope::from_str(content);
+        let buffer = UndoableBuffer::new(rope, 100);
+        let doc = PlainEditor::new(buffer);
+
+        Self {
+            doc,
+            cache: RenderCache::default(),
+            resolved_content: weaver_common::ResolvedContent::new(),
+            title: String::new(),
+            path: String::new(),
+            tags: Vec::new(),
+            created_at: now_iso(),
+            pending_images: HashMap::new(),
+            finalized_images: HashMap::new(),
+        }
+    }
+
+    /// Create an editor from a snapshot (EntryJson).
+    #[wasm_bindgen(js_name = fromSnapshot)]
+    pub fn from_snapshot(snapshot: JsValue) -> Result<JsEditor, JsError> {
+        let entry: EntryJson = serde_wasm_bindgen::from_value(snapshot)
+            .map_err(|e| JsError::new(&format!("Invalid snapshot: {}", e)))?;
+
+        let rope = EditorRope::from_str(&entry.content);
+        let buffer = UndoableBuffer::new(rope, 100);
+        let doc = PlainEditor::new(buffer);
+
+        Ok(Self {
+            doc,
+            cache: RenderCache::default(),
+            resolved_content: weaver_common::ResolvedContent::new(),
+            title: entry.title,
+            path: entry.path,
+            tags: entry.tags.unwrap_or_default(),
+            created_at: entry.created_at,
+            pending_images: HashMap::new(),
+            finalized_images: HashMap::new(),
+        })
+    }
+
+    /// Set pre-resolved embed content.
+    #[wasm_bindgen(js_name = setResolvedContent)]
+    pub fn set_resolved_content(&mut self, content: JsResolvedContent) {
+        self.resolved_content = content.into_inner();
+    }
+
+    // === Content access ===
+
+    /// Get the markdown content.
+    #[wasm_bindgen(js_name = getMarkdown)]
+    pub fn get_markdown(&self) -> String {
+        self.doc.content_string()
+    }
+
+    /// Get the current state as a snapshot (EntryJson).
+    #[wasm_bindgen(js_name = getSnapshot)]
+    pub fn get_snapshot(&self) -> Result<JsValue, JsError> {
+        let entry = EntryJson {
+            title: self.title.clone(),
+            path: self.path.clone(),
+            content: self.doc.content_string(),
+            created_at: self.created_at.clone(),
+            updated_at: Some(now_iso()),
+            tags: if self.tags.is_empty() {
+                None
+            } else {
+                Some(self.tags.clone())
+            },
+            embeds: self.build_embeds(),
+            authors: None,
+            content_warnings: None,
+            rating: None,
+        };
+
+        serde_wasm_bindgen::to_value(&entry)
+            .map_err(|e| JsError::new(&format!("Serialization error: {}", e)))
+    }
+
+    /// Get the entry JSON, validating required fields.
+    ///
+    /// Throws if title or path is empty, or if there are pending images.
+    #[wasm_bindgen(js_name = toEntry)]
+    pub fn to_entry(&self) -> Result<JsValue, JsError> {
+        if self.title.is_empty() {
+            return Err(JsError::new("Title is required"));
+        }
+        if self.path.is_empty() {
+            return Err(JsError::new("Path is required"));
+        }
+        if !self.pending_images.is_empty() {
+            return Err(JsError::new(
+                "Pending images must be finalized before publishing",
+            ));
+        }
+
+        self.get_snapshot()
+    }
+
+    // === Metadata ===
+
+    /// Get the title.
+    #[wasm_bindgen(js_name = getTitle)]
+    pub fn get_title(&self) -> String {
+        self.title.clone()
+    }
+
+    /// Set the title.
+    #[wasm_bindgen(js_name = setTitle)]
+    pub fn set_title(&mut self, title: &str) {
+        self.title = title.to_string();
+    }
+
+    /// Get the path.
+    #[wasm_bindgen(js_name = getPath)]
+    pub fn get_path(&self) -> String {
+        self.path.clone()
+    }
+
+    /// Set the path.
+    #[wasm_bindgen(js_name = setPath)]
+    pub fn set_path(&mut self, path: &str) {
+        self.path = path.to_string();
+    }
+
+    /// Get the tags.
+    #[wasm_bindgen(js_name = getTags)]
+    pub fn get_tags(&self) -> Vec<String> {
+        self.tags.clone()
+    }
+
+    /// Set the tags.
+    #[wasm_bindgen(js_name = setTags)]
+    pub fn set_tags(&mut self, tags: Vec<String>) {
+        self.tags = tags;
+    }
+
+    // === Actions ===
+
+    /// Execute an editor action.
+    #[wasm_bindgen(js_name = executeAction)]
+    pub fn execute_action(&mut self, action: JsValue) -> Result<(), JsError> {
+        let js_action = parse_action(action)?;
+        let kind = js_action.to_action_kind();
+
+        let clipboard = BrowserClipboard::empty();
+        match kind {
+            ActionKind::Editor(editor_action) => {
+                execute_action_with_clipboard(&mut self.doc, &editor_action, &clipboard);
+            }
+            ActionKind::Format(format_action) => {
+                apply_formatting(&mut self.doc, format_action);
+            }
+        }
+
+        Ok(())
+    }
+
+    // === Image handling ===
+
+    /// Add a pending image (called when user adds an image).
+    #[wasm_bindgen(js_name = addPendingImage)]
+    pub fn add_pending_image(&mut self, image: JsValue) -> Result<(), JsError> {
+        let pending: PendingImage = serde_wasm_bindgen::from_value(image)
+            .map_err(|e| JsError::new(&format!("Invalid pending image: {}", e)))?;
+
+        self.pending_images
+            .insert(pending.local_id.clone(), pending);
+        Ok(())
+    }
+
+    /// Finalize an image after upload.
+    #[wasm_bindgen(js_name = finalizeImage)]
+    pub fn finalize_image(&mut self, local_id: &str, finalized: JsValue) -> Result<(), JsError> {
+        let finalized: FinalizedImage = serde_wasm_bindgen::from_value(finalized)
+            .map_err(|e| JsError::new(&format!("Invalid finalized image: {}", e)))?;
+
+        self.pending_images.remove(local_id);
+        self.finalized_images
+            .insert(local_id.to_string(), finalized);
+        Ok(())
+    }
+
+    /// Remove a pending image.
+    #[wasm_bindgen(js_name = removeImage)]
+    pub fn remove_image(&mut self, local_id: &str) {
+        self.pending_images.remove(local_id);
+        self.finalized_images.remove(local_id);
+    }
+
+    /// Get pending images that need upload.
+    #[wasm_bindgen(js_name = getPendingImages)]
+    pub fn get_pending_images(&self) -> Result<JsValue, JsError> {
+        let pending: Vec<_> = self.pending_images.values().cloned().collect();
+        serde_wasm_bindgen::to_value(&pending)
+            .map_err(|e| JsError::new(&format!("Serialization error: {}", e)))
+    }
+
+    /// Get staging URIs for cleanup after publish.
+    #[wasm_bindgen(js_name = getStagingUris)]
+    pub fn get_staging_uris(&self) -> Vec<String> {
+        self.finalized_images
+            .values()
+            .map(|f| f.staging_uri.clone())
+            .collect()
+    }
+
+    // === Cursor/selection ===
+
+    /// Get the current cursor offset.
+    #[wasm_bindgen(js_name = getCursorOffset)]
+    pub fn get_cursor_offset(&self) -> usize {
+        self.doc.cursor_offset()
+    }
+
+    /// Set the cursor offset.
+    #[wasm_bindgen(js_name = setCursorOffset)]
+    pub fn set_cursor_offset(&mut self, offset: usize) {
+        self.doc.set_cursor_offset(offset);
+    }
+
+    /// Get the document length in characters.
+    #[wasm_bindgen(js_name = getLength)]
+    pub fn get_length(&self) -> usize {
+        self.doc.len_chars()
+    }
+
+    // === Undo/redo ===
+
+    /// Check if undo is available.
+    #[wasm_bindgen(js_name = canUndo)]
+    pub fn can_undo(&self) -> bool {
+        self.doc.can_undo()
+    }
+
+    /// Check if redo is available.
+    #[wasm_bindgen(js_name = canRedo)]
+    pub fn can_redo(&self) -> bool {
+        self.doc.can_redo()
+    }
+}
+
+impl Default for JsEditor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl JsEditor {
+    /// Build embeds from finalized images.
+    fn build_embeds(&self) -> Option<EntryEmbeds> {
+        if self.finalized_images.is_empty() {
+            return None;
+        }
+
+        use crate::types::{ImageEmbed, ImagesEmbed};
+
+        let images: Vec<ImageEmbed> = self
+            .finalized_images
+            .values()
+            .map(|f| ImageEmbed {
+                image: f.blob_ref.clone(),
+                alt: String::new(), // TODO: track alt text
+                aspect_ratio: None,
+            })
+            .collect();
+
+        Some(EntryEmbeds {
+            images: Some(ImagesEmbed { images }),
+            records: None,
+            externals: None,
+            videos: None,
+        })
+    }
+}
+
+/// Get current time as ISO string.
+fn now_iso() -> String {
+    // Use js_sys::Date for browser-compatible time
+    let date = js_sys::Date::new_0();
+    date.to_iso_string().into()
+}

crates/weaver-editor-js/src/lib.rs

···
+//! WASM bindings for the weaver markdown editor.
+//!
+//! Provides embeddable editor components for JavaScript/TypeScript apps.
+//!
+//! # Features
+//!
+//! - `collab`: Enable collaborative editing via Loro CRDT + iroh P2P
+//! - `syntax-highlighting`: Enable syntax highlighting for code blocks
+
+mod actions;
+mod editor;
+mod types;
+
+#[cfg(feature = "collab")]
+mod collab;
+
+pub use actions::*;
+pub use editor::*;
+pub use types::*;
+
+#[cfg(feature = "collab")]
+pub use collab::*;
+
+use wasm_bindgen::prelude::*;
+
+/// Initialize panic hook for better error messages in console.
+#[wasm_bindgen(start)]
+pub fn init() {
+    console_error_panic_hook::set_once();
+}

crates/weaver-editor-js/src/types.rs

···
+//! Types exposed to JavaScript via wasm-bindgen.
+
+use serde::{Deserialize, Serialize};
+use tsify_next::Tsify;
+use wasm_bindgen::prelude::*;
+
+/// Pending image waiting for upload.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+#[serde(rename_all = "camelCase")]
+pub struct PendingImage {
+    pub local_id: String,
+    #[tsify(type = "Uint8Array")]
+    #[serde(with = "serde_bytes")]
+    pub data: Vec<u8>,
+    pub mime_type: String,
+    pub name: String,
+}
+
+/// Finalized image with blob ref and staging URI.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+#[serde(rename_all = "camelCase")]
+pub struct FinalizedImage {
+    pub blob_ref: JsBlobRef,
+    /// AT URI of the staging record (sh.weaver.publish.blob).
+    pub staging_uri: String,
+}
+
+/// Blob reference matching AT Protocol blob format.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+#[serde(rename_all = "camelCase")]
+pub struct JsBlobRef {
+    #[serde(rename = "$type")]
+    pub type_marker: String, // "blob"
+    pub r#ref: BlobLink,
+    pub mime_type: String,
+    pub size: u64,
+}
+
+/// CID link for blob.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct BlobLink {
+    #[serde(rename = "$link")]
+    pub link: String,
+}
+
+/// Entry JSON matching sh.weaver.notebook.entry lexicon.
+///
+/// Used for snapshots (drafts) and final entry output.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+#[serde(rename_all = "camelCase")]
+pub struct EntryJson {
+    pub title: String,
+    pub path: String,
+    pub content: String,
+    pub created_at: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub updated_at: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tags: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub embeds: Option<EntryEmbeds>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub authors: Option<Vec<Author>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content_warnings: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rating: Option<String>,
+}
+
+/// Entry embeds container.
+#[derive(Debug, Clone, Default, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+#[serde(rename_all = "camelCase")]
+pub struct EntryEmbeds {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub images: Option<ImagesEmbed>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub records: Option<RecordsEmbed>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub externals: Option<ExternalsEmbed>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub videos: Option<VideosEmbed>,
+}
+
+/// Image embed container.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct ImagesEmbed {
+    pub images: Vec<ImageEmbed>,
+}
+
+/// Single image embed.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+#[serde(rename_all = "camelCase")]
+pub struct ImageEmbed {
+    pub image: JsBlobRef,
+    pub alt: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub aspect_ratio: Option<AspectRatio>,
+}
+
+/// Aspect ratio for images/videos.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct AspectRatio {
+    pub width: u32,
+    pub height: u32,
+}
+
+/// Record embed container.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct RecordsEmbed {
+    pub records: Vec<RecordEmbed>,
+}
+
+/// Single record embed (strong ref).
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct RecordEmbed {
+    pub uri: String,
+    pub cid: String,
+}
+
+/// External link embed container.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct ExternalsEmbed {
+    pub externals: Vec<ExternalEmbed>,
+}
+
+/// Single external link embed.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct ExternalEmbed {
+    pub uri: String,
+    pub title: String,
+    pub description: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thumb: Option<JsBlobRef>,
+}
+
+/// Video embed container.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct VideosEmbed {
+    pub videos: Vec<VideoEmbed>,
+}
+
+/// Single video embed.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+#[serde(rename_all = "camelCase")]
+pub struct VideoEmbed {
+    pub video: JsBlobRef,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub alt: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub aspect_ratio: Option<AspectRatio>,
+}
+
+/// Author reference.
+#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct Author {
+    pub did: String,
+}
+
+/// Pre-rendered embed content for initial load.
+#[wasm_bindgen]
+pub struct JsResolvedContent {
+    inner: weaver_common::ResolvedContent,
+}
+
+#[wasm_bindgen]
+impl JsResolvedContent {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Self {
+            inner: weaver_common::ResolvedContent::new(),
+        }
+    }
+
+    /// Add pre-rendered HTML for an AT URI.
+    #[wasm_bindgen(js_name = addEmbed)]
+    pub fn add_embed(&mut self, at_uri: &str, html: &str) -> Result<(), JsError> {
+        use weaver_common::jacquard::{CowStr, IntoStatic, types::string::AtUri};
+
+        let uri = AtUri::new(at_uri)
+            .map_err(|e| JsError::new(&format!("Invalid AT URI: {}", e)))?
+            .into_static();
+
+        self.inner
+            .add_embed(uri, CowStr::from(html.to_string()), None);
+        Ok(())
+    }
+}
+
+impl Default for JsResolvedContent {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl JsResolvedContent {
+    pub fn into_inner(self) -> weaver_common::ResolvedContent {
+        self.inner
+    }
+
+    pub fn inner_ref(&self) -> &weaver_common::ResolvedContent {
+        &self.inner
+    }
+}
+
+/// Create an empty resolved content container.
+#[wasm_bindgen]
+pub fn create_resolved_content() -> JsResolvedContent {
+    JsResolvedContent::new()
+}