@openpresentation/opf-editor 0.8.0 → 0.10.0

package/README.md

@@ -2,7 +2,9 @@
 
 Unfinished prepared shaping work is preserved in the [September 15 roadmap](docs/roadmap-shaping-20260915.md); it is not part of the published runtime.
 
-Version 0.8.0 requires `@openpresentation/opf` ^0.11.0, renderer ^0.9.0, and PPTX ^0.9.0. Named ColorRefs (scheme slots, roles, and `var:<id>`) paint through the published renderer and hex-resolve on export. Payload ids share the slide id namespace for pagination and transfer. Native `schemeClr`, theme write, and `p:hf` remain out of scope.
+Version 0.10.0 requires `@openpresentation/opf` ^0.11.2, renderer ^0.11.0, and PPTX ^0.11.0 (install them together so cover centering resolves the same core everywhere; renderer 0.11.0 also activates the playground's automatic script fonts and lazy Intos fonts). Version 0.9.0 required `@openpresentation/opf` ^0.11.1, renderer ^0.10.0, and PPTX ^0.10.0. Composition and slide transfer fall back to the shared `aptos` font scheme and report unknown scheme ids through `onDiagnostic`; gallery apply keeps every font-scheme role.
+
+Version 0.8.0 required `@openpresentation/opf` ^0.11.0, renderer ^0.9.0, and PPTX ^0.9.0. Named ColorRefs (scheme slots, roles, and `var:<id>`) paint through the published renderer and hex-resolve on export. Payload ids share the slide id namespace for pagination and transfer. Native `schemeClr`, theme write, and `p:hf` remain out of scope.
 
 Version 0.7.0 and this checkout require Node 24 (`24.x`). Use `.nvmrc` for local development. Earlier published versions retain their original engine declarations. Browser entrypoints remain browser-safe; native application compatibility is verified separately.
 
@@ -70,7 +72,7 @@ await canvas.ready;
 // canvas.destroy() when unmounting.
 ```
 
-Load the same font bytes into the browser using `loadBrowserFontRegistry` from `@openpresentation/opf-render/fonts-browser` before mounting. The host owns font URLs, storage and collaboration. `onDraft` provides live document drafts; the session only changes on commit. Escape cancels. Concurrent edits to the selected payload cancel a stale draft.
+Load the same font bytes into the browser using `loadBrowserFontRegistry` from `@openpresentation/opf-render/fonts-browser` before mounting. The host owns font URLs, storage and collaboration. For non-Latin documents, pass the pinned script pack's location as `scriptBaseUrl` and call `fonts.ensureScripts(document)` after edits (renderer with `scripts: 'auto'`, FF-19): only the faces for the scripts a document draws are fetched, once, hash-verified, for example Noto Sans JP for Japanese; a Latin-only document fetches none. The playground does this from `./script-fonts/`, which `npm run build:playground` fills with the pinned faces. `onDraft` provides live document drafts; the session only changes on commit. Escape cancels. Concurrent edits to the selected payload cancel a stale draft.
 
 These APIs were introduced in 0.1.0. Version 0.7.0 requires core 0.10.0 and renderer 0.8.0 for the canvas, including shared accepted geometry, styled/merged cells, rich table values, headers and content-aware row heights. See the OPF repository’s `docs/live-editor.md` for setup, the support matrix and roadmap. `pnpm pack:ecosystem` in that repository also prepares local preview tarballs for coordinated development.
 
@@ -162,6 +164,43 @@ toolbar.append(themeSelect);
 
 Invalid IDs throw before they reach the document. Existing object-form references keep their sibling override fields and replace only `id`.
 
+## Dimension switches
+
+`@openpresentation/opf-editor/switches` turns "switch this pptx.gallery dimension to X" into one validated, undoable transaction. It covers the 14 gallery dimensions (FF-16, [font-fidelity-everywhere](https://github.com/OpenPresentation/opf/tree/main/docs/programs/font-fidelity-everywhere)):
+
+```js
+import { switchDimension, prepareDimensionSwitch, SWITCH_DIMENSIONS } from "@openpresentation/opf-editor/switches";
+
+switchDimension(editor, "font-schemes", "georgia");                      // /design/fontScheme
+switchDimension(editor, "charts", "line", { slideIndex: 1 });            // /slides/1/chart/type
+switchDimension(editor, "blocks", "list", { path: "slides.2.blocks.0" }); // replace one block
+editor.undo();                                                            // one step per switch
+const { patches, document } = prepareDimensionSwitch(editor.document, "themes", "classic"); // preview only
+```
+
+| Dimension | Document patch | Notes |
+| --- | --- | --- |
+| `layouts` | `/slides/N/layout` | Needs `slideIndex`. Adds the blank payloads the layout declares, like the JSON editor's layout choice; existing content stays. |
+| `color-schemes`, `font-schemes` | `/design/colorScheme`, `/design/fontScheme` | Deck by default, one slide with `slideIndex`. An inline object value is replaced by the bare id. |
+| `themes` | `/design/theme` plus the theme's color scheme, font scheme, background and dimensions | Writes the whole bundle, as the gallery's theme snippet does, so fonts follow. `bundle: false` changes only the id. |
+| `languages`, `narratives`, `tones`, `audiences` | `/language`, `/narrative`, `/tone`, `/audience` | Catalog ids; `audiences` accepts an id or an array. |
+| `backgrounds` | `/design/background` | A background object or a shorthand string (theme slot such as `dark1`, or a hex color). |
+| `headers-footers` | `/design/header`, `/design/footer` | `{header?, footer?}`: an absent field stays, `null` removes it. |
+| `image-treatments` | `/design/slideImage`, `/design/imageFill` | `{slideImage?, imageFill?}`, same rule. |
+| `socials` | `/speaker/socials/<platform>` or the `organization` | `{platform, handle}` with `owner` and `index`; the owner must exist. |
+| `charts` | `<chart owner>/chart/type` | The slide's first chart, or the block named by `path`. The data is kept as it is and only the document schema is checked: the editor does not verify that the data suits the new type, so preview the result (map types, for example, expect their own data). |
+| `blocks` | replaces one block | `path` names a complete `blocks/N` block or a slide/region with one content field. The value is a block kind or a block object. |
+
+A deck-level design switch cannot reach a slide that carries its own value for that key. The result lists those slides in `shadowed`; `clearSlideOverrides: true` removes the overrides in the same transaction. `record` adds a gallery item's catalog record inline in the same transaction when neither the document nor the bundled catalog defines its id (a gallery-only layout or font scheme). Every switch is validated: an unknown catalog id, an invalid value or an invalid resulting document throws before anything changes, and switching to the current value commits nothing. The editor session emits the usual `patch`, `undo` and `redo` events with `meta.source: "dimension-switch"` and `meta.dimension`, so the canvas and any host preview recompose from the switched document. `resolveSlideFonts(document, slideIndex)` returns the heading, body and code families the preview measures and the export names.
+
+### Content-type conversion: replacement only (FF-16 decision)
+
+The editor does not convert one content type into another. `blocks` is block replacement only: the old payload is discarded (text is not turned into list items, a list into a chart, and so on) and the block keeps only its `id` and `extensions`. Author the replacement content explicitly, or insert and remove blocks. This release provides no conversion API.
+
+### What a switch does not establish
+
+A switch changes the document; it does not change what the engines support. Language changes recompose fonts only as far as the installed core, renderer and PPTX packages implement the language and script model (FF-18, FF-19); the editor's own composition measures the Latin families. `image-treatments` previews only where the installed renderer draws `design.slideImage`. `test/switches.mjs` checks the patch, one undo step, undo/redo, and preview refresh for all 14 dimensions. `test/switches-export.mjs` exports after each switch, undo and redo and applies opf-pptx's FF-08 typeface check (`checkPptxTypefaces`) when the installed package has it; set `OPF_REQUIRE_FF08=1` to fail instead of skip when it does not. Published opf-pptx 0.9.1 does not include it.
+
 ## Optional React Bindings
 
 React bindings are isolated under `@openpresentation/opf-editor/react` and require the host app to pass its React runtime. The core package does not add React to the critical path.
@@ -198,21 +237,17 @@ Svelte bindings are isolated under `@openpresentation/opf-editor/svelte` as acti
 
 ## Release Lane
 
-Public npm package publication is handled by `.github/workflows/release.yml` with npm provenance.
-
-Required first-publish setup:
-
-1. An npm owner for the `@openpresentation` scope must run the first publish or reserve/grant the `@openpresentation/opf-editor` package.
-2. Configure npm Trusted Publishing for GitHub repository `OpenPresentation/opf-editor` and workflow `.github/workflows/release.yml`.
-3. Publish by creating a GitHub Release or manually running the Release workflow after CI passes.
+Public npm package publication is handled by `.github/workflows/release.yml` through npm Trusted Publishing (GitHub Actions OIDC) with npm provenance; no npm token is stored. The owner authorized agents to prepare and publish npm releases whenever a release is required (2026-09-29). This authorization does not waive any gate.
 
-This repo does not require an npm automation token when Trusted Publishing is configured.
+1. Open a release-prep PR containing only the version bump, `CHANGELOG.md`, dependency ranges, lockfile and current-instruction docs. Publish in dependency order (core, then renderer, then PPTX, then editor): refresh this repo's lockfile only after the required `@openpresentation/opf`, `@openpresentation/opf-render` and `@openpresentation/opf-pptx` versions are on the registry (`npm install --package-lock-only`), then run `npm run test:packed` against them.
+2. Merge after CI is green, then publish by pushing the git tag `opf-editor-v<version>` (or `@openpresentation/opf-editor@v<version>`) at the merge commit. The workflow verifies that the tag matches `package.json` and reruns audit, typecheck, validate, tests, playground, code/JSON browser and packed checks before `npm publish --access public --provenance`. A manual `workflow_dispatch` runs the same job without the tag check and is a fallback only.
+3. Verify with `npm view @openpresentation/opf-editor@<version> version gitHead dist.attestations` and, from the core repo, `node scripts/test-editor-publication.mjs <version> <release-commit> <this-checkout>`. Never republish an existing version.
 
 ## Shared dynamic composition
 
 The current checkout uses `@openpresentation/opf/composition` for portable geometry. Slides can select `auto`, `row`, `column`, or `grid`, set weighted tracks, and request path-specific overflow diagnostics. See the sibling OPF repo's `docs/dynamic-composition.md` for the complete contract.
 
-Version 0.8.0 requires `@openpresentation/opf@^0.11.0`. The optional renderer peer requires `@openpresentation/opf-render@^0.9.0`. Coordinated playground export uses `@openpresentation/opf-pptx@^0.9.0`. Clean registry installs support the composition APIs without sibling checkouts. For coordinated source development, build OPF and run `node scripts/link-ecosystem.mjs` there; `pnpm test:ecosystem` verifies shared geometry and import/export behavior.
+Version 0.10.0 requires `@openpresentation/opf@^0.11.2`. The optional renderer peer requires `@openpresentation/opf-render@^0.11.0`. Coordinated playground export uses `@openpresentation/opf-pptx@^0.11.0`. Clean registry installs support the composition APIs without sibling checkouts. For coordinated source development, build OPF and run `node scripts/link-ecosystem.mjs` there; `pnpm test:ecosystem` verifies shared geometry and import/export behavior.
 
 ## Local interactive demo
 
@@ -224,7 +259,7 @@ Nested content groups expose their bounds through `editor.composeSlide(index).gr
 
 `editor.paginateSlide(index, {minFontSize:24})` splits a crowded draft into ordinary OPF slides as one undoable transaction. It returns the change and source mappings; failed pagination leaves the document unchanged. The playground’s Split overflow action demonstrates the workflow.
 
-`composeSlide(index, {textMeasurement})` and `paginateSlide(index, {textMeasurement})` accept the same font provider as preview and export. The local playground now uses bundled, embedded fonts and reports substitutions.
+`composeSlide(index, {textMeasurement})` and `paginateSlide(index, {textMeasurement})` accept the same font provider as preview and export. The local playground now uses bundled, embedded fonts and reports substitutions. The font a user selects (for example Calibri or Aptos) is the source of truth and stays in the document; because license-restricted (proprietary) fonts are never bundled, the canvas draws an open look-alike (a metric-compatible one such as Carlito for Calibri where it exists, a visual-only fallback for Aptos today) and the substitution report says so. Release caveat: the published editor depends on opf-pptx `^0.9.0`, which resolves 0.9.1 and still writes the substitute into the PPTX; selected-name export arrives with the next opf-pptx release. See the [OPF font policy](https://github.com/OpenPresentation/opf/blob/main/docs/font-fidelity.md#font-policy-ff-31).
 
 
 ## Copy, paste, and gallery imports
@@ -235,7 +270,7 @@ The `/galleries` export provides `loadOpfGallery` and `loadOpfGalleryItem`, acce
 
 The playground includes Copy OPF and Import dialogs with paste, file/drop, gallery search, and URL tabs. Files accept OPF JSON and PowerPoint `.pptx` up to 20 MB. PPTX conversion runs locally using `@openpresentation/opf-pptx`; review the converted preview and diagnostics before inserting slides or opening a presentation. Applying an import is one undoable edit. Custom registries persist in local storage; defaults are configured in `examples/galleries.json`. Copy permissions may require using the Select all fallback. Pasting within text fields keeps normal text editing. Cmd/Ctrl+Shift+C opens copying and Cmd/Ctrl+O opens file import.
 
-The **PowerPoint** button commits the current canvas draft and prepares an editable `.pptx` download from that snapshot, using the preview's text measurements. Conversion diagnostics remain visible in the download dialog. Missing/remote images require an explicit host resolver or embedded data; export does not silently fetch them or omit them. Save OPF separately to retain the complete original source. Native fonts must be installed in PowerPoint; the download does not embed font binaries. Arbitrary native positions and unsupported PowerPoint features can change during reimport.
+The **PowerPoint** button commits the current canvas draft and prepares an editable `.pptx` download from that snapshot, using the preview's text measurements. Conversion diagnostics remain visible in the download dialog. Missing/remote images require an explicit host resolver or embedded data; export does not silently fetch them or omit them. Save OPF separately to retain the complete original source. With an opf-pptx that includes FF-31 (after 0.9.1), the download names the font the user selected, never the preview look-alike, so PowerPoint shows that font when it is installed or available as a Microsoft 365 cloud font; opf-pptx 0.9.1, which the published editor resolves today, still writes the substitute. The download does not embed font binaries, and license-restricted (proprietary) fonts are never embedded. Arbitrary native positions and unsupported PowerPoint features can change during reimport.
 
 Run `npm ci`, `npm run build:playground`, then serve `artifacts/playground` with a local static server. This example uses the published core/render/PPTX packages and this checkout's editor source; it does not require an account, AI provider or paid service. `npm run test:playground` builds and executes a real browser flow (local Edge on Windows, installed Chromium in CI): author JSON, inline edit, export a native merged table, validate/reimport the actual downloaded file, undo/redo, save OPF and reject malformed input without changing the document. It is browser behavior evidence, not a claim of native PowerPoint raster equivalence.
 

package/dist/blocks.d.ts

@@ -9,5 +9,7 @@ export interface PreparedBlockChange { document:unknown;patches:JsonPatchOperati
 export declare function prepareBlockInsert(document:unknown,containerPath:string,block:unknown,index?:number):PreparedBlockChange;
 export declare function prepareBlockDuplicate(document:unknown,path:string):PreparedBlockChange;
 export declare function prepareBlockRemove(document:unknown,path:string):PreparedBlockChange;
+/** Replace one complete block (or a slide/region's single content field). Replacement only: the old payload is discarded and nothing is converted between content types. Keeps `id` and `extensions` when the new block sets none. */
+export declare function prepareBlockReplace(document:unknown,path:string,block:unknown):PreparedBlockChange;
 export type ContentBlockKind='text'|'list'|'chart'|'table'|'metric'|'quote'|'code'|'timeline'|'group'|'image'|'video';
 export declare function createContentBlock(kind:ContentBlockKind,options?:{source?:string}):Record<string,unknown>;

package/dist/blocks.js

@@ -83,6 +83,39 @@ function checkedBlock(document,path) {
   if(index>=blocks.length)throw new RangeError('Block does not exist.');
   return {parts,container,index,blocks};
 }
+/**
+ * Replace one complete block with another block. This is block replacement only (FF-16):
+ * the old payload is discarded and nothing is converted into the new content type. The
+ * block keeps its `id` and `extensions` when the new block sets none. An implicit slide or
+ * region payload (exactly one content field, no `blocks`) is replaced in place, keeping its
+ * other slide fields. The test guard fails if the block changed since it was read.
+ */
+export function prepareBlockReplace(document,path,block) {
+  if(!block||typeof block!=='object'||Array.isArray(block))throw new TypeError('Replace with an OPF content block object.');
+  const parts=splitOpfPath(path),pointer=opfPathToJsonPointer(parts);
+  const explicit=parts.at(-2)==='blocks'&&/^(0|[1-9][0-9]*)$/.test(parts.at(-1)??'');
+  let old,next;
+  if(explicit){
+    const {index,blocks}=checkedBlock(document,path);
+    old=blocks[index];
+    next=structuredClone(block);
+    for(const key of ['id','extensions'])if(next[key]===undefined&&old[key]!==undefined)next[key]=structuredClone(old[key]);
+  } else {
+    const implicit=listBlockContainers(document,{includeImplicit:true}).find(c=>c.path===pointer&&c.implicit);
+    if(!implicit)throw new TypeError('Choose a complete block using its blocks/index path, or a slide or region with one content field.');
+    if(implicit.count!==1)throw new TypeError('This slide or region holds several content fields. Choose one block, or insert and remove blocks.');
+    old=getValueAtPath(document,parts);
+    next=structuredClone(old);
+    for(const key of [...contentFields,'type'])delete next[key];
+    // The block's own id and extensions would overwrite the slide's; they are not carried over.
+    const {id:ignoredId,extensions:ignoredExtensions,...payload}=structuredClone(block);
+    Object.assign(next,payload);
+  }
+  const patches=[{op:'test',path:pointer,value:structuredClone(old)},{op:'replace',path:pointer,value:next}];
+  const result=applyJsonPatch(document,patches),validation=validateOpfDocument(result);
+  if(!validation.valid)throw new Error(validation.errors[0]?.message??'The replaced block is not valid OPF.');
+  return {document:result,patches,path:pointer,changed:JSON.stringify(old)!==JSON.stringify(next)};
+}
 /** Duplicate the entire block immediately after itself, preserving formatting and asset references. */
 export function prepareBlockDuplicate(document,path) {
   const {container,index,blocks}=checkedBlock(document,path);

package/dist/canvas.d.ts

@@ -54,6 +54,15 @@ export interface CanvasEditor {
   setRenderOptions(options: RenderSvgOptions): boolean;
   destroy(): void;
 }
+export declare function allocatedSelectionBox(
+  node: {
+    dataset?: DOMStringMap | Record<string, string>;
+    hasAttribute?(name: string): boolean;
+    getAttribute?(name: string): string | null;
+    getBBox?(): { x: number; y: number; width: number; height: number };
+  },
+  item?: { box?: { x: number; y: number; width: number; height: number } },
+): { x: number; y: number; width: number; height: number };
 export declare function createCanvasEditor(
   container: HTMLElement,
   options: CanvasEditorOptions,

package/dist/canvas.js

@@ -21,6 +21,38 @@ import { createRichTextInput } from "./rich-text-input.js";
 import { createRichTextToolbar } from "./rich-text-toolbar.js";
 export { getEditableFields } from "./canvas-fields.js";
 
+/** Allocated placeholder or internal-part bounds for the selection outline, not glyph ink. */
+export function allocatedSelectionBox(node, item) {
+  const traced = {
+    x: Number(node.dataset?.opfBoxX),
+    y: Number(node.dataset?.opfBoxY),
+    width: Number(node.dataset?.opfBoxWidth),
+    height: Number(node.dataset?.opfBoxHeight),
+  };
+  const hasTraced = [traced.x, traced.y, traced.width, traced.height].every(Number.isFinite) && (traced.width > 0 || traced.height > 0);
+  const partRole = typeof node.hasAttribute === "function" && (
+    node.hasAttribute("data-opf-code-role") ||
+    node.hasAttribute("data-opf-metric-role") ||
+    node.hasAttribute("data-opf-source-text")
+  );
+  if (partRole && hasTraced) return traced;
+  if (item?.box && [item.box.x, item.box.y, item.box.width, item.box.height].every(Number.isFinite)) {
+    return { x: item.box.x, y: item.box.y, width: item.box.width, height: item.box.height };
+  }
+  if (hasTraced) return traced;
+  let bounds = typeof node.getBBox === "function" ? node.getBBox() : { x: 0, y: 0, width: 0, height: 0 };
+  const lines = JSON.parse(node.getAttribute?.("data-opf-rich-lines") ?? "[]");
+  if (!bounds.width && !bounds.height && lines.length) {
+    return {
+      x: lines[0].x,
+      y: lines[0].y,
+      width: Number(node.getAttribute("data-opf-box-width")) || 8,
+      height: lines.reduce((sum, line) => sum + line.height, 0),
+    };
+  }
+  return bounds;
+}
+
 /** A framework-independent SVG canvas. Drafts render immediately; each edit commits once. */
 export function createCanvasEditor(container, options = {}) {
   if (!container?.ownerDocument)
@@ -160,10 +192,7 @@ export function createCanvasEditor(container, options = {}) {
         `Edit ${path.split(".").at(-1)}: ${["string", "number"].includes(typeof value) ? String(value).slice(0, 80) : "content properties"}`,
       );
       if (node.matches("g")) {
-        let bounds = node.getBBox();
-        if (!bounds.width && !bounds.height && (node.hasAttribute('data-opf-code-role')||node.hasAttribute('data-opf-metric-role')||node.hasAttribute('data-opf-source-text'))) bounds={x:Number(node.dataset.opfBoxX),y:Number(node.dataset.opfBoxY),width:Number(node.dataset.opfBoxWidth),height:Number(node.dataset.opfBoxHeight)};
-        const lines = JSON.parse(node.getAttribute("data-opf-rich-lines") ?? "[]");
-        if (!bounds.width && !bounds.height && lines.length) bounds = {x:lines[0].x,y:lines[0].y,width:Number(node.getAttribute("data-opf-box-width"))||8,height:lines.reduce((sum,line)=>sum+line.height,0)};
+        const bounds = allocatedSelectionBox(node, item);
         const rect = doc.createElementNS("http://www.w3.org/2000/svg", "rect");
         for (const [key, value] of Object.entries({
           x: bounds.x - 4,

package/dist/exact-source.js

@@ -0,0 +1,318 @@
+import { applyEdits, findNodeAtLocation, modify, parseTree } from "jsonc-parser";
+
+// Exact-source memory. Editing a slide rewrites only the tokens whose values changed, but a
+// value that later returns (Escape, Undo, Redo) would otherwise be re-serialized with
+// JSON.stringify, which turns an authored `"Café \/ Q1"` into `"Café / Q1"`. The memory
+// keeps the exact source bytes of documents that were seen, keyed by the parsed value.
+//
+// Limits: a source longer than MAX_EXACT_SOURCE_LENGTH characters is not remembered, and the
+// memory holds at most 64 sources and 8 MB in total (oldest evicted first). Edits keep working
+// beyond those limits, but restoring an edited value then uses normalized JSON spelling; the
+// memory reports this through `memory.limited` so a host can tell the author.
+export const MAX_EXACT_SOURCE_LENGTH = 2_000_000;
+const DEFAULT_LIMIT = 64;
+const DEFAULT_MAX_BYTES = 8_000_000;
+
+/**
+ * `last` is the last generated document and, when it came from typing into one existing string
+ * value, that value's path. A further edit of the same value replaces that transient state
+ * instead of crowding out older ones, so a long draft cannot evict the authored spelling.
+ * Discrete edits (add, remove, move) never coalesce.
+ */
+export function createSourceMemory(limit = DEFAULT_LIMIT, maxBytes = DEFAULT_MAX_BYTES) {
+  return { entries: new Map(), bytes: 0, last: null, limit, maxBytes, limited: false };
+}
+
+const sharedMemory = createSourceMemory();
+
+function forget(memory, key) {
+  const source = memory.entries.get(key);
+  if (source === undefined) return;
+  memory.bytes -= source.length;
+  memory.entries.delete(key);
+}
+
+function remember(memory, key, source) {
+  forget(memory, key);
+  if (source.length > MAX_EXACT_SOURCE_LENGTH) return;
+  memory.entries.set(key, source);
+  memory.bytes += source.length;
+  while ((memory.entries.size > memory.limit || memory.bytes > memory.maxBytes) && memory.entries.size > 1) {
+    forget(memory, memory.entries.keys().next().value);
+  }
+}
+
+function recall(memory, key) {
+  const source = memory.entries.get(key);
+  if (source === undefined) return undefined;
+  try {
+    if (JSON.stringify(JSON.parse(source)) === key) {
+      memory.entries.delete(key);
+      memory.entries.set(key, source);
+      return source;
+    }
+  } catch { /* An entry that no longer parses to this value is discarded. */ }
+  forget(memory, key);
+  return undefined;
+}
+
+const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const compare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+const canonical = (value) => JSON.stringify(value, (_name, item) => isObject(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => compare(a, b))) : item);
+
+/** The first duplicate object key in JSON source, as `{ key, path }`, or null. */
+export function findDuplicateKey(source) {
+  const tree = parseTree(source);
+  function walk(node, path) {
+    if (node.type === "object") {
+      const seen = new Set();
+      for (const property of node.children ?? []) {
+        const name = property.children?.[0]?.value;
+        if (seen.has(name)) return { key: name, path: [...path] };
+        seen.add(name);
+        const found = property.children?.[1] && walk(property.children[1], [...path, name]);
+        if (found) return found;
+      }
+    } else if (node.type === "array") {
+      for (const [index, child] of (node.children ?? []).entries()) {
+        const found = walk(child, [...path, index]);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  return tree ? walk(tree, []) : null;
+}
+
+const own = (object, name) => (Object.hasOwn(object, name) ? object[name] : undefined);
+const text = (value) => JSON.stringify(value);
+
+// Value differences as edit operations, all in the coordinates of the source being edited:
+//   replace  a leaf or subtree gets a new token
+//   copy     a slot of a same-length array takes the exact token of an equal element (a move)
+//   remove   an array element or object key is removed
+//   insert   an array element or object key is added
+// Reading goes through own properties only, so keys such as "__proto__" or "constructor" are
+// ordinary keys.
+function diff(before, after, path, ops) {
+  if (text(before) === text(after)) return;
+  if (Array.isArray(before) && Array.isArray(after)) {
+    const beforeKeys = before.map(text), afterKeys = after.map(text);
+    if (before.length === after.length) {
+      const holders = new Map();
+      beforeKeys.forEach((key, index) => { if (!holders.has(key)) holders.set(key, index); });
+      after.forEach((value, index) => {
+        if (beforeKeys[index] === afterKeys[index]) return;
+        const from = holders.get(afterKeys[index]);
+        if (from !== undefined) ops.push({ kind: "copy", path: [...path, index], from: [...path, from] });
+        else diff(before[index], value, [...path, index], ops);
+      });
+      return;
+    }
+    let head = 0;
+    while (head < before.length && head < after.length && beforeKeys[head] === afterKeys[head]) head++;
+    let tail = 0;
+    while (tail < before.length - head && tail < after.length - head && beforeKeys[before.length - 1 - tail] === afterKeys[after.length - 1 - tail]) tail++;
+    const removed = before.length - head - tail, inserted = after.length - head - tail, paired = Math.min(removed, inserted);
+    for (let offset = 0; offset < paired; offset++) diff(before[head + offset], after[head + offset], [...path, head + offset], ops);
+    for (let offset = removed - 1; offset >= paired; offset--) ops.push({ kind: "remove", path: [...path, head + offset] });
+    for (let offset = paired; offset < inserted; offset++) ops.push({ kind: "insert", path: [...path, head + offset], value: after[head + offset] });
+  } else if (isObject(before) && isObject(after)) {
+    for (const name of new Set([...Object.keys(before), ...Object.keys(after)])) {
+      const a = own(before, name), b = own(after, name);
+      if (a !== undefined && b !== undefined) diff(a, b, [...path, name], ops);
+      else if (a !== undefined) ops.push({ kind: "remove", path: [...path, name] });
+      else if (b !== undefined) ops.push({ kind: "insert", path: [...path, name], value: b });
+    }
+  } else ops.push({ kind: "replace", path, value: after });
+}
+
+// The smallest nodes that contain every edit: a changed value, or the object or array that gains
+// or loses a child.
+const maskPaths = (ops) => ops.map((op) => (op.kind === "remove" || op.kind === "insert" ? op.path.slice(0, -1) : op.path));
+
+function masked(source, paths) {
+  const tree = parseTree(source);
+  if (!tree) return null;
+  const ranges = [];
+  for (const path of paths) {
+    const node = findNodeAtLocation(tree, path);
+    if (!node) return null;
+    ranges.push([node.offset, node.offset + node.length]);
+  }
+  ranges.sort((a, b) => a[0] - b[0]);
+  let output = "", cursor = 0;
+  for (const [start, end] of ranges) {
+    if (start < cursor) { cursor = Math.max(cursor, end); continue; }
+    output += source.slice(cursor, start) + "\u0000";
+    cursor = end;
+  }
+  return output + source.slice(cursor);
+}
+
+// A remembered source may replace the current one only when both are byte-equal outside the
+// edited nodes: manual respellings elsewhere are never reverted.
+function equalOutside(current, remembered, paths) {
+  const a = masked(current, paths);
+  return a !== null && a === masked(remembered, paths);
+}
+
+function rememberedToken(remembered, tree, path, value) {
+  if (!tree) return undefined;
+  const node = findNodeAtLocation(tree, path);
+  if (!node) return undefined;
+  const token = remembered.slice(node.offset, node.offset + node.length);
+  try { if (canonical(JSON.parse(token)) === canonical(value)) return token; } catch { /* Not the same value. */ }
+  return undefined;
+}
+
+function layout(source) {
+  const indent = source.match(/^[\t ]+(?=\S)/m)?.[0] ?? "  ";
+  const eol = source.includes("\r\n") ? "\r\n" : "\n";
+  return { indent, eol, formattingOptions: { insertSpaces: !indent.includes("\t"), tabSize: indent.length, eol } };
+}
+
+// Insert a child (array element or object property) next to its siblings without reformatting
+// them: copy a representative separator, indentation included, from between two siblings.
+function insertChild(source, container, index, render) {
+  const children = container.children ?? [];
+  if (!children.length) return null;
+  const end = (node) => node.offset + node.length;
+  let separator;
+  if (children.length > 1) {
+    const at = Math.min(Math.max(index - 1, 0), children.length - 2);
+    separator = source.slice(end(children[at]), children[at + 1].offset);
+  } else {
+    const gap = source.slice(container.offset + 1, children[0].offset);
+    separator = gap.includes("\n") ? "," + gap : ", ";
+  }
+  if (!/^[\s,]*$/.test(separator) || !separator.includes(",")) return null;
+  const multiline = separator.includes("\n");
+  const indent = multiline ? separator.slice(separator.lastIndexOf("\n") + 1) : "";
+  const item = render(indent, multiline);
+  if (index < children.length) return source.slice(0, children[index].offset) + item + separator + source.slice(children[index].offset);
+  const last = end(children[children.length - 1]);
+  return source.slice(0, last) + separator + item + source.slice(last);
+}
+
+// Remove a child by its tree range, so the siblings keep their bytes: a last child goes with the
+// separator before it, any other child with the separator after it, and an only child empties the
+// container (`[]`, `{}`) instead of leaving a blank body.
+function removeChild(source, path) {
+  const node = findNodeAtLocation(parseTree(source), path);
+  if (!node) throw new Error("Missing node");
+  const child = node.parent?.type === "property" ? node.parent : node;
+  const parent = child.parent;
+  const siblings = parent.children;
+  const index = siblings.indexOf(child);
+  const end = (item) => item.offset + item.length;
+  let from, to;
+  if (siblings.length === 1) { from = parent.offset + 1; to = end(parent) - 1; }
+  else if (index < siblings.length - 1) { from = child.offset; to = siblings[index + 1].offset; }
+  else { from = end(siblings[index - 1]); to = end(child); }
+  return source.slice(0, from) + source.slice(to);
+}
+
+// Typing into one existing string value is the only edit whose intermediate states are worth
+// forgetting. Every discrete edit (add, remove, move) stays exactly restorable.
+function typingSignature(previous, ops) {
+  if (ops.length !== 1 || ops[0].kind !== "replace" || typeof ops[0].value !== "string") return null;
+  let value = previous;
+  for (const step of ops[0].path) {
+    if (value === null || typeof value !== "object" || !Object.hasOwn(value, step)) return null;
+    value = value[step];
+  }
+  return typeof value === "string" ? JSON.stringify(ops[0].path) : null;
+}
+
+/**
+ * Change only the affected values. Keeps authored indentation, escaping and all unrelated
+ * metadata/content byte-for-byte, including across canvas Escape, Undo and Redo.
+ * Throws when `source` is not valid JSON. The result always parses to `document`; if an
+ * in-place edit cannot achieve that (for example the source repeats an object key), the whole
+ * document is written as indented JSON instead.
+ */
+export function updateJsonSource(source, document, memory = sharedMemory) {
+  const previous = JSON.parse(source);
+  const previousKey = JSON.stringify(previous);
+  memory.limited = source.length > MAX_EXACT_SOURCE_LENGTH;
+  if (memory.entries.get(previousKey) !== source) {
+    // The current bytes were not produced here (initial source, typing, paste): they are the
+    // spelling to restore.
+    remember(memory, previousKey, source);
+    memory.last = null;
+  }
+  const ops = [];
+  diff(previous, document, [], ops);
+  if (!ops.length) return source;
+  const key = JSON.stringify(document);
+  const remembered = recall(memory, key);
+  if (remembered !== undefined && equalOutside(source, remembered, maskPaths(ops))) {
+    memory.last = null;
+    return remembered;
+  }
+  const rememberedTree = remembered === undefined ? null : parseTree(remembered);
+
+  const { indent, eol, formattingOptions } = layout(source);
+  const unit = indent.includes("\t") ? "\t" : indent;
+  const pretty = (value, lineIndent) => JSON.stringify(value, null, unit).split("\n").join(eol + lineIndent);
+  let result = source;
+  // Insertion copies the neighbours' separator; an empty container is written in the document's style.
+  function insert(path, value) {
+    const parentPath = path.slice(0, -1), last = path[path.length - 1];
+    const parent = findNodeAtLocation(parseTree(result), parentPath);
+    const isArray = typeof last === "number";
+    const container = parent && (parent.type === "array" || parent.type === "object");
+    const spliced = container
+      ? insertChild(result, parent, isArray ? last : parent.children?.length ?? 0, (lineIndent, multiline) => isArray
+        ? (multiline ? pretty(value, lineIndent) : text(value))
+        : `${text(last)}${multiline ? ": " : ":"}${multiline ? pretty(value, lineIndent) : text(value)}`)
+      : null;
+    if (spliced !== null) result = spliced;
+    else if (container && !parent.children?.length) {
+      const written = isArray ? [value] : Object.defineProperty({}, last, { value, enumerable: true, writable: true, configurable: true });
+      const lineIndent = result.slice(result.lastIndexOf("\n", parent.offset) + 1, parent.offset).match(/^[\t ]*/)[0];
+      const content = result.includes("\n") ? pretty(written, lineIndent) : text(written);
+      result = result.slice(0, parent.offset) + content + result.slice(parent.offset + parent.length);
+    } else result = applyEdits(result, modify(result, path, value, { formattingOptions, isArrayInsertion: isArray }));
+  }
+  try {
+    // Replacements and moves are position-independent: parse once and apply them back to front.
+    const tree = parseTree(source);
+    const edits = [];
+    for (const op of ops) {
+      if (op.kind !== "replace" && op.kind !== "copy") continue;
+      const node = findNodeAtLocation(tree, op.path);
+      if (!node) throw new Error("Missing node");
+      let token;
+      if (op.kind === "copy") {
+        const from = findNodeAtLocation(tree, op.from);
+        if (!from) throw new Error("Missing node");
+        token = source.slice(from.offset, from.offset + from.length);
+      } else token = rememberedToken(remembered, rememberedTree, op.path, op.value) ?? text(op.value);
+      edits.push({ from: node.offset, to: node.offset + node.length, token });
+    }
+    edits.sort((a, b) => b.from - a.from);
+    for (const edit of edits) result = result.slice(0, edit.from) + edit.token + result.slice(edit.to);
+    // Structural edits follow, in the order they were produced.
+    for (const op of ops) {
+      if (op.kind === "remove") result = removeChild(result, op.path);
+      else if (op.kind === "insert") insert(op.path, op.value);
+    }
+  } catch { result = ""; }
+  let valid = false;
+  try {
+    const parsed = JSON.parse(result);
+    valid = JSON.stringify(parsed) === key || canonical(parsed) === canonical(JSON.parse(key));
+  } catch { /* Fall back below. */ }
+  if (!valid) {
+    result = JSON.stringify(document, null, indent).replaceAll("\n", eol);
+    if (/\n$/.test(source)) result += eol;
+  }
+
+  const signature = typingSignature(previous, ops);
+  if (signature !== null && memory.last && memory.last.key === previousKey && memory.last.signature === signature) forget(memory, previousKey);
+  remember(memory, key, result);
+  memory.last = { key, signature };
+  return result;
+}

package/dist/font-defaults.js

@@ -0,0 +1,25 @@
+/**
+ * Last-resort font scheme id, shared with core pagination, opf-render and opf-pptx
+ * (`DEFAULT_FONT_SCHEME` in `@openpresentation/opf`). It applies only when neither the
+ * slide, the deck nor the resolved theme names a font scheme, so the editor measures and
+ * freezes the same fonts that preview and PowerPoint export use.
+ * Kept local until the published core exports the constant; a test asserts they agree.
+ */
+export const DEFAULT_FONT_SCHEME = "aptos";
+
+/**
+ * Resolve a font-scheme reference by the shared rule (`resolveFontSchemeReference` in
+ * `@openpresentation/opf`). An id that matches no record yields one
+ * `unresolved-font-scheme` diagnostic and uses the DEFAULT_FONT_SCHEME record as the base,
+ * with sibling overrides on top. Kept local until a published core exports the function;
+ * a test compares both whenever the installed core has it.
+ */
+export function resolveFontSchemeReference(reference, lookup, path = "design.fontScheme") {
+  const overrides = reference && typeof reference === "object" && !Array.isArray(reference) ? reference : undefined;
+  const id = typeof reference === "string" ? reference : typeof overrides?.id === "string" ? overrides.id : undefined;
+  const found = id === undefined ? undefined : lookup(id);
+  const base = found ?? lookup(DEFAULT_FONT_SCHEME) ?? {};
+  const scheme = overrides ? { ...base, ...overrides } : { ...base };
+  if (id === undefined || found !== undefined) return { scheme };
+  return { scheme, diagnostic: { code: "unresolved-font-scheme", path, id, fallback: DEFAULT_FONT_SCHEME, message: `Font scheme '${id}' is not in the inline or bundled catalogs; using the default font scheme '${DEFAULT_FONT_SCHEME}'.` } };
+}