superdoc-macros 0.1.0

package/dist/manager.d.ts

@@ -0,0 +1,102 @@
+/**
+ * `MacroKit` — הפאסדה שמארח מתקין פעם אחת ומקבל את שלוש היכולות מחווטות:
+ * סקריפטים (עם ארגז חול), מקליט, וקטעי טקסט עם השלמה אוטומטית — פלוס שמירה,
+ * ייבוא/ייצוא וקיצורי מקלדת.
+ *
+ * כלל בטיחות אחד נאכף כאן: אין ריצה בזמן הקלטה ואין שתי ריצות במקביל.
+ * ניגון או סקריפט שרצים תוך כדי הקלטה היו מוקלטים בעצמם ומכפילים את עצמם
+ * בניגון הבא.
+ */
+import { type MacroApiOptions } from './scripting/macro-api.js';
+import type { MacroRunner, MacroRunOptions, MacroRunResult } from './scripting/runner.js';
+import { type ReplayOptions, type ReplayResult } from './recorder/recorder.js';
+import { type AutoTextOptions } from './snippets/autotext.js';
+import { type ExpandOptions } from './snippets/snippets.js';
+import { type ShortcutTarget } from './shortcuts.js';
+import { type MacroStorage } from './storage.js';
+import type { MacroHost, RecordedMacro, SavedScript, Snippet } from './types.js';
+export interface MacroKitOptions {
+    host: MacroHost;
+    /** ברירת מחדל: localStorage. */
+    storage?: MacroStorage;
+    /**
+     * `'iframe'` (ברירת המחדל) מריץ סקריפטים בארגז חול; `'eval'` מריץ ישירות —
+     * ראו את האזהרה ב-eval-runner. אפשר גם למסור מריץ מותאם.
+     */
+    runner?: MacroRunner | 'iframe' | 'eval';
+    /** אפשרויות ריצה לסקריפטים (זמן, תקרת קריאות). */
+    runOptions?: MacroRunOptions;
+    /** אפשרויות ההשלמה האוטומטית. */
+    autoText?: Omit<AutoTextOptions, 'onExpand' | 'onError'> & AutoTextOptions;
+    /** יומן ריצה של `api.log`. */
+    onLog?: MacroApiOptions['onLog'];
+}
+export declare class MacroKit {
+    private readonly host;
+    private readonly storage;
+    private readonly runner;
+    private readonly runOptions;
+    private readonly onLog?;
+    private state;
+    private readonly recorder;
+    private readonly autoText;
+    private running;
+    constructor(options: MacroKitOptions);
+    listScripts(): readonly SavedScript[];
+    saveScript(input: {
+        id?: string;
+        name: string;
+        source: string;
+        shortcut?: string;
+    }): SavedScript;
+    removeScript(id: string): void;
+    runScript(id: string): Promise<MacroRunResult>;
+    /** מריצה סקריפט שלא נשמר — למשל מתוך עורך המאקרו לפני שמירה. */
+    runSource(source: string): Promise<MacroRunResult>;
+    get isRecording(): boolean;
+    get recordedStepCount(): number;
+    startRecording(): void;
+    /** עוצרת ושומרת. `null` כשלא הוקלט אף צעד — אין מה לשמור. */
+    stopRecording(name: string, shortcut?: string): RecordedMacro | null;
+    cancelRecording(): void;
+    listRecordings(): readonly RecordedMacro[];
+    removeRecording(id: string): void;
+    replayRecording(id: string, options?: ReplayOptions): Promise<ReplayResult>;
+    listSnippets(): readonly Snippet[];
+    saveSnippet(input: {
+        id?: string;
+        name: string;
+        text: string;
+        trigger?: string;
+        shortcut?: string;
+    }): Snippet;
+    removeSnippet(id: string): void;
+    expandSnippet(id: string, options?: ExpandOptions): Promise<{
+        ok: boolean;
+        message?: string;
+    }>;
+    /** מפעילה השלמה אוטומטית (trigger + רווח). מחזירה פונקציית כיבוי. */
+    enableAutoText(): () => void;
+    disableAutoText(): void;
+    /**
+     * קושרת את הקיצורים של כל מה ששמור (סקריפטים, הקלטות, קטעים) ליעד — בדרך
+     * כלל ה-container של העורך או `window`. הרשימה חיה: שמירה חדשה נקלטת בלי
+     * לקשור מחדש. מחזירה פונקציית ניתוק.
+     */
+    attachShortcuts(target: ShortcutTarget): () => void;
+    private currentBindings;
+    exportState(): string;
+    /**
+     * ייבוא מ-JSON שיוצא ב-`exportState`. במיזוג (`merge: true`) פריט מיובא עם
+     * `id` קיים מחליף את הקיים; בלי מיזוג המצב כולו מוחלף.
+     */
+    importState(json: string, options?: {
+        merge?: boolean;
+    }): {
+        ok: boolean;
+        message?: string;
+    };
+    private guardRun;
+    private upsert;
+    private persist;
+}

package/dist/manager.js

@@ -0,0 +1,249 @@
+/**
+ * `MacroKit` — הפאסדה שמארח מתקין פעם אחת ומקבל את שלוש היכולות מחווטות:
+ * סקריפטים (עם ארגז חול), מקליט, וקטעי טקסט עם השלמה אוטומטית — פלוס שמירה,
+ * ייבוא/ייצוא וקיצורי מקלדת.
+ *
+ * כלל בטיחות אחד נאכף כאן: אין ריצה בזמן הקלטה ואין שתי ריצות במקביל.
+ * ניגון או סקריפט שרצים תוך כדי הקלטה היו מוקלטים בעצמם ומכפילים את עצמם
+ * בניגון הבא.
+ */
+import { createMacroApi } from './scripting/macro-api.js';
+import { createEvalRunner } from './scripting/eval-runner.js';
+import { createIframeRunner } from './scripting/iframe-runner.js';
+import { MacroRecorder, replayMacro } from './recorder/recorder.js';
+import { AutoText } from './snippets/autotext.js';
+import { expandSnippet } from './snippets/snippets.js';
+import { bindShortcuts } from './shortcuts.js';
+import { createLocalStorage, emptyState, parsePersistedState } from './storage.js';
+let idCounter = 0;
+function newId() {
+    try {
+        return crypto.randomUUID();
+    }
+    catch {
+        idCounter += 1;
+        return `macro-${Date.now().toString(36)}-${idCounter}`;
+    }
+}
+export class MacroKit {
+    host;
+    storage;
+    runner;
+    runOptions;
+    onLog;
+    state;
+    recorder;
+    autoText;
+    running = false;
+    constructor(options) {
+        this.host = options.host;
+        this.storage = options.storage ?? createLocalStorage();
+        this.runOptions = options.runOptions ?? {};
+        this.onLog = options.onLog;
+        const runner = options.runner ?? 'iframe';
+        this.runner =
+            runner === 'iframe' ? createIframeRunner() : runner === 'eval' ? createEvalRunner() : runner;
+        this.state = this.storage.load() ?? emptyState();
+        this.recorder = new MacroRecorder(this.host);
+        this.autoText = new AutoText(this.host, () => this.state.snippets, options.autoText);
+    }
+    /* ---------- סקריפטים ---------- */
+    listScripts() {
+        return this.state.scripts;
+    }
+    saveScript(input) {
+        const script = {
+            id: input.id ?? newId(),
+            name: input.name,
+            source: input.source,
+            ...(input.shortcut ? { shortcut: input.shortcut } : {}),
+        };
+        this.upsert(this.state.scripts, script);
+        this.persist();
+        return script;
+    }
+    removeScript(id) {
+        this.state.scripts = this.state.scripts.filter((script) => script.id !== id);
+        this.persist();
+    }
+    async runScript(id) {
+        const script = this.state.scripts.find((entry) => entry.id === id);
+        if (!script)
+            return { ok: false, reason: 'error', message: 'המאקרו לא נמצא' };
+        return this.runSource(script.source);
+    }
+    /** מריצה סקריפט שלא נשמר — למשל מתוך עורך המאקרו לפני שמירה. */
+    async runSource(source) {
+        const guard = this.guardRun();
+        if (guard)
+            return guard;
+        this.running = true;
+        try {
+            const bridge = createMacroApi(this.host, { onLog: this.onLog });
+            return await this.runner.run(source, bridge, this.runOptions);
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    /* ---------- מקליט ---------- */
+    get isRecording() {
+        return this.recorder.recording;
+    }
+    get recordedStepCount() {
+        return this.recorder.stepCount;
+    }
+    startRecording() {
+        if (this.running)
+            return;
+        this.recorder.start();
+    }
+    /** עוצרת ושומרת. `null` כשלא הוקלט אף צעד — אין מה לשמור. */
+    stopRecording(name, shortcut) {
+        const steps = this.recorder.stop();
+        if (steps.length === 0)
+            return null;
+        const recording = {
+            version: 1,
+            id: newId(),
+            name,
+            createdAt: new Date().toISOString(),
+            ...(shortcut ? { shortcut } : {}),
+            steps,
+        };
+        this.state.recordings.push(recording);
+        this.persist();
+        return recording;
+    }
+    cancelRecording() {
+        this.recorder.cancel();
+    }
+    listRecordings() {
+        return this.state.recordings;
+    }
+    removeRecording(id) {
+        this.state.recordings = this.state.recordings.filter((recording) => recording.id !== id);
+        this.persist();
+    }
+    async replayRecording(id, options) {
+        const recording = this.state.recordings.find((entry) => entry.id === id);
+        if (!recording)
+            return { ok: false, completed: 0, failures: [{ stepIndex: -1, step: { type: 'insert-text', text: '' }, message: 'ההקלטה לא נמצאה' }] };
+        const guard = this.guardRun();
+        if (guard) {
+            return { ok: false, completed: 0, failures: [{ stepIndex: -1, step: { type: 'insert-text', text: '' }, message: guard.message }] };
+        }
+        this.running = true;
+        try {
+            return await replayMacro(this.host, recording.steps, options);
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    /* ---------- קטעי טקסט ---------- */
+    listSnippets() {
+        return this.state.snippets;
+    }
+    saveSnippet(input) {
+        const snippet = {
+            id: input.id ?? newId(),
+            name: input.name,
+            text: input.text,
+            ...(input.trigger ? { trigger: input.trigger } : {}),
+            ...(input.shortcut ? { shortcut: input.shortcut } : {}),
+        };
+        this.upsert(this.state.snippets, snippet);
+        this.persist();
+        return snippet;
+    }
+    removeSnippet(id) {
+        this.state.snippets = this.state.snippets.filter((snippet) => snippet.id !== id);
+        this.persist();
+    }
+    async expandSnippet(id, options) {
+        const snippet = this.state.snippets.find((entry) => entry.id === id);
+        if (!snippet)
+            return { ok: false, message: 'הקטע לא נמצא' };
+        const outcome = await expandSnippet(this.host, snippet, options);
+        return outcome.ok ? { ok: true } : { ok: false, message: outcome.message };
+    }
+    /** מפעילה השלמה אוטומטית (trigger + רווח). מחזירה פונקציית כיבוי. */
+    enableAutoText() {
+        return this.autoText.attach();
+    }
+    disableAutoText() {
+        this.autoText.detach();
+    }
+    /* ---------- קיצורי מקלדת ---------- */
+    /**
+     * קושרת את הקיצורים של כל מה ששמור (סקריפטים, הקלטות, קטעים) ליעד — בדרך
+     * כלל ה-container של העורך או `window`. הרשימה חיה: שמירה חדשה נקלטת בלי
+     * לקשור מחדש. מחזירה פונקציית ניתוק.
+     */
+    attachShortcuts(target) {
+        return bindShortcuts(target, () => this.currentBindings());
+    }
+    currentBindings() {
+        const bindings = [];
+        for (const script of this.state.scripts) {
+            if (script.shortcut)
+                bindings.push({ shortcut: script.shortcut, run: () => this.runScript(script.id) });
+        }
+        for (const recording of this.state.recordings) {
+            if (recording.shortcut)
+                bindings.push({ shortcut: recording.shortcut, run: () => this.replayRecording(recording.id) });
+        }
+        for (const snippet of this.state.snippets) {
+            if (snippet.shortcut)
+                bindings.push({ shortcut: snippet.shortcut, run: () => this.expandSnippet(snippet.id) });
+        }
+        return bindings;
+    }
+    /* ---------- ייבוא/ייצוא ---------- */
+    exportState() {
+        return JSON.stringify(this.state, null, 2);
+    }
+    /**
+     * ייבוא מ-JSON שיוצא ב-`exportState`. במיזוג (`merge: true`) פריט מיובא עם
+     * `id` קיים מחליף את הקיים; בלי מיזוג המצב כולו מוחלף.
+     */
+    importState(json, options = {}) {
+        const imported = parsePersistedState(json);
+        if (!imported)
+            return { ok: false, message: 'הקובץ אינו ייצוא מאקרו תקין' };
+        if (options.merge) {
+            for (const script of imported.scripts)
+                this.upsert(this.state.scripts, script);
+            for (const recording of imported.recordings)
+                this.upsert(this.state.recordings, recording);
+            for (const snippet of imported.snippets)
+                this.upsert(this.state.snippets, snippet);
+        }
+        else {
+            this.state = imported;
+        }
+        this.persist();
+        return { ok: true };
+    }
+    /* ---------- פנימי ---------- */
+    guardRun() {
+        if (this.recorder.recording) {
+            return { ok: false, reason: 'error', message: 'אי אפשר להריץ מאקרו בזמן הקלטה' };
+        }
+        if (this.running) {
+            return { ok: false, reason: 'error', message: 'מאקרו אחר עדיין רץ' };
+        }
+        return null;
+    }
+    upsert(list, item) {
+        const index = list.findIndex((entry) => entry.id === item.id);
+        if (index >= 0)
+            list[index] = item;
+        else
+            list.push(item);
+    }
+    persist() {
+        this.storage.save(this.state);
+    }
+}

package/dist/recorder/recorder.d.ts

@@ -0,0 +1,57 @@
+/**
+ * מקליט מאקרו בסגנון Word: מקליט **פקודות** והקלדה, לא מיקומי סמן.
+ *
+ * הבחירה הזאת מכוונת. הקלטת צעדי ProseMirror גולמיים (עם מיקומים אבסולוטיים)
+ * נשברת ברגע שהמסמך שונה ממה שהיה בזמן ההקלטה; הקלטת פקודות ("bold",
+ * "bullet-list", הקלדת "בס\"ד") מתנהגת כמו המקליט של Word — הפעולות חלות
+ * במקום שבו הסמן נמצא בזמן הניגון. זה גם מה שהופך הקלטה לניתנת לשמירה
+ * ולשיתוף: הצעדים JSON בלבד.
+ *
+ * מה לא נקלט: תנועת סמן ובחירה בעכבר. כמו ב-Word, מאקרו מוקלט פועל מהמקום
+ * שבו הסמן עומד כשמריצים אותו.
+ */
+import type { MacroHost, MacroStep } from '../types.js';
+export interface RecorderOptions {
+    /** סינון פקודות. ברירת המחדל מקליטה הכול חוץ מ-undo/redo. */
+    shouldRecordCommand?: (id: string) => boolean;
+    /** תקרת צעדים להקלטה אחת, נגד הקלטה שנשכחה פתוחה. */
+    maxSteps?: number;
+}
+export declare class MacroRecorder {
+    private readonly host;
+    private readonly shouldRecordCommand;
+    private readonly maxSteps;
+    private steps;
+    private disposers;
+    private active;
+    constructor(host: MacroHost, options?: RecorderOptions);
+    get recording(): boolean;
+    get stepCount(): number;
+    start(): void;
+    /** עוצרת ומחזירה את הצעדים. ריקה כשלא הוקלט דבר. */
+    stop(): MacroStep[];
+    /** עוצרת וזורקת את מה שהוקלט. */
+    cancel(): void;
+    private teardown;
+    private push;
+    private recordCommand;
+    private recordTextInput;
+}
+export interface ReplayFailure {
+    stepIndex: number;
+    step: MacroStep;
+    message: string;
+}
+export interface ReplayResult {
+    ok: boolean;
+    /** כמה צעדים הושלמו בהצלחה. */
+    completed: number;
+    failures: ReplayFailure[];
+}
+export interface ReplayOptions {
+    /** עצירה בכשל הראשון. ברירת מחדל: true — מאקרו שנכשל באמצע לא ממשיך לרוץ עיוור. */
+    stopOnError?: boolean;
+    /** נקראת לפני כל צעד; מאפשרת מד התקדמות. */
+    onStep?: (index: number, step: MacroStep) => void;
+}
+export declare function replayMacro(host: MacroHost, steps: readonly MacroStep[], options?: ReplayOptions): Promise<ReplayResult>;

package/dist/recorder/recorder.js

@@ -0,0 +1,141 @@
+const DEFAULT_MAX_STEPS = 5_000;
+/** undo/redo בזמן הקלטה מתקנים את ההקלטה עצמה — ניגון שלהם היה משחזר גם את הטעות. */
+function defaultShouldRecord(id) {
+    return id !== 'undo' && id !== 'redo';
+}
+export class MacroRecorder {
+    host;
+    shouldRecordCommand;
+    maxSteps;
+    steps = [];
+    disposers = [];
+    active = false;
+    constructor(host, options = {}) {
+        this.host = host;
+        this.shouldRecordCommand = options.shouldRecordCommand ?? defaultShouldRecord;
+        this.maxSteps = options.maxSteps ?? DEFAULT_MAX_STEPS;
+    }
+    get recording() {
+        return this.active;
+    }
+    get stepCount() {
+        return this.steps.length;
+    }
+    start() {
+        if (this.active)
+            return;
+        this.active = true;
+        this.steps = [];
+        this.disposers = [
+            this.host.onCommand((id, payload) => this.recordCommand(id, payload)),
+            this.host.onTextInput((event) => this.recordTextInput(event)),
+        ];
+    }
+    /** עוצרת ומחזירה את הצעדים. ריקה כשלא הוקלט דבר. */
+    stop() {
+        if (!this.active)
+            return [];
+        this.teardown();
+        const recorded = this.steps;
+        this.steps = [];
+        return recorded;
+    }
+    /** עוצרת וזורקת את מה שהוקלט. */
+    cancel() {
+        if (!this.active)
+            return;
+        this.teardown();
+        this.steps = [];
+    }
+    teardown() {
+        this.active = false;
+        for (const dispose of this.disposers.splice(0))
+            dispose();
+    }
+    push(step) {
+        if (this.steps.length >= this.maxSteps) {
+            this.teardown();
+            return;
+        }
+        this.steps.push(step);
+    }
+    recordCommand(id, payload) {
+        if (!this.shouldRecordCommand(id))
+            return;
+        this.push(payload === undefined ? { type: 'command', id } : { type: 'command', id, payload });
+    }
+    recordTextInput(event) {
+        const last = this.steps[this.steps.length - 1];
+        switch (event.kind) {
+            case 'insert-text': {
+                // הקשות רצופות מתלכדות לצעד אחד — גם קריא יותר וגם ניגון מהיר יותר.
+                if (last?.type === 'insert-text') {
+                    last.text += event.text;
+                    return;
+                }
+                this.push({ type: 'insert-text', text: event.text });
+                return;
+            }
+            case 'insert-paragraph':
+                this.push({ type: 'insert-paragraph' });
+                return;
+            case 'delete-backward': {
+                if (last?.type === 'delete-backward') {
+                    last.count += 1;
+                    return;
+                }
+                this.push({ type: 'delete-backward', count: 1 });
+                return;
+            }
+            case 'delete-forward': {
+                if (last?.type === 'delete-forward') {
+                    last.count += 1;
+                    return;
+                }
+                this.push({ type: 'delete-forward', count: 1 });
+                return;
+            }
+        }
+    }
+}
+async function runStep(host, step) {
+    switch (step.type) {
+        case 'command':
+            return host.commands.execute(step.id, step.payload);
+        case 'insert-text':
+            return host.insertText(step.text);
+        case 'insert-paragraph':
+            return host.insertText('\n');
+        case 'delete-backward':
+            return host.deleteBackward(step.count);
+        case 'delete-forward':
+            // המנוע אינו חושף מחיקה קדימה נפרדת; מדווח ככשל מפורש ולא מדלג בשקט.
+            return { ok: false, message: 'מחיקה קדימה אינה נתמכת בניגון', reason: 'unsupported-step' };
+    }
+}
+export async function replayMacro(host, steps, options = {}) {
+    const stopOnError = options.stopOnError ?? true;
+    const failures = [];
+    let completed = 0;
+    for (let index = 0; index < steps.length; index += 1) {
+        const step = steps[index];
+        if (!step)
+            continue;
+        options.onStep?.(index, step);
+        let outcome;
+        try {
+            outcome = await runStep(host, step);
+        }
+        catch (error) {
+            outcome = { ok: false, message: error instanceof Error ? error.message : String(error) };
+        }
+        if (outcome.ok) {
+            completed += 1;
+            continue;
+        }
+        failures.push({ stepIndex: index, step, message: outcome.message });
+        if (stopOnError)
+            break;
+    }
+    return { ok: failures.length === 0, completed, failures };
+}

package/dist/scripting/eval-runner.d.ts

@@ -0,0 +1,16 @@
+/**
+ * מריץ סקריפטים ישיר — `AsyncFunction` באותו הקשר של הדף.
+ *
+ * **אינו ארגז חול.** סקריפט שרץ כאן מקבל גישה לכל מה שהדף מכיר. מיועד לשני
+ * מצבים: בדיקות, וסביבה שבה כל המאקרו נכתבים בידי המשתמש עצמו והוחלט
+ * במפורש לוותר על בידוד (למשל בגלל CSP שחוסם iframe). ברירת המחדל של
+ * `MacroKit` היא מריץ ה-iframe.
+ *
+ * תקרת הזמן כאן היא race על ההבטחה בלבד: לולאה סינכרונית אינסופית תחסום את
+ * ה-thread ולא תיעצר. תקרת הקריאות כן נאכפת, דרך ה-bridge.
+ */
+import type { MacroBridge } from './macro-api.js';
+import { type MacroRunner } from './runner.js';
+/** עוטפת bridge בתקרת קריאות. חשופה כדי ששני המריצים ישתמשו באותה אכיפה. */
+export declare function limitCalls(bridge: MacroBridge, maxCalls: number): MacroBridge;
+export declare function createEvalRunner(): MacroRunner;

package/dist/scripting/eval-runner.js

@@ -0,0 +1,69 @@
+import { DEFAULT_MAX_API_CALLS, DEFAULT_TIMEOUT_MS, } from './runner.js';
+const AsyncFunction = Object.getPrototypeOf(async function () {
+    /* טיפוס בלבד */
+}).constructor;
+/** עוטפת bridge בתקרת קריאות. חשופה כדי ששני המריצים ישתמשו באותה אכיפה. */
+export function limitCalls(bridge, maxCalls) {
+    return {
+        api: bridge.api,
+        callCount: bridge.callCount,
+        call(method, args) {
+            if (bridge.callCount() >= maxCalls) {
+                return Promise.reject(new Error(`המאקרו חצה את תקרת הקריאות (${maxCalls}) ונעצר`));
+            }
+            return bridge.call(method, args);
+        },
+    };
+}
+/** proxy של api שמנתב הכול דרך `bridge.call`, כדי שהתקרה תיאכף גם כאן. */
+function apiThroughBridge(bridge) {
+    return new Proxy({}, {
+        get(_target, method) {
+            if (typeof method !== 'string')
+                return undefined;
+            return (...args) => bridge.call(method, args);
+        },
+    });
+}
+export function createEvalRunner() {
+    return {
+        async run(source, bridge, options = {}) {
+            const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            const limited = limitCalls(bridge, options.maxApiCalls ?? DEFAULT_MAX_API_CALLS);
+            let fn;
+            try {
+                fn = new AsyncFunction('api', `"use strict";\n${source}`);
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    reason: 'error',
+                    message: `שגיאת תחביר במאקרו: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+            let timer;
+            const timeout = new Promise((resolve) => {
+                timer = setTimeout(() => resolve({ ok: false, reason: 'timeout', message: `המאקרו לא הסתיים תוך ${timeoutMs / 1000} שניות ונעצר` }), timeoutMs);
+            });
+            const run = (async () => {
+                try {
+                    const value = await fn(apiThroughBridge(limited));
+                    return { ok: true, value };
+                }
+                catch (error) {
+                    return {
+                        ok: false,
+                        reason: 'error',
+                        message: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            })();
+            try {
+                return await Promise.race([run, timeout]);
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+    };
+}

package/dist/scripting/iframe-runner.d.ts

@@ -0,0 +1,41 @@
+import { type MacroRunner } from './runner.js';
+/** סימון ההודעות של הפרוטוקול, כדי לא להתנגש בהודעות אחרות בדף. */
+export declare const PROTOCOL_MARK: "__otzariaMacro";
+export type SandboxMessage = {
+    [PROTOCOL_MARK]: true;
+    kind: 'ready';
+} | {
+    [PROTOCOL_MARK]: true;
+    kind: 'call';
+    id: number;
+    method: string;
+    args: unknown[];
+} | {
+    [PROTOCOL_MARK]: true;
+    kind: 'done';
+    value: unknown;
+} | {
+    [PROTOCOL_MARK]: true;
+    kind: 'error';
+    message: string;
+};
+export type HostMessage = {
+    [PROTOCOL_MARK]: true;
+    kind: 'run';
+    source: string;
+} | {
+    [PROTOCOL_MARK]: true;
+    kind: 'result';
+    id: number;
+    ok: boolean;
+    value?: unknown;
+    message?: string;
+};
+/** האם הודעה שייכת לפרוטוקול. חשופה לבדיקות. */
+export declare function isProtocolMessage(data: unknown): data is SandboxMessage;
+/**
+ * הקוד שרץ בתוך ה-iframe. מחרוזת ולא פונקציה מוסרלת — כדי שה-build לא ישנה
+ * אותו (minify של שמות היה שובר את הפרוטוקול).
+ */
+export declare const SANDBOX_BOOTSTRAP: string;
+export declare function createIframeRunner(doc?: Document): MacroRunner;