@lyads/visual-editor 0.0.0-stage → 1.0.1

package/dist/canvas-runtime/image-tools.d.ts

@@ -0,0 +1,31 @@
+import type { CanvasContext } from './context';
+import type { ControlsOverlay } from './overlay';
+/**
+ * Corner grips on the selected image: the width follows the pointer and keeps the proportion.
+ * The keyboard does the same with the arrows, on the focused grip or, from the image itself,
+ * with Shift + Alt + left or right.
+ */
+export declare class ImageTools {
+    #private;
+    private readonly ctx;
+    constructor(ctx: CanvasContext, overlay: ControlsOverlay);
+    /** Moves the keyboard from the selected image to its resize grip. */
+    focusGrip(id: string): boolean;
+    /** Drops the size the keys left without sending it; false when there was none. */
+    dropKeys(): boolean;
+    get active(): boolean;
+    /**
+     * Changes the width of the selected image by `delta` pixels, keeping its proportion. The
+     * piece shows each step at once; the host receives one size when the keys rest.
+     */
+    nudge(id: string, delta: number): boolean;
+    /** Sends the size the keys left, before anything else is asked of the piece. */
+    flushKeys(): void;
+    /**
+     * Runs `then` once the size just sent is answered (a revision, or no answer in time); at once
+     * when none is on its way. Saving waits for it, so the size of the last key is what is saved.
+     */
+    afterAnswer(then: () => void): void;
+    /** A revision arrived: its markup already carries the accepted size. */
+    documentChanged(): void;
+}

package/dist/canvas-runtime/keyboard.d.ts

@@ -0,0 +1,18 @@
+import type { BlockDrag } from './block-drag';
+import type { CanvasContext } from './context';
+import type { ImageTools } from './image-tools';
+import type { TextSession } from './text-session';
+import type { ViewportRestorer } from './viewport';
+/**
+ * Keys pressed while the frame holds the keyboard. The shortcuts are the ones of the shell: the
+ * frame only forwards what it cannot do itself, as a typed intent.
+ */
+export declare class KeyboardIntents {
+    #private;
+    private readonly ctx;
+    private readonly text;
+    private readonly drag;
+    private readonly viewport;
+    private readonly images;
+    constructor(ctx: CanvasContext, text: TextSession, drag: BlockDrag, viewport: ViewportRestorer, images: ImageTools);
+}

package/dist/canvas-runtime/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/canvas-runtime/messages.d.ts

@@ -0,0 +1,26 @@
+type Payload = Readonly<Record<string, unknown>>;
+/**
+ * The only way out of the frame: every message carries the window nonce, the revision the frame
+ * currently shows and a growing sequence. Measurements are throttled here and keep their last
+ * value; what the person asked for is never dropped by this side.
+ */
+export declare class BridgeChannel {
+    #private;
+    private readonly nonce;
+    revision: number;
+    constructor(nonce: string, revision: number);
+    send(type: string, payload?: Payload): void;
+    /** Selection is the one unsequenced intent of the original contract. */
+    selection(nodeId: string): void;
+    /** At most thirty per second for each kind; the latest value is always delivered. */
+    telemetry(type: string, payload: Payload): void;
+    /** Coalesces drafts; the producer runs when the message leaves, so it carries the last text. */
+    draft(produce: () => Payload | undefined): void;
+    flushDraft(): void;
+    cancelDraft(): void;
+    /** One intent made while a commit awaits its revision; a newer one replaces it. */
+    defer(intent: (() => void) | undefined): void;
+    takeDeferred(): (() => void) | undefined;
+    dispose(): void;
+}
+export {};

package/dist/canvas-runtime/morph.d.ts

@@ -0,0 +1,21 @@
+export interface MorphOptions {
+    /** Nodes owned by the runtime: never matched, moved or removed. */
+    readonly keep: (node: Node) => boolean;
+    /** The element under edition is left exactly as it is, attributes and content. */
+    readonly frozen?: (element: Element) => boolean;
+}
+/**
+ * Reconciles the live preview with the next validated revision without reloading the window.
+ * The incoming markup is parsed into an inert document and is subject to the same CSP. It throws
+ * when the revision needs a new window; the caller then asks the host for one.
+ */
+export declare class DocumentMorph {
+    private readonly options;
+    constructor(options: MorphOptions);
+    apply(html: string): void;
+    private head;
+    private attributes;
+    private matches;
+    private children;
+    private node;
+}

package/dist/canvas-runtime/navigation.d.ts

@@ -0,0 +1,29 @@
+import type { CanvasContext } from './context';
+export type NavigationCommand = 'selectPrevious' | 'selectNext' | 'selectParent' | 'selectChild';
+/**
+ * Moves the selection with the arrows: up and down to the sibling before or after (or to the
+ * block next to it in the document when there is none), left to the block which contains it,
+ * right into its first block. Only blocks of the revision on screen are visited, in the order
+ * the piece shows them; the page scrolls only as far as needed to show the block reached.
+ */
+export declare class BlockNavigation {
+    #private;
+    private readonly ctx;
+    constructor(ctx: CanvasContext);
+    /**
+     * Where the next arrow starts: the block the previous arrow reached while it still holds the
+     * keyboard, otherwise the selected block, otherwise the focused one.
+     */
+    origin(focused: string | undefined): string | undefined;
+    /** A block the person can see: one with a box, not hidden, not inside a closed `details`. */
+    visible(id: string): boolean;
+    /** The visible block an arrow leads to from `id`, or nothing at the edges of the piece. */
+    target(id: string, command: NavigationCommand): string | undefined;
+    /** Selects the block an arrow leads to, gives it the keyboard and brings it into view. */
+    go(id: string, command: NavigationCommand): boolean;
+    /**
+     * Scrolls the piece the least needed for the block to be seen; never the host page. A block
+     * without a box, or fixed to the window, is not brought anywhere by scrolling.
+     */
+    reveal(element: Element): void;
+}

package/dist/canvas-runtime/overlay.d.ts

@@ -0,0 +1,15 @@
+import type { CanvasBridgeConfiguration } from '../renderers/canvas-bridge';
+/** The trusted layer above the piece: a shadow tree which document styles cannot reach. */
+export declare class ControlsOverlay {
+    #private;
+    private readonly cfg;
+    readonly element: HTMLElement;
+    readonly shadow: ShadowRoot;
+    constructor(cfg: CanvasBridgeConfiguration);
+    /** Colors of the host shell; anything which is not a plain color value is ignored. */
+    theme(value: unknown): void;
+    node<K extends keyof HTMLElementTagNameMap>(tag: K, className: string): HTMLElementTagNameMap[K];
+    /** Icon bodies come exclusively from the installed Lucide subset generated at build time. */
+    icon(name: string, size?: number): string | undefined;
+    button(label: string, icon: string, signal: AbortSignal, action: () => void): HTMLButtonElement;
+}

package/dist/canvas-runtime/pointer-intents.d.ts

@@ -0,0 +1,14 @@
+import type { BlockDrag } from './block-drag';
+import type { CanvasContext } from './context';
+import type { TextSession } from './text-session';
+/**
+ * Turns clicks on the piece into intents: one click selects a block and opens its text, a double
+ * click on an image asks for another one, the secondary button asks the host for its menu.
+ */
+export declare class PointerIntents {
+    #private;
+    private readonly ctx;
+    private readonly text;
+    private readonly drag;
+    constructor(ctx: CanvasContext, text: TextSession, drag: BlockDrag);
+}

package/dist/canvas-runtime/selection-layer.d.ts

@@ -0,0 +1,16 @@
+import type { CanvasContext } from './context';
+import type { ControlsOverlay } from './overlay';
+/**
+ * Shows which block is under the pointer and which one is selected: a thin box, the friendly
+ * name of the block and, on the hovered one, the button which asks the host for a new block.
+ */
+export declare class SelectionLayer {
+    #private;
+    private readonly ctx;
+    private readonly overlay;
+    private readonly editingId;
+    constructor(ctx: CanvasContext, overlay: ControlsOverlay, editingId: () => string | undefined);
+    get hoverId(): string | undefined;
+    hover(id: string | undefined): void;
+    highlight(id: string | undefined): void;
+}

package/dist/canvas-runtime/shared/shortcuts.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The keyboard contract of the editor, shared by the shell and by the frame runtime: one table,
+ * one matcher. It owns no DOM and no state, so both sides bundle it as it is.
+ */
+export declare const EDITOR_SHORTCUT_COMMANDS: readonly ["undo", "redo", "remove", "duplicate", "moveUp", "moveDown", "parent", "save", "insert", "menu", "selectPrevious", "selectNext", "selectParent", "selectChild", "shrinkImage", "growImage"];
+/**
+ * Commands which only mean something with the keyboard in the piece: bare arrows move the focus
+ * in every panel of the shell, and the menu key there belongs to the element which has it.
+ */
+export declare const CANVAS_ONLY_SHORTCUTS: ReadonlySet<string>;
+export type EditorShortcutCommand = (typeof EDITOR_SHORTCUT_COMMANDS)[number];
+export interface ShortcutKeyEvent {
+    readonly key: string;
+    readonly ctrlKey: boolean;
+    readonly metaKey: boolean;
+    readonly altKey: boolean;
+    readonly shiftKey: boolean;
+    readonly isComposing?: boolean;
+}
+export interface EditorShortcut {
+    readonly command: EditorShortcutCommand;
+    /** Keys as shown to the person; `Mod` stands for Ctrl or Cmd. */
+    readonly keys: readonly (readonly string[])[];
+}
+export declare const EDITOR_SHORTCUTS: readonly EditorShortcut[];
+/** Resolves a key press to the command it asks for; text keys never match. */
+export declare function matchEditorShortcut(event: ShortcutKeyEvent): EditorShortcutCommand | undefined;

package/dist/canvas-runtime/text-editor.d.ts

@@ -0,0 +1,55 @@
+import type { RichTextCommandName, RichTextCommandState } from '../rich-text/commands';
+export interface TextEditorOptions {
+    readonly blocks: boolean;
+    readonly links: boolean;
+}
+export interface TextEditorEvents {
+    /** The text or the selection changed. */
+    changed(documentChanged: boolean): void;
+    finish(): void;
+    history(direction: 'undo' | 'redo'): void;
+    /** The person asked to reach the formatting controls outside the frame. */
+    toolbar(): void;
+}
+export interface TextSelectionRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** The rich-text editor mounted over the real element of the piece, with its real CSS. */
+export declare class InlineTextEditor {
+    #private;
+    private readonly element;
+    private constructor();
+    /**
+     * Returns the editor, or how many parts of the element would look different when it cannot be
+     * edited in place faithfully (zero when its markup is simply outside what the editor
+     * represents). On a refusal the element is left exactly as it was.
+     */
+    static mount(element: HTMLElement, options: TextEditorOptions, events: TextEditorEvents): InlineTextEditor | {
+        readonly refused: number;
+    };
+    /** Every run of text and every decorated box of the element, with what makes it look so. */
+    private static appearance;
+    private static difference;
+    get dirty(): boolean;
+    exportHtml(): string;
+    contains(node: unknown): boolean;
+    setEditable(value: boolean): void;
+    /** Puts the caret where the person clicked; `end` is the keyboard entry. */
+    focus(point: {
+        x: number;
+        y: number;
+    } | 'end' | 'keep'): void;
+    run(command: RichTextCommandName, value: string | null): boolean;
+    history(direction: 'undo' | 'redo'): boolean;
+    state(): RichTextCommandState;
+    /** The selection rectangle in viewport coordinates, for the controls outside the frame. */
+    selectionRect(): TextSelectionRect;
+    /**
+     * `restore` returns the element to the markup it had before the edition; `keep` leaves the
+     * edited rendering in place until the next revision is reconciled over it.
+     */
+    destroy(mode: 'restore' | 'keep'): void;
+}

package/dist/canvas-runtime/text-session.d.ts

@@ -0,0 +1,39 @@
+import type { CanvasContext, FramePoint } from './context';
+import { InlineTextEditor } from './text-editor';
+export type EditPoint = FramePoint | 'end' | 'keep';
+/** The one text being edited in its own element, from the first caret to the host's answer. */
+export declare class TextSession {
+    #private;
+    private readonly ctx;
+    private readonly highlight;
+    constructor(ctx: CanvasContext, highlight: (id: string) => void);
+    get id(): string | undefined;
+    get active(): boolean;
+    get awaiting(): boolean;
+    get dirty(): boolean;
+    contains(target: unknown): boolean;
+    element(): HTMLElement | undefined;
+    editable(id: string | undefined): id is string;
+    focus(point: EditPoint): void;
+    /** The keyboard belongs to the open text whenever the frame holds it. */
+    reclaim(): void;
+    setEditable(): void;
+    report(): void;
+    /** The host refused the commit or never answered: the text stays editable and nothing is lost. */
+    resume(id: string): void;
+    /** The host refused to open the transaction: the element returns to what it was. */
+    reject(id: string): void;
+    end(mode: 'finish' | 'cancel', then?: () => void): void;
+    /** No local step is left: the history of the document takes the request. */
+    documentHistory(direction: 'undo' | 'redo'): void;
+    /** With a text open, its own history comes first wherever the key was pressed. */
+    history(direction: 'undo' | 'redo'): void;
+    run(command: Parameters<InlineTextEditor['run']>[0], value: string | null): void;
+    begin(id: string | undefined, point: EditPoint): boolean;
+    /**
+     * Another revision arrived. A changed text was confirmed by the host and ends here; a clean one
+     * is reported so it can open again over the new markup.
+     */
+    supersede(): string | undefined;
+    forgetRefusals(): void;
+}

package/dist/canvas-runtime/variable-marks.d.ts

@@ -0,0 +1,20 @@
+import type { CanvasContext } from './context';
+import type { ControlsOverlay } from './overlay';
+/**
+ * Shows the variables of the piece as tags without touching its text: a highlight of the CSS
+ * Highlight API over each `{{key}}` (the DOM, the text being edited and the saved piece stay
+ * exactly as they are), and, under the pointer, a label with the friendly name the host gave
+ * the variable. A browser without the API keeps the plain text.
+ */
+export declare class VariableMarks {
+    #private;
+    private readonly ctx;
+    constructor(ctx: CanvasContext, overlay: ControlsOverlay);
+    private registry;
+    private constructorOf;
+    private schedule;
+    private scan;
+    /** The label of the variable under the pointer, just above it. */
+    private hover;
+    private hide;
+}

package/dist/canvas-runtime/viewport.d.ts

@@ -0,0 +1,10 @@
+import type { CanvasContext } from './context';
+/** Restores the scroll position the host remembers, also after media which arrives late. */
+export declare class ViewportRestorer {
+    #private;
+    private readonly ctx;
+    constructor(ctx: CanvasContext);
+    /** The person acted: a late restoration would now move the piece under their hands. */
+    cancelDeferred(): void;
+    request(x: unknown, y: unknown): void;
+}

package/dist/codecs/css.d.ts

@@ -0,0 +1,74 @@
+import type { RichTextDecorationLine } from '../core/rich-text-format';
+import type { Diagnostic } from '../core/document';
+import { UrlPolicy } from '../security/url-policy';
+export interface CssInspection {
+    readonly diagnostics: readonly Diagnostic[];
+    readonly declarations: Readonly<Record<string, string>>;
+    readonly urls: readonly string[];
+    readonly urlCandidates: readonly string[];
+}
+/** What an author's CSS holds. Nothing here refuses a document; the host decides. */
+export interface CssSurvey {
+    /** Targets of `@import`, as written. */
+    readonly imports: readonly string[];
+    readonly fontFaces: number;
+    /** Every `url()` and string source the stylesheet refers to. */
+    readonly urls: readonly string[];
+    /** `expression()`, `behavior`, `-moz-binding` and URLs which would run code. */
+    readonly active: number;
+}
+/** Parse CSS rather than matching dangerous strings in the original stylesheet. */
+export declare class CssDocumentCodec {
+    #private;
+    constructor(urls?: UrlPolicy);
+    validate(css: string, context?: 'stylesheet' | 'declarationList'): readonly Diagnostic[];
+    inspect(css: string, context?: 'stylesheet' | 'declarationList'): CssInspection;
+    /** The only refusals left for the CSS of a document: its size and the element it lives in. */
+    documentDiagnostics(css: string): readonly Diagnostic[];
+    /**
+     * Tolerant inventory of imported CSS: hacks, vendor filters and parse errors are kept as
+     * written. It never validates; `inspect` stays the strict gate of what the editor writes.
+     */
+    survey(css: string, context?: 'stylesheet' | 'declarationList'): CssSurvey;
+    /**
+     * Removes from imported CSS what `survey` counts as active: a declaration which holds
+     * `expression()`, a binding, a behavior file or a code URL, and an `@import` of a code URL.
+     * Everything else keeps its bytes: the cut is made by the positions of the parser. The built-in
+     * behaviors of Outlook (`behavior:url(#default#VML)`) load nothing and stay: without them the
+     * VML of an e-mail does not draw.
+     */
+    stripActive(css: string, context?: 'stylesheet' | 'declarationList'): {
+        readonly css: string;
+        readonly removed: number;
+    };
+    /** Source spans of the declarations and imports to remove; undefined when unreadable. */
+    private activeSpans;
+    /**
+     * A value the grammar could not read is kept as text. Whether it means code is judged over
+     * that text with its escapes resolved and its white space removed, as an engine would join it.
+     */
+    private activeRaw;
+    /** `behavior:url(#default#VML)`: a behavior of the program itself, not a file it would load. */
+    private builtInBehavior;
+    readDeclarations(css: string): Readonly<Record<string, string>>;
+    /** Only semantic text declarations may enter the authenticated editing DOM. */
+    richTextStyles(css: string): Readonly<Record<string, string>> | undefined;
+    /** Conservative stylesheet check; cascade applicability is deliberately not inferred. */
+    hasDecorationRules(css: string): boolean;
+    /** Removes one line while keeping an independent strike/underline and its color/style. */
+    removeDecoration(css: string, line: RichTextDecorationLine): string;
+    /**
+     * Catalog defaults go before the author's rules, which keep precedence, yet after any
+     * leading `@charset` / `@import`, which only count at the top. The existing CSS is the
+     * author's and is kept as written, hacks included; only the incoming CSS is validated.
+     */
+    prependDefaults(existing: string, incoming: readonly string[]): string;
+    removeDeclarations(css: string, properties: readonly string[]): string;
+    /** Replaces every declaration of the property and keeps the priority the author gave it. */
+    setDeclaration(css: string, property: string, value: string): string;
+    /** Untouched declarations and comments keep their source text; empty separators are dropped. */
+    private remaining;
+    private join;
+    private error;
+    private unique;
+}

package/dist/codecs/html.d.ts

@@ -0,0 +1,81 @@
+import { BlockCatalog } from '../core/catalog';
+import { EditorDocument } from '../core/document';
+import type { DocumentKind, EditorDocumentData, ImportResult, SourceInput } from '../core/document';
+import { ContentPolicy } from '../security/policy';
+/** HTML5 parser, structural recognition and a bounded, private source-preservation cache. */
+export declare class HtmlDocumentCodec {
+    #private;
+    constructor(policy?: ContentPolicy, catalog?: BlockCatalog, cacheSize?: number);
+    /**
+     * Never refuses a document for what it contains. A source is only turned down when it is
+     * over the limits or when its tree cannot be written back as the same tree; a tree which
+     * needed one pass of the serializer to settle is accepted in that settled form.
+     */
+    import(source: SourceInput, kind: DocumentKind, previous?: EditorDocumentData): ImportResult;
+    /**
+     * Parses and validates auxiliary source (rich text projections, snippets, verification)
+     * without touching the preservation cache of the documents being edited.
+     */
+    inspect(source: SourceInput, kind: DocumentKind): ImportResult;
+    private read;
+    /**
+     * The tree the parser builds for this markup, in the shape of the document model, and the
+     * source slice of every node which stands alone in it. Throws over the node limits.
+     */
+    private tree;
+    export(input: EditorDocumentData | EditorDocument): SourceInput;
+    clearCache(): void;
+    private plain;
+    private roundTrips;
+    private forget;
+    /**
+     * `template`, `svg` and `math` are kept as one block of source. Their inner markup follows
+     * other parsing rules (inert content, foreign elements, CDATA) which a tree of HTML nodes
+     * would not write back as it was read.
+     */
+    private island;
+    private opener;
+    /** How a comment is written: as recorded, or by the grammar of old documents without it. */
+    private commentOpener;
+    private namespace;
+    /**
+     * Reparse output before returning it; serializer edge cases are a security boundary too.
+     * The tree read back has to be the tree which was written: the same nodes, attributes,
+     * text, comment forms and namespaces. Anything a parser would read differently, such as
+     * text which closes its own script or comment, fails here whatever the kind allows.
+     */
+    private verification;
+    /**
+     * A source slice may stand for a node only when it holds that node and nothing else.
+     * Foster parenting, formatting reconstruction and ignored tokens leave foreign source
+     * between the located children; implied elements carry no location and are transparent.
+     */
+    private selfContainedElement;
+    private tile;
+    private serialize;
+    /**
+     * Markup without `html`, `head` or `body` is read as a fragment. The fragment parser moves
+     * its result node by node, which is quadratic over tens of thousands of top-level nodes:
+     * such a wide source uses the flow content of the document parse, which is the same tree
+     * for everything a browser would place in a body.
+     */
+    private fragment;
+    private isDocument;
+    private findTitle;
+    private newId;
+    private reconcileIds;
+    /**
+     * Digest of a subtree, remembered per node object so that matching preserved slices and
+     * older identities costs one pass over the tree. It only chooses candidates: whatever is
+     * written is still verified against the exact document fingerprint by reparse.
+     */
+    private nodeFingerprint;
+    /** Two independent 32-bit mixes and the length: enough to pick a candidate, never a proof. */
+    private digest;
+    private ownStructure;
+    private nodeStructure;
+    private documentFingerprint;
+    private remember;
+    private error;
+    private notice;
+}

package/dist/compilation/browser-compiler.d.ts

@@ -0,0 +1,14 @@
+import type { MjmlCompilerPort } from '../renderers/email-renderer';
+import { GeneratedMjml } from './generated-mjml';
+import type { GeneratedMjmlCompilerPort } from './generated-mjml';
+export declare class BrowserMjmlCompiler implements MjmlCompilerPort, GeneratedMjmlCompilerPort {
+    private readonly guard;
+    private readonly jobs;
+    private disposed;
+    /** MJML from outside: no raw region is accepted. */
+    compile(source: string): Promise<string>;
+    /** MJML of the block codec, with the raw regions it generated. */
+    compileGenerated(mjml: GeneratedMjml): Promise<string>;
+    private run;
+    dispose(): void;
+}

package/dist/compilation/browser-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compilation/compile-lanes.d.ts

@@ -0,0 +1,18 @@
+import type { GeneratedMjmlCompilerPort } from './generated-mjml';
+/** A preview compilation replaced by a newer one before it started. */
+export declare const COMPILE_SUPERSEDED = "COMPILE_SUPERSEDED";
+/**
+ * Two lanes over one compiler, which runs at most two jobs at a time and refuses a third with
+ * `COMPILER_BUSY`. The preview lane has at most one compilation in flight and keeps only the
+ * newest one waiting: an older waiting preview is rejected with `COMPILE_SUPERSEDED`, because
+ * the frame only shows the newest revision. The final lane (save, conversion) runs one at a time
+ * in order, so the preview never takes its place; if a compiler shared with the host is busy with
+ * other work, the final job waits and tries again instead of failing.
+ */
+export declare class CompileLanes {
+    #private;
+    private readonly compiler;
+    readonly preview: GeneratedMjmlCompilerPort;
+    readonly final: GeneratedMjmlCompilerPort;
+    constructor(compiler: GeneratedMjmlCompilerPort);
+}

package/dist/compilation/generated-mjml.d.ts

@@ -0,0 +1,25 @@
+/**
+ * MJML written by the block codec, with the exact raw regions (`mj-raw`) it emitted. A raw
+ * region is accepted by the compilation only through this type, only inside `mj-column`, and
+ * only when it is one of `fragments` and passes `CompilationGuard.rawFragment`: one table row
+ * whose single cell holds markup the e-mail rules keep as it is. MJML that arrives as a string
+ * (`compile`) never has a raw region.
+ */
+export declare class GeneratedMjml {
+    readonly source: string;
+    readonly fragments: readonly string[];
+    constructor(source: string, fragments?: readonly string[]);
+}
+/** Compilers which accept generated MJML. Both bundled compilers implement it. */
+export interface GeneratedMjmlCompilerPort {
+    compileGenerated(mjml: GeneratedMjml): Promise<string>;
+}
+/** What a compilation worker receives: external MJML, or generated MJML with its regions. */
+export type CompileRequest = string | {
+    readonly source: string;
+    readonly fragments: string[];
+};
+export declare function readCompileRequest(request: unknown): {
+    source: string;
+    fragments?: readonly string[];
+} | undefined;

package/dist/compilation/guard.d.ts

@@ -0,0 +1,40 @@
+export declare const COMPILE_LIMITS: Readonly<{
+    sourceBytes: 200000;
+    outputBytes: 2000000;
+    timeoutMs: 15000;
+    parallelJobs: 2;
+}>;
+/** Compilation accepts content, never filesystem paths, configuration or plugins. */
+export declare class CompilationGuard {
+    private readonly codec;
+    /**
+     * Without `fragments` (MJML from outside) `mj-raw` is refused like an include. With them
+     * (MJML of the block codec) an `mj-raw` is accepted only as a child of `mj-column`, only
+     * when its content is exactly one of the fragments, and each fragment must pass
+     * `rawFragment`.
+     */
+    source(source: string, fragments?: readonly string[]): void;
+    /**
+     * A raw region of generated MJML. MJML writes it, as it is, inside the `tbody` of the column,
+     * so it is read here the way a browser reads it there: one row, one cell with only a class
+     * and a padding, and a content the e-mail rules keep without removing or rewriting anything.
+     */
+    rawFragment(fragment: string): void;
+    output(source: unknown): string;
+    private rawRegion;
+}
+export declare const MJML_OPTIONS: Readonly<{
+    fonts: {};
+    validationLevel: "strict";
+    ignoreIncludes: true;
+    useMjmlConfigOptions: false;
+    keepComments: true;
+    minify: false;
+    juiceOptions: {
+        webResources: {
+            images: boolean;
+            scripts: boolean;
+            links: boolean;
+        };
+    };
+}>;

package/dist/compilation/node-compiler.d.ts

@@ -0,0 +1,17 @@
+import type { MjmlCompilerPort } from '../renderers/email-renderer';
+import { GeneratedMjml } from './generated-mjml';
+import type { GeneratedMjmlCompilerPort } from './generated-mjml';
+export declare class NodeMjmlCompiler implements MjmlCompilerPort, GeneratedMjmlCompilerPort {
+    private readonly workerUrl;
+    private readonly timeoutMs;
+    private readonly guard;
+    private readonly jobs;
+    private disposed;
+    constructor(workerUrl: URL, timeoutMs?: number);
+    /** MJML from outside: no raw region is accepted. */
+    compile(source: string): Promise<string>;
+    /** MJML of the block codec, with the raw regions it generated. */
+    compileGenerated(mjml: GeneratedMjml): Promise<string>;
+    private run;
+    dispose(): void;
+}

package/dist/compilation/node-worker.d.ts

@@ -0,0 +1 @@
+export {};