@sutrata/editor 0.1.1 → 0.2.0

package/dist/file/docx-importer.js

@@ -56,19 +56,10 @@ function parseParagraph(p) {
     return { style, text: runs.map(r => r.text).join(''), runs, isPageBreak };
 }
 function parseTable(tbl) {
-    const tr = tbl.getElementsByTagNameNS(W_NS, 'tr')[0];
-    const cells = [];
-    if (tr) {
-        for (const tc of Array.from(tr.children)) {
-            if (tc.localName !== 'tc')
-                continue;
-            const paras = Array.from(tc.children)
-                .filter(c => c.localName === 'p')
-                .map(p => parseParagraph(p));
-            cells.push(paras);
-        }
-    }
-    return { cells };
+    const rows = Array.from(tbl.getElementsByTagNameNS(W_NS, 'tr')).map(tr => Array.from(tr.children)
+        .filter(tc => tc.localName === 'tc')
+        .map(tc => Array.from(tc.children).filter(c => c.localName === 'p').map(p => parseParagraph(p))));
+    return { cells: rows[0] ?? [], rows };
 }
 /** Rebuilds bold/italic/underline markup from formatting runs, matching the parser's inline syntax.
  *  Types that don't support inline spans in Sutra source (headings, character cues, notes, etc.)
@@ -207,12 +198,7 @@ function isBodyStart(item) {
         return true;
     return item.para.style !== null && BODY_STYLES.has(item.para.style);
 }
-/** Parses a .docx file (as produced by exportToDocx, possibly re-saved from Word with
- *  corrections and/or font changes) back into Sutra body text. The title page, if any,
- *  is not reimported — only content carrying the CineXxx paragraph styles the exporter
- *  applies to the screenplay body is recognized. */
-export async function importDocx(buffer) {
-    const warnings = [];
+async function readBodyItems(buffer) {
     let zip;
     try {
         zip = await JSZip.loadAsync(buffer);
@@ -239,6 +225,48 @@ export async function importDocx(buffer) {
         else if (child.localName === 'tbl')
             items.push({ kind: 'table', table: parseTable(child) });
     }
+    return items;
+}
+/** True when the document carries the CineXxx paragraph styles exportToDocx applies. */
+export async function isSutrataDocx(buffer) {
+    // Only styled paragraphs count: any Word document may contain tables.
+    return (await readBodyItems(buffer)).some(item => item.kind === 'para' && isBodyStart(item));
+}
+/**
+ * Plain text of any Word document, one line per paragraph (empty paragraphs
+ * become blank lines), with bold/italic/underline runs as Sutra emphasis
+ * markup. Table cells are read row by row, left to right. Used by the
+ * AI-assisted import for documents Sutrata did not write.
+ */
+export async function readDocxText(buffer) {
+    const lines = [];
+    const addPara = (para) => {
+        if (para.isPageBreak && !para.text.trim()) {
+            lines.push('');
+            return;
+        }
+        lines.push(renderInline(para.runs, { allowBold: true, allowItalic: true, allowUnderline: true }).replace(/\s+$/, ''));
+    };
+    for (const item of await readBodyItems(buffer)) {
+        if (item.kind === 'para')
+            addPara(item.para);
+        else
+            for (const row of item.table.rows)
+                for (const cell of row) {
+                    for (const p of cell)
+                        addPara(p);
+                    lines.push('');
+                }
+    }
+    return lines.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+/** Parses a .docx file (as produced by exportToDocx, possibly re-saved from Word with
+ *  corrections and/or font changes) back into Sutra body text. The title page, if any,
+ *  is not reimported — only content carrying the CineXxx paragraph styles the exporter
+ *  applies to the screenplay body is recognized. */
+export async function importDocx(buffer) {
+    const warnings = [];
+    const items = await readBodyItems(buffer);
     const startIdx = items.findIndex(isBodyStart);
     if (startIdx === -1) {
         warnings.push('No Sutrata screenplay content was found in this document — nothing was imported.');

package/dist/file/scene-number.d.ts

@@ -0,0 +1,5 @@
+import type { SceneHeadingNode } from '@sutrata/parser';
+/** The printed scene number: the `{#id}` (format spec §6.1, §7.4). */
+export declare function sceneNumberOf(node: SceneHeadingNode): string | null;
+/** `& status: omitted` (format spec §7.4). */
+export declare function isOmitted(node: SceneHeadingNode): boolean;

package/dist/file/scene-number.js

@@ -0,0 +1,8 @@
+/** The printed scene number: the `{#id}` (format spec §6.1, §7.4). */
+export function sceneNumberOf(node) {
+    return node.id || null;
+}
+/** `& status: omitted` (format spec §7.4). */
+export function isOmitted(node) {
+    return node.metadata.some(m => m.key === 'status' && m.value.trim().toLowerCase() === 'omitted');
+}

package/dist/file/workflow-reports.js

@@ -8,6 +8,7 @@ import { printPaginatorScript } from './print-paginator';
 // from the paper's inches lands exactly on one sheet.
 const CSS_PX_PER_IN = 96;
 import { DEFAULT_COVER_LAYOUT } from '../styles/types';
+import { sceneNumberOf, isOmitted } from './scene-number';
 // CSV Escape Helper
 function esc(val) {
     const str = val ? String(val) : '';
@@ -25,14 +26,15 @@ export function extractWorkflowData(ast) {
             sceneCount++;
             const rawHeading = node.text.toUpperCase();
             // Find metadata keys
-            const numMeta = node.metadata.find(m => m.key === 'number')?.value;
-            const sceneNum = numMeta || node.id || String(sceneCount);
+            const sceneNum = sceneNumberOf(node) || String(sceneCount);
             const synopsis = node.metadata.find(m => m.key === 'synopsis')?.value ?? '';
             const actors = node.metadata.find(m => m.key === 'actors')?.value ?? '';
             const status = node.metadata.find(m => m.key === 'status')?.value ?? '';
             const estDuration = node.metadata.find(m => m.key === 'est-duration')?.value ?? '';
-            // Collect all shot metadata lines
-            const shotLines = node.metadata.filter(m => m.key === 'shots').map(m => m.value);
+            // Collect shots: `& shots:` list items (§7.3) and repeated `& shots: text` lines
+            const shotLines = node.metadata
+                .filter(m => m.key === 'shots')
+                .flatMap(m => m.items ?? (m.value ? [m.value] : []));
             scenes.push({
                 number: sceneNum,
                 heading: rawHeading,
@@ -613,11 +615,15 @@ async function buildScreenplayPrintHtml(ast, title, styleOverride, customStyles
         }
         else if (node.type === 'scene-heading') {
             sceneOrdinal++;
-            const sceneLabel = node.id || String(sceneOrdinal);
+            // Scene number: the {#id} (format spec §6.1).
+            const printedNumber = sceneNumberOf(node);
+            const sceneLabel = printedNumber || String(sceneOrdinal);
+            // An omitted scene (§7.4) prints OMITTED in place of its heading; its body is a comment.
+            const title = isOmitted(node) ? 'OMITTED' : textHtml(node.text.toUpperCase());
             bodyHtml += tagScene(`
         <div class="print-scene-heading">
-          <span class="print-scene-title">${textHtml(node.text.toUpperCase())}</span>
-          ${node.id ? `<span class="print-scene-num">${escapeHtml(node.id)}</span>` : ''}
+          <span class="print-scene-title">${title}</span>
+          ${printedNumber ? `<span class="print-scene-num">${escapeHtml(printedNumber)}</span>` : ''}
         </div>
       `, sceneLabel, true);
             for (const sub of node.children) {

package/dist/findreplace/FindReplace.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useState, useCallback, useEffect, useRef } from 'react';
+import { useCanEdit } from '../extensions/session';
 import { useDocument } from '../context/DocumentContext';
 import { useTranslation } from '../i18n/useTranslation';
 import { findAll, replaceAll } from './find-engine';
@@ -9,6 +10,7 @@ import { setFindHighlights, clearFindHighlights } from '../editor/find-highlight
 import { setSourceFindHighlights, clearSourceFindHighlights, scrollToSourceMatch } from '../source/find-highlight-source';
 export function FindReplace() {
     const { text, setText, mode, findReplaceVisible, setFindReplaceVisible, findMode, setFindMode } = useDocument();
+    const canEdit = useCanEdit();
     const { t } = useTranslation();
     const [query, setQuery] = useState('');
     const [replacement, setReplacement] = useState('');
@@ -157,8 +159,9 @@ export function FindReplace() {
     }, [setFindReplaceVisible, goNext, goPrev]);
     if (!findReplaceVisible)
         return null;
-    const isReplace = findMode === 'replace';
+    // Read-only sessions can search but not replace.
+    const isReplace = findMode === 'replace' && canEdit;
     const hasMatches = matches.length > 0;
-    return (_jsxs("div", { className: "cs-find-replace", role: "dialog", "aria-label": isReplace ? 'Find and Replace' : 'Find', children: [_jsxs("div", { className: "cs-fr-header", children: [_jsxs("div", { className: "cs-fr-mode-tabs", children: [_jsx("button", { className: `cs-fr-tab${!isReplace ? ' cs-fr-tab-active' : ''}`, onClick: () => setFindMode('find'), children: t('findreplace.findOnly') }), _jsx("button", { className: `cs-fr-tab${isReplace ? ' cs-fr-tab-active' : ''}`, onClick: () => setFindMode('replace'), children: t('findreplace.title') })] }), _jsx("button", { className: "cs-fr-close", "aria-label": "Close", onClick: () => setFindReplaceVisible(false), children: "\u00D7" })] }), _jsxs("div", { className: "cs-fr-row", children: [_jsx("input", { ref: queryRef, className: "cs-fr-input", type: "text", placeholder: t('findreplace.find'), value: query, onChange: e => setQuery(e.target.value), onKeyDown: handleQueryKeyDown, "aria-label": "Find" }), _jsx("button", { type: "button", className: "cs-fr-nav-btn", "aria-label": "Previous match", title: "Previous match (Shift+Enter)", onClick: goPrev, disabled: !hasMatches, children: "\u25B2" }), _jsx("button", { type: "button", className: "cs-fr-nav-btn", "aria-label": "Next match", title: "Next match (Enter)", onClick: goNext, disabled: !hasMatches, children: "\u25BC" }), _jsx("button", { type: "button", className: `cs-fr-toggle${caseSensitive ? ' cs-fr-active' : ''}`, onClick: () => setCaseSensitive(v => !v), title: t('findreplace.caseSensitive'), "aria-pressed": caseSensitive, children: "Aa" })] }), _jsxs("div", { className: "cs-fr-status", children: [query && !hasMatches && (_jsx("span", { className: "cs-fr-nomatch", children: t('findreplace.noMatches') })), hasMatches && (_jsxs("span", { className: "cs-fr-nav-count", children: [currentIndex + 1, " of ", matches.length] }))] }), isReplace && (_jsxs(_Fragment, { children: [_jsx("div", { className: "cs-fr-row", children: _jsx("input", { className: "cs-fr-input", type: "text", placeholder: t('findreplace.replace'), value: replacement, onChange: e => setReplacement(e.target.value), onKeyDown: e => { if (e.key === 'Escape')
+    return (_jsxs("div", { className: "cs-find-replace", role: "dialog", "aria-label": isReplace ? 'Find and Replace' : 'Find', children: [_jsxs("div", { className: "cs-fr-header", children: [_jsxs("div", { className: "cs-fr-mode-tabs", children: [_jsx("button", { className: `cs-fr-tab${!isReplace ? ' cs-fr-tab-active' : ''}`, onClick: () => setFindMode('find'), children: t('findreplace.findOnly') }), canEdit && _jsx("button", { className: `cs-fr-tab${isReplace ? ' cs-fr-tab-active' : ''}`, onClick: () => setFindMode('replace'), children: t('findreplace.title') })] }), _jsx("button", { className: "cs-fr-close", "aria-label": "Close", onClick: () => setFindReplaceVisible(false), children: "\u00D7" })] }), _jsxs("div", { className: "cs-fr-row", children: [_jsx("input", { ref: queryRef, className: "cs-fr-input", type: "text", placeholder: t('findreplace.find'), value: query, onChange: e => setQuery(e.target.value), onKeyDown: handleQueryKeyDown, "aria-label": "Find" }), _jsx("button", { type: "button", className: "cs-fr-nav-btn", "aria-label": "Previous match", title: "Previous match (Shift+Enter)", onClick: goPrev, disabled: !hasMatches, children: "\u25B2" }), _jsx("button", { type: "button", className: "cs-fr-nav-btn", "aria-label": "Next match", title: "Next match (Enter)", onClick: goNext, disabled: !hasMatches, children: "\u25BC" }), _jsx("button", { type: "button", className: `cs-fr-toggle${caseSensitive ? ' cs-fr-active' : ''}`, onClick: () => setCaseSensitive(v => !v), title: t('findreplace.caseSensitive'), "aria-pressed": caseSensitive, children: "Aa" })] }), _jsxs("div", { className: "cs-fr-status", children: [query && !hasMatches && (_jsx("span", { className: "cs-fr-nomatch", children: t('findreplace.noMatches') })), hasMatches && (_jsxs("span", { className: "cs-fr-nav-count", children: [currentIndex + 1, " of ", matches.length] }))] }), isReplace && (_jsxs(_Fragment, { children: [_jsx("div", { className: "cs-fr-row", children: _jsx("input", { className: "cs-fr-input", type: "text", placeholder: t('findreplace.replace'), value: replacement, onChange: e => setReplacement(e.target.value), onKeyDown: e => { if (e.key === 'Escape')
                                 setFindReplaceVisible(false); }, "aria-label": "Replace with" }) }), _jsxs("div", { className: "cs-fr-actions", children: [_jsx("button", { className: "cs-fr-btn", onClick: handleReplaceOne, disabled: !hasMatches, children: t('findreplace.replaceOne') }), _jsx("button", { className: "cs-fr-btn", onClick: handleReplaceAll, disabled: !query || !hasMatches, children: t('findreplace.replaceAll') })] })] }))] }));
 }

package/dist/import/AIImportDialog.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+/**
+ * AI-assisted import (OSS spec §5.5): pick a Word/text/Markdown file (or paste
+ * text), confirm the provider's data policy, let the AI format it as Sutra in
+ * checked chunks, review side by side with per-block type correction, then
+ * replace or append as one undoable edit. Sutrata's own DOCX skips the AI.
+ * Rendered only when useAI() is non-null (a provider, and an edit session).
+ */
+export declare function AIImportDialog({ onClose }: {
+    onClose: () => void;
+}): React.JSX.Element | null;

package/dist/import/AIImportDialog.js

@@ -0,0 +1,112 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useMemo, useRef, useState } from 'react';
+import { useDocument } from '../context/DocumentContext';
+import { useAI } from '../extensions/ai-provider';
+import { readImportFile, IMPORT_ACCEPT } from './extract';
+import { runAiImport, splitBlocks, blockKind, retypeBlock } from './ai-import';
+import { applyImport } from './apply-import';
+const KIND_LABELS = {
+    scene_heading: 'Scene heading',
+    action: 'Action',
+    character: 'Character + dialogue',
+    transition: 'Transition',
+    centered: 'Centered',
+    lyrics: 'Lyrics',
+    note: 'Note',
+    section: 'Section',
+    other: 'Other',
+};
+const KIND_OPTIONS = Object.keys(KIND_LABELS).filter(k => k !== 'other');
+/**
+ * AI-assisted import (OSS spec §5.5): pick a Word/text/Markdown file (or paste
+ * text), confirm the provider's data policy, let the AI format it as Sutra in
+ * checked chunks, review side by side with per-block type correction, then
+ * replace or append as one undoable edit. Sutrata's own DOCX skips the AI.
+ * Rendered only when useAI() is non-null (a provider, and an edit session).
+ */
+export function AIImportDialog({ onClose }) {
+    const ai = useAI();
+    const { text, setText, showToast } = useDocument();
+    const [step, setStep] = useState({ name: 'source' });
+    const [pasted, setPasted] = useState('');
+    const [error, setError] = useState('');
+    const [agreed, setAgreed] = useState(false);
+    const abortRef = useRef(null);
+    const fileRef = useRef(null);
+    const formatted = useMemo(() => (step.name === 'review' ? step.blocks.join('\n\n') : ''), [step]);
+    if (!ai)
+        return null;
+    const close = () => {
+        abortRef.current?.abort();
+        onClose();
+    };
+    const pickFile = async (file) => {
+        if (!file)
+            return;
+        setError('');
+        try {
+            const source = await readImportFile(file);
+            if (source.kind === 'sutra') {
+                setStep({ name: 'review', fileName: source.name, source: source.sutra, blocks: splitBlocks(source.sutra), chunks: [], warnings: source.warnings });
+            }
+            else if (!source.text.trim()) {
+                setError(`${source.name} has no text to import.`);
+            }
+            else {
+                setStep({ name: 'confirm', fileName: source.name, text: source.text });
+            }
+        }
+        catch (e) {
+            setError(e instanceof Error ? e.message : String(e));
+        }
+    };
+    const start = async (fileName, source) => {
+        if (!(await ai.isConfigured())) {
+            if (ai.openSetup) {
+                close();
+                ai.openSetup();
+            }
+            else
+                setError(`${ai.displayName} is not available right now.`);
+            return;
+        }
+        const controller = new AbortController();
+        abortRef.current = controller;
+        setStep({ name: 'running', done: 0, total: 1 });
+        try {
+            const result = await runAiImport(ai, source, {
+                signal: controller.signal,
+                onProgress: (done, total) => setStep({ name: 'running', done, total }),
+            });
+            const warnings = result.chunks.flatMap(c => c.problems.map(p => `Part ${c.index + 1}: ${p}`));
+            setStep({ name: 'review', fileName, source, blocks: splitBlocks(result.sutra), chunks: result.chunks, warnings });
+        }
+        catch (e) {
+            if (controller.signal.aborted) {
+                setStep({ name: 'source' });
+                return;
+            }
+            setError(e instanceof Error ? e.message : String(e));
+            setStep({ name: 'confirm', fileName, text: source });
+        }
+        finally {
+            abortRef.current = null;
+        }
+    };
+    const finish = (how) => {
+        if (step.name !== 'review')
+            return;
+        applyImport(formatted, how, text, setText);
+        showToast(`Imported ${step.fileName} (${step.blocks.length} blocks).`, 'success');
+        onClose();
+    };
+    return (_jsx("div", { className: "cs-dialog-overlay", onClick: close, children: _jsxs("div", { className: "cs-dialog cs-ai-import-dialog", role: "dialog", "aria-modal": "true", "aria-label": "Import with AI", onClick: e => e.stopPropagation(), onKeyDown: e => { if (e.key === 'Escape')
+                close(); }, style: { maxWidth: step.name === 'review' ? '1100px' : '560px', width: '94%' }, children: [_jsxs("div", { className: "cs-dialog-header", children: [_jsx("span", { className: "cs-dialog-title", children: "Import with AI" }), _jsx("button", { className: "cs-fr-close", "aria-label": "Close", onClick: close, children: "\u00D7" })] }), _jsxs("div", { className: "cs-ai-import-body", children: [error && _jsx("div", { className: "cs-ai-import-error", role: "alert", children: error }), step.name === 'source' && (_jsxs(_Fragment, { children: [_jsx("p", { className: "cs-ai-import-hint", children: "Import a screenplay written in Word, a text file or Markdown. The AI formats it as Sutra; you review the result before anything changes. A Word file exported from Sutrata is imported directly, without AI." }), _jsx("input", { ref: fileRef, type: "file", accept: IMPORT_ACCEPT, "aria-label": "Choose a file to import", onChange: e => void pickFile(e.target.files?.[0]) }), _jsx("label", { className: "cs-settings-label", htmlFor: "cs-ai-import-paste", style: { display: 'block', marginTop: 12 }, children: "\u2026or paste the text" }), _jsx("textarea", { id: "cs-ai-import-paste", className: "cs-ai-import-paste", rows: 8, value: pasted, onChange: e => setPasted(e.target.value) }), _jsx("div", { className: "cs-ai-import-actions", children: _jsx("button", { type: "button", className: "cs-confirm-btn-primary", disabled: !pasted.trim(), onClick: () => setStep({ name: 'confirm', fileName: 'pasted text', text: pasted.trim() }), children: "Continue" }) })] })), step.name === 'confirm' && (_jsxs(_Fragment, { children: [_jsxs("p", { className: "cs-ai-import-hint", children: [_jsx("strong", { children: step.fileName }), " (", step.text.length.toLocaleString(), " characters) will be sent to", ' ', _jsx("strong", { children: ai.displayName }), " to be formatted."] }), _jsx("div", { className: "cs-ai-import-policy", "aria-label": "Data policy", children: ai.dataPolicyText }), _jsxs("label", { className: "cs-ai-import-agree", children: [_jsx("input", { type: "checkbox", checked: agreed, onChange: e => setAgreed(e.target.checked) }), "I understand, send this text to ", ai.displayName] }), _jsxs("div", { className: "cs-ai-import-actions", children: [_jsx("button", { type: "button", className: "cs-confirm-btn-cancel", onClick: () => setStep({ name: 'source' }), children: "Back" }), _jsx("button", { type: "button", className: "cs-confirm-btn-primary", disabled: !agreed, onClick: () => void start(step.fileName, step.text), children: "Format with AI" })] })] })), step.name === 'running' && (_jsxs(_Fragment, { children: [_jsxs("p", { className: "cs-ai-import-hint", role: "status", children: [_jsx("span", { className: "cs-spinner", style: { width: 10, height: 10, borderWidth: 1.5, marginRight: 8 } }), "Formatting part ", Math.min(step.done + 1, step.total), " of ", step.total, "\u2026"] }), _jsx("div", { className: "cs-ai-import-actions", children: _jsx("button", { type: "button", className: "cs-confirm-btn-cancel", onClick: () => abortRef.current?.abort(), children: "Cancel" }) })] })), step.name === 'review' && (_jsxs(_Fragment, { children: [step.warnings.length > 0 && (_jsxs("div", { className: "cs-export-warnings cs-ai-import-warnings", role: "alert", children: [_jsx("div", { className: "cs-export-warn-title", children: "Check these parts before importing" }), step.warnings.map((w, i) => _jsxs("div", { className: "cs-export-warn-item", children: ["\u2022 ", w] }, i))] })), _jsxs("div", { className: "cs-ai-import-review", children: [_jsxs("section", { "aria-label": "Source", children: [_jsx("div", { className: "cs-ai-import-col-title", children: "Source" }), _jsx("pre", { className: "cs-ai-import-source", children: step.source })] }), _jsxs("section", { "aria-label": "Formatted", children: [_jsxs("div", { className: "cs-ai-import-col-title", children: ["Formatted (", step.blocks.length, " blocks)"] }), _jsx("ol", { className: "cs-ai-import-blocks", children: step.blocks.map((block, i) => {
+                                                        const kind = blockKind(block);
+                                                        return (_jsxs("li", { className: "cs-ai-import-block", children: [_jsxs("select", { "aria-label": `Block ${i + 1} type`, className: "cs-settings-select", value: kind, onChange: e => {
+                                                                        const blocks = [...step.blocks];
+                                                                        blocks[i] = retypeBlock(block, e.target.value);
+                                                                        setStep({ ...step, blocks });
+                                                                    }, children: [kind === 'other' && _jsx("option", { value: "other", children: KIND_LABELS.other }), KIND_OPTIONS.map(k => _jsx("option", { value: k, children: KIND_LABELS[k] }, k))] }), _jsx("pre", { children: block })] }, i));
+                                                    }) })] })] }), _jsxs("div", { className: "cs-ai-import-actions", children: [_jsx("button", { type: "button", className: "cs-confirm-btn-cancel", onClick: close, children: "Cancel" }), _jsx("button", { type: "button", className: "cs-confirm-btn-cancel", onClick: () => finish('append'), disabled: !step.blocks.length, children: "Append to document" }), _jsx("button", { type: "button", className: "cs-confirm-btn-primary", title: "Replaces the script; the title page is kept", onClick: () => finish('replace'), disabled: !step.blocks.length, children: "Replace script" })] })] }))] })] }) }));
+}

package/dist/import/ai-import.d.ts

@@ -0,0 +1,51 @@
+import type { AIProvider } from '../extensions/ai-provider';
+/**
+ * AI-assisted import of screenplays written elsewhere (OSS spec §5.5).
+ *
+ * The source is split into chunks at blank lines (preferring likely scene
+ * boundaries), each chunk is formatted by the injected AIProvider, and every
+ * result is checked: it must parse to at least one block, and its words must
+ * match the chunk's words. A failing chunk is retried once; if it still
+ * fails, the better attempt is kept and the problem is reported.
+ */
+/** Target chunk size in characters: big enough for context, small enough for any provider. */
+export declare const DEFAULT_CHUNK_CHARS = 6000;
+/** Split `text` into paragraphs (blank-line separated) and group them into chunks of about `maxChars`. */
+export declare function chunkSource(text: string, maxChars?: number): string[];
+/** Words for the content comparison: letters/marks/digits, NFC, case-folded. Sigils and punctuation don't count. */
+export declare function contentWords(text: string): string[];
+export interface ContentDiff {
+    /** Words in the source missing from the result (with multiplicity). */
+    dropped: string[];
+    /** Words in the result not in the source. */
+    added: string[];
+}
+export declare function compareContent(source: string, result: string): ContentDiff;
+/** Strip a code fence or stray frontmatter a model might wrap around its answer. */
+export declare function cleanImportOutput(raw: string): string;
+export interface ChunkResult {
+    index: number;
+    source: string;
+    output: string;
+    attempts: number;
+    /** Why the chunk's output may not be faithful; empty when it passed. */
+    problems: string[];
+    diff: ContentDiff;
+}
+export declare function formatChunk(ai: AIProvider, source: string, index: number, signal?: AbortSignal): Promise<ChunkResult>;
+export interface ImportResult {
+    /** The formatted Sutra body, chunks joined with blank lines. */
+    sutra: string;
+    chunks: ChunkResult[];
+}
+export declare function runAiImport(ai: AIProvider, sourceText: string, opts?: {
+    signal?: AbortSignal;
+    maxChars?: number;
+    onProgress?(done: number, total: number): void;
+}): Promise<ImportResult>;
+export type BlockKind = 'scene_heading' | 'action' | 'character' | 'transition' | 'centered' | 'lyrics' | 'note' | 'section' | 'other';
+/** Split Sutra text into blank-line separated blocks (multi-line comments kept whole). */
+export declare function splitBlocks(sutra: string): string[];
+export declare function blockKind(block: string): BlockKind;
+/** Rewrite `block` as element `kind`, keeping its words (and a heading's metadata lines). */
+export declare function retypeBlock(block: string, kind: BlockKind): string;

package/dist/import/ai-import.js

@@ -0,0 +1,200 @@
+import { parse } from '@sutrata/parser';
+import { IMPORT_FORMAT_SYSTEM_PROMPT } from '../ai/prompts';
+/**
+ * AI-assisted import of screenplays written elsewhere (OSS spec §5.5).
+ *
+ * The source is split into chunks at blank lines (preferring likely scene
+ * boundaries), each chunk is formatted by the injected AIProvider, and every
+ * result is checked: it must parse to at least one block, and its words must
+ * match the chunk's words. A failing chunk is retried once; if it still
+ * fails, the better attempt is kept and the problem is reported.
+ */
+/** Target chunk size in characters: big enough for context, small enough for any provider. */
+export const DEFAULT_CHUNK_CHARS = 6000;
+/** A line that probably starts a scene: sluglines in Latin script, "SCENE 12", or a Sutra/Markdown heading. */
+const LIKELY_SCENE = /^\s*(?:##?\s|\.?(?:INT|EXT|INT\.?\/EXT|I\/E)[.\s]|SCENE\s+\d|\d+[A-Z]?[.)]?\s+(?:INT|EXT)[.\s])/i;
+/** Split `text` into paragraphs (blank-line separated) and group them into chunks of about `maxChars`. */
+export function chunkSource(text, maxChars = DEFAULT_CHUNK_CHARS) {
+    const paragraphs = text.replace(/\r\n?/g, '\n').split(/\n\s*\n/).map(p => p.replace(/^\n+|\n+$/g, '')).filter(p => p.trim());
+    const pieces = [];
+    for (const p of paragraphs) {
+        if (p.length <= maxChars) {
+            pieces.push(p);
+            continue;
+        }
+        // An oversized paragraph is split at line boundaries.
+        let current = [];
+        let size = 0;
+        for (const line of p.split('\n')) {
+            if (size + line.length > maxChars && current.length) {
+                pieces.push(current.join('\n'));
+                current = [];
+                size = 0;
+            }
+            current.push(line);
+            size += line.length + 1;
+        }
+        if (current.length)
+            pieces.push(current.join('\n'));
+    }
+    const chunks = [];
+    let current = [];
+    let size = 0;
+    for (const piece of pieces) {
+        const full = size + piece.length > maxChars;
+        // Past half the budget, break early at a scene boundary rather than mid-scene.
+        const sceneBreak = size > maxChars / 2 && LIKELY_SCENE.test(piece);
+        if (current.length && (full || sceneBreak)) {
+            chunks.push(current.join('\n\n'));
+            current = [];
+            size = 0;
+        }
+        current.push(piece);
+        size += piece.length + 2;
+    }
+    if (current.length)
+        chunks.push(current.join('\n\n'));
+    return chunks;
+}
+/** Words for the content comparison: letters/marks/digits, NFC, case-folded. Sigils and punctuation don't count. */
+export function contentWords(text) {
+    // Attribute blocks ({#12}, {lang=hi}) are Sutra markup, not content.
+    const stripped = text.normalize('NFC').replace(/\{[^{}\n]*\}/g, ' ');
+    return (stripped.match(/[\p{L}\p{M}\p{N}]+/gu) ?? []).map(w => w.toLocaleLowerCase());
+}
+export function compareContent(source, result) {
+    const count = (words) => {
+        const m = new Map();
+        for (const w of words)
+            m.set(w, (m.get(w) ?? 0) + 1);
+        return m;
+    };
+    const a = count(contentWords(source));
+    const b = count(contentWords(result));
+    const diff = (x, y) => [...x].flatMap(([w, n]) => Array(Math.max(0, n - (y.get(w) ?? 0))).fill(w));
+    return { dropped: diff(a, b), added: diff(b, a) };
+}
+/** Page furniture a formatter may legitimately drop. */
+const FURNITURE = new Set(['continued', 'cont', 'd', 'more']);
+/** Whether a diff is small enough to accept: page numbers and furniture aside, nothing changed. */
+function acceptable(diff) {
+    const significant = (w) => !FURNITURE.has(w) && !/^\d+$/.test(w);
+    return !diff.dropped.some(significant) && !diff.added.some(significant);
+}
+/** Strip a code fence or stray frontmatter a model might wrap around its answer. */
+export function cleanImportOutput(raw) {
+    let out = raw.trim().replace(/^```[\w-]*\n/, '').replace(/\n```\s*$/, '');
+    if (out.startsWith('---\n')) {
+        const end = out.indexOf('\n---', 4);
+        if (end !== -1)
+            out = out.slice(end + 4);
+    }
+    return out.replace(/\r\n?/g, '\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+function problemsOf(output, diff) {
+    const problems = [];
+    if (!output)
+        problems.push('The AI returned nothing for this part.');
+    else if (parse(output).children.length === 0)
+        problems.push('The AI output is not a Sutra screenplay.');
+    const shown = (ws) => [...new Set(ws)].slice(0, 8).join(', ');
+    if (!acceptable(diff)) {
+        if (diff.dropped.length)
+            problems.push(`Missing from the result (${diff.dropped.length}): ${shown(diff.dropped)}`);
+        if (diff.added.length)
+            problems.push(`Not in the source (${diff.added.length}): ${shown(diff.added)}`);
+    }
+    return problems;
+}
+export async function formatChunk(ai, source, index, signal) {
+    let best = null;
+    for (let attempt = 1; attempt <= 2; attempt++) {
+        signal?.throwIfAborted();
+        const output = cleanImportOutput(await ai.complete({ system: IMPORT_FORMAT_SYSTEM_PROMPT, prompt: source, signal }));
+        const diff = compareContent(source, output);
+        const result = { index, source, output, attempts: attempt, problems: problemsOf(output, diff), diff };
+        if (result.problems.length === 0)
+            return result;
+        const size = (r) => r.diff.dropped.length + r.diff.added.length + (r.output ? 0 : 1e9);
+        if (!best || size(result) < size(best))
+            best = { ...result };
+        best.attempts = attempt;
+    }
+    return best;
+}
+export async function runAiImport(ai, sourceText, opts = {}) {
+    const sources = chunkSource(sourceText, opts.maxChars);
+    const chunks = [];
+    opts.onProgress?.(0, sources.length);
+    for (const [i, source] of sources.entries()) {
+        chunks.push(await formatChunk(ai, source, i, opts.signal));
+        opts.onProgress?.(i + 1, sources.length);
+    }
+    return { sutra: chunks.map(c => c.output).filter(Boolean).join('\n\n'), chunks };
+}
+/** Split Sutra text into blank-line separated blocks (multi-line comments kept whole). */
+export function splitBlocks(sutra) {
+    const blocks = [];
+    let current = [];
+    let inComment = false;
+    for (const line of sutra.split('\n')) {
+        if (!line.trim() && !inComment) {
+            if (current.length)
+                blocks.push(current.join('\n'));
+            current = [];
+            continue;
+        }
+        current.push(line);
+        if (line.includes('<!--') && !line.includes('-->'))
+            inComment = true;
+        else if (inComment && line.includes('-->'))
+            inComment = false;
+    }
+    if (current.length)
+        blocks.push(current.join('\n'));
+    return blocks;
+}
+export function blockKind(block) {
+    const node = parse(block + '\n').children[0];
+    switch (node?.type) {
+        case 'scene-heading': return 'scene_heading';
+        case 'section': return 'section';
+        case 'action': return 'action';
+        case 'character':
+        case 'dual-dialogue': return 'character';
+        case 'transition': return 'transition';
+        case 'centered': return 'centered';
+        case 'lyrics': return 'lyrics';
+        case 'note': return 'note';
+        default: return 'other';
+    }
+}
+/** A block's text without its Sutra sigils, one entry per line. */
+function plainLines(block) {
+    return block.split('\n').map(l => l.trim()
+        .replace(/^(?:##|#|@|>>|~)\s*/, '')
+        .replace(/\s*<<$/, '')
+        .replace(/^\[\[\s*(.*?)\s*\]\]$/, '$1'))
+        .filter(Boolean);
+}
+/** Rewrite `block` as element `kind`, keeping its words (and a heading's metadata lines). */
+export function retypeBlock(block, kind) {
+    if (kind === 'other')
+        return block;
+    const lines = plainLines(block);
+    const [first = '', ...rest] = lines;
+    switch (kind) {
+        case 'scene_heading': {
+            const meta = rest.filter(l => l.startsWith('& '));
+            const body = rest.filter(l => !l.startsWith('& '));
+            return [`## ${[first, ...body].join(' ')}`, ...meta].join('\n');
+        }
+        case 'section': return `# ${lines.join(' ')}`;
+        case 'action': return lines.join('\n');
+        case 'character': return [`@${first}`, ...rest].join('\n');
+        case 'transition': return lines.map(l => `>> ${l}`).join('\n');
+        case 'centered': return lines.map(l => `>> ${l} <<`).join('\n');
+        case 'lyrics': return lines.map(l => `~ ${l}`).join('\n');
+        case 'note': return `[[ ${lines.join(' ')} ]]`;
+    }
+}

package/dist/import/apply-import.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Put imported Sutra into the document as ONE edit (a single undo step):
+ * `replace` swaps the body and keeps the title page; `append` adds after the
+ * last block. Goes through whichever editor is mounted; without one, sets
+ * the text directly.
+ */
+export declare function applyImport(body: string, how: 'replace' | 'append', text: string, setText: (t: string) => void): void;

package/dist/import/apply-import.js

@@ -0,0 +1,35 @@
+import { parse } from '@sutrata/parser';
+import { getEditorView, getSourceView } from '../editor/editor-bus';
+import { sutraToProsemirror } from '../editor/sutra-to-prosemirror';
+/**
+ * Put imported Sutra into the document as ONE edit (a single undo step):
+ * `replace` swaps the body and keeps the title page; `append` adds after the
+ * last block. Goes through whichever editor is mounted; without one, sets
+ * the text directly.
+ */
+export function applyImport(body, how, text, setText) {
+    const view = getEditorView();
+    if (view) {
+        const nodes = [];
+        sutraToProsemirror(parse(body + '\n')).forEach(n => { if (n.type.name !== 'title_page')
+            nodes.push(n); });
+        const doc = view.state.doc;
+        const first = doc.firstChild;
+        const bodyStart = first && first.type.name === 'title_page' ? first.nodeSize : 0;
+        const tr = how === 'replace'
+            ? view.state.tr.replaceWith(bodyStart, doc.content.size, nodes)
+            : view.state.tr.insert(doc.content.size, nodes);
+        view.dispatch(tr.scrollIntoView());
+        return;
+    }
+    const frontmatter = parse(text).frontmatter?.raw ?? '';
+    const next = how === 'replace'
+        ? `${frontmatter}${frontmatter ? '\n' : ''}${body.trim()}\n`
+        : `${text.trimEnd()}\n\n${body.trim()}\n`;
+    const source = getSourceView();
+    if (source) {
+        source.dispatch({ changes: { from: 0, to: source.state.doc.length, insert: next } });
+        return;
+    }
+    setText(next);
+}

package/dist/import/extract.d.ts

@@ -0,0 +1,17 @@
+export type ImportSource = 
+/** A DOCX exported by Sutrata: imported losslessly, no AI needed. */
+{
+    kind: 'sutra';
+    name: string;
+    sutra: string;
+    warnings: string[];
+}
+/** Anything else: plain text (with emphasis markup) for the AI formatter. */
+ | {
+    kind: 'text';
+    name: string;
+    text: string;
+};
+export declare const IMPORT_ACCEPT = ".docx,.txt,.text,.md,.markdown";
+/** Read a picked file for import. Word documents Sutrata wrote keep the lossless importer. */
+export declare function readImportFile(file: File): Promise<ImportSource>;