shelving 1.208.0 → 1.209.0

package/README.md

@@ -2,40 +2,16 @@
 
 [![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org) [![Release](https://github.com/dhoulb/shelving/actions/workflows/release.yaml/badge.svg)](https://github.com/dhoulb/shelving/actions/workflows/release.yaml) [![npm](https://img.shields.io/npm/dm/shelving.svg)](https://www.npmjs.com/package/shelving)
 
-Shelving is a TypeScript toolkit for working with typed data. At its core it is a schema validation library — every schema has a `validate()` method that returns a typed value or throws a human-readable error. On top of that it provides a database provider abstraction, an API provider abstraction, observable state stores, React integration, and a large set of typed utility functions.
+TypeScript data toolkit — schema validation, database and API providers, observable state stores, React integration, and typed utility functions.
 
-> Note: Shelving is in active development and does not yet follow semver.
+## Documentation
 
-## Installation
+Full documentation is published at **<https://dhoulb.github.io/shelving/>**.
 
 ```sh
 npm install shelving
 ```
 
-Shelving is an ES module. Import from the main package or from individual module subpaths:
-
-```ts
-import { STRING, DataSchema } from "shelving"
-import { MemoryDBProvider } from "shelving/db"
-```
-
-## Modules
-
-| Module | Description |
-|---|---|
-| [schema](modules/schema/README.md) | Schema validation — the foundation of everything |
-| [db](modules/db/README.md) | Database provider abstraction (Collections, providers, queries) |
-| [api](modules/api/README.md) | API provider abstraction (Endpoints, providers, caching) |
-| [store](modules/store/README.md) | Observable state containers, Suspense-compatible |
-| [sequence](modules/sequence/README.md) | Async-iterable utilities (`DeferredSequence`) |
-| [react](modules/react/README.md) | React hooks for stores and sequences |
-| [error](modules/error/README.md) | Typed error classes |
-| [util](modules/util/README.md) | Typed helpers for arrays, objects, strings, data, queries, updates |
-| [markup](modules/markup/README.md) | Markdown renderer for user-facing content |
-| [cloudflare](modules/cloudflare/README.md) | Cloudflare Workers providers (KV, D1) |
-| [firestore](modules/firestore/README.md) | Firestore providers (client, lite, server) |
-| [bun](modules/bun/README.md) | Bun PostgreSQL provider |
-
 ## Changelog
 
 See [Releases](https://github.com/dhoulb/shelving/releases).

package/extract/DirectoryExtractor.d.ts

@@ -36,7 +36,7 @@ export declare class DirectoryExtractor extends Extractor<Path, DirectoryElement
     private readonly _base;
     private readonly _ignore;
     constructor({ index, extractors, base, ignore }?: DirectoryExtractorOptions);
-    extract(path: Path): Promise<DirectoryElement>;
+    extract(source: Path): Promise<DirectoryElement>;
     private _extractDirectory;
     private _extractChild;
 }

package/extract/DirectoryExtractor.js

@@ -1,7 +1,7 @@
 import { readdir } from "node:fs/promises";
 import { mergeElements } from "../util/element.js";
 import { splitFileExtension } from "../util/file.js";
-import { anyMatch, requirePath, splitAbsolutePath } from "../util/index.js";
+import { anyMatch, requirePath, splitPath } from "../util/index.js";
 import { requireSlug } from "../util/string.js";
 import { Extractor, mergeTreeElements } from "./Extractor.js";
 import { FileExtractor } from "./FileExtractor.js";
@@ -60,12 +60,12 @@ export class DirectoryExtractor extends Extractor {
         this._base = base;
         this._ignore = ignore;
     }
-    extract(path) {
-        return this._extractDirectory(requirePath(path, this._base, this.extract));
+    extract(source) {
+        return this._extractDirectory(requirePath(source, this._base, this.extract));
     }
-    async _extractDirectory(path) {
-        const name = splitAbsolutePath(path).at(-1) ?? "";
-        const entries = await readdir(path, { withFileTypes: true });
+    async _extractDirectory(source) {
+        const name = splitPath(source).at(-1) ?? "";
+        const entries = await readdir(source, { withFileTypes: true });
         // Keep track of the current index entry and children by key, so we can merge same-key elements.
         let index;
         const items = {};
@@ -74,7 +74,7 @@ export class DirectoryExtractor extends Extractor {
             if (anyMatch(entry.name, ...this._ignore))
                 continue;
             // Extract the child element and possibly merge it.
-            const child = await this._extractChild(path, entry);
+            const child = await this._extractChild(source, entry);
             if (child) {
                 // Is this entry an index? If so, we'll treat it as the directory itself and merge it with any existing index entry if needed.
                 if (anyMatch(entry.name, ...this._indexes)) {
@@ -91,7 +91,7 @@ export class DirectoryExtractor extends Extractor {
             type: "tree-directory",
             key: requireSlug(name),
             props: {
-                path,
+                source,
                 name,
                 // `title` is only set when the absorbed index file has a confident one (e.g. README H1).
                 // Renderers fall back to `name` otherwise.

package/extract/Extractor.d.ts

@@ -17,7 +17,7 @@ export declare abstract class Extractor<I, O extends TreeElement = TreeElement>
 }
 /**
  * Merge two file elements with the same `key`.
- * - `title` and `path` are taken from `primary` (the higher-priority element).
+ * - `title` and `source` are taken from `primary` (the higher-priority element).
  * - `description` is taken from `primary` if set, otherwise from `secondary`.
  * - `content` and `children` from both are concatenated (primary first).
  */

package/extract/Extractor.js

@@ -21,10 +21,18 @@ export function mergeTreeElements(primary, secondary) {
         props: {
             ...primary.props,
             title: primary.props.title,
-            path: primary.props.path,
+            source: primary.props.source,
             description: primary.props.description ?? secondary.props.description,
-            content: mergeElements(primary.props.content, secondary.props.content),
+            content: _mergeContent(primary.props.content, secondary.props.content),
             children: mergeElements(primary.props.children, secondary.props.children),
         },
     };
 }
+/** Merge two markup content strings — primary first, secondary appended after a blank line. Returns `undefined` if both are empty. */
+function _mergeContent(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return `${a}\n\n${b}`;
+}

package/extract/FileExtractor.d.ts

@@ -4,19 +4,21 @@ import { Extractor } from "./Extractor.js";
 /**
  * Base extractor for a file in a tree.
  * - Reads the file's content as text and stores it in `content`.
- * - Sets `key` to the slugified basename without extension.
- * - Sets `name` to the display-ready basename without extension (e.g. `"OptionalSchema"`, not `"OptionalSchema.ts"`).
- * - Does NOT set `title` — `title` is only set by subclasses that have a confident source for one
- *   (e.g. `MarkdownExtractor` uses the first `<h1>`). Renderers fall back to `name` when missing.
+ * - Sets `source` to the file's absolute path (`BunFile.name`); throws `RequiredError` if missing or non-absolute.
+ * - Sets `name` to the basename without extension, preserving case (e.g. `"OptionalSchema"` from `"OptionalSchema.ts"`); URL paths use `name`.
+ * - Sets `key` to the slugified `name` (e.g. `"optionalschema"`) — only used by React for reconciliation and by `DirectoryExtractor` to merge same-key siblings (e.g. `TEMPLATE.md` + `template.ts`).
+ * - Does NOT set `title` — `title` is only set by subclasses that have a confident source for one (e.g. `MarkdownExtractor` uses the first `<h1>`). Renderers fall back to `name` when missing.
  * - Subclasses (e.g. `MarkdownExtractor`, `TypescriptExtractor`) override `extractProps()` to parse the content into richer elements.
  */
 export declare class FileExtractor extends Extractor<BunFile, FileElement> {
     extract(file: BunFile): Promise<FileElement>;
     /**
      * Build the file element props from the extracted content.
-     * - `name` is the basename without extension (e.g. `"array"`) — display-ready, used by menus and cards.
+     * - `name` is the basename without extension (e.g. `"array"`) — display-ready, used by menus, cards, and URL paths.
      * - Override to parse `text` into richer elements (content/children/description) and to set
      *   `title` if a confident title is available.
      */
-    extractProps(name: string, content: string): FileElementProps;
+    extractProps(name: string, content: string): Partial<FileElementProps> & {
+        name: string;
+    };
 }

package/extract/FileExtractor.js

@@ -1,30 +1,35 @@
+import { RequiredError } from "../error/RequiredError.js";
 import { splitFileExtension } from "../util/file.js";
-import { isAbsolutePath, splitAbsolutePath } from "../util/index.js";
+import { isAbsolutePath, splitPath } from "../util/index.js";
 import { requireSlug } from "../util/string.js";
 import { Extractor } from "./Extractor.js";
 /**
  * Base extractor for a file in a tree.
  * - Reads the file's content as text and stores it in `content`.
- * - Sets `key` to the slugified basename without extension.
- * - Sets `name` to the display-ready basename without extension (e.g. `"OptionalSchema"`, not `"OptionalSchema.ts"`).
- * - Does NOT set `title` — `title` is only set by subclasses that have a confident source for one
- *   (e.g. `MarkdownExtractor` uses the first `<h1>`). Renderers fall back to `name` when missing.
+ * - Sets `source` to the file's absolute path (`BunFile.name`); throws `RequiredError` if missing or non-absolute.
+ * - Sets `name` to the basename without extension, preserving case (e.g. `"OptionalSchema"` from `"OptionalSchema.ts"`); URL paths use `name`.
+ * - Sets `key` to the slugified `name` (e.g. `"optionalschema"`) — only used by React for reconciliation and by `DirectoryExtractor` to merge same-key siblings (e.g. `TEMPLATE.md` + `template.ts`).
+ * - Does NOT set `title` — `title` is only set by subclasses that have a confident source for one (e.g. `MarkdownExtractor` uses the first `<h1>`). Renderers fall back to `name` when missing.
  * - Subclasses (e.g. `MarkdownExtractor`, `TypescriptExtractor`) override `extractProps()` to parse the content into richer elements.
  */
 export class FileExtractor extends Extractor {
     async extract(file) {
-        const path = file.name ?? "unnamed";
-        const filename = isAbsolutePath(path) ? (splitAbsolutePath(path).at(-1) ?? "unnamed") : path;
+        const source = file.name;
+        if (!source || !isAbsolutePath(source))
+            throw new RequiredError("FileExtractor requires an absolute file path", { received: source });
+        const filename = splitPath(source).at(-1) ?? "unnamed";
         const [base = filename] = splitFileExtension(filename);
+        const text = await file.text();
+        const props = { ...this.extractProps(base, text), source };
         return {
             type: "tree-file",
             key: requireSlug(base),
-            props: this.extractProps(base, await file.text()),
+            props,
         };
     }
     /**
      * Build the file element props from the extracted content.
-     * - `name` is the basename without extension (e.g. `"array"`) — display-ready, used by menus and cards.
+     * - `name` is the basename without extension (e.g. `"array"`) — display-ready, used by menus, cards, and URL paths.
      * - Override to parse `text` into richer elements (content/children/description) and to set
      *   `title` if a confident title is available.
      */

package/extract/MarkdownExtractor.d.ts

@@ -1,17 +1,20 @@
-import type { MarkupOptions } from "../markup/util/options.js";
-import type { Elements, FileElementProps } from "../util/element.js";
+import type { FileElementProps } from "../util/element.js";
 import { FileExtractor } from "./FileExtractor.js";
 /**
- * File extractor that parses a Markdown file into a tree element.
- * - Parses the file content using the markup module.
- * - Sets `title` from the first `<h1>` heading if one is present — otherwise leaves it undefined
+ * File extractor for Markdown files.
+ * - Stores the raw markdown text as `content`; rendering happens at output time via `<Markup>`.
+ * - Sets `title` from the first `# h1` heading if one is present — otherwise leaves it undefined
  *   (a confident title only).
  */
 export declare class MarkdownExtractor extends FileExtractor {
     /** Markdown contributes the canonical title/path when merging same-key elements. */
     readonly priority = 10;
-    private readonly _options;
-    constructor(options?: MarkupOptions);
-    extractProps(name: string, text: string): FileElementProps;
-    render(text: string): Elements;
+    extractProps(name: string, text: string): Partial<FileElementProps> & {
+        name: string;
+    };
 }
+/**
+ * Find the first `# h1` heading in a markdown source string and return its text, or `undefined` if none.
+ * - Looks for a line starting with a single `#` followed by whitespace; doesn't match `##`+.
+ */
+export declare function extractMarkdownTitle(text: string): string | undefined;

package/extract/MarkdownExtractor.js

@@ -1,33 +1,22 @@
-import { renderMarkup } from "../markup/render.js";
-import { MARKUP_RULES } from "../markup/rule/index.js";
-import { getElements, getElementText } from "../util/element.js";
 import { FileExtractor } from "./FileExtractor.js";
 /**
- * File extractor that parses a Markdown file into a tree element.
- * - Parses the file content using the markup module.
- * - Sets `title` from the first `<h1>` heading if one is present — otherwise leaves it undefined
+ * File extractor for Markdown files.
+ * - Stores the raw markdown text as `content`; rendering happens at output time via `<Markup>`.
+ * - Sets `title` from the first `# h1` heading if one is present — otherwise leaves it undefined
  *   (a confident title only).
  */
 export class MarkdownExtractor extends FileExtractor {
     /** Markdown contributes the canonical title/path when merging same-key elements. */
     priority = 10;
-    _options;
-    constructor(options = { rules: MARKUP_RULES }) {
-        super();
-        this._options = options;
-    }
     extractProps(name, text) {
-        const content = this.render(text);
-        const title = _getFirstHeadingText(content);
-        return { name, title, content };
-    }
-    render(text) {
-        return renderMarkup(text, this._options);
+        return { name, title: extractMarkdownTitle(text), content: text };
     }
 }
-/** Find the first `h1` element and extract its text content. */
-function _getFirstHeadingText(markdown) {
-    for (const el of getElements(markdown))
-        if (el.type === "h1")
-            return getElementText(el.props.children) || undefined;
+/**
+ * Find the first `# h1` heading in a markdown source string and return its text, or `undefined` if none.
+ * - Looks for a line starting with a single `#` followed by whitespace; doesn't match `##`+.
+ */
+export function extractMarkdownTitle(text) {
+    const match = text.match(/^#\s+(.+?)\s*$/m);
+    return match?.[1];
 }

package/extract/TypescriptExtractor.d.ts

@@ -9,5 +9,7 @@ import { FileExtractor } from "./FileExtractor.js";
  * - Does not set `title` — TS source files have no confident title source. The renderer falls back to `name`.
  */
 export declare class TypescriptExtractor extends FileExtractor {
-    extractProps(name: string, text: string): FileElementProps;
+    extractProps(name: string, text: string): Partial<FileElementProps> & {
+        name: string;
+    };
 }

package/extract/TypescriptExtractor.js

@@ -33,8 +33,8 @@ function _mergeOverloads(existing, next) {
     const b = next.props;
     const merged = {
         ...a,
-        // Keep first description encountered; fill in if `existing` had none.
-        description: a.description ?? b.description,
+        // Keep first content encountered; fill in if `existing` had none.
+        content: a.content ?? b.content,
         // Append signatures.
         signatures: _concat(a.signatures, b.signatures),
         // Append params, returns, throws, examples — never dedupe (per spec).
@@ -97,7 +97,7 @@ function _extractStatement(statement, source) {
         props: {
             name,
             kind,
-            description: jsDoc?.description,
+            content: _buildJSDocContent(jsDoc?.description, jsDoc?.unhandled),
             signatures: signature ? [signature] : undefined,
             params,
             returns,
@@ -107,6 +107,18 @@ function _extractStatement(statement, source) {
         },
     };
 }
+/**
+ * Combine the JSDoc leading-description text and any unhandled `@rule` blocks into a single markup content string.
+ * - Unhandled rules (anything not `@param`/`@returns`/`@throws`/`@example`) are appended after the description, separated by blank lines, with their `@name` preserved.
+ * - Returns `undefined` if both are empty.
+ */
+function _buildJSDocContent(description, unhandled) {
+    if (!description)
+        return unhandled;
+    if (!unhandled)
+        return description;
+    return `${description}\n\n${unhandled}`;
+}
 /** Check if a statement has an `export` modifier. */
 function _isExported(statement) {
     const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined;
@@ -199,7 +211,8 @@ function _getClassMembers(statement, source) {
             if (modifiers?.some(m => m.kind === ts.SyntaxKind.PrivateKeyword || m.kind === ts.SyntaxKind.ProtectedKeyword))
                 continue;
         }
-        const description = _getJSDoc(member, source)?.description;
+        const memberJSDoc = _getJSDoc(member, source);
+        const content = _buildJSDocContent(memberJSDoc?.description, memberJSDoc?.unhandled);
         if (ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) {
             const params = member.parameters.map(p => p.getText(source)).join(", ");
             const ret = member.type ? member.type.getText(source) : "void";
@@ -217,7 +230,7 @@ function _getClassMembers(statement, source) {
                 members.push({
                     type: "tree-documentation",
                     key,
-                    props: { name, description, kind: "method", signatures: [signature] },
+                    props: { name, content, kind: "method", signatures: [signature] },
                 });
             }
         }
@@ -226,12 +239,14 @@ function _getClassMembers(statement, source) {
             members.push({
                 type: "tree-documentation",
                 key: requireSlug(name),
-                props: { name, description, kind: "property", signatures: type ? [type] : undefined },
+                props: { name, content, kind: "property", signatures: type ? [type] : undefined },
             });
         }
     }
     return members.length ? members : undefined;
 }
+/** `@rule` names handled by dedicated parsers — everything else is appended to `unhandled` as raw markup. */
+const _HANDLED_RULES = new Set(["param", "params", "return", "returns", "throw", "throws", "example", "examples"]);
 /** Extract JSDoc from a node. */
 function _getJSDoc(node, source) {
     const ranges = ts.getLeadingCommentRanges(source.text, node.pos);
@@ -250,15 +265,54 @@ function _getJSDoc(node, source) {
         const returns = _parseJSDocReturns(text);
         const throws = _parseJSDocThrows(text);
         const examples = _parseJSDocExamples(text);
+        const unhandled = _parseJSDocUnhandled(text);
         return {
             description: description || undefined,
             params: params.length ? params : undefined,
             returns: returns.length ? returns : undefined,
             throws: throws.length ? throws : undefined,
             examples: examples.length ? examples : undefined,
+            unhandled,
         };
     }
 }
+/**
+ * Walk the JSDoc body for `@rule` blocks not handled by dedicated parsers (param/returns/throws/example).
+ * - Each rule block extends from its `@name` line up to the next `@rule` or the end of the docblock.
+ * - Returns the unhandled blocks joined by blank lines as `@name body`, preserved verbatim for downstream markup rendering.
+ * - Returns `undefined` if every rule is handled or there are none.
+ */
+function _parseJSDocUnhandled(text) {
+    const body = text
+        .replace(/^\/\*\*\s*/, "")
+        .replace(/\s*\*\/$/, "")
+        .split("\n")
+        .map(l => l.replace(/^\s*\*\s?/, ""))
+        .join("\n");
+    const sections = [];
+    let currentName;
+    let currentLines = [];
+    const flush = () => {
+        if (currentName && !_HANDLED_RULES.has(currentName)) {
+            sections.push(`@${currentName} ${currentLines.join("\n")}`.trimEnd());
+        }
+        currentName = undefined;
+        currentLines = [];
+    };
+    for (const line of body.split("\n")) {
+        const match = line.match(/^@(\w+)\s*(.*)$/);
+        if (match) {
+            flush();
+            currentName = match[1];
+            currentLines = match[2] ? [match[2]] : [];
+        }
+        else if (currentName) {
+            currentLines.push(line);
+        }
+    }
+    flush();
+    return sections.length ? sections.join("\n\n") : undefined;
+}
 /** Parse a JSDoc comment block into its description text. */
 function _parseJSDocComment(text) {
     const lines = text

package/markup/rule/index.d.ts

@@ -1,3 +1,4 @@
+import type { MarkupOptions } from "../util/options.js";
 import type { MarkupRules } from "../util/rule.js";
 /** Markup rules that work in a block context. */
 export declare const MARKUP_RULES_BLOCK: MarkupRules;
@@ -30,6 +31,8 @@ export declare const MARKUP_RULES_INLINE: MarkupRules;
  *   - If the first thing in the definition isn't a URL, then it's recognised as a sidenote/footnote and tapping it will scroll you to that point (and popup the definition like Marco Arment's Bigfoot code).
  */
 export declare const MARKUP_RULES: MarkupRules;
+/** Default markup options — uses `MARKUP_RULES` with no other overrides. */
+export declare const MARKUP_OPTIONS: MarkupOptions;
 export * from "./blockquote.js";
 export * from "./code.js";
 export * from "./fenced.js";

package/markup/rule/index.js

@@ -48,6 +48,8 @@ export const MARKUP_RULES_INLINE = [CODE_RULE, LINK_RULE, AUTOLINK_RULE, INLINE_
  *   - If the first thing in the definition isn't a URL, then it's recognised as a sidenote/footnote and tapping it will scroll you to that point (and popup the definition like Marco Arment's Bigfoot code).
  */
 export const MARKUP_RULES = [...MARKUP_RULES_BLOCK, ...MARKUP_RULES_INLINE];
+/** Default markup options — uses `MARKUP_RULES` with no other overrides. */
+export const MARKUP_OPTIONS = { rules: MARKUP_RULES };
 export * from "./blockquote.js";
 export * from "./code.js";
 export * from "./fenced.js";

package/markup/rule/link.js

@@ -1,16 +1,16 @@
 import { formatURI } from "../../util/format.js";
+import { getLink } from "../../util/link.js";
 import { getRegExp } from "../../util/regexp.js";
-import { getURI, HTTP_SCHEMES } from "../../util/uri.js";
-import { getURL } from "../../util/url.js";
+import { HTTP_SCHEMES } from "../../util/uri.js";
 import { renderMarkup } from "../render.js";
 import { REACT_ELEMENT_TYPE } from "../util/internal.js";
 import { createMarkupRule } from "../util/rule.js";
 /** Render `<a href="">` if the link is a valid one, or `<a>` (with no `href`) if it isn't. */
 function renderLinkMarkupRule({ groups: { title, href: unsafeHref } }, options, key) {
-    const { base, schemes = HTTP_SCHEMES, rel } = options;
-    const uri = getURL(unsafeHref, base) ?? getURI(unsafeHref);
-    const href = uri && schemes.includes(uri.protocol) ? uri.href : undefined;
-    const children = title ? renderMarkup(title, options, "link") : uri ? formatURI(uri) : "";
+    const { url, root, schemes = HTTP_SCHEMES, rel } = options;
+    const resolved = getLink(unsafeHref, url, root);
+    const href = resolved && schemes.some(s => resolved.startsWith(s)) ? resolved : undefined;
+    const children = title ? renderMarkup(title, options, "link") : resolved ? formatURI(resolved) : "";
     return {
         key,
         $$typeof: REACT_ELEMENT_TYPE,

package/markup/util/options.d.ts

@@ -1,5 +1,5 @@
 import type { URISchemes } from "../../util/uri.js";
-import type { URLString } from "../../util/url.js";
+import type { ImmutableURL } from "../../util/url.js";
 import type { MarkupRules } from "./rule.js";
 /** The current parsing options (represents the current state of the parsing). */
 export type MarkupOptions = {
@@ -11,10 +11,15 @@ export type MarkupOptions = {
      */
     readonly rel?: string | undefined;
     /**
-     * Set the base URL that any relative URLs will be relative to
-     * @default `window.location.href` in browser environments, and `undefined` in server environments.
+     * Current page URL — used as the base for resolving relative refs (`./foo`, `#x`, bare segments) in link hrefs.
+     * @default Falls back to `root` if not set.
      */
-    readonly base?: URLString | undefined;
+    readonly url?: ImmutableURL | undefined;
+    /**
+     * Site root URL — used as the base for resolving site-absolute path hrefs (`/foo`), honoring its subfolder.
+     * @default Falls back to `url` if not set.
+     */
+    readonly root?: ImmutableURL | undefined;
     /**
      * Valid URI schemes/protocols for URLs and URIs.
      * @example ["http:", "https:"]

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.208.0",
+	"version": "1.209.0",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",
@@ -15,7 +15,7 @@
 		"@types/bun": "^1.3.14",
 		"@types/react": "^19.2.14",
 		"@types/react-dom": "^19.2.3",
-		"@typescript/native-preview": "^7.0.0-dev.20260514.1",
+		"@typescript/native-preview": "^7.0.0-dev.20260516.1",
 		"firebase": "^12.13.0",
 		"react": "^19.3.0-canary-fef12a01-20260413",
 		"react-dom": "^19.3.0-canary-fef12a01-20260413",