npm - openwriter - Versions diffs - 0.39.0 → 0.40.0 - Mend

openwriter 0.39.0 → 0.40.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/client/assets/index-DiJrXBgV.css +1 -0
package/dist/client/assets/{index-DKnYQz7a.js → index-vmEPerKn.js} +53 -53
package/dist/client/index.html +2 -2
package/dist/plugins/x-api/dist/index.js +130 -2
package/dist/plugins/x-api/dist/server-bridge.d.ts +22 -0
package/dist/plugins/x-api/dist/server-bridge.js +43 -0
package/dist/server/connection-routes.js +66 -0
package/dist/server/tiptap-draftjs.js +296 -0
package/package.json +1 -1
package/dist/client/assets/index-D57aFMR_.css +0 -1

package/dist/client/index.html CHANGED Viewed

@@ -10,8 +10,8 @@
     <!-- Fonts are self-hosted (bundled via @fontsource, imported in main.tsx →
          themes/vendored-fonts.css). No external font CDN: a local-first editor
          must work offline and behind content blockers. -->
-    <script type="module" crossorigin src="/assets/index-DKnYQz7a.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-D57aFMR_.css">
+    <script type="module" crossorigin src="/assets/index-vmEPerKn.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DiJrXBgV.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/plugins/x-api/dist/index.js CHANGED Viewed

@@ -8,23 +8,48 @@ import { join, extname } from 'path';
 import { readFileSync, existsSync } from 'fs';
 import sharp from 'sharp';
 import twitter from 'twitter-text';
+import { getServerBridge } from './server-bridge.js';
 const { parseTweet } = twitter;
-function createXClient(config) {
+/** X Articles API base. Two-step: draft, then publish. */
+const X_API_BASE = 'https://api.x.com/2';
+/** Build the OAuth1 signer from plugin config / env. Returns null when any of
+ *  the four credentials is missing. Shared by the SDK client and the raw
+ *  Articles calls (which the SDK doesn't model). */
+function createOAuth1(config) {
     const apiKey = config['api-key'] || process.env.X_API_KEY || '';
     const apiSecret = config['api-secret'] || process.env.X_API_SECRET || '';
     const accessToken = config['access-token'] || process.env.X_ACCESS_TOKEN || '';
     const accessTokenSecret = config['access-token-secret'] || process.env.X_ACCESS_TOKEN_SECRET || '';
     if (!apiKey || !apiSecret || !accessToken || !accessTokenSecret)
         return null;
-    const oauth1 = new OAuth1({
+    return new OAuth1({
         apiKey,
         apiSecret,
         callback: 'oob',
         accessToken,
         accessTokenSecret,
     });
+}
+function createXClient(config) {
+    const oauth1 = createOAuth1(config);
+    if (!oauth1)
+        return null;
     return new Client({ oauth1 });
 }
+/** Make an OAuth1-signed JSON request to the X API. The SDK has no Articles
+ *  resource, so we sign + fetch directly. `buildRequestHeader` correctly
+ *  excludes a JSON body from the OAuth1 signature base string. */
+async function xApiFetch(oauth1, method, path, body) {
+    const url = `${X_API_BASE}${path}`;
+    const bodyStr = body ? JSON.stringify(body) : '';
+    const authHeader = await oauth1.buildRequestHeader(method, url, bodyStr);
+    const headers = { Authorization: authHeader };
+    if (body)
+        headers['Content-Type'] = 'application/json';
+    const res = await fetch(url, { method, headers, body: body ? bodyStr : undefined });
+    const data = await res.json().catch(() => ({}));
+    return { ok: res.ok, status: res.status, data };
+}
 const plugin = {
     name: '@openwriter/plugin-x-api',
     version: '0.1.0',
@@ -235,6 +260,109 @@ const plugin = {
                 res.status(500).json({ success: false, error: err.message });
             }
         });
+        // POST /api/x/post-article — publish the active document as a native X
+        // Article. Two-step X flow: draft, then publish. Reads the active server
+        // doc (same source the managed/publish path reads) and converts it to X's
+        // DraftJS content_state via the shared converter.
+        ctx.app.post('/api/x/post-article', async (_req, res) => {
+            try {
+                const oauth1 = createOAuth1(ctx.config);
+                if (!oauth1) {
+                    res.status(400).json({ success: false, error: 'X API credentials not configured' });
+                    return;
+                }
+                const bridge = await getServerBridge();
+                const doc = bridge.getDocument();
+                const title = (bridge.getTitle() || '').trim();
+                const metadata = bridge.getMetadata() || {};
+                if (!title || title === 'Untitled') {
+                    res.status(400).json({ success: false, error: 'Article needs a title before posting.' });
+                    return;
+                }
+                const contentState = bridge.tiptapToDraftjs(doc);
+                if (!contentState.blocks.some((b) => (b.text || '').trim().length > 0)) {
+                    res.status(400).json({ success: false, error: 'Article body is empty.' });
+                    return;
+                }
+                // Optional cover image — upload to X and attach as cover_media.
+                let coverMedia;
+                const coverSrc = metadata?.articleContext?.coverImage;
+                if (coverSrc && typeof coverSrc === 'string' && /^\/_images\/[^/\\]+$/.test(coverSrc)) {
+                    const client = createXClient(ctx.config);
+                    if (client) {
+                        const mediaId = await uploadCoverMedia(client, ctx.dataDir, coverSrc);
+                        if (mediaId)
+                            coverMedia = { media_category: 'TWEET_IMAGE', media_id: mediaId };
+                    }
+                }
+                // Step 1 — create the draft.
+                const draftBody = { title, content_state: contentState };
+                if (coverMedia)
+                    draftBody.cover_media = coverMedia;
+                const draft = await xApiFetch(oauth1, 'POST', '/articles/draft', draftBody);
+                if (!draft.ok) {
+                    const detail = draft.data?.detail || draft.data?.title || JSON.stringify(draft.data);
+                    console.error('[X Plugin] Article draft failed:', draft.status, detail);
+                    res.status(draft.status || 500).json({ success: false, error: `Draft failed: ${detail}` });
+                    return;
+                }
+                const articleId = draft.data?.data?.id;
+                if (!articleId) {
+                    res.status(500).json({ success: false, error: 'Draft created but no article id returned.' });
+                    return;
+                }
+                // Step 2 — publish the draft (makes it public). Surface any error
+                // verbatim — a draft is private until this succeeds.
+                const published = await xApiFetch(oauth1, 'POST', `/articles/${articleId}/publish`);
+                if (!published.ok) {
+                    const detail = published.data?.detail || published.data?.title || JSON.stringify(published.data);
+                    console.error('[X Plugin] Article publish failed:', published.status, detail);
+                    res.status(published.status || 500).json({ success: false, articleId, error: `Publish failed: ${detail}` });
+                    return;
+                }
+                const postId = published.data?.data?.post_id;
+                const articleUrl = postId ? `https://x.com/i/status/${postId}` : undefined;
+                console.log(`[X Plugin] Article published: ${articleId} -> ${articleUrl}`);
+                res.json({ success: true, articleId, postId, articleUrl });
+            }
+            catch (err) {
+                const detail = err.data ? JSON.stringify(err.data) : err.message;
+                console.error('[X Plugin] Post article failed:', detail);
+                res.status(500).json({ success: false, error: detail });
+            }
+        });
     },
 };
+/** Upload an article cover image to X, returning its media_id. Mirrors the
+ *  /api/x/upload-media compression rules (>3MB or PNG -> JPEG). Returns null on
+ *  any failure — the article still posts, just without a cover. */
+async function uploadCoverMedia(client, dataDir, src) {
+    try {
+        const filename = src.replace('/_images/', '');
+        const filePath = join(dataDir, '_images', filename);
+        if (!existsSync(filePath))
+            return null;
+        const ext = extname(filename).toLowerCase();
+        const mimeMap = {
+            '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+            '.png': 'image/png', '.webp': 'image/webp',
+            '.gif': 'image/jpeg', '.bmp': 'image/bmp',
+            '.tiff': 'image/tiff', '.tif': 'image/tiff',
+        };
+        let fileBuffer = readFileSync(filePath);
+        let uploadType = mimeMap[ext] || 'image/jpeg';
+        if (fileBuffer.length > 3 * 1024 * 1024 || ext === '.png') {
+            fileBuffer = Buffer.from(await sharp(fileBuffer).jpeg({ quality: 85 }).toBuffer());
+            uploadType = 'image/jpeg';
+        }
+        const uploadResult = await client.media.upload({
+            body: { media: fileBuffer.toString('base64'), mediaCategory: 'tweet_image', mediaType: uploadType },
+        });
+        return uploadResult?.data?.id || uploadResult?.media_id_string || null;
+    }
+    catch (err) {
+        console.error('[X Plugin] Cover upload failed:', err.message);
+        return null;
+    }
+}
 export default plugin;

package/dist/plugins/x-api/dist/server-bridge.d.ts ADDED Viewed

@@ -0,0 +1,22 @@
+/**
+ * Thin runtime bridge to the OpenWriter server modules this plugin needs for
+ * article publishing — the active document, its title/metadata, the data dir,
+ * and the shared TipTap -> DraftJS converter.
+ *
+ * The converter (server/tiptap-draftjs.ts) is shared with plugins/publish so
+ * both posting paths produce identical X content_state. We import the compiled
+ * server module at runtime rather than vendoring it, resolving both the npm
+ * package layout and the monorepo layout — the same dual-path trick the publish
+ * plugin's helpers use.
+ */
+export interface ServerBridge {
+    getDocument: () => any;
+    getTitle: () => string;
+    getMetadata: () => Record<string, any>;
+    getDataDir: () => string;
+    tiptapToDraftjs: (doc: any) => {
+        blocks: any[];
+        entities: any[];
+    };
+}
+export declare function getServerBridge(): Promise<ServerBridge>;

package/dist/plugins/x-api/dist/server-bridge.js ADDED Viewed

@@ -0,0 +1,43 @@
+/**
+ * Thin runtime bridge to the OpenWriter server modules this plugin needs for
+ * article publishing — the active document, its title/metadata, the data dir,
+ * and the shared TipTap -> DraftJS converter.
+ *
+ * The converter (server/tiptap-draftjs.ts) is shared with plugins/publish so
+ * both posting paths produce identical X content_state. We import the compiled
+ * server module at runtime rather than vendoring it, resolving both the npm
+ * package layout and the monorepo layout — the same dual-path trick the publish
+ * plugin's helpers use.
+ */
+// npm package: dist/plugins/x-api/dist/server-bridge.js -> dist/server/
+// monorepo:    plugins/x-api/dist/server-bridge.js      -> packages/openwriter/dist/server/
+const npmBase = new URL('../../../server/', import.meta.url).href;
+const monoBase = new URL('../../../packages/openwriter/dist/server/', import.meta.url).href;
+let cached = null;
+async function tryImport(base) {
+    const [state, helpers, draftjs] = await Promise.all([
+        import(base + 'state.js'),
+        import(base + 'helpers.js'),
+        import(base + 'tiptap-draftjs.js'),
+    ]);
+    return { state, helpers, draftjs };
+}
+export async function getServerBridge() {
+    if (cached)
+        return cached;
+    let state, helpers, draftjs;
+    try {
+        ({ state, helpers, draftjs } = await tryImport(npmBase));
+    }
+    catch {
+        ({ state, helpers, draftjs } = await tryImport(monoBase));
+    }
+    cached = {
+        getDocument: state.getDocument,
+        getTitle: state.getTitle,
+        getMetadata: state.getMetadata,
+        getDataDir: helpers.getDataDir,
+        tiptapToDraftjs: draftjs.tiptapToDraftjs,
+    };
+    return cached;
+}

package/dist/server/connection-routes.js CHANGED Viewed

@@ -3,7 +3,12 @@
  * Local app no longer stores connections.
  */
 import { Router } from 'express';
+import { readFileSync, existsSync } from 'fs';
+import { join, extname } from 'path';
 import { platformFetch, isAuthenticated } from './connections.js';
+import { getDocument, getTitle, getMetadata } from './state.js';
+import { getDataDir } from './helpers.js';
+import { tiptapToDraftjs } from './tiptap-draftjs.js';
 export function createConnectionRouter() {
     const router = Router();
     // Unified connections list (OAuth + newsletter domains)
@@ -376,5 +381,66 @@ export function createConnectionRouter() {
             res.status(500).json({ success: false, error: err.message });
         }
     });
+    // POST /api/x/post-article — publish the active doc as a native X Article.
+    // Platform connection first (managed path), then fall through to the x-api
+    // plugin (direct OAuth1). Mirrors the /api/x/post routing. The article body
+    // is read from the active server doc and converted to X content_state here;
+    // the cover image (articleContext.coverImage) is uploaded via the platform.
+    router.post('/api/x/post-article', async (req, res, next) => {
+        const conn = await getFirstXConnection();
+        if (!conn) {
+            next();
+            return;
+        } // No platform connection → direct plugin path
+        try {
+            const title = (getTitle() || '').trim();
+            if (!title || title === 'Untitled') {
+                res.status(400).json({ success: false, error: 'Article needs a title before posting.' });
+                return;
+            }
+            const contentState = tiptapToDraftjs(getDocument());
+            if (!contentState.blocks.some((b) => (b.text || '').trim().length > 0)) {
+                res.status(400).json({ success: false, error: 'Article body is empty.' });
+                return;
+            }
+            // Optional cover — upload through the platform, attach by media id.
+            let coverMediaId;
+            const coverSrc = getMetadata()?.articleContext?.coverImage;
+            if (coverSrc && typeof coverSrc === 'string' && /^\/_images\/[^/\\]+$/.test(coverSrc)) {
+                const filename = coverSrc.replace('/_images/', '');
+                const filePath = join(getDataDir(), '_images', filename);
+                if (existsSync(filePath)) {
+                    const ext = extname(filename).toLowerCase();
+                    const mimeMap = {
+                        '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+                        '.png': 'image/png', '.webp': 'image/webp',
+                        '.gif': 'image/gif', '.bmp': 'image/bmp',
+                    };
+                    const uploadRes = await platformFetch(`/connections/${conn.id}/upload-media`, {
+                        method: 'POST',
+                        body: JSON.stringify({ media_base64: readFileSync(filePath).toString('base64'), media_type: mimeMap[ext] || 'image/jpeg' }),
+                    });
+                    if (uploadRes.ok) {
+                        const data = await uploadRes.json();
+                        if (data.mediaId)
+                            coverMediaId = data.mediaId;
+                    }
+                }
+            }
+            const upstream = await platformFetch(`/connections/${conn.id}/post-article`, {
+                method: 'POST',
+                body: JSON.stringify({ title, content_state: contentState, cover_media_id: coverMediaId }),
+            });
+            const data = await upstream.json();
+            if (!upstream.ok || !data.success) {
+                res.status(upstream.status || 500).json({ success: false, error: data.error || 'Article publish failed' });
+                return;
+            }
+            res.json({ success: true, articleId: data.articleId, postId: data.postId, articleUrl: data.post_url });
+        }
+        catch (err) {
+            res.status(500).json({ success: false, error: err.message });
+        }
+    });
     return router;
 }

package/dist/server/tiptap-draftjs.js ADDED Viewed

@@ -0,0 +1,296 @@
+/**
+ * TipTap / ProseMirror JSON  ->  X Articles DraftJS `content_state`.
+ *
+ * X's `POST /2/articles/draft` takes the article body as a DraftJS raw content
+ * state, in X's snake_case field naming:
+ *
+ *   {
+ *     blocks: [
+ *       { key, text, type, depth?, inline_style_ranges?, entity_ranges? }
+ *     ],
+ *     entities: [ { key, value: { type, mutability, data } } ]
+ *   }
+ *
+ * (Minimal valid body: `{"blocks":[{"text":"hi","type":"unstyled"}],"entities":[]}`.)
+ *
+ * This is the SINGLE shared converter imported by both posting paths — the
+ * direct plugin (plugins/x-api) and the managed plugin (plugins/publish) — so
+ * the OpenWriter-doc → X conversion lives in exactly one place. It is a pure
+ * function with no runtime deps, which keeps it trivially unit-testable and
+ * importable from either plugin's compiled context.
+ *
+ * v1 fidelity:
+ *   - blocks:  heading (h1–h6), paragraph, bullet/ordered/task lists (nested
+ *              via `depth`), blockquote, code-block.
+ *   - inline:  bold, italic, underline, strikethrough, inline code, links.
+ *   - tables:  degrade to pipe-joined text rows (no DraftJS table primitive).
+ *   - cover:   handled out of band via `cover_media` on the draft call — NOT
+ *              here. Body images degrade to their alt text (an inline-image
+ *              atomic-block shape isn't confirmed against X's schema yet).
+ *   - rules:   horizontalRule degrades to a blank separator block.
+ *   - marks X's DraftJS editor doesn't model (highlight, sub/superscript)
+ *     drop to plain text — the text always survives.
+ */
+/** TipTap mark type -> X DraftJS inline style. X's article schema accepts only
+ *  [bold, italic, strikethrough] (lowercase). Marks absent here (underline,
+ *  inline code, highlight, sub/superscript) drop silently — the underlying text
+ *  is unaffected. Verified against X's live validation. */
+const MARK_STYLE = {
+    bold: 'bold',
+    italic: 'italic',
+    strike: 'strikethrough',
+};
+const HEADER_TYPE = ['', 'header-one', 'header-two', 'header-three', 'header-four', 'header-five', 'header-six'];
+/** Accumulates blocks + entities and hands out unique keys. */
+class BuildContext {
+    blocks = [];
+    entities = [];
+    blockN = 0;
+    entityN = 0;
+    nextBlockKey() {
+        return 'b' + (this.blockN++).toString(36);
+    }
+    addEntity(type, mutability, data) {
+        const n = this.entityN++;
+        // entities[].key is a string; the returned integer is what entity_ranges use.
+        this.entities.push({ key: String(n), value: { type, mutability, data } });
+        return n;
+    }
+    pushText(text, type, depth = 0) {
+        const block = { key: this.nextBlockKey(), text, type };
+        if (depth)
+            block.depth = depth;
+        this.blocks.push(block);
+    }
+    pushInline(inline, type, depth = 0) {
+        const block = { key: this.nextBlockKey(), text: inline.text, type };
+        if (depth)
+            block.depth = depth;
+        if (inline.styles.length)
+            block.inline_style_ranges = mergeStyleRanges(inline.styles);
+        if (inline.entityRanges.length)
+            block.entity_ranges = inline.entityRanges;
+        this.blocks.push(block);
+    }
+}
+/** Convert a TipTap document (`{ type: 'doc', content: [...] }`) to X's DraftJS
+ *  content_state. Always returns at least one block — an empty doc yields a
+ *  single empty unstyled block, since X rejects a draft with no blocks. */
+export function tiptapToDraftjs(doc) {
+    const ctx = new BuildContext();
+    walkBlocks(doc?.content || [], 0, ctx);
+    if (ctx.blocks.length === 0)
+        ctx.pushText('', 'unstyled');
+    return { blocks: ctx.blocks, entities: ctx.entities };
+}
+function walkBlocks(nodes, depth, ctx) {
+    for (const node of nodes || []) {
+        switch (node?.type) {
+            case 'heading': {
+                const level = Math.min(Math.max(Number(node.attrs?.level) || 1, 1), 6);
+                ctx.pushInline(buildInline(node.content, ctx), HEADER_TYPE[level], depth);
+                break;
+            }
+            case 'paragraph':
+                ctx.pushInline(buildInline(node.content, ctx), 'unstyled', depth);
+                break;
+            case 'bulletList':
+                walkList(node.content, 'unordered-list-item', depth, ctx);
+                break;
+            case 'orderedList':
+                walkList(node.content, 'ordered-list-item', depth, ctx);
+                break;
+            case 'taskList':
+                walkTaskList(node.content, depth, ctx);
+                break;
+            case 'blockquote':
+                walkBlockquote(node.content, depth, ctx);
+                break;
+            case 'codeBlock': {
+                // DraftJS models a code block as one code-block per line; this is the
+                // faithful raw shape and round-trips cleanly in X's editor.
+                const lines = plainText(node.content).split('\n');
+                for (const line of lines)
+                    ctx.pushText(line, 'code-block', depth);
+                break;
+            }
+            case 'horizontalRule':
+                // No confirmed DraftJS divider primitive in X's article schema — emit a
+                // blank separator block rather than risk a rejected payload.
+                ctx.pushText('', 'unstyled', depth);
+                break;
+            case 'image':
+                // Inline body images need an uploaded media_id + an atomic-block entity
+                // shape not yet confirmed against X's schema. Preserve the alt text so
+                // context isn't silently lost; the hero/cover image is handled by
+                // cover_media on the draft call, not here.
+                if (node.attrs?.alt)
+                    ctx.pushText(String(node.attrs.alt), 'unstyled', depth);
+                break;
+            case 'table':
+                walkTable(node, depth, ctx);
+                break;
+            case 'footnoteSection':
+                walkFootnoteSection(node.content, depth, ctx);
+                break;
+            default:
+                // Unknown container — descend so nested content isn't dropped.
+                if (node?.content)
+                    walkBlocks(node.content, depth, ctx);
+        }
+    }
+}
+/** Walk a bullet/ordered list. Each listItem's first paragraph becomes one
+ *  list-item block; nested lists recurse at depth+1 (DraftJS list nesting). */
+function walkList(items, blockType, depth, ctx) {
+    for (const item of items || []) {
+        for (const child of item.content || []) {
+            if (child.type === 'bulletList')
+                walkList(child.content, 'unordered-list-item', depth + 1, ctx);
+            else if (child.type === 'orderedList')
+                walkList(child.content, 'ordered-list-item', depth + 1, ctx);
+            else if (child.type === 'paragraph')
+                ctx.pushInline(buildInline(child.content, ctx), blockType, depth);
+            else
+                walkBlocks([child], depth, ctx);
+        }
+    }
+}
+/** X's DraftJS has no task-list type; degrade each task item to a bullet with a
+ *  leading checkbox glyph (☑ / ☐) so the checked state survives visually. */
+function walkTaskList(items, depth, ctx) {
+    for (const item of items || []) {
+        const prefix = item.attrs?.checked ? '☑ ' : '☐ ';
+        let prefixed = false;
+        for (const child of item.content || []) {
+            if (child.type === 'taskList')
+                walkTaskList(child.content, depth + 1, ctx);
+            else if (child.type === 'paragraph') {
+                const inline = buildInline(child.content, ctx);
+                if (!prefixed) {
+                    shiftRanges(inline, prefix.length);
+                    inline.text = prefix + inline.text;
+                    prefixed = true;
+                }
+                ctx.pushInline(inline, 'unordered-list-item', depth);
+            }
+            else
+                walkBlocks([child], depth, ctx);
+        }
+    }
+}
+/** Each paragraph inside a blockquote becomes its own `blockquote` block. */
+function walkBlockquote(nodes, depth, ctx) {
+    for (const child of nodes || []) {
+        if (child.type === 'paragraph')
+            ctx.pushInline(buildInline(child.content, ctx), 'blockquote', depth);
+        else
+            walkBlocks([child], depth, ctx);
+    }
+}
+/** Degrade a table to one unstyled text block per row, cells pipe-joined. No
+ *  data is lost; the grid structure flattens to readable text. */
+function walkTable(node, depth, ctx) {
+    for (const row of node.content || []) {
+        const cells = (row.content || []).map((cell) => (cell.content || []).map((p) => plainInline(p.content)).join(' ').trim());
+        ctx.pushText(cells.join(' | '), 'unstyled', depth);
+    }
+}
+/** Footnote definitions render as plain blocks, first paragraph prefixed with
+ *  its label, so the reference text isn't orphaned. */
+function walkFootnoteSection(definitions, depth, ctx) {
+    for (const def of definitions || []) {
+        if (def.type !== 'footnoteDefinition')
+            continue;
+        const label = def.attrs?.label || '';
+        const paragraphs = (def.content || []).filter((c) => c.type === 'paragraph');
+        paragraphs.forEach((p, i) => {
+            const inline = buildInline(p.content, ctx);
+            if (i === 0) {
+                const prefix = `[${label}] `;
+                shiftRanges(inline, prefix.length);
+                inline.text = prefix + inline.text;
+            }
+            ctx.pushInline(inline, 'unstyled', depth);
+        });
+    }
+}
+/** Walk a node's inline content into { text, inline-style ranges, entity ranges },
+ *  registering link entities into the build context as it goes. */
+function buildInline(nodes, ctx) {
+    let text = '';
+    const styles = [];
+    const entityRanges = [];
+    for (const node of nodes || []) {
+        if (node.type === 'hardBreak') {
+            text += '\n';
+            continue;
+        }
+        if (node.type === 'footnoteReference') {
+            text += `[${node.attrs?.label || ''}]`;
+            continue;
+        }
+        if (node.type !== 'text') {
+            if (node.text)
+                text += node.text;
+            continue;
+        }
+        const piece = node.text || '';
+        const offset = text.length;
+        text += piece;
+        const length = piece.length;
+        if (length === 0)
+            continue;
+        for (const mark of node.marks || []) {
+            const style = MARK_STYLE[mark.type];
+            if (style)
+                styles.push({ offset, length, style });
+            if (mark.type === 'link') {
+                const href = mark.attrs?.href || '';
+                if (href) {
+                    const key = ctx.addEntity('link', 'mutable', { url: href });
+                    entityRanges.push({ offset, length, key });
+                }
+            }
+        }
+    }
+    return { text, styles, entityRanges };
+}
+/** Shift every range offset right by `n` (used when a text prefix — checkbox
+ *  glyph, footnote label — is prepended after inline ranges were computed). */
+function shiftRanges(inline, n) {
+    for (const s of inline.styles)
+        s.offset += n;
+    for (const e of inline.entityRanges)
+        e.offset += n;
+}
+/** Merge adjacent ranges with the same style (`...a..**b**..` split across
+ *  text nodes) into one, keeping the output minimal and stable. */
+function mergeStyleRanges(ranges) {
+    const sorted = [...ranges].sort((a, b) => a.style.localeCompare(b.style) || a.offset - b.offset);
+    const out = [];
+    for (const r of sorted) {
+        const last = out[out.length - 1];
+        if (last && last.style === r.style && last.offset + last.length === r.offset) {
+            last.length += r.length;
+        }
+        else {
+            out.push({ ...r });
+        }
+    }
+    return out;
+}
+/** Plain text of a node's inline content, marks ignored. */
+function plainInline(nodes) {
+    if (!nodes)
+        return '';
+    return nodes
+        .map((n) => (n.type === 'hardBreak' ? '\n' : n.text || ''))
+        .join('');
+}
+/** Plain text of block content (e.g. a code block's lines). */
+function plainText(nodes) {
+    if (!nodes)
+        return '';
+    return nodes.map((n) => n.text || '').join('');
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "openwriter",
-  "version": "0.39.0",
+  "version": "0.40.0",
   "description": "The open-source writing surface for AI agents. Markdown-native editor with pending change review — your agent writes, you accept or reject.",
   "type": "module",
   "license": "MIT",