@variance-authority/core 0.1.0

package/dist/format/provenance.d.ts

@@ -0,0 +1,179 @@
+import { type Digest } from './hash.js';
+/**
+ * Provenance: the chain that lets a diff arrive already carrying a name.
+ *
+ * Principle 5 says causality flows forward — code to semantic to raster — and the
+ * system never infers cause from pixels. Provenance is what makes that possible:
+ * every serialized node remembers which components produced it, so by the time a
+ * change is observed, its owner is already known rather than reconstructed.
+ */
+export interface Provenance {
+    /**
+     * Composite components enclosing this node, innermost first:
+     * `['Button', 'Header', 'CheckoutPage']`. Host elements are excluded — they
+     * are not units anyone owns or adjudicates.
+     */
+    readonly owners: readonly OwnerFrame[];
+    /**
+     * The component whose JSX literally created this element, when the renderer
+     * records it. Distinct from `owners[0]`, which is the nearest *enclosing*
+     * component: a `<Button>` passed as a prop and rendered by `Toolbar` is owned
+     * by its author but enclosed by `Toolbar`. Attribution needs the author;
+     * "where did it end up" needs the enclosure.
+     */
+    readonly createdBy?: string;
+    /** Enabled per project via a compiler plugin; absent otherwise. */
+    readonly source?: SourceLocation;
+    /**
+     * Call-site candidates read off the fiber, awaiting a source map. **Transient.**
+     *
+     * This is what a project that installed *nothing* has: React's development
+     * build constructs an `Error` inside its own `jsx` and keeps it on every fiber,
+     * so the call site is already present in any dev server, Vitest or Jest run.
+     * What it is not yet is a location — a frame names the module the browser was
+     * served, and the file a reviewer opens is a source map away.
+     *
+     * Present only between the page read and resolution. The collector spends it,
+     * writing `source`; normalize drops it either way, so it never reaches a
+     * document, a digest or a baseline. That is deliberate rather than tidy: a
+     * frame holds an absolute URL with a build hash in it, and hashing one would
+     * make every baseline disagree with the next dev-server restart.
+     */
+    readonly stack?: readonly StackFrame[];
+}
+/**
+ * One frame of a stack an engine wrote, as positions in the served module.
+ *
+ * Not a `SourceLocation` and deliberately not shaped like one. A `SourceLocation`
+ * is an answer — a file and a line somebody can open. This is the question: a URL
+ * the browser fetched, at coordinates in the code it was actually sent.
+ */
+export interface StackFrame {
+    /** The URL the engine reported, with any query string kept — it is part of the module's identity. */
+    readonly url: string;
+    /** 1-based, as the engine counts. */
+    readonly line: number;
+    /** 1-based, as the engine counts. */
+    readonly column: number;
+    /** The function the engine named, when it named one. Top-level code has none. */
+    readonly function?: string;
+}
+export interface OwnerFrame {
+    /** `displayName`, falling back to function name, falling back to `Anonymous`. */
+    readonly name: string;
+    /**
+     * Digest of this boundary's serializable props.
+     *
+     * This is what separates a *root* change from a *collateral* one (spec §6.2):
+     * a subtree that changed while its incoming props digest held is an internal
+     * change and this component is the root. If the digest moved too, the change
+     * arrived from outside and the root is upstream.
+     */
+    readonly propsDigest: Digest;
+    /**
+     * The component whose JSX created *this component's* element.
+     *
+     * Needed because the two useful senses of "who is responsible" separate here.
+     * `Provenance.createdBy` names whoever rendered the host node — for a `<Chip>`,
+     * that is `Chip` itself. This names whoever decided a `<Chip>` belongs at this
+     * point in the tree, which is a different component and the one that owns a
+     * structural change. When a list reorders, blaming the moved element reports
+     * the thing that was rearranged; this names the code that rearranged it.
+     */
+    readonly createdBy?: string;
+}
+export interface SourceLocation {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+}
+/**
+ * Where a JSX transform leaves the location, and where a fiber reader finds it.
+ *
+ * Every JSX transform in ordinary use already computes this. The automatic dev
+ * runtime passes `{fileName, lineNumber, columnNumber}` as the fifth argument to
+ * `jsxDEV`; the classic transform passes it as a `__source` prop. **React 19
+ * discards both** — `jsxDEV`'s public export takes four parameters and
+ * synthesizes its own `Error` for the fifth, and `createElement` skips
+ * `__source` by name when it copies config into props (both read in 19.2.8).
+ * Nothing is missing from the build; the last hop is missing from the runtime.
+ *
+ * So the runtime is the hop: `@variance-authority/jsx-source` sits in front of
+ * React's, writes the location here, and hands the props on unchanged. A symbol
+ * rather than a string key is what makes that free — `for…in` does not enumerate
+ * it, so `react-dom` never renders it as an attribute, `propsDigest` never
+ * digests it, and a component spreading `{...props}` onto a host element does not
+ * put it in the document.
+ *
+ * `Symbol.for` rather than a module-level symbol: the writer is in the page's
+ * bundle and the reader is in a page agent evaluated beside it. They are two
+ * module graphs and will never share an import, so the registry is the only
+ * place they can meet.
+ */
+export declare const JSX_SOURCE: unique symbol;
+/**
+ * The location a JSX runtime recorded on this props object, if one did.
+ *
+ * Total, and deliberately so: this runs once per node across a whole document,
+ * for props objects React built from arbitrary user code. A shape that does not
+ * match is absence, never a throw.
+ */
+export declare function jsxSourceOf(props: unknown): SourceLocation | undefined;
+/**
+ * The same location, expressed relative to a root.
+ *
+ * A transform writes the path it compiled — which for every bundler in ordinary
+ * use is absolute, because that is what its module graph holds. Two things go
+ * wrong if that reaches a report. A baseline committed from one machine names
+ * `/Users/somebody/...`, which is both a home directory in a public repository
+ * and a path that resolves nowhere in CI; and the location no longer matches
+ * `SourceRef.file`, which the source index has always answered with
+ * repository-relative paths.
+ *
+ * A path *outside* the root is returned untouched rather than turned into a
+ * chain of `..`. Something compiled from elsewhere — a linked package, a
+ * dependency shipping JSX — is genuinely not at a repository-relative path, and
+ * an absolute one an editor can open beats a relative one that resolves nowhere.
+ */
+export declare function relativizeSource(location: SourceLocation, root: string): SourceLocation;
+/**
+ * Digest a props object, tolerating values that cannot be serialized.
+ *
+ * The stability requirement cuts both ways (spec §11.2). Over-invalidation:
+ * inline arrow functions and object literals get a fresh identity every render,
+ * so identity-based digests would report every subject as changed, every build.
+ * Under-invalidation: collapsing all functions to one token hides a genuinely
+ * swapped handler.
+ *
+ * We resolve toward *shape*, deliberately accepting the under-invalidation:
+ * - a function digests as its name, so `onClick={handleSave}` differs from
+ *   `onClick={handleDelete}` but re-creating the same arrow does not register;
+ * - an element digests as its type, so swapping `<Icon>` for `<Avatar>`
+ *   registers but re-creating the same element does not.
+ *
+ * The accepted cost is real: renaming nothing but rebinding an anonymous closure
+ * to different behavior is invisible here. That is tolerable only because props
+ * digests are an *attribution* input, not a correctness gate — the rendered
+ * output still changes, and the semantic diff still catches it. The digest
+ * decides who gets blamed, not whether anything happened.
+ */
+export declare function propsDigest(props: Readonly<Record<string, unknown>>): Digest;
+/**
+ * The same projection, over one value rather than a props object.
+ *
+ * `propsDigest` is this function with a name that says what its argument is. The
+ * split exists because {@link Holding} digests things that are not props — a
+ * `useState` cell, a `useSyncExternalStore` snapshot, a context's current value,
+ * one prop on its own — and every one of them needs *this* shaper rather than a
+ * second one written to look like it.
+ *
+ * Nothing about the projection is incidental to that reuse, and two of its
+ * defences are load-bearing for hooks in a way they never were for props. A
+ * `useRef` cell holds a DOM node about as often as not, and `asHostObject` is
+ * what stops walking one from dragging the whole fiber graph through the digest
+ * and killing the renderer. An effect cell's `next` closes a ring, and the cycle
+ * guard is what makes that a token instead of a hang. A second implementation
+ * would have to rediscover both, in a page, on somebody else's site.
+ */
+export declare function heldDigest(value: unknown): Digest;
+//# sourceMappingURL=provenance.d.ts.map

package/dist/format/provenance.js

@@ -0,0 +1,222 @@
+import { digestValue } from './hash.js';
+/**
+ * Where a JSX transform leaves the location, and where a fiber reader finds it.
+ *
+ * Every JSX transform in ordinary use already computes this. The automatic dev
+ * runtime passes `{fileName, lineNumber, columnNumber}` as the fifth argument to
+ * `jsxDEV`; the classic transform passes it as a `__source` prop. **React 19
+ * discards both** — `jsxDEV`'s public export takes four parameters and
+ * synthesizes its own `Error` for the fifth, and `createElement` skips
+ * `__source` by name when it copies config into props (both read in 19.2.8).
+ * Nothing is missing from the build; the last hop is missing from the runtime.
+ *
+ * So the runtime is the hop: `@variance-authority/jsx-source` sits in front of
+ * React's, writes the location here, and hands the props on unchanged. A symbol
+ * rather than a string key is what makes that free — `for…in` does not enumerate
+ * it, so `react-dom` never renders it as an attribute, `propsDigest` never
+ * digests it, and a component spreading `{...props}` onto a host element does not
+ * put it in the document.
+ *
+ * `Symbol.for` rather than a module-level symbol: the writer is in the page's
+ * bundle and the reader is in a page agent evaluated beside it. They are two
+ * module graphs and will never share an import, so the registry is the only
+ * place they can meet.
+ */
+export const JSX_SOURCE = Symbol.for('@variance-authority/jsx-source');
+/**
+ * The location a JSX runtime recorded on this props object, if one did.
+ *
+ * Total, and deliberately so: this runs once per node across a whole document,
+ * for props objects React built from arbitrary user code. A shape that does not
+ * match is absence, never a throw.
+ */
+export function jsxSourceOf(props) {
+    if (props === null || typeof props !== 'object')
+        return undefined;
+    const recorded = props[JSX_SOURCE];
+    if (recorded === null || typeof recorded !== 'object')
+        return undefined;
+    const { file, line, column } = recorded;
+    if (typeof file !== 'string' || file === '' || typeof line !== 'number')
+        return undefined;
+    return { file, line, column: typeof column === 'number' ? column : 0 };
+}
+/**
+ * The same location, expressed relative to a root.
+ *
+ * A transform writes the path it compiled — which for every bundler in ordinary
+ * use is absolute, because that is what its module graph holds. Two things go
+ * wrong if that reaches a report. A baseline committed from one machine names
+ * `/Users/somebody/...`, which is both a home directory in a public repository
+ * and a path that resolves nowhere in CI; and the location no longer matches
+ * `SourceRef.file`, which the source index has always answered with
+ * repository-relative paths.
+ *
+ * A path *outside* the root is returned untouched rather than turned into a
+ * chain of `..`. Something compiled from elsewhere — a linked package, a
+ * dependency shipping JSX — is genuinely not at a repository-relative path, and
+ * an absolute one an editor can open beats a relative one that resolves nowhere.
+ */
+export function relativizeSource(location, root) {
+    const path = location.file.replace(/\\/g, '/');
+    const base = root.replace(/\\/g, '/').replace(/\/+$/, '');
+    if (base === '' || !path.startsWith(`${base}/`))
+        return location;
+    return { ...location, file: path.slice(base.length + 1) };
+}
+/**
+ * Digest a props object, tolerating values that cannot be serialized.
+ *
+ * The stability requirement cuts both ways (spec §11.2). Over-invalidation:
+ * inline arrow functions and object literals get a fresh identity every render,
+ * so identity-based digests would report every subject as changed, every build.
+ * Under-invalidation: collapsing all functions to one token hides a genuinely
+ * swapped handler.
+ *
+ * We resolve toward *shape*, deliberately accepting the under-invalidation:
+ * - a function digests as its name, so `onClick={handleSave}` differs from
+ *   `onClick={handleDelete}` but re-creating the same arrow does not register;
+ * - an element digests as its type, so swapping `<Icon>` for `<Avatar>`
+ *   registers but re-creating the same element does not.
+ *
+ * The accepted cost is real: renaming nothing but rebinding an anonymous closure
+ * to different behavior is invisible here. That is tolerable only because props
+ * digests are an *attribution* input, not a correctness gate — the rendered
+ * output still changes, and the semantic diff still catches it. The digest
+ * decides who gets blamed, not whether anything happened.
+ */
+export function propsDigest(props) {
+    return heldDigest(props);
+}
+/**
+ * The same projection, over one value rather than a props object.
+ *
+ * `propsDigest` is this function with a name that says what its argument is. The
+ * split exists because {@link Holding} digests things that are not props — a
+ * `useState` cell, a `useSyncExternalStore` snapshot, a context's current value,
+ * one prop on its own — and every one of them needs *this* shaper rather than a
+ * second one written to look like it.
+ *
+ * Nothing about the projection is incidental to that reuse, and two of its
+ * defences are load-bearing for hooks in a way they never were for props. A
+ * `useRef` cell holds a DOM node about as often as not, and `asHostObject` is
+ * what stops walking one from dragging the whole fiber graph through the digest
+ * and killing the renderer. An effect cell's `next` closes a ring, and the cycle
+ * guard is what makes that a token instead of a hang. A second implementation
+ * would have to rediscover both, in a page, on somebody else's site.
+ */
+export function heldDigest(value) {
+    return digestValue(shapeOf(value, new WeakSet(), { left: MAX_VALUES }));
+}
+/**
+ * Values one digest may walk before it stops walking.
+ *
+ * The cycle guard below unwinds on exit, deliberately — two references to one
+ * object must digest the same wherever they appear — and the cost of that is
+ * that a *shared* subgraph is re-walked once per path to it. On a graph with
+ * enough sharing that is exponential, and exponential inside somebody else's
+ * page is not a slow digest: it is the renderer process dying with the capture
+ * in it. Far above any authored props object; only a graph nobody meant to hand
+ * us reaches it.
+ */
+const MAX_VALUES = 20_000;
+function shapeOf(value, seen, budget) {
+    if (value === null)
+        return null;
+    switch (typeof value) {
+        case 'undefined':
+            // Distinguished from absence: `{a: undefined}` and `{}` render the same
+            // but are different authoring intents, and the docket should say which.
+            return '\u0000undefined';
+        case 'boolean':
+        case 'string':
+            return value;
+        case 'number':
+            return Number.isFinite(value) ? value : `\u0000number:${String(value)}`;
+        case 'bigint':
+            return `\u0000bigint:${value.toString()}`;
+        case 'symbol':
+            return `\u0000symbol:${value.description ?? ''}`;
+        case 'function':
+            return `\u0000fn:${value.name || 'anonymous'}`;
+    }
+    const object = value;
+    // A cyclic prop graph is normal (a node holding its parent). Recursing is not.
+    if (seen.has(object))
+        return '\u0000cycle';
+    if ((budget.left -= 1) < 0)
+        return '\u0000budget';
+    seen.add(object);
+    try {
+        if (Array.isArray(object)) {
+            return object.map((item) => shapeOf(item, seen, budget));
+        }
+        const element = asReactElement(object);
+        if (element)
+            return `\u0000element:${element}`;
+        const host = asHostObject(object);
+        if (host !== null)
+            return host;
+        const shape = {};
+        for (const key of Object.keys(object).sort()) {
+            shape[key] = shapeOf(object[key], seen, budget);
+        }
+        return shape;
+    }
+    finally {
+        seen.delete(object);
+    }
+}
+/**
+ * A DOM node or a window, named rather than walked.
+ *
+ * **The reason this exists is a crash.** A prop holding an element is ordinary —
+ * Storybook hands every story its `canvasElement` — and `Object.keys` on an
+ * element returns its expandos, which on a React page are `__reactFiber$…` and
+ * `__reactContainer$…`. Walking one therefore walks the entire fiber graph
+ * through `child`, `sibling`, `return` and `alternate`, and that graph shares
+ * subtrees along many paths. Verified: hashing `canvasElement` on a story with
+ * two nested Suspense boundaries takes the renderer process down with an
+ * out-of-memory kill, taking the capture with it.
+ *
+ * Naming it is also the answer that was right anyway. A digest exists to say
+ * whether the *inputs* to a component changed, and an element's identity moves
+ * on every remount while its expandos move on every render — so walking one
+ * would report a prop change on a subject nobody touched. Detected structurally,
+ * because `core` runs in Node as well as in a page and may not assume `Node`
+ * exists (ADR-0001).
+ */
+function asHostObject(object) {
+    const node = object;
+    if (typeof node.nodeType === 'number' && typeof node.nodeName === 'string') {
+        return `\u0000node:${node.nodeName}`;
+    }
+    // A window holds every global there is, including the document, and is the
+    // same explosion by another door.
+    if (node.window === object)
+        return '\u0000window';
+    return null;
+}
+/**
+ * Recognize a React element without importing React.
+ *
+ * `core` must stay framework-free (ADR-0001), and the element brand is a stable
+ * public contract — `Symbol.for('react.element')` for the classic runtime,
+ * `react.transitional.element` since React 19. Structural detection here beats a
+ * dependency edge from `core` to React.
+ */
+function asReactElement(object) {
+    const $$typeof = object.$$typeof;
+    if (typeof $$typeof !== 'symbol')
+        return null;
+    const brand = $$typeof.description ?? '';
+    if (brand !== 'react.element' && brand !== 'react.transitional.element')
+        return null;
+    const type = object.type;
+    if (typeof type === 'string')
+        return type;
+    if (typeof type === 'function')
+        return type.name || 'Anonymous';
+    return 'Unknown';
+}
+//# sourceMappingURL=provenance.js.map

package/dist/format/provenance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.js","sourceRoot":"","sources":["../../src/format/provenance.ts"],"names":[],"mappings":"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","sourcesContent":["import { digestValue, type Digest } from './hash.js';\n\n/**\n * Provenance: the chain that lets a diff arrive already carrying a name.\n *\n * Principle 5 says causality flows forward — code to semantic to raster — and the\n * system never infers cause from pixels. Provenance is what makes that possible:\n * every serialized node remembers which components produced it, so by the time a\n * change is observed, its owner is already known rather than reconstructed.\n */\n\nexport interface Provenance {\n  /**\n   * Composite components enclosing this node, innermost first:\n   * `['Button', 'Header', 'CheckoutPage']`. Host elements are excluded — they\n   * are not units anyone owns or adjudicates.\n   */\n  readonly owners: readonly OwnerFrame[];\n\n  /**\n   * The component whose JSX literally created this element, when the renderer\n   * records it. Distinct from `owners[0]`, which is the nearest *enclosing*\n   * component: a `<Button>` passed as a prop and rendered by `Toolbar` is owned\n   * by its author but enclosed by `Toolbar`. Attribution needs the author;\n   * \"where did it end up\" needs the enclosure.\n   */\n  readonly createdBy?: string;\n\n  /** Enabled per project via a compiler plugin; absent otherwise. */\n  readonly source?: SourceLocation;\n\n  /**\n   * Call-site candidates read off the fiber, awaiting a source map. **Transient.**\n   *\n   * This is what a project that installed *nothing* has: React's development\n   * build constructs an `Error` inside its own `jsx` and keeps it on every fiber,\n   * so the call site is already present in any dev server, Vitest or Jest run.\n   * What it is not yet is a location — a frame names the module the browser was\n   * served, and the file a reviewer opens is a source map away.\n   *\n   * Present only between the page read and resolution. The collector spends it,\n   * writing `source`; normalize drops it either way, so it never reaches a\n   * document, a digest or a baseline. That is deliberate rather than tidy: a\n   * frame holds an absolute URL with a build hash in it, and hashing one would\n   * make every baseline disagree with the next dev-server restart.\n   */\n  readonly stack?: readonly StackFrame[];\n}\n\n/**\n * One frame of a stack an engine wrote, as positions in the served module.\n *\n * Not a `SourceLocation` and deliberately not shaped like one. A `SourceLocation`\n * is an answer — a file and a line somebody can open. This is the question: a URL\n * the browser fetched, at coordinates in the code it was actually sent.\n */\nexport interface StackFrame {\n  /** The URL the engine reported, with any query string kept — it is part of the module's identity. */\n  readonly url: string;\n  /** 1-based, as the engine counts. */\n  readonly line: number;\n  /** 1-based, as the engine counts. */\n  readonly column: number;\n  /** The function the engine named, when it named one. Top-level code has none. */\n  readonly function?: string;\n}\n\nexport interface OwnerFrame {\n  /** `displayName`, falling back to function name, falling back to `Anonymous`. */\n  readonly name: string;\n\n  /**\n   * Digest of this boundary's serializable props.\n   *\n   * This is what separates a *root* change from a *collateral* one (spec §6.2):\n   * a subtree that changed while its incoming props digest held is an internal\n   * change and this component is the root. If the digest moved too, the change\n   * arrived from outside and the root is upstream.\n   */\n  readonly propsDigest: Digest;\n\n  /**\n   * The component whose JSX created *this component's* element.\n   *\n   * Needed because the two useful senses of \"who is responsible\" separate here.\n   * `Provenance.createdBy` names whoever rendered the host node — for a `<Chip>`,\n   * that is `Chip` itself. This names whoever decided a `<Chip>` belongs at this\n   * point in the tree, which is a different component and the one that owns a\n   * structural change. When a list reorders, blaming the moved element reports\n   * the thing that was rearranged; this names the code that rearranged it.\n   */\n  readonly createdBy?: string;\n}\n\nexport interface SourceLocation {\n  readonly file: string;\n  readonly line: number;\n  readonly column: number;\n}\n\n/**\n * Where a JSX transform leaves the location, and where a fiber reader finds it.\n *\n * Every JSX transform in ordinary use already computes this. The automatic dev\n * runtime passes `{fileName, lineNumber, columnNumber}` as the fifth argument to\n * `jsxDEV`; the classic transform passes it as a `__source` prop. **React 19\n * discards both** — `jsxDEV`'s public export takes four parameters and\n * synthesizes its own `Error` for the fifth, and `createElement` skips\n * `__source` by name when it copies config into props (both read in 19.2.8).\n * Nothing is missing from the build; the last hop is missing from the runtime.\n *\n * So the runtime is the hop: `@variance-authority/jsx-source` sits in front of\n * React's, writes the location here, and hands the props on unchanged. A symbol\n * rather than a string key is what makes that free — `for…in` does not enumerate\n * it, so `react-dom` never renders it as an attribute, `propsDigest` never\n * digests it, and a component spreading `{...props}` onto a host element does not\n * put it in the document.\n *\n * `Symbol.for` rather than a module-level symbol: the writer is in the page's\n * bundle and the reader is in a page agent evaluated beside it. They are two\n * module graphs and will never share an import, so the registry is the only\n * place they can meet.\n */\nexport const JSX_SOURCE: unique symbol = Symbol.for(\n  '@variance-authority/jsx-source',\n) as typeof JSX_SOURCE;\n\n/**\n * The location a JSX runtime recorded on this props object, if one did.\n *\n * Total, and deliberately so: this runs once per node across a whole document,\n * for props objects React built from arbitrary user code. A shape that does not\n * match is absence, never a throw.\n */\nexport function jsxSourceOf(props: unknown): SourceLocation | undefined {\n  if (props === null || typeof props !== 'object') return undefined;\n\n  const recorded = (props as Record<symbol, unknown>)[JSX_SOURCE];\n  if (recorded === null || typeof recorded !== 'object') return undefined;\n\n  const { file, line, column } = recorded as Partial<SourceLocation>;\n  if (typeof file !== 'string' || file === '' || typeof line !== 'number') return undefined;\n\n  return { file, line, column: typeof column === 'number' ? column : 0 };\n}\n\n/**\n * The same location, expressed relative to a root.\n *\n * A transform writes the path it compiled — which for every bundler in ordinary\n * use is absolute, because that is what its module graph holds. Two things go\n * wrong if that reaches a report. A baseline committed from one machine names\n * `/Users/somebody/...`, which is both a home directory in a public repository\n * and a path that resolves nowhere in CI; and the location no longer matches\n * `SourceRef.file`, which the source index has always answered with\n * repository-relative paths.\n *\n * A path *outside* the root is returned untouched rather than turned into a\n * chain of `..`. Something compiled from elsewhere — a linked package, a\n * dependency shipping JSX — is genuinely not at a repository-relative path, and\n * an absolute one an editor can open beats a relative one that resolves nowhere.\n */\nexport function relativizeSource(location: SourceLocation, root: string): SourceLocation {\n  const path = location.file.replace(/\\\\/g, '/');\n  const base = root.replace(/\\\\/g, '/').replace(/\\/+$/, '');\n  if (base === '' || !path.startsWith(`${base}/`)) return location;\n\n  return { ...location, file: path.slice(base.length + 1) };\n}\n\n/**\n * Digest a props object, tolerating values that cannot be serialized.\n *\n * The stability requirement cuts both ways (spec §11.2). Over-invalidation:\n * inline arrow functions and object literals get a fresh identity every render,\n * so identity-based digests would report every subject as changed, every build.\n * Under-invalidation: collapsing all functions to one token hides a genuinely\n * swapped handler.\n *\n * We resolve toward *shape*, deliberately accepting the under-invalidation:\n * - a function digests as its name, so `onClick={handleSave}` differs from\n *   `onClick={handleDelete}` but re-creating the same arrow does not register;\n * - an element digests as its type, so swapping `<Icon>` for `<Avatar>`\n *   registers but re-creating the same element does not.\n *\n * The accepted cost is real: renaming nothing but rebinding an anonymous closure\n * to different behavior is invisible here. That is tolerable only because props\n * digests are an *attribution* input, not a correctness gate — the rendered\n * output still changes, and the semantic diff still catches it. The digest\n * decides who gets blamed, not whether anything happened.\n */\nexport function propsDigest(props: Readonly<Record<string, unknown>>): Digest {\n  return heldDigest(props);\n}\n\n/**\n * The same projection, over one value rather than a props object.\n *\n * `propsDigest` is this function with a name that says what its argument is. The\n * split exists because {@link Holding} digests things that are not props — a\n * `useState` cell, a `useSyncExternalStore` snapshot, a context's current value,\n * one prop on its own — and every one of them needs *this* shaper rather than a\n * second one written to look like it.\n *\n * Nothing about the projection is incidental to that reuse, and two of its\n * defences are load-bearing for hooks in a way they never were for props. A\n * `useRef` cell holds a DOM node about as often as not, and `asHostObject` is\n * what stops walking one from dragging the whole fiber graph through the digest\n * and killing the renderer. An effect cell's `next` closes a ring, and the cycle\n * guard is what makes that a token instead of a hang. A second implementation\n * would have to rediscover both, in a page, on somebody else's site.\n */\nexport function heldDigest(value: unknown): Digest {\n  return digestValue(shapeOf(value, new WeakSet(), { left: MAX_VALUES }) as never);\n}\n\n/**\n * Values one digest may walk before it stops walking.\n *\n * The cycle guard below unwinds on exit, deliberately — two references to one\n * object must digest the same wherever they appear — and the cost of that is\n * that a *shared* subgraph is re-walked once per path to it. On a graph with\n * enough sharing that is exponential, and exponential inside somebody else's\n * page is not a slow digest: it is the renderer process dying with the capture\n * in it. Far above any authored props object; only a graph nobody meant to hand\n * us reaches it.\n */\nconst MAX_VALUES = 20_000;\n\ninterface Budget {\n  left: number;\n}\n\nfunction shapeOf(value: unknown, seen: WeakSet<object>, budget: Budget): unknown {\n  if (value === null) return null;\n\n  switch (typeof value) {\n    case 'undefined':\n      // Distinguished from absence: `{a: undefined}` and `{}` render the same\n      // but are different authoring intents, and the docket should say which.\n      return '\\u0000undefined';\n    case 'boolean':\n    case 'string':\n      return value;\n    case 'number':\n      return Number.isFinite(value) ? value : `\\u0000number:${String(value)}`;\n    case 'bigint':\n      return `\\u0000bigint:${value.toString()}`;\n    case 'symbol':\n      return `\\u0000symbol:${value.description ?? ''}`;\n    case 'function':\n      return `\\u0000fn:${value.name || 'anonymous'}`;\n  }\n\n  const object = value as object;\n\n  // A cyclic prop graph is normal (a node holding its parent). Recursing is not.\n  if (seen.has(object)) return '\\u0000cycle';\n  if ((budget.left -= 1) < 0) return '\\u0000budget';\n  seen.add(object);\n\n  try {\n    if (Array.isArray(object)) {\n      return object.map((item) => shapeOf(item, seen, budget));\n    }\n\n    const element = asReactElement(object);\n    if (element) return `\\u0000element:${element}`;\n\n    const host = asHostObject(object);\n    if (host !== null) return host;\n\n    const shape: Record<string, unknown> = {};\n    for (const key of Object.keys(object).sort()) {\n      shape[key] = shapeOf((object as Record<string, unknown>)[key], seen, budget);\n    }\n    return shape;\n  } finally {\n    seen.delete(object);\n  }\n}\n\n/**\n * A DOM node or a window, named rather than walked.\n *\n * **The reason this exists is a crash.** A prop holding an element is ordinary —\n * Storybook hands every story its `canvasElement` — and `Object.keys` on an\n * element returns its expandos, which on a React page are `__reactFiber$…` and\n * `__reactContainer$…`. Walking one therefore walks the entire fiber graph\n * through `child`, `sibling`, `return` and `alternate`, and that graph shares\n * subtrees along many paths. Verified: hashing `canvasElement` on a story with\n * two nested Suspense boundaries takes the renderer process down with an\n * out-of-memory kill, taking the capture with it.\n *\n * Naming it is also the answer that was right anyway. A digest exists to say\n * whether the *inputs* to a component changed, and an element's identity moves\n * on every remount while its expandos move on every render — so walking one\n * would report a prop change on a subject nobody touched. Detected structurally,\n * because `core` runs in Node as well as in a page and may not assume `Node`\n * exists (ADR-0001).\n */\nfunction asHostObject(object: object): string | null {\n  const node = object as { nodeType?: unknown; nodeName?: unknown; window?: unknown };\n\n  if (typeof node.nodeType === 'number' && typeof node.nodeName === 'string') {\n    return `\\u0000node:${node.nodeName}`;\n  }\n\n  // A window holds every global there is, including the document, and is the\n  // same explosion by another door.\n  if (node.window === object) return '\\u0000window';\n\n  return null;\n}\n\n/**\n * Recognize a React element without importing React.\n *\n * `core` must stay framework-free (ADR-0001), and the element brand is a stable\n * public contract — `Symbol.for('react.element')` for the classic runtime,\n * `react.transitional.element` since React 19. Structural detection here beats a\n * dependency edge from `core` to React.\n */\nfunction asReactElement(object: object): string | null {\n  const $$typeof = (object as { $$typeof?: symbol }).$$typeof;\n  if (typeof $$typeof !== 'symbol') return null;\n\n  const brand = $$typeof.description ?? '';\n  if (brand !== 'react.element' && brand !== 'react.transitional.element') return null;\n\n  const type = (object as { type?: unknown }).type;\n  if (typeof type === 'string') return type;\n  if (typeof type === 'function') return type.name || 'Anonymous';\n  return 'Unknown';\n}\n"]}

package/dist/format/sha256.d.ts

@@ -0,0 +1,34 @@
+/**
+ * SHA-256, in portable TypeScript.
+ *
+ * `core` originally used `node:crypto`, which was wrong — and the reason is not
+ * ergonomic. `propsDigest` has to run *inside the page*: a React prop can be a
+ * function or an element, and neither survives serialization out to a host
+ * process, so the digest must be taken where the value still exists. A `core`
+ * that imports `node:crypto` cannot run there, which quietly contradicted the
+ * remote-sub-renderer story in ADR-0002 and the DOM-free boundary in ADR-0001.
+ * (The `lib: ["ES2022"]` guard is one-directional: it stops `core` reaching into
+ * a browser, not `core` depending on Node.)
+ *
+ * `crypto.subtle.digest` is the obvious replacement and is not usable: it is
+ * async, and hashing is synchronous throughout by design — making it async would
+ * colour the entire normalizer for no benefit.
+ *
+ * So the algorithm lives here. It is fully specified by FIPS 180-4, so this
+ * produces byte-identical output to any other correct implementation on any
+ * runtime, which is exactly the determinism Principle 2 requires. Performance is
+ * not a consideration until a gate in ADR-0004 fires; none has.
+ */
+/** Hash a UTF-8 string, returning lowercase hex. */
+export declare function sha256Hex(input: string): string;
+/**
+ * Hash raw bytes, returning lowercase hex.
+ *
+ * The string form is this with one encoding step in front of it, and not the
+ * other way round: an image is bytes, and routing it through a string would mean
+ * choosing an encoding that survives arbitrary octets — which is a second
+ * decision, made in the wrong place, that changes the digest if it is ever
+ * revisited.
+ */
+export declare function sha256HexBytes(bytes: Uint8Array): string;
+//# sourceMappingURL=sha256.d.ts.map

package/dist/format/sha256.js

@@ -0,0 +1,152 @@
+/**
+ * SHA-256, in portable TypeScript.
+ *
+ * `core` originally used `node:crypto`, which was wrong — and the reason is not
+ * ergonomic. `propsDigest` has to run *inside the page*: a React prop can be a
+ * function or an element, and neither survives serialization out to a host
+ * process, so the digest must be taken where the value still exists. A `core`
+ * that imports `node:crypto` cannot run there, which quietly contradicted the
+ * remote-sub-renderer story in ADR-0002 and the DOM-free boundary in ADR-0001.
+ * (The `lib: ["ES2022"]` guard is one-directional: it stops `core` reaching into
+ * a browser, not `core` depending on Node.)
+ *
+ * `crypto.subtle.digest` is the obvious replacement and is not usable: it is
+ * async, and hashing is synchronous throughout by design — making it async would
+ * colour the entire normalizer for no benefit.
+ *
+ * So the algorithm lives here. It is fully specified by FIPS 180-4, so this
+ * produces byte-identical output to any other correct implementation on any
+ * runtime, which is exactly the determinism Principle 2 requires. Performance is
+ * not a consideration until a gate in ADR-0004 fires; none has.
+ */
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+const INITIAL = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+/** Hash a UTF-8 string, returning lowercase hex. */
+export function sha256Hex(input) {
+    return sha256HexBytes(utf8Bytes(input));
+}
+/**
+ * Hash raw bytes, returning lowercase hex.
+ *
+ * The string form is this with one encoding step in front of it, and not the
+ * other way round: an image is bytes, and routing it through a string would mean
+ * choosing an encoding that survives arbitrary octets — which is a second
+ * decision, made in the wrong place, that changes the digest if it is ever
+ * revisited.
+ */
+export function sha256HexBytes(bytes) {
+    const state = new Uint32Array(INITIAL);
+    // Padding: a single 1 bit, zeros, then the 64-bit big-endian bit length.
+    const bitLength = bytes.length * 8;
+    // Padding is minimal by definition: the smallest multiple of 64 that fits the
+    // message, the 0x80 byte, and the 8-byte length. Rounding up unconditionally
+    // would append a spare block whenever `length + 9` is already a multiple of
+    // 64, which is a different message and therefore a different digest.
+    const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
+    const padded = new Uint8Array(paddedLength);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    // Written as two 32-bit halves rather than a BigInt: inputs never approach
+    // 2^32 bits (512 MiB), and the high word is always zero in practice, but
+    // emitting it keeps the block format exactly as specified.
+    const view = new DataView(padded.buffer);
+    view.setUint32(paddedLength - 8, Math.floor(bitLength / 0x100000000), false);
+    view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+    const w = new Uint32Array(64);
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+        for (let i = 0; i < 16; i += 1) {
+            w[i] = view.getUint32(offset + i * 4, false);
+        }
+        for (let i = 16; i < 64; i += 1) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, h] = state;
+        for (let i = 0; i < 64; i += 1) {
+            const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const temp1 = (h + S1 + ch + K[i] + w[i]) >>> 0;
+            const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = (S0 + maj) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temp1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temp1 + temp2) >>> 0;
+        }
+        state[0] = (state[0] + a) >>> 0;
+        state[1] = (state[1] + b) >>> 0;
+        state[2] = (state[2] + c) >>> 0;
+        state[3] = (state[3] + d) >>> 0;
+        state[4] = (state[4] + e) >>> 0;
+        state[5] = (state[5] + f) >>> 0;
+        state[6] = (state[6] + g) >>> 0;
+        state[7] = (state[7] + h) >>> 0;
+    }
+    let hex = '';
+    for (const word of state) {
+        hex += word.toString(16).padStart(8, '0');
+    }
+    return hex;
+}
+function rotr(value, bits) {
+    return ((value >>> bits) | (value << (32 - bits))) >>> 0;
+}
+/**
+ * Encode as UTF-8 without `TextEncoder`.
+ *
+ * `TextEncoder` is available everywhere this runs today, but hand-encoding keeps
+ * `core` free of *every* host global, not merely the Node ones — which is the
+ * property that just failed to hold. Lone surrogates are encoded as U+FFFD, the
+ * same substitution `TextEncoder` makes, so a malformed string cannot produce
+ * two different digests on two runtimes.
+ */
+function utf8Bytes(input) {
+    const bytes = [];
+    for (let i = 0; i < input.length; i += 1) {
+        let code = input.charCodeAt(i);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = input.charCodeAt(i + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                code = 0x10000 + ((code - 0xd800) << 10) + (next - 0xdc00);
+                i += 1;
+            }
+            else {
+                code = 0xfffd;
+            }
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            code = 0xfffd;
+        }
+        if (code < 0x80) {
+            bytes.push(code);
+        }
+        else if (code < 0x800) {
+            bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+        }
+        else if (code < 0x10000) {
+            bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+        }
+        else {
+            bytes.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 0x3f), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+        }
+    }
+    return Uint8Array.from(bytes);
+}
+//# sourceMappingURL=sha256.js.map