@openleaf-editor/core 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/disclosure.js

@@ -0,0 +1,144 @@
+/**
+ * Make `<details>` open and close while editing.
+ *
+ * Outside a contenteditable the browser toggles a `<details>` when its
+ * `<summary>` is clicked, and nothing has to be written for it. Inside one that
+ * default action does not happen: the click is spent placing a caret, so the
+ * element stays in whatever state it was parsed in.
+ *
+ * The consequence is worse than a control that does nothing. A `<details>` parsed
+ * without `open` renders collapsed, and its contents are then unreachable --
+ * there is no gesture that expands it, so an author cannot edit or even read the
+ * body of a collapsible section they already have in a document.
+ *
+ * So the toggle is written by hand, against the node's own `open` attribute
+ * rather than the DOM's. That is what makes the state part of the document and
+ * therefore part of what round-trips; toggling the element directly would be
+ * undone by the next redraw.
+ */
+import { Plugin, PluginKey, TextSelection } from 'prosemirror-state';
+const key = new PluginKey('openleaf-disclosure');
+export function disclosurePlugin() {
+    return new Plugin({
+        key,
+        props: {
+            handleDOMEvents: {
+                /*
+                 * A DOM listener rather than `handleClickOn`.
+                 *
+                 * ProseMirror calls `handleClickOn` for each node around the click from
+                 * the inside out, and whether the summary arrives as the direct node
+                 * depends on whether the pointer landed on its text, its marker or its
+                 * padding. That made the toggle fire on some clicks and not others --
+                 * the section appeared stuck open, which is worse than not working at
+                 * all, because it looks like the state is wrong rather than the control.
+                 *
+                 * The target's nearest `<summary>` is not ambiguous.
+                 */
+                click(view, event) {
+                    const target = event.target;
+                    if (!target)
+                        return false;
+                    const from = target.nodeType === 1 ? target : target.parentElement;
+                    const summary = from?.closest?.('summary');
+                    if (!summary || !view.dom.contains(summary))
+                        return false;
+                    /*
+                     * `handleDOMEvents` runs before ProseMirror's `view.editable` check
+                     * (`runCustomHandler` is first in `initInput`). Typing, paste, drop
+                     * and the keymaps get that gate for free; this click does not, so a
+                     * read-only editor still flipped `open` and fired `openleaf:change`.
+                     *
+                     * `view.editable` rather than the host's `readonly` attribute, same
+                     * as the table context menu and the media resize handle: it is the
+                     * flag ProseMirror itself consults, the element derives it from the
+                     * attribute, and a view mounted without the custom element can set
+                     * it directly.
+                     *
+                     * Returning false, not swallowing the event: outside contenteditable
+                     * the browser toggles a `<details>` natively, so collapsed sections
+                     * stay readable without writing the node. `preventDefault` below is
+                     * only needed when we own the toggle.
+                     */
+                    if (!view.editable)
+                        return false;
+                    const $pos = view.state.doc.resolve(view.posAtDOM(summary, 0));
+                    for (let depth = $pos.depth; depth >= 0; depth -= 1) {
+                        const node = $pos.node(depth);
+                        if (node.type.name !== 'details')
+                            continue;
+                        // Once the element carries `open`, the browser's own activation
+                        // behaviour for a summary works again and fires alongside this --
+                        // two toggles that cancel. Only one may act, and it has to be this
+                        // one: the DOM's idea of open is discarded on the next redraw, the
+                        // node's is what round-trips.
+                        event.preventDefault();
+                        /*
+                         * Put the caret in the label explicitly.
+                         *
+                         * `setNodeMarkup` replaces the details node, and a selection mapped
+                         * through a replacement does not reliably survive it: Chromium kept
+                         * the caret and Firefox dropped it, which left the label uneditable
+                         * in one browser and not the other. Where the click already landed
+                         * inside the label is preferred, so clicking a word still puts the
+                         * caret at that word; otherwise it goes to the end of the label.
+                         */
+                        const detailsPos = $pos.before(depth);
+                        const summaryNode = node.firstChild;
+                        const labelFrom = detailsPos + 2;
+                        const labelTo = labelFrom + (summaryNode?.content.size ?? 0);
+                        const clicked = view.state.selection.from;
+                        const caret = clicked >= labelFrom && clicked <= labelTo ? clicked : labelTo;
+                        const tr = view.state.tr.setNodeMarkup(detailsPos, undefined, {
+                            ...node.attrs,
+                            open: !node.attrs['open'],
+                        });
+                        tr.setSelection(TextSelection.near(tr.doc.resolve(tr.mapping.map(caret))));
+                        /*
+                         * Keep the toggle off the undo stack.
+                         *
+                         * `open` lives in the document, so flipping it is by every mechanical
+                         * measure a document change: it is a step, it maps positions, it
+                         * serializes on save. History would take it on those grounds alone.
+                         *
+                         * But the undo stack does not model changes to the document, it
+                         * models an author's intent to have made them, and expanding a
+                         * section in order to read it is not an edit -- it is how you look at
+                         * a document whose parts are folded away. An author who opened three
+                         * collapsed sections while hunting for a paragraph, fixed a typo in
+                         * the third and pressed Ctrl+Z got the typo back and the section
+                         * closed under them; the correction they meant to take back was four
+                         * undos away, behind their own navigation. Losing the ability to undo
+                         * a fold costs nothing -- the gesture that made it is one click away
+                         * and visible on screen -- while losing the edit next to it costs the
+                         * work.
+                         *
+                         * `addToHistory: false` is the key `prosemirror-history` reads to
+                         * exclude a transaction; the attribute still changes, and still
+                         * round-trips.
+                         */
+                        tr.setMeta('addToHistory', false);
+                        view.dispatch(tr);
+                        /*
+                         * And take the focus, because clicking a summary does not give it.
+                         *
+                         * `<summary>` is a natively focusable widget, and Firefox declines to
+                         * put a caret in one inside a contenteditable -- focus stayed on
+                         * `<body>`, so the selection above was correct and every keystroke
+                         * still went nowhere. Handling the click means owning the focus that
+                         * the default action would otherwise have arranged.
+                         */
+                        if (!view.hasFocus())
+                            view.focus();
+                        // False, not true: ProseMirror still gets to finish its own handling
+                        // of the click. Swallowing it here changed nothing for the better and
+                        // made the interaction harder to reason about.
+                        return false;
+                    }
+                    return false;
+                },
+            },
+        },
+    });
+}
+//# sourceMappingURL=disclosure.js.map

package/dist/disclosure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"disclosure.js","sourceRoot":"","sources":["../src/disclosure.ts"],"names":[],"mappings":"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"}

package/dist/elements.d.ts

@@ -0,0 +1,2 @@
+export * from '@openleaf-editor/content-policy/elements';
+//# sourceMappingURL=elements.d.ts.map

package/dist/elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elements.d.ts","sourceRoot":"","sources":["../src/elements.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAA"}

package/dist/elements.js

@@ -0,0 +1,2 @@
+export * from '@openleaf-editor/content-policy/elements';
+//# sourceMappingURL=elements.js.map

package/dist/elements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elements.js","sourceRoot":"","sources":["../src/elements.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAA"}

package/dist/embed.d.ts

@@ -1,52 +1,2 @@
-/**
- * Which `<iframe>` sources the schema will store.
- *
- * An iframe is a nested browsing context. Allowing an arbitrary `src` is
- * allowing a third-party page to run in yours, which is why the preservation
- * layer used to drop every iframe it saw. Modelling embeds at all means
- * answering "which hosts, on which paths, over which scheme" in one place --
- * here -- so the schema, the insert command and `@openleaf-editor/sanitize`
- * cannot drift.
- *
- * Relative iframe URLs are refused: a CMS that later hosts an uploaded HTML
- * file at a relative path would otherwise turn a stored embed into a stored
- * XSS. `http:` is refused for the same reason every other URL check prefers
- * an allowlist of schemes: mixed content is not an embed, it is a warning.
- */
-export interface EmbedHostRule {
-    /** Hostname, compared case-insensitively, with a leading `www.` ignored. */
-    readonly host: string;
-    /** Path that must match. Absent means any path on that host. */
-    readonly path?: RegExp;
-}
-/**
- * Hosts an author may embed.
- *
- * Each rule is a known player page, not a whole site. `youtube.com/` would
- * let an author embed `youtube.com/watch` as a nested YouTube UI; `/embed/`
- * is the documented iframe URL.
- */
-export declare const EMBED_HOSTS: readonly EmbedHostRule[];
-/** True when this URL is an https embed the schema will store. */
-export declare function isAllowedEmbedSrc(value: string | null | undefined): boolean;
-/** The URL, or null when it must not be stored as an iframe `src`. */
-export declare function safeEmbedSrc(value: string | null | undefined): string | null;
-/**
- * Permissions policy tokens an iframe may advertise.
- *
- * Anything not in the closed set is dropped rather than stored: `allow` is how
- * an embed asks to skip the sandbox the rest of the page lives in.
- *
- * The attribute is a **semicolon**-delimited list of directives, each one a
- * feature name followed by an optional origin allowlist -- `camera 'self';
- * fullscreen *`. Splitting on whitespace instead read the standard YouTube
- * string `allow="autoplay; fullscreen; picture-in-picture"` as the tokens
- * "autoplay;" and "fullscreen;", so only the last survived, and a trailing
- * semicolon lost every permission the author had.
- *
- * Only the feature name is kept. Dropping the origin allowlist leaves the
- * attribute's default, which is the frame's own origin -- so `camera *` narrows
- * to the embed itself rather than being stored as written.
- */
-export declare function safeAllowList(value: string | null | undefined): string | null;
+export * from '@openleaf-editor/content-policy/embed';
 //# sourceMappingURL=embed.d.ts.map

package/dist/embed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embed.d.ts","sourceRoot":"","sources":["../src/embed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,gEAAgE;IAChE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,aAAa,EAS/C,CAAA;AA8BD,kEAAkE;AAClE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAY3E;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAE5E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAW7E"}
+{"version":3,"file":"embed.d.ts","sourceRoot":"","sources":["../src/embed.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAA"}

package/dist/embed.js

@@ -1,116 +1,2 @@
-/**
- * Which `<iframe>` sources the schema will store.
- *
- * An iframe is a nested browsing context. Allowing an arbitrary `src` is
- * allowing a third-party page to run in yours, which is why the preservation
- * layer used to drop every iframe it saw. Modelling embeds at all means
- * answering "which hosts, on which paths, over which scheme" in one place --
- * here -- so the schema, the insert command and `@openleaf-editor/sanitize`
- * cannot drift.
- *
- * Relative iframe URLs are refused: a CMS that later hosts an uploaded HTML
- * file at a relative path would otherwise turn a stored embed into a stored
- * XSS. `http:` is refused for the same reason every other URL check prefers
- * an allowlist of schemes: mixed content is not an embed, it is a warning.
- */
-import { isSafeUrl } from './url.js';
-/**
- * Hosts an author may embed.
- *
- * Each rule is a known player page, not a whole site. `youtube.com/` would
- * let an author embed `youtube.com/watch` as a nested YouTube UI; `/embed/`
- * is the documented iframe URL.
- */
-export const EMBED_HOSTS = [
-    { host: 'youtube.com', path: /^\/embed\// },
-    { host: 'youtube-nocookie.com', path: /^\/embed\// },
-    { host: 'player.vimeo.com', path: /^\/video\// },
-    { host: 'dailymotion.com', path: /^\/embed\// },
-    { host: 'player.twitch.tv' },
-    { host: 'w.soundcloud.com', path: /^\/player\/?/ },
-    { host: 'open.spotify.com', path: /^\/embed\// },
-    { host: 'google.com', path: /^\/maps\/embed/ },
-];
-const ALLOW_TOKENS = new Set([
-    'accelerometer',
-    'autoplay',
-    'clipboard-write',
-    'encrypted-media',
-    'fullscreen',
-    'gyroscope',
-    'picture-in-picture',
-    'web-share',
-]);
-function hostnameOf(value) {
-    try {
-        const url = new URL(value);
-        return url.hostname.replace(/^www\./i, '').toLowerCase();
-    }
-    catch {
-        return '';
-    }
-}
-function parsed(value) {
-    try {
-        return new URL(value);
-    }
-    catch {
-        return null;
-    }
-}
-/** True when this URL is an https embed the schema will store. */
-export function isAllowedEmbedSrc(value) {
-    if (value === null || value === undefined)
-        return false;
-    if (!isSafeUrl(value))
-        return false;
-    const url = parsed(value.trim());
-    if (!url)
-        return false;
-    if (url.protocol !== 'https:')
-        return false;
-    const host = hostnameOf(value);
-    return EMBED_HOSTS.some((rule) => {
-        if (rule.host !== host)
-            return false;
-        if (!rule.path)
-            return true;
-        return rule.path.test(url.pathname);
-    });
-}
-/** The URL, or null when it must not be stored as an iframe `src`. */
-export function safeEmbedSrc(value) {
-    return isAllowedEmbedSrc(value) ? value : null;
-}
-/**
- * Permissions policy tokens an iframe may advertise.
- *
- * Anything not in the closed set is dropped rather than stored: `allow` is how
- * an embed asks to skip the sandbox the rest of the page lives in.
- *
- * The attribute is a **semicolon**-delimited list of directives, each one a
- * feature name followed by an optional origin allowlist -- `camera 'self';
- * fullscreen *`. Splitting on whitespace instead read the standard YouTube
- * string `allow="autoplay; fullscreen; picture-in-picture"` as the tokens
- * "autoplay;" and "fullscreen;", so only the last survived, and a trailing
- * semicolon lost every permission the author had.
- *
- * Only the feature name is kept. Dropping the origin allowlist leaves the
- * attribute's default, which is the frame's own origin -- so `camera *` narrows
- * to the embed itself rather than being stored as written.
- */
-export function safeAllowList(value) {
-    if (value === null || value === undefined)
-        return null;
-    const kept = [];
-    const seen = new Set();
-    for (const directive of value.split(';')) {
-        const name = (directive.trim().split(/\s+/)[0] ?? '').toLowerCase();
-        if (!ALLOW_TOKENS.has(name) || seen.has(name))
-            continue;
-        seen.add(name);
-        kept.push(name);
-    }
-    return kept.length > 0 ? kept.join('; ') : null;
-}
+export * from '@openleaf-editor/content-policy/embed';
 //# sourceMappingURL=embed.js.map

package/dist/embed.js.map

@@ -1 +1 @@
-{"version":3,"file":"embed.js","sourceRoot":"","sources":["../src/embed.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"embed.js","sourceRoot":"","sources":["../src/embed.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAA"}

package/dist/errors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The one error type OpenLeaf throws on purpose.
+ *
+ * Before this there were four styles and no way to tell them apart: `parseHtml`
+ * coerced anything to an empty document, `serializeHtml(null)` surfaced a raw
+ * ProseMirror `TypeError` with nothing naming OpenLeaf in it, a bad
+ * `registerEditorPlugin` argument was accepted and failed much later through
+ * `console.error`, and a schema collision threw on some unrelated later call.
+ * A `catch` block could not distinguish "the integrator passed the wrong thing"
+ * from "the library has a bug", so integrators either swallowed everything or
+ * nothing.
+ *
+ * `code` is the stable part. Messages are for people and may be reworded; the
+ * code is what a `catch` should switch on.
+ */
+export type OpenLeafErrorCode = 
+/** A public function was called with a value it cannot accept. */
+'invalid-argument'
+/** Input nests deeper than the recursive DOM walks can survive. */
+ | 'depth-limit'
+/** Two schema extensions define the same node or mark name. */
+ | 'schema-conflict'
+/** No `Document` was available and none was supplied. */
+ | 'no-document';
+export declare class OpenLeafError extends Error {
+    readonly code: OpenLeafErrorCode;
+    constructor(code: OpenLeafErrorCode, message: string, options?: ErrorOptions);
+}
+/**
+ * A duck check rather than `instanceof`.
+ *
+ * Two copies of `@openleaf-editor/core` on one page -- which the plugin bundles
+ * exist to prevent but a mis-pinned install still produces -- have two distinct
+ * `OpenLeafError` classes, and `instanceof` is false across them. The code is
+ * what callers actually branch on, so that is what this checks.
+ */
+export declare function isOpenLeafError(value: unknown, code?: OpenLeafErrorCode): boolean;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,MAAM,iBAAiB;AAC3B,kEAAkE;AAChE,kBAAkB;AACpB,mEAAmE;GACjE,aAAa;AACf,+DAA+D;GAC7D,iBAAiB;AACnB,yDAAyD;GACvD,aAAa,CAAA;AAEjB,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;gBAEpB,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAQ7E;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAGjF"}

package/dist/errors.js

@@ -0,0 +1,40 @@
+/**
+ * The one error type OpenLeaf throws on purpose.
+ *
+ * Before this there were four styles and no way to tell them apart: `parseHtml`
+ * coerced anything to an empty document, `serializeHtml(null)` surfaced a raw
+ * ProseMirror `TypeError` with nothing naming OpenLeaf in it, a bad
+ * `registerEditorPlugin` argument was accepted and failed much later through
+ * `console.error`, and a schema collision threw on some unrelated later call.
+ * A `catch` block could not distinguish "the integrator passed the wrong thing"
+ * from "the library has a bug", so integrators either swallowed everything or
+ * nothing.
+ *
+ * `code` is the stable part. Messages are for people and may be reworded; the
+ * code is what a `catch` should switch on.
+ */
+export class OpenLeafError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        // Set explicitly rather than via a class field: a field would be an own
+        // property on every instance, and `name` is conventionally read off the
+        // prototype chain by anything formatting an error.
+        this.name = 'OpenLeafError';
+    }
+}
+/**
+ * A duck check rather than `instanceof`.
+ *
+ * Two copies of `@openleaf-editor/core` on one page -- which the plugin bundles
+ * exist to prevent but a mis-pinned install still produces -- have two distinct
+ * `OpenLeafError` classes, and `instanceof` is false across them. The code is
+ * what callers actually branch on, so that is what this checks.
+ */
+export function isOpenLeafError(value, code) {
+    if (!(value instanceof Error) || value.name !== 'OpenLeafError')
+        return false;
+    return code === undefined || value.code === code;
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAYH,MAAM,OAAO,aAAc,SAAQ,KAAK;IAC7B,IAAI,CAAmB;IAEhC,YAAY,IAAuB,EAAE,OAAe,EAAE,OAAsB;QAC1E,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,wEAAwE;QACxE,wEAAwE;QACxE,mDAAmD;QACnD,IAAI,CAAC,IAAI,GAAG,eAAe,CAAA;IAC7B,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,KAAc,EAAE,IAAwB;IACtE,IAAI,CAAC,CAAC,KAAK,YAAY,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,eAAe;QAAE,OAAO,KAAK,CAAA;IAC7E,OAAO,IAAI,KAAK,SAAS,IAAK,KAAuB,CAAC,IAAI,KAAK,IAAI,CAAA;AACrE,CAAC"}

package/dist/extensions.d.ts

@@ -51,15 +51,28 @@ export interface SchemaExtension {
     /**
      * Re-emit attributes the spec does not model. Defaults to true.
      *
-     * Adding a node type strictly *reduces* fidelity for the tag it claims: before
-     * the node existed, the preservation layer kept the element and every
-     * attribute on it; afterwards the spec keeps only what it declares. A callout
-     * node modelling `class` silently drops `id` and `data-analytics` that used to
-     * survive.
+     * Adding a node or mark type strictly *reduces* fidelity for the tag it
+     * claims: before the type existed, the preservation layer kept the element
+     * and every attribute on it; afterwards the spec keeps only what it declares.
+     * A callout node modelling `class` silently drops `id` and `data-analytics`
+     * that used to survive, and a `strong` mark used to drop `class` the same way.
      *
      * So unmodelled attributes are captured on parse and merged back on
      * serialize, by default, at schema-build time -- which means an author cannot
      * opt out by forgetting.
+     *
+     * ## Setting this to `false` is security-relevant
+     *
+     * The capture is also where `on*` handlers and unsafe URL schemes are
+     * filtered out of the residue -- see `withCarriedAttributes` below. Turning
+     * the carry off skips the wrapper entirely, and with it that filter, so a
+     * spec's own `getAttrs` becomes the only thing standing between pasted
+     * `onclick` and the stored document.
+     *
+     * It exists for specs that already model every attribute they claim, where
+     * carrying would emit the same value twice. It is not a performance knob, and
+     * a plugin that sets it is making a decision `SECURITY.md` documents under
+     * "Plugin trust model". If you set it, your `getAttrs` owns the scrub.
      */
     readonly carryUnknownAttributes?: boolean;
 }
@@ -86,6 +99,34 @@ export declare function createSchema(list?: readonly SchemaExtension[]): Schema;
  * "bind to this" and would be captured at import by every consumer, which is
  * exactly what made the schema impossible to extend. Memoized, and invalidated
  * whenever the registry changes.
+ *
+ * ## Why the subscription is in here and not at module scope
+ *
+ * This package declares `"sideEffects": false`, which is a literal promise that
+ * evaluating a module for its own sake changes nothing observable. The bare
+ * top-level `onSchemaExtensionsChange(() => { cached = null })` that used to sit
+ * below this function broke that promise: it mutates the listener set in the
+ * registry above, which is observable by anything that calls `notify()`.
+ *
+ * What it did *not* do, measured rather than assumed, is actually get dropped.
+ * Both rollup 4 (`treeshake.moduleSideEffects: false`) and webpack 5
+ * (`optimization.sideEffects`) keep the statement, because the arrow function
+ * writes `cached` and `cached` is read by this function -- so the tree-shaker
+ * can see the statement contributes to a live export and retains it. A probe
+ * that warms the memo, registers an extension and re-reads the schema returns
+ * the plugin's node type under both bundlers, before and after this change.
+ *
+ * It is moved anyway, because the retention depended entirely on that linkage
+ * being visible. It is not a property of the invalidator; it is a property of
+ * this particular pair of statements, and it would quietly stop holding the
+ * moment the memo is refactored -- at which point the failure is silent and
+ * total, since `coreSchema()` would keep handing back a schema built before the
+ * first `registerSchemaExtension` call. Registering on the first call costs a
+ * boolean and makes the flag true instead of true-by-luck.
+ *
+ * There is no window in which the invalidator is missing: the subscription is
+ * installed before the value it guards ever exists, and nothing can reach the
+ * memo except through here.
  */
 export declare function coreSchema(): Schema;
 //# sourceMappingURL=extensions.d.ts.map

package/dist/extensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../src/extensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,EACL,MAAM,EAEN,KAAK,QAAQ,EACb,KAAK,QAAQ,EAGd,MAAM,mBAAmB,CAAA;AAW1B,MAAM,WAAW,eAAe;IAC9B,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,gEAAgE;IAChE,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAA;IACnD,iCAAiC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAA;IACnD,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACrC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAA;CAC1C;AAED,gFAAgF;AAChF,eAAO,MAAM,YAAY,sBAAsB,CAAA;AAmB/C;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,eAAe,GAAG,MAAM,IAAI,CAe9E;AAED,wBAAgB,0BAA0B,IAAI,SAAS,eAAe,EAAE,CAEvE;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAKzE;AAED,gDAAgD;AAChD,wBAAgB,qBAAqB,IAAI,IAAI,CAG5C;AA8PD,wBAAgB,YAAY,CAAC,IAAI,GAAE,SAAS,eAAe,EAAO,GAAG,MAAM,CAyB1E;AAID;;;;;;;GAOG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAGnC"}
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../src/extensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,EAEL,MAAM,EAEN,KAAK,QAAQ,EACb,KAAK,QAAQ,EAGd,MAAM,mBAAmB,CAAA;AAqB1B,MAAM,WAAW,eAAe;IAC9B,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,gEAAgE;IAChE,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAA;IACnD,iCAAiC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAA;IACnD,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACrC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAA;CAC1C;AAED,gFAAgF;AAChF,eAAO,MAAM,YAAY,sBAAsB,CAAA;AAmB/C;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,eAAe,GAAG,MAAM,IAAI,CAoB9E;AAED,wBAAgB,0BAA0B,IAAI,SAAS,eAAe,EAAE,CAEvE;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAKzE;AAED,gDAAgD;AAChD,wBAAgB,qBAAqB,IAAI,IAAI,CAG5C;AAmdD,wBAAgB,YAAY,CAAC,IAAI,GAAE,SAAS,eAAe,EAAO,GAAG,MAAM,CA4B1E;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,UAAU,IAAI,MAAM,CASnC"}