@vectojs/markdown 0.23.3 → 0.25.0

package/dist/markdown-image.d.ts

@@ -1,5 +1,10 @@
 import type { InlineObjectBox, InlineObjectSurface } from '@vectojs/core';
 import type { Token, Tokens } from 'marked';
+import type { ImageSource } from '@vectojs/ui';
+/** Resolve a markdown image `src` to a generic {@link ImageSource}. */
+export type MarkdownImageResolver = (src: string) => ImageSource | Promise<ImageSource>;
+/** Default resolver — identity mapping to `{kind:'url'}`. */
+export declare const defaultMarkdownImageResolver: MarkdownImageResolver;
 /**
  * Image predicates over a `marked` token tree, plus the raster store for images
  * that render *inline* rather than as their own block.
@@ -75,16 +80,26 @@ export declare function lastIndexOfImage(tokens: Token[]): number;
  * `InlineObject`, and the box it occupies is fixed when the span is collected, so
  * the natural size has to be readable from here before the next layout rather than
  * applied to an entity afterwards.
+ *
+ * Supports generic {@link ImageSource}: `url` decodes via `HTMLImageElement`,
+ * `blob` via `createImageBitmap` (with object-URL fallback), and `bitmap` is used
+ * directly. The backing `source` is the `CanvasImageSource` drawn by
+ * `paintInlineImage`; `bitmap` is retained as a legacy alias for `url` rasters so
+ * existing tests that reach through `raster.bitmap` keep working.
  */
 export interface InlineImageRaster {
     /** `undefined` when this environment has no `Image` (SSR, plain unit tests). */
     bitmap?: HTMLImageElement;
+    /** Generic backing source for `IRenderer.drawImage` / `InlineObjectSurface`. */
+    source?: CanvasImageSource;
     decoded: boolean;
     /** Natural size, known only once decoded. */
     naturalWidth?: number;
     naturalHeight?: number;
     /** Set when the decode failed, so a broken URL is not retried every frame. */
     failed?: boolean;
+    /** Release `ImageBitmap` / revoke `blob:` URL when evicted or cleared. */
+    dispose?: () => void;
 }
 /** Subscribe `notify` to inline-image decodes. Idempotent per closure. */
 export declare function subscribeInlineImageRaster(notify: () => void): void;
@@ -102,14 +117,22 @@ export declare function unsubscribeInlineImageRaster(notify: () => void): void;
  * paint path calls it on every visible frame, and only the first call starts a
  * decode. Exported because the span collector needs the natural size to size its
  * box, which is the whole reason this store reports one.
+ *
+ * When a resolver is supplied, its result (which may be `blob` or `bitmap`) is
+ * decoded instead of the raw `src` URL. Resolver may be async — the raster stays
+ * square until the promise settles, then notifies waiters so the owner can
+ * re-measure.
  */
-export declare function ensureInlineImageRaster(src: string): InlineImageRaster;
+export declare function ensureInlineImageRaster(src: string, resolver?: MarkdownImageResolver): InlineImageRaster;
 /**
  * Paint one inline image into the box the layout engine reserved for it.
  *
  * Draws nothing until the raster decodes — one frame of empty box, then a repaint
  * through {@link inlineImageRasterWaiters}. Mirrors `paintInlineMath`; a
  * placeholder slab would flash a grey rectangle mid-sentence on every first paint.
+ *
+ * Supports generic {@link ImageSource} backing: `source` may be an `ImageBitmap`
+ * or an `HTMLImageElement`.
  */
 export declare function paintInlineImage(src: string, surface: InlineObjectSurface, box: InlineObjectBox): void;
 /** Drop every cached raster. Tests only — a decode is process-wide state. */

package/dist/markdown-inline.d.ts

@@ -1,6 +1,7 @@
 import { type StyledSpan, type TextStyle } from '@vectojs/core';
 import { RichText } from '@vectojs/ui';
 import type { Token } from 'marked';
+import { type MarkdownImageResolver } from './markdown-image';
 import type { MarkdownTheme } from './theme';
 /**
  * Inline tokens to `RichText` spans: the entity decoder, the span collector and
@@ -62,7 +63,14 @@ blockFontSize?: number,
  * call site that has none to thread — nested recursive calls, and callers
  * predating this feature — costs nothing extra.
  */
-abbr?: ReadonlyMap<string, string>): void;
+abbr?: ReadonlyMap<string, string>, 
+/**
+ * How a markdown image `src` becomes a generic {@link ImageSource}. When
+ * omitted the default identity `{kind:'url'}` mapping is used, so a plain
+ * `![alt](https://…)` keeps its historic path and an app can supply a
+ * CapGlyph adapter that returns `{kind:'bitmap'}` for `capglyph:` URLs.
+ */
+imageResolver?: MarkdownImageResolver): void;
 /**
  * One trailing inline construct that has opened but not closed yet.
  *
@@ -93,4 +101,4 @@ export declare function findUnclosedInline(text: string): UnclosedInline | null;
 /** Parse inline markdown tokens and produce a {@link RichText} entity. */
 export declare function renderInlineToRichText(tokens: Token[] | undefined, fallbackText: string, font: string, color: string, maxWidth: number, theme: Required<MarkdownTheme>, selectable: boolean, onLinkClick?: (url: string) => void, 
 /** The document's `*[TERM]: definition` dictionary — see {@link emitProse}. */
-abbr?: ReadonlyMap<string, string>): RichText;
+abbr?: ReadonlyMap<string, string>, imageResolver?: MarkdownImageResolver): RichText;

package/dist/projection-policy.d.ts

@@ -0,0 +1,54 @@
+import { Entity } from '@vectojs/core';
+import { Stack } from '@vectojs/ui';
+/**
+ * Markdown projection-policy switcher (RFC4 §6 dogfood, CTX-0601).
+ *
+ * Assigns the per-block `domPolicy`/`domKind` the capability negotiation
+ * (`Scene.resolveProjectionFor`) consumes. DOM-free plain data only: this
+ * module never creates an element — the `'prose'`/`'code'` kind specs that
+ * materialize blocks live with the backend (the dogfood page registers them
+ * on `DOMProjection`; custom backends register their own).
+ *
+ * Block → kind mapping (the §4 matrix in Markdown terms):
+ *
+ * - ui `Text` / `RichText` (headings, paragraphs) → `'prose'`:
+ *   long/selectable text whose native value (selection, Ctrl+F, translation)
+ *   outweighs DOM cost, so `'auto'` resolves `dom`.
+ * - `CodeBlock` → `'code'`: selectable source text; `'auto'` rests on
+ *   `canvas` (row default) until measured, explicit `'dom'` materializes it.
+ * - `Table` → `''` (unsupported-kind): composite interactive widget, stays
+ *   canvas with a reported reason.
+ * - Grouping wrappers (children present, no specific class) → `'container'`:
+ *   never materialized itself; children negotiate individually.
+ * - Anything else (rules, borders, backgrounds) → `''`: canvas leaves.
+ *
+ * Kinds are assigned to top-level blocks only; nested content keeps its own
+ * `domKind` (default `''` → canvas, reported) until a finer pass tags it.
+ */
+/** Dogfood switcher mode (RFC4 §6): forced canvas, forced dom, or negotiated. */
+export type MarkdownProjectionMode = 'canvas' | 'dom' | 'hybrid';
+/** One top-level document block with its negotiation kind. */
+export interface ClassifiedProjectionBlock {
+    node: Entity;
+    /** Stable human label for readouts (`index: Class (role)`). */
+    label: string;
+    /** `domKind` for negotiation; `''` means canvas-only (reported fallback). */
+    domKind: string;
+}
+/** Classify one top-level block (see module doc for the mapping). */
+export declare function classifyProjectionBlock(node: Entity, index: number): ClassifiedProjectionBlock;
+/**
+ * Top-level blocks of a document's content stack, in order, with kinds
+ * assigned onto the blocks (idempotent — re-running keeps prior kinds).
+ */
+export declare function classifyProjectionBlocks(content: Stack): ClassifiedProjectionBlock[];
+/**
+ * Apply a switcher mode to a whole Markdown subtree (kinds must already be
+ * assigned via {@link classifyProjectionBlocks} or by hand):
+ *
+ * - `'canvas'` — every node `'canvas'`: byte-identical to today.
+ * - `'dom'` — `'dom'` where the node has a materializable kind
+ *   (`'prose'`/`'code'`), `'canvas'` elsewhere (tables, figures, chrome).
+ * - `'hybrid'` — every node `'auto'`: the engine negotiates per block.
+ */
+export declare function applyProjectionMode(root: Entity, mode: MarkdownProjectionMode): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectojs/markdown",
-  "version": "0.23.3",
+  "version": "0.25.0",
   "publishConfig": {
     "access": "public"
   },
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@vectojs/tex": "^0.1.3",
-    "marked": "^18.0.10"
+    "marked": "^18.0.11"
   },
   "peerDependencies": {
     "@vectojs/core": ">=1.34.0 <2.0.0",
@@ -56,7 +56,7 @@
     "@vectojs/ui": "workspace:*",
     "esbuild": "^0.28.1",
     "prettier": "^3.9.6",
-    "puppeteer-core": "^25.8.0",
+    "puppeteer-core": "^25.9.0",
     "tsup": "^8.3.5",
     "vitest": "^4.1.11"
   }