@sutrata/editor 0.1.2 → 0.2.0

package/dist/extensions/ai-provider.js

@@ -0,0 +1,27 @@
+import { createContext, useContext } from 'react';
+import { isFeatureEnabled, useSession } from './session';
+const AIProviderContext = createContext(null);
+export const AIProviderProvider = AIProviderContext.Provider;
+/**
+ * The AI provider, or null when AI is unavailable in this session: no
+ * provider was injected, the session cannot edit, or `featureFlags.ai` is off.
+ * Components hide their AI UI when this is null.
+ */
+export function useAI() {
+    const provider = useContext(AIProviderContext);
+    const session = useSession();
+    if (!provider || session.permission !== 'edit' || !isFeatureEnabled(session, 'ai'))
+        return null;
+    return provider;
+}
+/** `Calling <label>...` text for the status bar; '' when idle. */
+export function formatActivity(calls) {
+    if (calls.length === 0)
+        return '';
+    if (calls.length === 1)
+        return `Calling ${calls[0].label}...`;
+    const unique = Array.from(new Set(calls.map(c => c.label)));
+    if (unique.length === 1)
+        return `Calling ${unique[0]} (${calls.length} calls)...`;
+    return `Calling ${unique.join(', ')}...`;
+}

package/dist/extensions/collab.d.ts

@@ -0,0 +1,21 @@
+import type { Schema } from 'prosemirror-model';
+import type { Plugin } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+/**
+ * Binds the formatted editor to a real-time sync provider (e.g. a Yjs
+ * document via y-prosemirror) (OSS spec §11.5).
+ *
+ * `plugins` are added whenever the editor creates its state; `attach` is
+ * called once the view exists and returns a detach function, called when
+ * the view is destroyed.
+ *
+ * The editor serializes the shared ProseMirror document back to Sutra text
+ * with the AST-lossless serializer (packages/editor/tests/lossless-round-trip.test.ts),
+ * so collaborators see the same document the file contains.
+ */
+export interface CollabBinding {
+    plugins(schema: Schema): Plugin[];
+    attach(view: EditorView): () => void;
+}
+export declare const CollabBindingProvider: import("react").Provider<CollabBinding | null>;
+export declare function useCollabBinding(): CollabBinding | null;

package/dist/extensions/collab.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from 'react';
+const CollabBindingContext = createContext(null);
+export const CollabBindingProvider = CollabBindingContext.Provider;
+export function useCollabBinding() {
+    return useContext(CollabBindingContext);
+}

package/dist/extensions/command-registry.d.ts

@@ -0,0 +1,49 @@
+import type { ReactNode } from 'react';
+import type { EditorView } from 'prosemirror-view';
+import type { EditorView as SourceEditorView } from '@codemirror/view';
+import type { EditorMode } from '../types';
+import type { RegistryStore } from './registry-store';
+export interface CommandContext {
+    /** The formatted editor, when it is mounted. */
+    view: EditorView | null;
+    /** The source editor, when it is mounted. */
+    sourceView: SourceEditorView | null;
+    mode: EditorMode;
+    text: string;
+    setText(next: string): void;
+}
+/**
+ * A command contributed by the embedder or built into the editor (OSS spec §11.5).
+ *
+ * - `shortcut`: a key binding such as `Mod-Shift-K` or `Alt-Shift-H` (`Mod` is
+ *   Ctrl, or Cmd on macOS; `-` or `+` separate parts). Handled globally, in
+ *   both editing modes.
+ * - `shortcutHint`: shown in tooltips only — for keys something else already
+ *   binds (e.g. ProseMirror's Mod-B).
+ * - `menu`: `toolbar` places it in the element toolbar (in `group`),
+ *   `appbar` in the app bar.
+ * - `readOnly: true` keeps it available in read/comment sessions; otherwise
+ *   it is hidden and its shortcut inactive there.
+ */
+export interface CommandContribution {
+    id: string;
+    label: string;
+    run(ctx: CommandContext): void;
+    shortcut?: string;
+    shortcutHint?: string;
+    menu?: 'toolbar' | 'appbar';
+    group?: string;
+    /** Icon at the requested pixel size. */
+    icon?: (size: number) => ReactNode;
+    /** Short syntax hint shown under toolbar labels (e.g. the `@` sigil). */
+    sigil?: string;
+    /** Highlights the toolbar button (e.g. the block type at the caret). */
+    isActive?(ctx: CommandContext): boolean;
+    readOnly?: boolean;
+}
+export type CommandRegistry = RegistryStore<CommandContribution>;
+export declare function createCommandRegistry(initial?: CommandContribution[]): CommandRegistry;
+export declare const CommandRegistryProvider: import("react").Provider<CommandRegistry>;
+export declare function useCommandRegistry(): CommandRegistry;
+/** True when `e` matches a binding like `Mod-Shift-K` / `Alt+Shift+H`. */
+export declare function matchesShortcut(shortcut: string, e: KeyboardEvent): boolean;

package/dist/extensions/command-registry.js

@@ -0,0 +1,28 @@
+import { createContext, useContext } from 'react';
+import { createRegistryStore } from './registry-store';
+export function createCommandRegistry(initial = []) {
+    return createRegistryStore(initial);
+}
+const CommandRegistryContext = createContext(createCommandRegistry());
+export const CommandRegistryProvider = CommandRegistryContext.Provider;
+export function useCommandRegistry() {
+    return useContext(CommandRegistryContext);
+}
+const IS_MAC = typeof navigator !== 'undefined' && /Mac|iPhone|iPad/.test(navigator.platform);
+/** True when `e` matches a binding like `Mod-Shift-K` / `Alt+Shift+H`. */
+export function matchesShortcut(shortcut, e) {
+    const parts = shortcut.split(/[-+](?=.)/);
+    const key = parts.pop();
+    const mods = new Set(parts.map(p => p.toLowerCase()));
+    const wantCtrl = mods.has('ctrl') || (mods.has('mod') && !IS_MAC);
+    const wantMeta = mods.has('cmd') || mods.has('meta') || (mods.has('mod') && IS_MAC);
+    if (e.ctrlKey !== wantCtrl || e.metaKey !== wantMeta)
+        return false;
+    if (e.altKey !== mods.has('alt') || e.shiftKey !== mods.has('shift'))
+        return false;
+    if (/^[a-z]$/i.test(key))
+        return e.code === `Key${key.toUpperCase()}`;
+    if (/^[0-9]$/.test(key))
+        return e.code === `Digit${key}`;
+    return e.key.toLowerCase() === key.toLowerCase();
+}

package/dist/extensions/decorations.d.ts

@@ -0,0 +1,48 @@
+import type { DocumentNode } from '@sutrata/parser';
+/**
+ * Where a decoration sits. Anchors are scene-relative so they survive edits
+ * elsewhere in the document: `sceneId` is the scene's `{#id}` (scenes
+ * without one cannot be anchored — the navigator flags them), and
+ * `from`/`to` are character offsets into that scene's text as returned by
+ * `ctx.sceneText(sceneId)`.
+ *
+ * Scene text is the scene's blocks (heading through the last block before
+ * the next heading) joined with '\n', with line breaks as '\n'.
+ */
+export interface Anchor {
+    sceneId: string;
+    from?: number;
+    to?: number;
+}
+export type DecorationSpec = {
+    /** `inline`: a text range (default: the whole scene). `node`: the block containing `from` (default: the heading). */
+    kind: 'inline' | 'node';
+    anchor: Anchor;
+    className?: string;
+    attrs?: Record<string, string>;
+    /** Called on click, including in read-only and comment sessions. */
+    onClick?(e: MouseEvent): void;
+} | {
+    /** A DOM element inserted at `anchor.from` (default: the start of the scene). */
+    kind: 'widget';
+    anchor: Anchor;
+    side?: -1 | 1;
+    render(): HTMLElement;
+};
+export interface DecorationContext {
+    ast: DocumentNode;
+    /** The anchorable text of a scene, or null if no scene has that id. */
+    sceneText(sceneId: string): string | null;
+}
+/**
+ * External annotations — comment threads, breakdown highlights, revision
+ * marks — rendered in the formatted editor (OSS spec §11.5).
+ * `subscribe` tells the editor to call `getDecorations` again.
+ */
+export interface DecorationProvider {
+    id: string;
+    subscribe(onChange: () => void): () => void;
+    getDecorations(ctx: DecorationContext): DecorationSpec[];
+}
+export declare const DecorationProvidersProvider: import("react").Provider<readonly DecorationProvider[]>;
+export declare function useDecorationProviders(): readonly DecorationProvider[];

package/dist/extensions/decorations.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from 'react';
+const DecorationProvidersContext = createContext([]);
+export const DecorationProvidersProvider = DecorationProvidersContext.Provider;
+export function useDecorationProviders() {
+    return useContext(DecorationProvidersContext);
+}

package/dist/extensions/export-registry.d.ts

@@ -0,0 +1,59 @@
+import type { DocumentNode, RomanizeVariant } from '@sutrata/parser';
+import type { ScreenplayStyleDefinition } from '../styles/types';
+import type { RegistryStore } from './registry-store';
+export interface ExportOptions {
+    /** Style chosen in the dialog (screenplay exports), or undefined for the document's own. */
+    styleId?: string;
+    skipNotes: boolean;
+    /** Set when `text`/`ast` are a romanized copy (Indic → ISO 15919). */
+    romanized: {
+        scope: 'all' | 'dialogue';
+        variant: RomanizeVariant;
+    } | null;
+}
+export interface ExportContext {
+    /** The document — or its romanized copy, see options.romanized. */
+    text: string;
+    ast: DocumentNode;
+    /** The document's resolved style. */
+    style: ScreenplayStyleDefinition;
+    customStyles: ScreenplayStyleDefinition[];
+    options: ExportOptions;
+    /** File name without extension, from the open document. */
+    baseName: string;
+}
+/** What `run` produced: a file to download (optionally with warnings), or nothing if it handled output itself. */
+export type ExportOutput = Blob | {
+    blob?: Blob;
+    warnings?: string[];
+} | void;
+/**
+ * An export format or report contributed by the embedder or built into the
+ * editor (OSS spec §11.5). The Export dialog renders every registered
+ * exporter: `screenplay` ones as cards, `report` ones grouped by `family`
+ * with `formatLabel` chips.
+ */
+export interface ExportContribution {
+    id: string;
+    label: string;
+    group: 'screenplay' | 'report';
+    description?: string;
+    /** Reports: the report this format belongs to (e.g. "Shot List"). */
+    family?: string;
+    /** Reports: the chip label (e.g. "Word (.docx)"). */
+    formatLabel?: string;
+    /** Which dialog options apply. */
+    supports?: {
+        style?: boolean;
+        skipNotes?: boolean;
+        romanize?: boolean;
+    };
+    run(ctx: ExportContext): Promise<ExportOutput>;
+    fileName(ctx: ExportContext): string;
+    /** Toast shown after a successful export. */
+    successMessage?: string;
+}
+export type ExportRegistry = RegistryStore<ExportContribution>;
+export declare function createExportRegistry(initial?: ExportContribution[]): ExportRegistry;
+export declare const ExportRegistryProvider: import("react").Provider<ExportRegistry>;
+export declare function useExportRegistry(): ExportRegistry;

package/dist/extensions/export-registry.js

@@ -0,0 +1,10 @@
+import { createContext, useContext } from 'react';
+import { createRegistryStore } from './registry-store';
+export function createExportRegistry(initial = []) {
+    return createRegistryStore(initial);
+}
+const ExportRegistryContext = createContext(createExportRegistry());
+export const ExportRegistryProvider = ExportRegistryContext.Provider;
+export function useExportRegistry() {
+    return useContext(ExportRegistryContext);
+}

package/dist/extensions/panel-registry.d.ts

@@ -0,0 +1,30 @@
+import type { ReactNode } from 'react';
+import type { DocumentNode } from '@sutrata/parser';
+import type { RegistryStore } from './registry-store';
+/**
+ * - `sidebar`: tabs beside the scene navigator (the built-in first tab).
+ * - `inspector`: sections in a panel on the right of the editor.
+ * - `appbar`: small items in the app bar, before Settings.
+ * - `settings`: sections in the Settings dialog.
+ */
+export type PanelLocation = 'sidebar' | 'inspector' | 'appbar' | 'settings';
+export interface PanelRenderContext {
+    ast: DocumentNode;
+    /** Ids of scenes that have one, in document order. */
+    sceneIds: string[];
+    /** Id of the scene containing the caret, if it has one. */
+    activeSceneId: string | null;
+}
+/** A panel contributed by the embedder (OSS spec §11.5). */
+export interface PanelContribution {
+    id: string;
+    title: string;
+    location: PanelLocation;
+    render(ctx: PanelRenderContext): ReactNode;
+}
+export type PanelRegistry = RegistryStore<PanelContribution>;
+export declare function createPanelRegistry(initial?: PanelContribution[]): PanelRegistry;
+export declare const PanelRegistryProvider: import("react").Provider<PanelRegistry>;
+export declare function usePanelRegistry(): PanelRegistry;
+/** Registered panels for `location`, re-rendering when registrations change. */
+export declare function usePanels(location: PanelLocation): PanelContribution[];

package/dist/extensions/panel-registry.js

@@ -0,0 +1,16 @@
+import { createContext, useContext, useMemo } from 'react';
+import { createRegistryStore, useRegistryList } from './registry-store';
+export function createPanelRegistry(initial = []) {
+    return createRegistryStore(initial);
+}
+const EMPTY_REGISTRY = createPanelRegistry();
+const PanelRegistryContext = createContext(EMPTY_REGISTRY);
+export const PanelRegistryProvider = PanelRegistryContext.Provider;
+export function usePanelRegistry() {
+    return useContext(PanelRegistryContext);
+}
+/** Registered panels for `location`, re-rendering when registrations change. */
+export function usePanels(location) {
+    const all = useRegistryList(usePanelRegistry());
+    return useMemo(() => all.filter(p => p.location === location), [all, location]);
+}

package/dist/extensions/registries.d.ts

@@ -0,0 +1,15 @@
+import type { PanelRegistry } from './panel-registry';
+import type { CommandRegistry } from './command-registry';
+import type { ExportRegistry } from './export-registry';
+export interface Registries {
+    panels: PanelRegistry;
+    commands: CommandRegistry;
+    exporters: ExportRegistry;
+}
+/**
+ * Live registries for DocumentProvider's `panels` / `commands` / `exporters`
+ * props. Register up front or at runtime; each `register()` returns an
+ * unregister function. The editor's built-ins are not in these registries —
+ * registering an entry with a built-in's id replaces it.
+ */
+export declare function createRegistries(): Registries;

package/dist/extensions/registries.js

@@ -0,0 +1,12 @@
+import { createPanelRegistry } from './panel-registry';
+import { createCommandRegistry } from './command-registry';
+import { createExportRegistry } from './export-registry';
+/**
+ * Live registries for DocumentProvider's `panels` / `commands` / `exporters`
+ * props. Register up front or at runtime; each `register()` returns an
+ * unregister function. The editor's built-ins are not in these registries —
+ * registering an entry with a built-in's id replaces it.
+ */
+export function createRegistries() {
+    return { panels: createPanelRegistry(), commands: createCommandRegistry(), exporters: createExportRegistry() };
+}

package/dist/extensions/registry-store.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The live list behind every registry (panels, commands, exporters).
+ * `register` replaces an entry with the same id and returns an unregister
+ * function; `list` returns the same array until something changes, so it can
+ * back useSyncExternalStore.
+ */
+export interface RegistryStore<T extends {
+    id: string;
+}> {
+    register(entry: T): () => void;
+    list(): readonly T[];
+    subscribe(listener: () => void): () => void;
+}
+export declare function createRegistryStore<T extends {
+    id: string;
+}>(initial?: readonly T[]): RegistryStore<T>;
+export declare function useRegistryList<T extends {
+    id: string;
+}>(store: RegistryStore<T>): readonly T[];
+/**
+ * Built-in entries followed by registered ones; a registered entry with a
+ * built-in's id replaces it in place.
+ */
+export declare function withBuiltins<T extends {
+    id: string;
+}>(builtins: readonly T[], registered: readonly T[]): T[];

package/dist/extensions/registry-store.js

@@ -0,0 +1,35 @@
+import { useSyncExternalStore } from 'react';
+export function createRegistryStore(initial = []) {
+    let entries = [...initial];
+    const listeners = new Set();
+    const set = (next) => {
+        entries = next;
+        for (const l of listeners)
+            l();
+    };
+    return {
+        register(entry) {
+            set([...entries.filter(e => e.id !== entry.id), entry]);
+            return () => set(entries.filter(e => e !== entry));
+        },
+        list: () => entries,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => { listeners.delete(listener); };
+        },
+    };
+}
+export function useRegistryList(store) {
+    return useSyncExternalStore(store.subscribe, store.list, store.list);
+}
+/**
+ * Built-in entries followed by registered ones; a registered entry with a
+ * built-in's id replaces it in place.
+ */
+export function withBuiltins(builtins, registered) {
+    const byId = new Map(registered.map(e => [e.id, e]));
+    return [
+        ...builtins.map(b => byId.get(b.id) ?? b),
+        ...registered.filter(e => !builtins.some(b => b.id === e.id)),
+    ];
+}

package/dist/extensions/session.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Who is using the editor and what they may do (OSS spec §11.5). Optional:
+ * without one, the editor behaves as a single local user with full edit
+ * rights and no feature flags.
+ *
+ * - `edit`: everything.
+ * - `read`: the document cannot be changed. The formatted and source editors
+ *   are read-only; save/open/import, AI, voice, the element toolbar, and
+ *   structural navigator actions (reorder, synopsis edits, scene-number
+ *   locking) are unavailable.
+ * - `comment`: like `read`; decoration providers (comment threads) may still
+ *   handle clicks.
+ *
+ * `featureFlags`: `ai: false` hides AI features, `voice: false` hides voice
+ * dictation. Unset flags count as enabled.
+ */
+export interface SessionContext {
+    userId: string | null;
+    displayName: string | null;
+    permission: 'read' | 'comment' | 'edit';
+    featureFlags: Record<string, boolean>;
+}
+export declare const DEFAULT_SESSION: SessionContext;
+export declare const SessionProvider: import("react").Provider<SessionContext>;
+export declare function useSession(): SessionContext;
+/** True when the current session may change the document. */
+export declare function useCanEdit(): boolean;
+/** A feature is on unless the session's featureFlags turn it off explicitly. */
+export declare function isFeatureEnabled(session: SessionContext, flag: string): boolean;

package/dist/extensions/session.js

@@ -0,0 +1,20 @@
+import { createContext, useContext } from 'react';
+export const DEFAULT_SESSION = {
+    userId: null,
+    displayName: null,
+    permission: 'edit',
+    featureFlags: {},
+};
+const SessionReactContext = createContext(DEFAULT_SESSION);
+export const SessionProvider = SessionReactContext.Provider;
+export function useSession() {
+    return useContext(SessionReactContext);
+}
+/** True when the current session may change the document. */
+export function useCanEdit() {
+    return useSession().permission === 'edit';
+}
+/** A feature is on unless the session's featureFlags turn it off explicitly. */
+export function isFeatureEnabled(session, flag) {
+    return session.featureFlags[flag] !== false;
+}

package/dist/extensions/speech-provider.d.ts

@@ -0,0 +1,35 @@
+export interface SpeechRecognitionCallbacks {
+    onResult(text: string, isFinal: boolean): void;
+    onError(error: string): void;
+    onEnd(): void;
+}
+/** A running live-recognition session. */
+export interface SpeechRecognitionSession {
+    /** Stop listening; pending results are still delivered. */
+    stop(): void;
+    /** Stop listening and drop pending results. */
+    abort(): void;
+}
+/**
+ * Speech-to-text, injected by the embedder (OSS spec §11.5). Voice dictation
+ * uses live recognition (`listen`) and formats the transcript with the
+ * AIProvider, so the voice UI appears only when both are available.
+ */
+export interface SpeechProvider {
+    id: string;
+    displayName: string;
+    /** Whether recognition can run here (e.g. the browser has the Web Speech API). */
+    isSupported(): boolean;
+    /** Start live recognition for a BCP-47 language (e.g. `hi-IN`). */
+    listen(language: string, callbacks: SpeechRecognitionCallbacks): SpeechRecognitionSession;
+    /** Optional batch transcription of recorded audio. */
+    transcribe?(audio: Blob, opts?: {
+        language?: string;
+    }): Promise<string>;
+}
+export declare const SpeechProviderProvider: import("react").Provider<SpeechProvider | null>;
+/**
+ * The speech provider, or null when voice dictation is unavailable: no speech
+ * or AI provider, a session that cannot edit, or `featureFlags.voice` off.
+ */
+export declare function useSpeech(): SpeechProvider | null;

package/dist/extensions/speech-provider.js

@@ -0,0 +1,17 @@
+import { createContext, useContext } from 'react';
+import { isFeatureEnabled, useSession } from './session';
+import { useAI } from './ai-provider';
+const SpeechProviderContext = createContext(null);
+export const SpeechProviderProvider = SpeechProviderContext.Provider;
+/**
+ * The speech provider, or null when voice dictation is unavailable: no speech
+ * or AI provider, a session that cannot edit, or `featureFlags.voice` off.
+ */
+export function useSpeech() {
+    const provider = useContext(SpeechProviderContext);
+    const ai = useAI();
+    const session = useSession();
+    if (!provider || !ai || !isFeatureEnabled(session, 'voice'))
+        return null;
+    return provider;
+}

package/dist/file/builtin-exporters.d.ts

@@ -0,0 +1,9 @@
+import type { ExportContribution } from '../extensions/export-registry';
+type Translate = (key: string) => string;
+/**
+ * The editor's own export formats and reports, registered like an
+ * embedder's. PDF and print views open a print preview window instead of
+ * returning a file; their run() must open it synchronously (popup blockers).
+ */
+export declare function builtinExporters(t: Translate): ExportContribution[];
+export {};

package/dist/file/builtin-exporters.js

@@ -0,0 +1,72 @@
+import { exportFountain } from '@sutrata/parser';
+import { exportToDocx } from './docx-exporter';
+import { extractWorkflowData, exportOneLinerCsv, exportShotListCsv, exportCastReportCsv, exportOneLinerDocx, exportShotListDocx, exportCastReportDocx, openPrintPreview, openScreenplayPrintPreview, } from './workflow-reports';
+/** Short descriptions of the built-in report families, shown under each report's title. */
+const REPORT_DESCRIPTIONS = {
+    'One-Liner Schedule': 'A scene-by-scene production stripboard breakdown with locations, cast, and timings.',
+    'Shot List': 'Camera shot specifications extracted from scene headings and production notes.',
+    'Cast Breakdown': 'Character occurrences, dialogue counts, and assigned actors list.',
+};
+const suffix = (ctx) => (ctx.options.romanized ? '_romanized' : '');
+const titleSuffix = (ctx) => (ctx.options.romanized ? ' (ROMANIZED)' : '');
+/** CSV with a BOM so Excel reads UTF-8 (Indic text) correctly. */
+function csv(content) {
+    return new Blob(['\uFEFF', content], { type: 'text/csv;charset=utf-8' });
+}
+function report(id, family, formatLabel, ext, stem, run, successMessage) {
+    return {
+        id, label: `${family} — ${formatLabel}`, group: 'report', family, formatLabel,
+        description: REPORT_DESCRIPTIONS[family],
+        supports: { romanize: true },
+        run,
+        fileName: ctx => `${ctx.baseName}_${stem}${suffix(ctx)}.${ext ?? 'html'}`,
+        successMessage,
+    };
+}
+/**
+ * The editor's own export formats and reports, registered like an
+ * embedder's. PDF and print views open a print preview window instead of
+ * returning a file; their run() must open it synchronously (popup blockers).
+ */
+export function builtinExporters(t) {
+    return [
+        {
+            id: 'pdf', label: 'PDF / Print Preview', group: 'screenplay',
+            description: 'Print-ready industry screenplay layout styled according to your active visual template.',
+            supports: { style: true, skipNotes: true, romanize: true },
+            run: async (ctx) => {
+                const title = `${ctx.baseName.toUpperCase()} - SCREENPLAY${titleSuffix(ctx)}`;
+                await openScreenplayPrintPreview(ctx.ast, title, ctx.options.styleId, ctx.customStyles, ctx.options.skipNotes);
+            },
+            fileName: ctx => `${ctx.baseName}${suffix(ctx)}.pdf`,
+            successMessage: 'Opened Screenplay Print Preview',
+        },
+        {
+            id: 'docx', label: 'Microsoft Word (.docx)', group: 'screenplay',
+            description: t('export.docxDesc'),
+            supports: { style: true, skipNotes: true, romanize: true },
+            run: ctx => exportToDocx(ctx.ast, ctx.options.styleId, ctx.customStyles, ctx.options.skipNotes),
+            fileName: ctx => `${ctx.baseName}${suffix(ctx)}.docx`,
+            successMessage: 'Exported Word document (.docx)',
+        },
+        {
+            id: 'fountain', label: 'Fountain (.fountain)', group: 'screenplay',
+            description: t('export.fountainDesc'),
+            run: async (ctx) => {
+                const result = exportFountain(ctx.ast);
+                return { blob: new Blob([result.text], { type: 'text/plain;charset=utf-8' }), warnings: result.warnings };
+            },
+            fileName: ctx => `${ctx.baseName}.fountain`,
+            successMessage: 'Exported Fountain screenplay',
+        },
+        report('oneliner-print', 'One-Liner Schedule', 'Print View', null, 'one_liner', async (ctx) => {
+            await openPrintPreview(extractWorkflowData(ctx.ast).scenes, `${ctx.baseName.toUpperCase()} - ONE-LINER SCHEDULE${titleSuffix(ctx)}`);
+        }, 'Opened One-Liner Schedule'),
+        report('oneliner-docx', 'One-Liner Schedule', 'Word (.docx)', 'docx', 'one_liner', ctx => exportOneLinerDocx(extractWorkflowData(ctx.ast).scenes), 'Exported One-Liner DOCX'),
+        report('oneliner-csv', 'One-Liner Schedule', 'Spreadsheet (.csv)', 'csv', 'one_liner', async (ctx) => csv(exportOneLinerCsv(extractWorkflowData(ctx.ast).scenes)), 'Exported One-Liner CSV'),
+        report('shotlist-docx', 'Shot List', 'Word (.docx)', 'docx', 'shot_list', ctx => exportShotListDocx(extractWorkflowData(ctx.ast).scenes), 'Exported Shot List DOCX'),
+        report('shotlist-csv', 'Shot List', 'Spreadsheet (.csv)', 'csv', 'shot_list', async (ctx) => csv(exportShotListCsv(extractWorkflowData(ctx.ast).scenes)), 'Exported Shot List CSV'),
+        report('cast-docx', 'Cast Breakdown', 'Word (.docx)', 'docx', 'cast_report', ctx => exportCastReportDocx(extractWorkflowData(ctx.ast).characters), 'Exported Cast Report DOCX'),
+        report('cast-csv', 'Cast Breakdown', 'Spreadsheet (.csv)', 'csv', 'cast_report', async (ctx) => csv(exportCastReportCsv(extractWorkflowData(ctx.ast).characters)), 'Exported Cast Report CSV'),
+    ];
+}

package/dist/file/docx-exporter.js

@@ -3,6 +3,7 @@ import { resolveStyle } from '../styles/registry';
 import { styleToDocxParagraphStyles } from '../styles/docx-adapter';
 import { SCRIPT_UNICODE_RANGES } from '../styles/script-ranges';
 import { DEFAULT_COVER_LAYOUT } from '../styles/types';
+import { sceneNumberOf, isOmitted } from './scene-number';
 /** Flatten inline span trees into flat formatting runs. `skipNotes` drops inline
  *  `[[ ]]` note spans entirely (see the "Skip notes" export option). */
 function flattenSpans(spans, props = {}, skipNotes = false) {
@@ -418,13 +419,15 @@ export async function exportToDocx(ast, styleOverride, customStyles = [], skipNo
             }
         }
         else if (node.type === 'scene-heading') {
-            const headingRuns = runsFor([{ text: node.text.toUpperCase(), bold: true }]);
-            if (node.id) {
-                headingRuns.push(new TextRun({ text: '\t' }), ...runsFor([{ text: node.id, bold: true }]));
+            // Scene number: the {#id} (§6.1); an omitted scene prints OMITTED (§7.4).
+            const sceneNumber = sceneNumberOf(node);
+            const headingRuns = runsFor([{ text: isOmitted(node) ? 'OMITTED' : node.text.toUpperCase(), bold: true }]);
+            if (sceneNumber) {
+                headingRuns.push(new TextRun({ text: '\t' }), ...runsFor([{ text: sceneNumber, bold: true }]));
             }
             childrenNodes.push(new Paragraph({
                 style: 'CineSceneHeading',
-                tabStops: node.id
+                tabStops: sceneNumber
                     ? [{ type: TabStopType.RIGHT, position: contentRightEdgeTwips }]
                     : undefined,
                 children: headingRuns,

package/dist/file/docx-importer.d.ts

@@ -3,6 +3,15 @@ export interface DocxImportResult {
     bodyText: string | null;
     warnings: string[];
 }
+/** True when the document carries the CineXxx paragraph styles exportToDocx applies. */
+export declare function isSutrataDocx(buffer: ArrayBuffer): Promise<boolean>;
+/**
+ * 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 declare function readDocxText(buffer: ArrayBuffer): Promise<string>;
 /** 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