@arbidocs/react 0.5.111 → 0.5.113

package/dist/artifacts/index.d.cts

@@ -1,476 +0,0 @@
-import { RedlineWithRegions, RedlineRegion } from './redline-core.cjs';
-export { RegionKind, buildHybridRedlineMarkdown, buildHybridRedlineWithRegions, normalizeMarkdown, revertRedlineRegion } from './redline-core.cjs';
-import * as _tanstack_react_query from '@tanstack/react-query';
-import { D as DraftCleanReport } from '../stored-markdown.d-Bp18vrbr.cjs';
-export { a as DraftCleanStage, c as cleanDraftMarkdown, b as cleanDraftWithReport, p as promoteBoldTitle, r as repairParsedStructure, d as repairParsedTitle, s as stripAgentPreamble, u as unescapeMarkdown, e as unwrapCitationLinks } from '../stored-markdown.d-Bp18vrbr.cjs';
-import { FC, ComponentPropsWithoutRef, ReactNode } from 'react';
-import { ArtifactEvent } from '@arbidocs/sdk/browser';
-
-/**
- * Where a redline is computed. The default runs on the calling thread; a host with large
- * documents passes an engine backed by a Web Worker (for example a Comlink proxy exposing the same
- * three functions) so typing never waits on a diff.
- */
-interface RedlineEngine {
-    buildRedline(baseText: string, compareText: string): string | Promise<string>;
-    buildRedlineWithRegions(baseText: string, compareText: string): RedlineWithRegions | Promise<RedlineWithRegions>;
-    revertRegion(baseText: string, compareText: string, regionId: string): string | Promise<string>;
-}
-/** Main-thread engine: the pure functions of `redline-diff`. */
-declare const mainThreadRedlineEngine: RedlineEngine;
-
-/** What a redline view can show. Mirrors the status parts of `@arbidocs/blocks/artifacts`. */
-type RedlineState = {
-    kind: 'idle';
-} | {
-    kind: 'computing';
-} | {
-    kind: 'ready';
-    markdown: string;
-    regions: RedlineRegion[];
-} | {
-    kind: 'identical';
-} | {
-    kind: 'unavailable';
-};
-interface UseRedlineOptions {
-    /** The older side. `null` means the text could not be loaded; `undefined` means not chosen. */
-    baseText: string | null | undefined;
-    /** The newer side (a loaded version, or the live edit buffer). */
-    compareText: string | null | undefined;
-    /** Either text is still being fetched. */
-    isLoading?: boolean;
-    /** Defaults to the main thread; pass a worker-backed engine for big documents. */
-    engine?: RedlineEngine;
-}
-interface UseRedlineResult {
-    state: RedlineState;
-    /** Undo one change: resolves with the compare text rebuilt without it (null if nothing changed). */
-    revertRegion: (regionId: string) => Promise<string | null>;
-}
-/**
- * Track-changes between two texts. Stale results are dropped when the inputs change mid-compute,
- * and a failed diff reports `unavailable` instead of throwing into the render.
- */
-declare function useRedline({ baseText, compareText, isLoading, engine, }: UseRedlineOptions): UseRedlineResult;
-
-/**
- * Versions of a document. A document keeps ONE id for its whole life; its versions live inside it
- * (`current_version` + `versions`, numbered 1..n). A version is named by a version reference
- * `doc-…@v{n}`; a plain document id means its current version. The workspace list carries every
- * document's `versions`, and `GET /v1/document/{id}/versions` (`arbi.documents.versions`) the same
- * list on its own.
- */
-/** One version entry as the API returns it (a subset of `DocVersion`). */
-interface DocVersionEntry {
-    n: number;
-    file_name?: string | null;
-    created_at?: string | null;
-    reason?: string | null;
-    /** The version an edit started from, when it was not the previous one. */
-    made_from?: number | null;
-    is_current?: boolean | null;
-    /** The assistant message whose turn made this version, and its thread (none: a person's). */
-    source_message_ext_id?: string | null;
-    conversation_ext_id?: string | null;
-}
-/** The fields of a workspace document the version list needs (a subset of the API type). */
-interface VersionedDoc {
-    external_id?: string | null;
-    current_version?: number | null;
-    versions?: readonly DocVersionEntry[] | null;
-    file_name?: string | null;
-    created_at?: string | null;
-}
-/** One row of a version list. Matches `VersionEntry` of `@arbidocs/blocks/artifacts`. */
-interface ArtifactVersion {
-    /** The version reference `doc-…@v{n}`: what opening or comparing this version names. */
-    id: string;
-    /** The document (the same for every version). */
-    docId: string;
-    /** File name as stored. */
-    name: string;
-    /** ISO timestamp. */
-    createdAt: string;
-    /** 1-based version number within the document. */
-    number: number;
-    /** upload | edit | signed | sync */
-    reason: string;
-    isCurrent: boolean;
-    /** The version this one was saved from (an older one than the previous version when restored). */
-    savedFromId?: string | null;
-    /** The thread (and its message) whose turn made this version; none for a person's. */
-    thread?: {
-        conversationId: string;
-        messageId: string | null;
-    } | null;
-}
-/** `doc-…@v{n}`: a reference to version `n` of a document. */
-declare function versionRef(docId: string, version: number): string;
-/**
- * Split a reference into the document and the version it names. A plain document id (or anything
- * else) names no version: the document's current one.
- */
-declare function parseVersionRef(ref: string | null | undefined): {
-    docId: string;
-    version: number | null;
-};
-/** The version a version was saved from: `made_from`, else the one before it. */
-declare function savedFromId(docId: string, entry: DocVersionEntry): string | null;
-/** A document's version entries (oldest first) as plain version rows. */
-declare function toArtifactVersions(docId: string | null | undefined, entries: readonly DocVersionEntry[] | null | undefined, currentVersion?: number | null): ArtifactVersion[];
-/** The versions of a listed document, oldest first (`[]` when the document is not given). */
-declare function documentVersions(doc: VersionedDoc | null | undefined): ArtifactVersion[];
-/** The row `ref` names: an exact version, or (a plain document id) the current version. */
-declare function findVersion(versions: readonly ArtifactVersion[], ref: string | null | undefined): ArtifactVersion | undefined;
-/**
- * "v2": the version number `ref` names. `null` when there is nothing to tell apart (the document
- * has a single version, or it is unknown), so unversioned documents stay unlabelled.
- */
-declare function versionLabel(versions: readonly ArtifactVersion[], ref: string | null | undefined): string | null;
-/**
- * Join parsed chunks into one markdown text (blank line between chunks).
- *
- * `unescape: true` for an artifact stored from markdown: the backend's parse of a `.md` escapes
- * markdown punctuation, which `unescapeMarkdown` undoes (see its rule), and mangles its title
- * (`repairParsedTitle`, `repairParsedStructure`: doubled headings, `- ` stacked on list markers,
- * one-line tables), then normalised. Leave it off for the parse
- * of a PDF or Word file.
- */
-declare function flattenChunks(chunks: readonly {
-    content?: string | null;
-}[] | null | undefined, options?: {
-    unescape?: boolean;
-}): string;
-/** Is `id` a real, saved document id? Local drafts have placeholder ids and no backend document. */
-declare function isDocumentId(id: string | null | undefined): id is string;
-
-/** What a save reports back. `docId` is the new version when the backend already knows it. */
-interface ArtifactSaveResult {
-    docId?: string;
-    /** 1-based number of the version that was just saved (1 for the first save of a draft). */
-    version?: number;
-}
-interface ArtifactEditSessionOptions {
-    /** The artifact being edited. Changing it discards the buffer and any comparison. */
-    docId: string | null | undefined;
-    /**
-     * The saved text of the open version. `undefined` while it loads; whenever it changes the
-     * baseline follows it (a version arriving from the realtime channel, a finished stream).
-     */
-    baseline: string | undefined;
-    /**
-     * A new document the user types from scratch: open straight in the editor, seeded with
-     * `initialContent`, instead of showing a read-only view. Read when `docId` changes.
-     */
-    startEditing?: boolean;
-    initialContent?: string;
-    /** The version this one was saved from. Offering "compare with previous" needs it. */
-    savedFromId?: string | null;
-    /** Controlled comparison target. Omit for an uncontrolled one the session owns. */
-    compareId?: string | null;
-    onCompareChange?: (id: string | null) => void;
-    /** The saved text of the compare target (the older side of the diff). */
-    compareText?: string | null;
-    compareLoading?: boolean;
-    /** Starting a comparison opens the editor with track changes on (default true). */
-    compareOpensEditor?: boolean;
-    /** Persist the buffer as a NEW version. Rejecting keeps the buffer so nothing is lost. */
-    save: (content: string) => Promise<ArtifactSaveResult | void>;
-    onSaved?: (result: ArtifactSaveResult, content: string) => void;
-    onSaveError?: (error: unknown) => void;
-    /** Every buffer change (a host keeps a draft store in sync with it). */
-    onContentChange?: (content: string) => void;
-    /** The unsaved-changes flag, for a host that warns before a panel is closed. */
-    onDirtyChange?: (dirty: boolean) => void;
-    /** Where the diff runs. Defaults to the main thread. */
-    redlineEngine?: RedlineEngine;
-    /** Typing is never debounced; the diff trails the buffer by this long. Default 300ms. */
-    diffDelayMs?: number;
-}
-interface ArtifactEditSession {
-    isEditing: boolean;
-    /** The saved text of the open version. */
-    baseline: string;
-    /** The text in the editor (the baseline until the first edit). */
-    content: string;
-    hasChanges: boolean;
-    isSaving: boolean;
-    canCompare: boolean;
-    compareId: string | null;
-    showTrackChanges: boolean;
-    /** Track changes between the compare target and the (debounced) buffer. */
-    redline: UseRedlineResult;
-    startEdit: () => void;
-    /** Discard the buffer and any comparison; back to the rendered view. */
-    cancel: () => void;
-    /** Save the buffer as a new version. Resolves false when it failed (the buffer is kept). */
-    save: () => Promise<boolean>;
-    /** The editor's `onChange`; also replaces the buffer (for example after an undo-this-change). */
-    change: (markdown: string) => void;
-    /** The editor's `onNormalized`: adopt its canonical form as the baseline so Save does not fire. */
-    normalized: (markdown: string) => void;
-    /** Compare with the previous version (when no id is given). */
-    compare: (id?: string) => void;
-    stopCompare: () => void;
-    setShowTrackChanges: (show: boolean) => void;
-    /** Undo one tracked change in the buffer. */
-    revertRegion: (regionId: string) => Promise<void>;
-}
-/**
- * The state machine of an artifact edit session, with no SDK and no network: the edit buffer and
- * its baseline, the dirty flag, immutable-version saves and a track-changes comparison. A host
- * supplies the saved text and a `save` function (see `useArtifactSession` for the SDK binding).
- */
-declare function useArtifactEditSession(options: ArtifactEditSessionOptions): ArtifactEditSession;
-
-/**
- * Where the text of a stored artifact is:
- *  - `loading`: the first request is in flight (or there is no document yet);
- *  - `parsing`: the backend has not finished parsing the upload (the endpoint answers 404, 422 or
- *    500, or an empty parse, for a few seconds after an upload) and the hook is retrying;
- *  - `ready`: the text is here (an empty document is `ready` with `text: null`);
- *  - `error`: the retries ran out, or the request was refused (401/403).
- */
-type ArtifactTextStatus = 'loading' | 'parsing' | 'ready' | 'error';
-/** How long `useArtifactText` keeps asking while a document is still being parsed. */
-interface ArtifactTextRetry {
-    /** Retries after the first request. Default 12. */
-    attempts?: number;
-    /** Delay before the first retry; it grows by 1.6x each time. Default 1000 ms. */
-    baseDelayMs?: number;
-    /** Cap for one delay. Default 5000 ms (12 retries are about 50 s in all). */
-    maxDelayMs?: number;
-}
-declare const DEFAULT_ARTIFACT_TEXT_RETRY: Required<ArtifactTextRetry>;
-interface ArtifactText {
-    /**
-     * The markdown, clean: `undefined` while `loading` or `parsing`, `null` when there is none (an
-     * empty document, or `error`).
-     */
-    text: string | null | undefined;
-    /** `status` is `loading` or `parsing`. */
-    isLoading: boolean;
-    status: ArtifactTextStatus;
-    /** The last request error while `parsing` or after `error`. */
-    error: Error | null;
-    /** Ask again now (after an `error`). */
-    retry: () => void;
-}
-/**
- * The saved markdown of an artifact version (its parsed chunks, joined and unescaped).
- *
- * A freshly uploaded document is parsed asynchronously, and for roughly 3 to 20 seconds the parsed
- * content endpoint answers 404, 422 or 500 (or an empty parse). The hook therefore retries with a
- * growing delay (see `ArtifactTextRetry`) and reports `status: 'parsing'` meanwhile, so a host can
- * show "Preparing editor..." instead of opening an editor on an empty baseline. After the last
- * retry the status is `error`; `retry()` starts a new round.
- *
- * The text is run through `unescapeMarkdown`: an artifact is always stored from markdown, and the
- * backend's parse of a `.md` escapes its punctuation.
- */
-declare function useArtifactText(docId: string | null | undefined, options?: {
-    enabled?: boolean;
-    retry?: ArtifactTextRetry;
-}): ArtifactText;
-
-/**
- * The versions of an artifact, oldest first. `docId` is a document id or a version reference
- * (`doc-…@v2`). Every listed document carries its versions; a document that is not in the
- * workspace list asks for its version list.
- */
-declare function useArtifactVersions(workspaceId: string | undefined, docId: string | null | undefined): ArtifactVersion[];
-interface SaveArtifactVersionInput {
-    /** File name of the new version (`.md` is added when missing). */
-    title: string;
-    content: string;
-    /** Save as the next version of this document (it keeps its id); omit for a new document. */
-    versionOf?: string | null;
-    /** The processing config (auto-title, parsing) to run the upload with. */
-    configId?: string | null;
-    /** `artifact` (default) for AI-style drafts; `source` for a document the user typed. */
-    wpType?: 'artifact' | 'source';
-}
-/**
- * Save markdown as a NEW immutable version (the next version of `versionOf`'s document, which keeps
- * its id) and refresh the workspace document list, version lists and the document's text.
- */
-declare function useSaveArtifactVersion(): _tanstack_react_query.UseMutationResult<ArtifactSaveResult, Error, SaveArtifactVersionInput, unknown>;
-interface ArtifactSessionOptions extends Pick<ArtifactEditSessionOptions, 'onSaved' | 'onSaveError' | 'onCompareChange' | 'compareId' | 'compareOpensEditor' | 'redlineEngine' | 'onDirtyChange'> {
-    workspaceId: string | undefined;
-    /**
-     * The open document (its current version), a version reference `doc-…@v{n}`, or the placeholder
-     * id of an unsaved local draft (anything that is not a backend document id, i.e. does not start
-     * with `doc`).
-     */
-    docId: string | null | undefined;
-    /**
-     * The text of a local draft (nothing is fetched for it). The FIRST save uploads it as a real
-     * document with no parent and the session switches to the new id; later saves chain from it.
-     */
-    draftContent?: string;
-    /** Name for saved versions. Defaults to the open version's file name, else "Untitled". */
-    title?: string;
-    /** Processing config for saved versions. */
-    configId?: string | null;
-}
-/** Everything `ArtifactEditor` (`@arbidocs/blocks/artifacts`) takes from a session, flat. */
-interface ArtifactSessionView {
-    content: string;
-    isEditing: boolean;
-    hasChanges: boolean;
-    isSaving: boolean;
-    canCompare: boolean;
-    comparing: boolean;
-    compareId: string | null;
-    showTrackChanges: boolean;
-    versions: ArtifactVersion[];
-    currentVersionId: string;
-    onStartEdit: () => void;
-    onCancel: () => void;
-    onSave: () => void;
-    onCompare: () => void;
-    onStopCompare: () => void;
-    onToggleTrackChanges: () => void;
-    /**
-     * Whether the text is ready. `ArtifactEditor` renders "Preparing editor..." while it is
-     * `loading` or `parsing` (a fresh upload is parsed for a few seconds) and an error with Retry.
-     */
-    status: ArtifactTextStatus;
-    /** Ask for the text again after an `error`. */
-    onRetry: () => void;
-}
-interface ArtifactSession extends ArtifactEditSession {
-    /** The open document: the new real id once a local draft has been saved. */
-    docId: string | null | undefined;
-    /** The open version is an unsaved local draft (no backend document yet). */
-    isLocal: boolean;
-    isLoading: boolean;
-    /** See `ArtifactTextStatus`. */
-    status: ArtifactTextStatus;
-    versions: ArtifactVersion[];
-    /** "v2" for any version (reference) of the document. */
-    labelOf: (id: string | null | undefined) => string | null;
-    /** Props for `<ArtifactEditor>`. */
-    view: ArtifactSessionView;
-    /** Props for `<ArtifactMarkdownEditor>` (`@arbidocs/blocks/artifacts/editor`). */
-    editorProps: {
-        markdown: string;
-        onChange: (markdown: string) => void;
-        onNormalized: (markdown: string) => void;
-    };
-    /** Props for `<ArtifactRedlineView>`. */
-    redlineProps: {
-        state: ArtifactEditSession['redline']['state'];
-        onRevert: (regionId: string) => void;
-    };
-}
-/**
- * Edit an artifact through the SDK: load it, edit it, save it as a new version, list its versions
- * and compare any two with track changes. Needs an `<ArbiHost>` with an `arbi` and a selected workspace.
- *
- * ```tsx
- * const session = useArtifactSession({ workspaceId, docId, onSaved: ({ docId }) => docId && open(docId) })
- * <ArtifactEditor {...session.view} onOpenVersion={open}
- *   editor={<ArtifactMarkdownEditor {...session.editorProps} />}
- *   redline={<ArtifactRedlineView {...session.redlineProps} />} />
- * ```
- */
-declare function useArtifactSession(options: ArtifactSessionOptions): ArtifactSession;
-
-/**
- * The stored source of a live artifact (the `.html` / `.jsx` file itself; the parsed text strips
- * it). `undefined` until it has loaded.
- */
-declare function useArtifactSource(documentId: string | null | undefined, enabled?: boolean): _tanstack_react_query.UseQueryResult<string, Error>;
-
-/** The `<del>` / `<ins>` renderers `ArtifactRedlineView` hands to a markdown renderer. */
-interface ArtifactRedlineComponents {
-    del: FC<ComponentPropsWithoutRef<'del'> & {
-        'data-cid'?: string;
-    }>;
-    ins: FC<ComponentPropsWithoutRef<'ins'> & {
-        'data-cid'?: string;
-    }>;
-}
-/**
- * The kit's markdown renderer as the `renderMarkdown` slot of `ArtifactEditor` and
- * `ArtifactRedlineView`: full markdown (tables, lists, code) plus the raw `<del>` / `<ins>` tags
- * of a redline.
- */
-declare function renderArtifactMarkdown(markdown: string, components?: ArtifactRedlineComponents): ReactNode;
-
-/**
- * Where a drafted artifact is in its STREAM -> PERSIST -> EDIT life:
- *  - `streaming`: the agent is still working (or has produced nothing final): show the live canvas;
- *  - `persisting`: the finished draft is being stored as version 1 of the artifact;
- *  - `parsing`: stored; the backend is still parsing it, so there is no editable text yet;
- *  - `ready`: the text is readable: mount the editor on `docId`;
- *  - `error`: storing failed or the parse never produced text (`retry()` starts over).
- */
-type StreamedArtifactPhase = 'streaming' | 'persisting' | 'parsing' | 'ready' | 'error';
-interface UseStreamedArtifactOptions {
-    /** The artifacts of the agent run (`useConnectedAiTask().artifacts`). */
-    artifacts: ArtifactEvent[];
-    workspaceId: string | undefined;
-    /**
-     * The run has stopped: not busy and not failed. Nothing is stored before this, so a draft that
-     * is still streaming is never persisted half-written.
-     */
-    settled: boolean;
-    /**
-     * Make the stored markdown from the streamed content. Default `cleanDraftWithReport`, which is
-     * guarded: it stores the raw streamed text (or links-only text) rather than a cleanup that would
-     * lose content (see `DraftCleanReport`).
-     */
-    clean?: (streamed: string) => string;
-    /** Called once per stored draft with what the cleanup did (`stage` is not `cleaned` if guarded). */
-    onCleaned?: (report: DraftCleanReport) => void;
-    /** Processing config for the stored version. */
-    configId?: string | null;
-    /** How long to wait for the parse (see `useArtifactText`). */
-    parseRetry?: ArtifactTextRetry;
-}
-interface StreamedArtifact {
-    phase: StreamedArtifactPhase;
-    /** The finished streamed artifact (its `title` names the stored versions). */
-    artifact: ArtifactEvent | undefined;
-    /** The backend document to edit, once there is one (while `parsing` and `ready`). */
-    docId: string | undefined;
-    error: Error | null;
-    /** What the cleanup did to the stored draft (`null` until it was stored, or with a custom `clean`). */
-    cleaned: DraftCleanReport | null;
-    /** After an `error`: store again or ask for the parse again. */
-    retry: () => void;
-}
-/**
- * The lifecycle of an agent-drafted artifact, so a host passes the stream and renders the phase.
- *
- * While the agent streams, the draft lives only on the canvas. Once the run is `settled` and the
- * draft is complete, a draft that is not yet a backend document is cleaned (`cleanDraftMarkdown`)
- * and stored ONCE as the artifact's first version (`wpType: 'artifact'`); a draft that already is a
- * backend document passes through. The hook then waits for the parse (`useArtifactText`, which
- * retries) and reports `ready` with the `docId` to open in an editor.
- *
- * Needs an `<ArbiHost>` with an `arbi` and a workspace. `@arbidocs/blocks/connect` has the whole thing as a
- * component (`StreamedArtifact`).
- */
-declare function useStreamedArtifact({ artifacts, workspaceId, settled, clean, onCleaned, configId, parseRetry, }: UseStreamedArtifactOptions): StreamedArtifact;
-
-/**
- * Which live renderer, if any, an artifact maps to. Kept free of heavy imports (no compiler) so the
- * document viewer can use it without pulling the preview code into its bundle.
- *
- * The backend persists an artifact's render mode in the saved file's extension: .html / .jsx are live
- * artifacts; document drafts are stored as .docx and open in the Word editor.
- */
-type ArtifactPreviewKind = 'html' | 'react';
-declare function artifactKindFromFileName(fileName?: string | null): ArtifactPreviewKind | null;
-declare function artifactKindFromMode(mode?: string | null): ArtifactPreviewKind | null;
-/**
- * The viewer tab an artifact opens on: a generated image on its media view ('pdf'), an html/react
- * artifact on its rendered Preview, and a document draft (stored as .docx) in the Word editor.
- */
-declare function viewerTabForArtifactMode(mode?: string | null): 'pdf' | 'preview' | 'edit';
-
-export { type ArtifactEditSession, type ArtifactEditSessionOptions, type ArtifactPreviewKind, type ArtifactRedlineComponents, type ArtifactSaveResult, type ArtifactSession, type ArtifactSessionOptions, type ArtifactSessionView, type ArtifactText, type ArtifactTextRetry, type ArtifactTextStatus, type ArtifactVersion, DEFAULT_ARTIFACT_TEXT_RETRY, type DocVersionEntry, DraftCleanReport, type RedlineEngine, RedlineRegion, type RedlineState, RedlineWithRegions, type SaveArtifactVersionInput, type StreamedArtifact, type StreamedArtifactPhase, type UseRedlineOptions, type UseRedlineResult, type UseStreamedArtifactOptions, type VersionedDoc, artifactKindFromFileName, artifactKindFromMode, documentVersions, findVersion, flattenChunks, isDocumentId, mainThreadRedlineEngine, parseVersionRef, renderArtifactMarkdown, savedFromId, toArtifactVersions, useArtifactEditSession, useArtifactSession, useArtifactSource, useArtifactText, useArtifactVersions, useRedline, useSaveArtifactVersion, useStreamedArtifact, versionLabel, versionRef, viewerTabForArtifactMode };

package/dist/artifacts/redline-core.d.cts

@@ -1,39 +0,0 @@
-/**
- * Redline diff core
- *
- * Pure (no DOM, no Worker globals) logic for building a Word-style redline
- * markdown string from two flattened document texts. Lives outside the
- * worker file so it's straightforward to unit test.
- *
- * Strategy: hybrid line + word diff with structural safety.
- *  1. `diffLines` splits the texts into add/remove/equal blocks.
- *  2. For an adjacent [removed, added] pair (a modified region):
- *     - If either side contains markdown structure that can't safely host
- *       inline tags (code fences, table rows, horizontal rules), fall back
- *       to block-level wrapping (whole-line del/ins, line by line).
- *     - Otherwise run `diffWords`. Markdown leading markers (#, -, *, 1., >)
- *       become unchanged word tokens, so when only the heading/list text
- *       changes the marker stays *outside* the inline tags and the heading
- *       still parses.
- *  3. Pure removed / added blocks (no paired counterpart) are wrapped
- *     line-by-line so structural prefixes stay outside the tag.
- */
-declare function buildHybridRedlineMarkdown(rawBase: string, rawCompare: string): string;
-type RegionKind = 'replace' | 'remove' | 'add' | 'move';
-interface RedlineRegion {
-    id: string;
-    kind: RegionKind;
-    baseText: string;
-    compareText: string;
-}
-interface RedlineWithRegions {
-    markdown: string;
-    regions: RedlineRegion[];
-}
-declare function buildHybridRedlineWithRegions(rawBase: string, rawCompare: string): RedlineWithRegions;
-declare function revertRedlineRegion(rawBase: string, rawCompare: string, targetId: string): string;
-
-/** Normalise markdown to its canonical spelling. Falls back to a light cleanup if parsing throws. */
-declare function normalizeMarkdown(text: string): string;
-
-export { type RedlineRegion, type RedlineWithRegions, type RegionKind, buildHybridRedlineMarkdown, buildHybridRedlineWithRegions, normalizeMarkdown, revertRedlineRegion };

package/dist/bundle-YNOX7VIL.js

@@ -1,5 +0,0 @@
-export { buildBundle } from './chunk-NIKPG4PW.js';
-import './chunk-PTOP7OHG.js';
-import './chunk-T3USOSVN.js';
-//# sourceMappingURL=bundle-YNOX7VIL.js.map
-//# sourceMappingURL=bundle-YNOX7VIL.js.map

package/dist/bundle-YNOX7VIL.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"bundle-YNOX7VIL.js"}

package/dist/bundle.d-BnCSbHy2.d.cts

@@ -1,85 +0,0 @@
-/**
- * Page stamps for a production set: a Bates label and an optional QR code. Both are drawn as
- * plain vector content on a white plate, in the DISPLAYED frame, so cropped and rotated pages come
- * out upright. They are added to a document that is already frozen: nothing here can bring back
- * content a redaction removed.
- */
-
-type StampCorner = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
-interface BatesOptions {
-    /** Text before the number, e.g. `ACME-`. Plain characters a standard font can draw. */
-    prefix?: string;
-    /** First number. Default 1. */
-    start?: number;
-    /** Zero-pad the number to this many digits. Default 6. */
-    digits?: number;
-    corner?: StampCorner;
-}
-declare function batesLabel(options: BatesOptions, index: number): string;
-
-/**
- * Production bundle: take documents that are ALREADY frozen (or never needed freezing) and number
- * them consecutively with a Bates label, optionally adding a QR code that links back to the
- * document in ARBI.
- *
- * `merged` joins the documents into one PDF; `per-document` keeps one PDF each. Either way the
- * numbering runs on across the whole set in the order given, so a label is unique within the
- * production. Splitting a document is deliberately not part of this.
- *
- * `indexPage` adds an index first (every document with its Bates range): the first page(s) of a
- * merged file, or an `index.pdf` of its own ahead of the per-document files. It is not numbered.
- */
-
-type BundleLayout = 'merged' | 'per-document';
-interface BundleItem {
-    /** Shown in the index and used to name the output file. */
-    name: string;
-    /** External id of the document this PDF represents. */
-    documentId: string;
-    /** PDF bytes, normally the output of `freezePdf`. */
-    bytes: Uint8Array;
-    /** What the QR code opens. Required for every item when `qr` is on. */
-    qrUrl?: string;
-}
-interface BundleOptions {
-    layout: BundleLayout;
-    bates: BatesOptions;
-    /** Add a QR code (to each item's `qrUrl`) on every page. Default false. */
-    qr?: boolean;
-    qrCorner?: StampCorner;
-    /** Name of the merged file. Default `production.pdf`. */
-    mergedName?: string;
-    /** Put an index page (documents and Bates ranges) at the start. Default false. */
-    indexPage?: boolean;
-    /** ISO timestamp; defaults to now. Injectable for deterministic tests. */
-    now?: string;
-    /** Who produced the set; recorded in a merged file's metadata. */
-    author?: string;
-    onProgress?: (done: number, total: number) => void;
-    signal?: AbortSignal;
-}
-interface BundleIndexEntry {
-    documentId: string;
-    name: string;
-    /** The output file that holds this document. */
-    file: string;
-    pages: number;
-    firstLabel: string;
-    lastLabel: string;
-}
-interface BundleFile {
-    name: string;
-    bytes: Uint8Array;
-    pages: number;
-    firstLabel: string;
-    lastLabel: string;
-}
-interface BundleResult {
-    files: BundleFile[];
-    index: BundleIndexEntry[];
-    /** Index pages added at the start (0 without `indexPage`). */
-    indexPages: number;
-}
-declare function buildBundle(items: BundleItem[], options: BundleOptions): Promise<BundleResult>;
-
-export { type BatesOptions as B, type StampCorner as S, type BundleFile as a, type BundleIndexEntry as b, type BundleItem as c, type BundleLayout as d, type BundleOptions as e, type BundleResult as f, batesLabel as g, buildBundle as h };