@avocadostudio-ai/shared 0.3.3 → 0.5.0

package/dist/links.d.ts

@@ -17,7 +17,14 @@
  * never decides what the editor may type.
  */
 /** How a link string addresses its target. */
-export type LinkKind = "empty" | "page" | "external" | "email" | "phone" | "anchor";
+export type LinkKind = "empty" | "page" | "file" | "external" | "email" | "phone" | "anchor";
+/** Does this route-shaped path name a document rather than a page? */
+export declare function isFilePath(path: string): boolean;
+/**
+ * The file extensions this module recognises, for a caller that has to describe
+ * them — an upload control's `accept`, a picker's filter, a docs page.
+ */
+export declare function knownFileExtensions(): string[];
 /** A link string, classified. */
 export type ParsedLink = {
     kind: LinkKind;
@@ -59,19 +66,49 @@ export declare function normalizeLinkPath(path: string): string;
  * disagree about what "dead" means.
  */
 export declare function isKnownRoute(path: string, knownSlugs: Iterable<string>): boolean;
+/**
+ * A document the site can link to, as the editor needs to know it.
+ *
+ * `path` is what goes in the link. Everything else is for showing it to a
+ * person, and every field but `path` is optional because a site that answers
+ * this question from a directory listing has only the path.
+ */
+export type LinkFileOption = {
+    /** The URL to link to — `/downloads/menu-de.pdf`. */
+    path: string;
+    /** What to call it in a picker. Defaults to the filename. */
+    name?: string;
+    /** MIME type, when the store knows it. */
+    contentType?: string;
+    /** Bytes, when the store knows it — a picker shows it, nothing decides on it. */
+    size?: number;
+};
 /** A parsed link plus what the site knows about its target. */
 export type ResolvedLink = ParsedLink & {
     /** The matching page, when `kind` is `page` and the route is known. */
     page?: LinkPageOption;
-    /** True for a `page` link whose route matches nothing the site knows about. */
+    /** The matching document, when `kind` is `file` and the asset list has it. */
+    file?: LinkFileOption;
+    /**
+     * True for a link whose target matches nothing the site knows about.
+     *
+     * For a `page` this is decided from the slug list, which is always present.
+     * For a `file` it is decided from the asset list, which is *not* — a site
+     * that cannot enumerate its documents passes none, and then `missing` stays
+     * undefined rather than becoming `true`. "We did not check" and "it is not
+     * there" have to stay distinguishable, or every site without an asset store
+     * would report all of its own documents as broken.
+     */
     missing?: boolean;
 };
 /**
- * Classify a link *and* look up its page. Pages may be keyed by `slug` or by
+ * Classify a link *and* look up its target. Pages may be keyed by `slug` or by
  * `path` (they differ on locale-prefixed sites — see
  * `docs/ideas/page-identity-punch-list.md`), so both are matched.
+ *
+ * `files` is optional and its absence is meaningful — see `missing` above.
  */
-export declare function resolveLink(value: unknown, pages?: readonly LinkPageOption[]): ResolvedLink;
+export declare function resolveLink(value: unknown, pages?: readonly LinkPageOption[], files?: readonly LinkFileOption[]): ResolvedLink;
 /**
  * How well a page answers what was typed, from 0 (nothing in common) to 1.
  *
@@ -84,8 +121,72 @@ export declare function resolveLink(value: unknown, pages?: readonly LinkPageOpt
  * (see `tokenWeights`); without it every word counts the same.
  */
 export declare function scoreLinkCandidate(query: string, page: LinkPageOption, corpus?: readonly LinkPageOption[]): number;
-/** Known pages ranked by how well they answer `query`, best first. */
+/**
+ * Known pages ranked by how well they answer `query`, best first.
+ *
+ * Held to the same floor as `suggestLinkTarget`, which it did not used to be:
+ * anything sharing a single token came back, so on a tri-lingual site every
+ * `/fr/*` page answered every French-flavoured query. Typing a document path
+ * into the link picker listed `/fr/`, `/fr/faq/` and `/fr/evenements/` — six
+ * rows of pages, each one click away from replacing a working PDF link with a
+ * link to the FAQ. A near-miss still ranks well above the floor; what the floor
+ * removes is the coincidence.
+ */
 export declare function rankLinkTargets(query: string, pages: readonly LinkPageOption[]): LinkPageOption[];
+/**
+ * Known documents ranked by how well they answer `query`, best first.
+ *
+ * The same scorer as pages, and the corpus weighting is what makes it work
+ * here: every document on a site shares its directory and its extension, so
+ * `downloads` and `pdf` identify nothing and are weighted to nearly nothing,
+ * while the part of the filename someone got wrong is what decides the order.
+ *
+ * This is the half a substring filter cannot do. `AadventureArenaBerm` is a
+ * real filename on a real site, typo included; a person typing it from memory
+ * gets one character wrong and a substring match returns nothing at all —
+ * which reads exactly like "this site has no such document".
+ */
+export declare function rankFileTargets(query: string, files: readonly LinkFileOption[]): LinkFileOption[];
+/** What a link picker should offer for what has been typed so far. */
+export type LinkSuggestions = {
+    pages: LinkPageOption[];
+    files: LinkFileOption[];
+};
+/**
+ * The pages and documents to offer for a partly-typed link.
+ *
+ * Two surfaces ask this question — the property panel's link field and the
+ * prose editor's link popover — and they answered it with their own inline
+ * copies of "substring, else rank". The copies disagreed, and both made the
+ * same mistake: they ranked *pages* for a query the parser had already
+ * classified as a document. A screenshot of the result is why this function
+ * exists — `/downloads/…-Gruppen-FR.pdf` typed in, six pages offered, not one
+ * of the site's fifteen PDFs among them.
+ *
+ * So the kind decides which list is offered at all:
+ *
+ * - a document path offers documents, never pages;
+ * - a route offers pages, and any document whose path literally contains what
+ *   was typed (`menu` should still find the menu PDFs);
+ * - `mailto:`, `tel:`, `#anchor` and `https://` offer neither — there is
+ *   nothing on this site they could mean, and the caller's empty state can say
+ *   so instead.
+ *
+ * Within a kind, a literal substring is what a person typing into a box
+ * expects, and ranking is the fallback for when nothing matches literally.
+ */
+export declare function suggestLinkTargets(query: string, options?: {
+    pages?: readonly LinkPageOption[];
+    files?: readonly LinkFileOption[];
+    limit?: number;
+    /**
+     * With an empty box, list the site's first documents alongside its pages.
+     * The prose picker wants that — it is how an editor discovers the site has
+     * documents at all. The link *field* does not: a document shelf under every
+     * link field would bury the pages, which is what a link usually wants.
+     */
+    browseFiles?: boolean;
+}): LinkSuggestions;
 /**
  * The page a dead internal link probably meant.
  *
@@ -120,3 +221,23 @@ export declare function linkAttrs(href: unknown, newTab?: unknown): {
     target?: string;
     rel?: string;
 };
+/**
+ * Every href inside a richtext value.
+ *
+ * A link is not only a `link`-kind prop. Most of the links on a real page are
+ * written *into* prose — `[Menükarte](/downloads/menu-de.pdf)` — and every
+ * link-aware surface we have was walking declared fields only. So the four
+ * menu-PDF links on a live site's Bistro section were not checked, not
+ * rewritten on rename, and not reported; the one linking to a filename with a
+ * typo in it had been wrong since August with nothing able to notice.
+ *
+ * Three shapes, because a richtext value is three things depending on where it
+ * came from: markdown (a site that projects its CMS prose to markdown), a
+ * ProseMirror document (the editor's own format), and raw HTML (a block with a
+ * loose schema). Walking all three costs one function and means a caller never
+ * has to know which it was handed.
+ *
+ * Returns hrefs in document order, duplicates included — a caller that reports
+ * findings wants one per occurrence, and a caller that wants a set can make one.
+ */
+export declare function linksInRichText(value: unknown): string[];

package/dist/links.js

@@ -16,6 +16,53 @@
  * a rewrite and be invisible from here. `resolveLink` reports what it knows; it
  * never decides what the editor may type.
  */
+/**
+ * Extensions that mean "this path is a document, not a route".
+ *
+ * A site's menu PDF lives at `/downloads/menu-de.pdf`, which has every
+ * syntactic property of an internal route and is not one. Classified as a page
+ * it resolves against the slug list, matches nothing, and comes back
+ * `missing: true` — so the editor's link field shows a broken-page warning on
+ * a link that works, and `seo.internal-link-dead` would report every document
+ * on the site. The distinction cannot come from the shape of the string; the
+ * extension is the only signal there is.
+ *
+ * Deliberately documents and archives only. Images are absent because an image
+ * belongs to the `image` kind and its own picker, and media extensions are
+ * absent because a `.mp4` in a link is nearly always an embed URL. A path with
+ * no extension, or one not listed here, stays a page — the failure that costs
+ * something is calling a route a file, not the reverse.
+ */
+const FILE_EXTENSIONS = new Set([
+    "pdf",
+    "doc", "docx", "rtf", "odt",
+    "xls", "xlsx", "csv", "ods",
+    "ppt", "pptx", "odp",
+    "zip", "gz", "tar",
+    "txt", "ics", "vcf", "epub"
+]);
+/**
+ * The extension of a path, lowercased, or "" — from the last segment only, so
+ * a dot in a directory name (`/v1.2/guide`) is not read as one.
+ */
+function extensionOf(path) {
+    const segment = path.split("/").pop() ?? "";
+    const dot = segment.lastIndexOf(".");
+    if (dot <= 0 || dot === segment.length - 1)
+        return "";
+    return segment.slice(dot + 1).toLowerCase();
+}
+/** Does this route-shaped path name a document rather than a page? */
+export function isFilePath(path) {
+    return FILE_EXTENSIONS.has(extensionOf(path));
+}
+/**
+ * The file extensions this module recognises, for a caller that has to describe
+ * them — an upload control's `accept`, a picker's filter, a docs page.
+ */
+export function knownFileExtensions() {
+    return [...FILE_EXTENSIONS];
+}
 /**
  * A bare "/" is the default value every link field is born with
  * (`defaultScalarForField`), so treating it as a real link to the homepage
@@ -64,7 +111,16 @@ export function parseLink(value) {
      * offer matches while you type.
      */
     const [pathPart = "", ...rest] = trimmed.split(/(?=[?#])/);
-    return { kind: "page", raw, path: pathPart, suffix: rest.join("") || undefined };
+    const suffix = rest.join("") || undefined;
+    /*
+     * A document is not a route. Decided here rather than at each call site so
+     * the editor's warning, the dead-link check and the rename rewriter cannot
+     * disagree about it — the reason this module exists at all.
+     */
+    if (isFilePath(pathPart)) {
+        return { kind: "file", raw, path: pathPart, suffix, target: pathPart };
+    }
+    return { kind: "page", raw, path: pathPart, suffix };
 }
 /**
  * Give a route its leading slash and drop a trailing one.
@@ -94,13 +150,26 @@ export function isKnownRoute(path, knownSlugs) {
     const normalized = normalizeLinkPath(target);
     return known.has(target) || known.has(normalized) || known.has(`${normalized}/`);
 }
+/** Compare two link paths the way a reader would: slashes and case-in-host aside. */
+function samePath(a, b) {
+    return normalizeLinkPath(a) === normalizeLinkPath(b);
+}
 /**
- * Classify a link *and* look up its page. Pages may be keyed by `slug` or by
+ * Classify a link *and* look up its target. Pages may be keyed by `slug` or by
  * `path` (they differ on locale-prefixed sites — see
  * `docs/ideas/page-identity-punch-list.md`), so both are matched.
+ *
+ * `files` is optional and its absence is meaningful — see `missing` above.
  */
-export function resolveLink(value, pages = []) {
+export function resolveLink(value, pages = [], files) {
     const parsed = parseLink(value);
+    if (parsed.kind === "file") {
+        if (!files)
+            return parsed;
+        const wanted = parsed.path ?? "";
+        const file = files.find((f) => samePath(f.path, wanted));
+        return file ? { ...parsed, file } : { ...parsed, missing: true };
+    }
     if (parsed.kind !== "page")
         return parsed;
     const wanted = normalizeLinkPath(parsed.path ?? "");
@@ -181,14 +250,97 @@ export function scoreLinkCandidate(query, page, corpus) {
  * none — the editor has to stop and rule it out.
  */
 const SUGGESTION_MIN_SCORE = 0.45;
-/** Known pages ranked by how well they answer `query`, best first. */
+/**
+ * Known pages ranked by how well they answer `query`, best first.
+ *
+ * Held to the same floor as `suggestLinkTarget`, which it did not used to be:
+ * anything sharing a single token came back, so on a tri-lingual site every
+ * `/fr/*` page answered every French-flavoured query. Typing a document path
+ * into the link picker listed `/fr/`, `/fr/faq/` and `/fr/evenements/` — six
+ * rows of pages, each one click away from replacing a working PDF link with a
+ * link to the FAQ. A near-miss still ranks well above the floor; what the floor
+ * removes is the coincidence.
+ */
 export function rankLinkTargets(query, pages) {
     return pages
         .map((page) => ({ page, score: scoreLinkCandidate(query, page, pages) }))
-        .filter((entry) => entry.score > 0)
+        .filter((entry) => entry.score >= SUGGESTION_MIN_SCORE)
         .sort((a, b) => b.score - a.score)
         .map((entry) => entry.page);
 }
+/** A document, in the shape the page scorer reads. */
+function fileAsPage(file) {
+    return { slug: file.path, ...(file.name ? { title: file.name } : {}) };
+}
+/**
+ * Known documents ranked by how well they answer `query`, best first.
+ *
+ * The same scorer as pages, and the corpus weighting is what makes it work
+ * here: every document on a site shares its directory and its extension, so
+ * `downloads` and `pdf` identify nothing and are weighted to nearly nothing,
+ * while the part of the filename someone got wrong is what decides the order.
+ *
+ * This is the half a substring filter cannot do. `AadventureArenaBerm` is a
+ * real filename on a real site, typo included; a person typing it from memory
+ * gets one character wrong and a substring match returns nothing at all —
+ * which reads exactly like "this site has no such document".
+ */
+export function rankFileTargets(query, files) {
+    const corpus = files.map(fileAsPage);
+    return files
+        .map((file) => ({ file, score: scoreLinkCandidate(query, fileAsPage(file), corpus) }))
+        .filter((entry) => entry.score >= SUGGESTION_MIN_SCORE)
+        .sort((a, b) => b.score - a.score)
+        .map((entry) => entry.file);
+}
+/**
+ * The pages and documents to offer for a partly-typed link.
+ *
+ * Two surfaces ask this question — the property panel's link field and the
+ * prose editor's link popover — and they answered it with their own inline
+ * copies of "substring, else rank". The copies disagreed, and both made the
+ * same mistake: they ranked *pages* for a query the parser had already
+ * classified as a document. A screenshot of the result is why this function
+ * exists — `/downloads/…-Gruppen-FR.pdf` typed in, six pages offered, not one
+ * of the site's fifteen PDFs among them.
+ *
+ * So the kind decides which list is offered at all:
+ *
+ * - a document path offers documents, never pages;
+ * - a route offers pages, and any document whose path literally contains what
+ *   was typed (`menu` should still find the menu PDFs);
+ * - `mailto:`, `tel:`, `#anchor` and `https://` offer neither — there is
+ *   nothing on this site they could mean, and the caller's empty state can say
+ *   so instead.
+ *
+ * Within a kind, a literal substring is what a person typing into a box
+ * expects, and ranking is the fallback for when nothing matches literally.
+ */
+export function suggestLinkTargets(query, options = {}) {
+    const { pages = [], files, limit = 6, browseFiles = false } = options;
+    const trimmed = query.trim();
+    const kind = parseLink(trimmed).kind;
+    if (kind === "empty") {
+        return {
+            pages: pages.slice(0, limit),
+            files: browseFiles ? (files ?? []).slice(0, limit) : []
+        };
+    }
+    if (kind !== "page" && kind !== "file")
+        return { pages: [], files: [] };
+    const needle = trimmed.toLowerCase();
+    const matchesFile = (file) => file.path.toLowerCase().includes(needle) || (file.name ?? "").toLowerCase().includes(needle);
+    const known = files ?? [];
+    const literalFiles = known.filter(matchesFile);
+    const fileMatches = literalFiles.length > 0 ? literalFiles : kind === "file" ? rankFileTargets(trimmed, known) : [];
+    if (kind === "file")
+        return { pages: [], files: fileMatches.slice(0, limit) };
+    const literalPages = pages.filter((page) => page.slug.toLowerCase().includes(needle) ||
+        (page.path ?? "").toLowerCase().includes(needle) ||
+        (page.title ?? "").toLowerCase().includes(needle));
+    const pageMatches = literalPages.length > 0 ? literalPages : rankLinkTargets(trimmed, pages);
+    return { pages: pageMatches.slice(0, limit), files: fileMatches.slice(0, limit) };
+}
 /**
  * The page a dead internal link probably meant.
  *
@@ -256,3 +408,102 @@ export function linkAttrs(href, newTab) {
     }
     return { href: value };
 }
+// ---------------------------------------------------------------------------
+// Links written inside prose
+// ---------------------------------------------------------------------------
+/**
+ * Every href inside a richtext value.
+ *
+ * A link is not only a `link`-kind prop. Most of the links on a real page are
+ * written *into* prose — `[Menükarte](/downloads/menu-de.pdf)` — and every
+ * link-aware surface we have was walking declared fields only. So the four
+ * menu-PDF links on a live site's Bistro section were not checked, not
+ * rewritten on rename, and not reported; the one linking to a filename with a
+ * typo in it had been wrong since August with nothing able to notice.
+ *
+ * Three shapes, because a richtext value is three things depending on where it
+ * came from: markdown (a site that projects its CMS prose to markdown), a
+ * ProseMirror document (the editor's own format), and raw HTML (a block with a
+ * loose schema). Walking all three costs one function and means a caller never
+ * has to know which it was handed.
+ *
+ * Returns hrefs in document order, duplicates included — a caller that reports
+ * findings wants one per occurrence, and a caller that wants a set can make one.
+ */
+export function linksInRichText(value) {
+    const out = [];
+    collectLinks(value, out);
+    return out;
+}
+/**
+ * Markdown inline links. Images (`![alt](src)`) are matched only so the leading
+ * `!` can be seen and the match discarded — an image src is not a link and must
+ * not be route-checked.
+ *
+ * Two forms for the destination, because markdown has two: `<...>`, which
+ * exists precisely so a path may contain spaces, and the bare form, which may
+ * not. Written as separate branches rather than one optional bracket, since a
+ * pattern that forbids spaces inside the brackets silently drops exactly the
+ * links the brackets were there for.
+ */
+const MARKDOWN_LINK_RE = /(!?)\[(?:[^\]\\]|\\.)*\]\(\s*(?:<([^>]*)>|([^\s)]+))(?:\s+["'(][^)]*)?\s*\)/g;
+const HTML_HREF_RE = /<a\b[^>]*?\bhref\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s">]+))/gi;
+function collectLinks(value, out) {
+    if (typeof value === "string") {
+        for (const m of value.matchAll(MARKDOWN_LINK_RE)) {
+            // `!` marks an image, whose src is not a link and must not be route-checked.
+            if (m[1] === "!")
+                continue;
+            const href = m[2] ?? m[3];
+            if (href)
+                out.push(href);
+        }
+        for (const m of value.matchAll(HTML_HREF_RE)) {
+            const href = m[1] ?? m[2] ?? m[3];
+            if (href)
+                out.push(href);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            collectLinks(entry, out);
+        return;
+    }
+    if (typeof value !== "object" || value === null)
+        return;
+    const node = value;
+    /*
+     * A ProseMirror link is a mark on a text node, and Portable Text keeps the
+     * same idea in `markDefs`. Both put the target under `href`, so reading that
+     * covers the editor's own documents and a CMS's alike.
+     */
+    const marks = node.marks;
+    if (Array.isArray(marks)) {
+        for (const mark of marks) {
+            if (typeof mark !== "object" || mark === null)
+                continue;
+            const attrs = mark.attrs;
+            const href = isRecordish(attrs) ? attrs.href : undefined;
+            if (typeof href === "string" && href)
+                out.push(href);
+        }
+    }
+    const markDefs = node.markDefs;
+    if (Array.isArray(markDefs)) {
+        for (const def of markDefs) {
+            const href = isRecordish(def) ? def.href : undefined;
+            if (typeof href === "string" && href)
+                out.push(href);
+        }
+    }
+    if (typeof node.href === "string" && node.href && node.type !== "image")
+        out.push(node.href);
+    for (const key of ["content", "children", "blocks"]) {
+        if (Array.isArray(node[key]))
+            collectLinks(node[key], out);
+    }
+}
+function isRecordish(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/panel-coverage.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Can a human actually edit this site in the property panel?
+ *
+ * `editableCoverage` answers the same question for the *preview*: which fields
+ * carry a marker the overlay can find. This is the panel's half, and it was the
+ * half with no check at all — which is why a real integration shipped a panel
+ * whose list rows read `Item 4`, `Item 5`, whose labels came from somebody
+ * else's block, and whose polymorphic branches were never narrowed. Every one of
+ * those was visible in the data the whole time. Nobody was asking.
+ *
+ * The check needs no browser, no screenshot and no model. It has the manifest
+ * (what the panel will render) and the site's own pages (what the rows really
+ * contain), and every finding below is a disagreement between the two.
+ *
+ * It resolves metadata through `resolveEditorBlockMeta` and rows through
+ * `resolveListItemFields` — the same functions the panel itself uses — so its
+ * findings are the panel's behaviour rather than a model of it. A checker that
+ * approximates the panel reports gaps the panel does not have and misses the
+ * ones it does, and gets switched off within a week.
+ *
+ * Pass `builtinTypes` (the registry the *editor* will run with) to get the
+ * collision findings. Without it, collisions are simply not reported — an
+ * absent input is never evidence.
+ */
+import { type EditorBlockDefinition } from "./editor-block-meta.ts";
+import type { BlockMeta, FieldMeta } from "./blocks/_registry.ts";
+export type PanelFindingCode = 
+/** A list row the panel labels `Item N` — present in the content, unidentifiable in the panel. */
+"unlabelled_row"
+/** A row whose discriminant value has no branch, so it is edited against the union of all branches. */
+ | "unmatched_branch"
+/** A list declares a discriminator and no branch map, or vice versa. */
+ | "incomplete_polymorphism"
+/** A prop the content holds that no field or list describes — uneditable, and invisible. */
+ | "orphan_prop"
+/** A field declared for rows that no row ever has. Panel noise. */
+ | "phantom_field"
+/** The type name exists in the editor's own registry with a different shape. */
+ | "colliding_type"
+/** An image row labelled by its filename while a populated alt field sits beside it. */
+ | "filename_row_label";
+export type PanelFinding = {
+    code: PanelFindingCode;
+    blockType: string;
+    /** Where the problem is, in the same path grammar operations use. */
+    path?: string;
+    /** One page slug that exhibits it, so the report points somewhere. */
+    exampleSlug?: string;
+    /** How many occurrences across everything examined. */
+    count: number;
+    detail: string;
+};
+export type PanelCoverage = {
+    /** List rows examined across every page. */
+    rowsExamined: number;
+    /** Rows the panel can label from their own content. */
+    rowsLabelled: number;
+    findings: PanelFinding[];
+    /** Block types on a page that the manifest does not describe. Not our business, but worth saying. */
+    unknownBlockTypes: string[];
+};
+type PageLike = {
+    slug?: string;
+    blocks?: Array<{
+        type?: string;
+        props?: Record<string, unknown>;
+    } | null | undefined>;
+};
+type ManifestLike = {
+    blocks: EditorBlockDefinition[];
+};
+/**
+ * The label the panel puts on a collapsed list row.
+ *
+ * Mirrors `PropertyPanel`'s own derivation exactly, including its fallbacks: the
+ * first text-ish field with a value, else the filename of the first image, else
+ * `Item N`. Kept here so the two cannot drift — the panel imports this.
+ */
+export declare function deriveRowLabel(fields: Record<string, FieldMeta>, item: Record<string, unknown>, index: number, options?: {
+    discriminator?: string;
+}): {
+    label: string;
+    source: "text" | "filename" | "fallback";
+};
+export declare function panelCoverage(manifest: ManifestLike, pages: PageLike[], options?: {
+    builtinTypes?: Record<string, BlockMeta>;
+}): PanelCoverage;
+/** A human-readable report, in the shape `formatEditableCoverage` uses. */
+export declare function formatPanelCoverage(report: PanelCoverage): string;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avocadostudio-ai/shared",
-  "version": "0.3.3",
+  "version": "0.5.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,7 +19,7 @@
   ],
   "dependencies": {
     "zod": "^4.3.6",
-    "@avocadostudio-ai/richtext": "^0.3.3"
+    "@avocadostudio-ai/richtext": "^0.5.0"
   },
   "devDependencies": {
     "tsx": "^4.21.0",