@ai-matrx/rich-content 0.2.9 → 0.2.15

package/dist/rich-document/RichDocumentActionProvider.js

@@ -0,0 +1,18 @@
+"use client";
+import { useActionSurfaceProvider } from "./runtime/useActionSurfaceProvider.js";
+function RichDocumentActionProvider(props) {
+  const { content, source, surfaceId, actions } = props;
+  useActionSurfaceProvider({
+    content,
+    source,
+    actions,
+    actionsVariant: "remote",
+    actionsSurfaceId: surfaceId
+  });
+  return null;
+}
+var RichDocumentActionProvider_default = RichDocumentActionProvider;
+export {
+  RichDocumentActionProvider,
+  RichDocumentActionProvider_default as default
+};

package/dist/rich-document/RichDocumentActionSurface.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+export interface RichDocumentActionSurfaceProps {
+    surfaceId: string;
+    /** Which inline variant to render. Defaults to "bar". */
+    variant?: "bar" | "mini-bar" | "menu";
+    className?: string;
+    /** Rendered when no provider is currently registered. */
+    fallback?: React.ReactNode;
+}
+export declare function RichDocumentActionSurface(props: RichDocumentActionSurfaceProps): React.ReactElement | null;
+export default RichDocumentActionSurface;

package/dist/rich-document/RichDocumentActionSurface.js

@@ -0,0 +1,59 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { cn } from "@ai-matrx/design-system";
+import { useTopProvider } from "./runtime/actionSurfacesStore.js";
+import { getBridge } from "./runtime/providerBridge.js";
+import { ActionBar } from "./variants/ActionBar.js";
+import { MiniActionBar } from "./variants/MiniActionBar.js";
+import { MenuVariant } from "./variants/MenuVariant.js";
+function RichDocumentActionSurface(props) {
+  const { surfaceId, variant = "bar", className, fallback = null } = props;
+  const provider = useTopProvider(surfaceId);
+  if (!provider) {
+    return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+  }
+  const bridge = getBridge(provider.providerId);
+  if (!bridge) {
+    return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+  }
+  switch (variant) {
+    case "bar":
+      return /* @__PURE__ */ jsx(
+        ActionBar,
+        {
+          actions: bridge.resolvedActions,
+          getCtx: bridge.getCtx,
+          target: bridge.target,
+          sourceId: provider.contentSourceId,
+          className
+        }
+      );
+    case "mini-bar":
+      return /* @__PURE__ */ jsx(
+        MiniActionBar,
+        {
+          actions: bridge.resolvedActions,
+          getCtx: bridge.getCtx,
+          target: bridge.target,
+          sourceId: provider.contentSourceId,
+          className
+        }
+      );
+    case "menu":
+      return /* @__PURE__ */ jsx(
+        MenuVariant,
+        {
+          target: bridge.target,
+          getCtx: bridge.getCtx,
+          className: cn(className)
+        }
+      );
+    default:
+      return null;
+  }
+}
+var RichDocumentActionSurface_default = RichDocumentActionSurface;
+export {
+  RichDocumentActionSurface,
+  RichDocumentActionSurface_default as default
+};

package/dist/rich-document/RichDocumentActions.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+import type { ContentSource, RichDocumentActionsProp } from "./types.js";
+export interface RichDocumentActionsProps {
+    content: string;
+    source: ContentSource;
+    actions?: RichDocumentActionsProp;
+    className?: string;
+    /** Hide the ⋯ overflow menu (the primary row still renders). */
+    hideOverflow?: boolean;
+}
+export declare function RichDocumentActions(props: RichDocumentActionsProps): React.ReactElement;
+export default RichDocumentActions;

package/dist/rich-document/RichDocumentActions.js

@@ -0,0 +1,29 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useActionSurfaceProvider } from "./runtime/useActionSurfaceProvider.js";
+import { ActionBar } from "./variants/ActionBar.js";
+function RichDocumentActions(props) {
+  const { content, source, actions, className, hideOverflow } = props;
+  const { ctx, getCtx, resolvedActions, target } = useActionSurfaceProvider({
+    content,
+    source,
+    actions,
+    actionsVariant: "bar"
+  });
+  return /* @__PURE__ */ jsx(
+    ActionBar,
+    {
+      actions: resolvedActions,
+      getCtx,
+      target,
+      sourceId: ctx.instanceKey("alchemy"),
+      className,
+      hideOverflow
+    }
+  );
+}
+var RichDocumentActions_default = RichDocumentActions;
+export {
+  RichDocumentActions,
+  RichDocumentActions_default as default
+};

package/dist/rich-document/actions/hostActions.d.ts

@@ -0,0 +1,5 @@
+import type { RichDocumentAction } from "../types.js";
+/** "Clear" — the host empties its own content (a transcript pad). */
+export declare function clearContentAction(onClear: () => void, label?: string): RichDocumentAction;
+/** A host copy that joins more than this content (transcript + cleaned text). */
+export declare function hostCopyAction(id: string, label: string, run: () => void | Promise<void>): RichDocumentAction;

package/dist/rich-document/actions/hostActions.js

@@ -0,0 +1,31 @@
+import { Files, Trash2 } from "lucide-react";
+function clearContentAction(onClear, label = "Clear") {
+  return {
+    id: "host:clear-content",
+    label,
+    icon: Trash2,
+    iconColor: "text-muted-foreground",
+    category: "edit",
+    supportedSources: "*",
+    renderSlot: "both",
+    order: 90,
+    run: () => onClear()
+  };
+}
+function hostCopyAction(id, label, run) {
+  return {
+    id: `host:${id}`,
+    label,
+    icon: Files,
+    iconColor: "text-muted-foreground",
+    category: "copy",
+    supportedSources: "*",
+    renderSlot: "both",
+    order: 80,
+    run: () => run()
+  };
+}
+export {
+  clearContentAction,
+  hostCopyAction
+};

package/dist/rich-document/actions/labels.d.ts

@@ -0,0 +1,9 @@
+/** The engine half of the rich-document action helpers (the host keeps its handler helpers). */
+import type { RichDocumentActionContext } from "../types.js";
+/** Storage key for "do this action after the person signs in" payloads. */
+export declare const PENDING_ACTION_KEY = "matrx_pending_post_auth_action";
+/**
+ * Resolve an action label to a string. Supports both static labels and `(ctx) => string`
+ * callbacks so labels like "Edit history (3)" can pull counts from the live context.
+ */
+export declare function resolveActionLabel(label: string | ((ctx: RichDocumentActionContext) => string), ctx: RichDocumentActionContext): string;

package/dist/rich-document/actions/labels.js

@@ -0,0 +1,8 @@
+const PENDING_ACTION_KEY = "matrx_pending_post_auth_action";
+function resolveActionLabel(label, ctx) {
+  return typeof label === "function" ? label(ctx) : label;
+}
+export {
+  PENDING_ACTION_KEY,
+  resolveActionLabel
+};

package/dist/rich-document/actions/markdownTable.d.ts

@@ -0,0 +1,9 @@
+export interface ParsedTable {
+    headers: string[];
+    rows: string[][];
+}
+export declare function cleanCell(text: string): string;
+/** The first markdown table in `content`, or null when there is none. */
+export declare function parseFirstMarkdownTable(content: string): ParsedTable | null;
+/** RFC 4180 CSV (comma) or TSV (tab) text for a parsed table. */
+export declare function tableToDelimited(table: ParsedTable, delimiter: "," | "\t"): string;

package/dist/rich-document/actions/markdownTable.js

@@ -0,0 +1,39 @@
+import { tableToCsv } from "../../display/tables/table-csv.js";
+import { unwrapCodeSpans } from "@ai-matrx/content-ir/source";
+import {
+  findTableEnd,
+  rowCells,
+  tableStartsAt,
+  unescapeCellPipes
+} from "../../display/markdown-classification/processors/utils/gfm-table-lines.js";
+function splitRow(line) {
+  return rowCells(line).map((cell) => cleanCell(unescapeCellPipes(cell)));
+}
+function cleanCell(text) {
+  return unwrapCodeSpans(text).replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/~~([^~]+)~~/g, "$1").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1").replace(/<br\s*\/?>/gi, " ").trim();
+}
+function parseFirstMarkdownTable(content) {
+  const lines = content.split("\n");
+  for (let i = 0; i + 1 < lines.length; i += 1) {
+    if (!tableStartsAt(lines, i)) continue;
+    const headers = splitRow(lines[i]);
+    const rows = [];
+    const end = findTableEnd(lines, i);
+    for (let j = i + 2; j < end; j += 1) {
+      const cells = splitRow(lines[j]);
+      rows.push(headers.map((_, k) => cells[k] ?? ""));
+    }
+    return { headers, rows };
+  }
+  return null;
+}
+function tableToDelimited(table, delimiter) {
+  if (delimiter === ",") return tableToCsv(table.headers, table.rows);
+  const flat = (value) => value.replace(/[\t\r\n]+/g, " ");
+  return [table.headers, ...table.rows].map((row) => row.map(flat).join("	")).join("\n");
+}
+export {
+  cleanCell,
+  parseFirstMarkdownTable,
+  tableToDelimited
+};

package/dist/rich-document/actions/provider.d.ts

@@ -0,0 +1,58 @@
+import { type Action, type ActionProvider, type ClickTarget } from "@ai-matrx/alchemy/actions";
+import type { WriteTarget } from "@ai-matrx/alchemy/declare";
+import type { RichDocumentAction, RichDocumentActionContext, RichDocumentActionId } from "../types.js";
+export declare const RICH_DOCUMENT_PROVIDER_ID = "rich-document";
+/** The write target every source adapter serves (edit, delete, regenerate, fork…). */
+export declare const RICH_DOCUMENT_SOURCE_TARGET = "rich_document_source";
+export declare const SOURCE_WRITE_TARGET: WriteTarget;
+/** Register an action at module load. A duplicate id is refused. */
+export declare function registerAction(action: RichDocumentAction): void;
+/** Get one action by ID. Returns undefined if unregistered. */
+export declare function getAction(id: RichDocumentActionId | string): RichDocumentAction | undefined;
+/** Get all registered actions. */
+export declare function getAllActions(): RichDocumentAction[];
+/** The one id for a named menu group, shared with the context-menu provider. */
+export declare function richDocumentSectionId(label: string): string;
+export interface RichDocumentTargetHost {
+    kind: "rich-document";
+    /** Render-time context: labels, shown/hidden, toggle state. */
+    ctx: RichDocumentActionContext;
+    /** Click-time context factory: what handlers run against (live content). */
+    getCtx: () => RichDocumentActionContext;
+    /** This host's own actions (the `actions.extra` prop). */
+    extra: readonly RichDocumentAction[];
+}
+/** The rich-document half of a composite host, for hosts that build one. */
+export declare function richDocumentTargetHost(ctx: RichDocumentActionContext, options?: {
+    getCtx?: () => RichDocumentActionContext;
+    extra?: readonly RichDocumentAction[];
+}): RichDocumentTargetHost;
+/** THE ClickTarget for a rich-document context. */
+export declare function richDocumentClickTarget(ctx: RichDocumentActionContext, options?: {
+    getCtx?: () => RichDocumentActionContext;
+    exclude?: readonly string[];
+    extra?: readonly RichDocumentAction[];
+}): ClickTarget;
+export declare function toAlchemyAction(rd: RichDocumentAction): Action;
+/**
+ * Register this provider into the app's one registry, once per registry.
+ * Called by the rich-document layouts (the only hosts that need it), so the
+ * app's root host never imports the handler graph.
+ */
+export declare function ensureRichDocumentProvider(registry: {
+    register(p: ActionProvider): () => void;
+}): void;
+/** The provider registered into the app's Alchemy action registry. */
+export declare const richDocumentActionProvider: ActionProvider;
+/** Re-render hook for hosts: the list changed (a handler module loaded). */
+export declare function subscribeRichDocumentActions(listener: () => void): () => void;
+/**
+ * The actions eligible for a context — synchronously, through the package's
+ * ONE eligibility pass. Used where a host needs the list during render (the
+ * remote-surface spec snapshot, the code-block bridge, the parity tests).
+ * A host extra whose id collides with a built-in is refused (the built-in wins).
+ */
+export declare function resolveActions(ctx: RichDocumentActionContext, options?: {
+    exclude?: (RichDocumentActionId | string)[];
+    extra?: RichDocumentAction[];
+}): RichDocumentAction[];

package/dist/rich-document/actions/provider.js

@@ -0,0 +1,245 @@
+import { holdDeliberateIntent } from "../../host/app-bindings.js";
+import {
+  computeEligibility,
+  createClickTarget
+} from "@ai-matrx/alchemy/actions";
+import { registerAlchemyIcon } from "../../utils/alchemy-icon-keys.js";
+import { MENU_STRUCTURE, menuStructureVersion } from "../variants/shared/menuStructure.js";
+import { resolveActionLabel } from "./labels.js";
+import { ensureRichDocumentRegistrations } from "../registrations.js";
+const RICH_DOCUMENT_PROVIDER_ID = "rich-document";
+const RICH_DOCUMENT_SOURCE_TARGET = "rich_document_source";
+const SOURCE_WRITE_TARGET = {
+  name: RICH_DOCUMENT_SOURCE_TARGET,
+  label: "This content",
+  description: "The record the content came from, changed through its source adapter.",
+  valueType: "document",
+  mode: "entity"
+};
+function store() {
+  const key = /* @__PURE__ */ Symbol.for("ai-matrx.rich-document.actions");
+  const g = globalThis;
+  let s = g[key];
+  if (!s) {
+    s = { actions: /* @__PURE__ */ new Map(), listeners: /* @__PURE__ */ new Set() };
+    g[key] = s;
+  }
+  return s;
+}
+function readStore() {
+  ensureRichDocumentRegistrations();
+  return store();
+}
+function registerAction(action) {
+  const { actions: ACTIONS, listeners } = store();
+  if (ACTIONS.has(action.id)) {
+    if (true) {
+      console.warn(
+        `[rich-document] action "${action.id}" re-registered (fast refresh) \u2014 replaced.`
+      );
+    } else {
+      throw new DuplicateActionError(action.id, RICH_DOCUMENT_PROVIDER_ID, RICH_DOCUMENT_PROVIDER_ID);
+    }
+  }
+  ACTIONS.set(action.id, action);
+  for (const l of [...listeners]) l();
+}
+function getAction(id) {
+  return readStore().actions.get(id);
+}
+function getAllActions() {
+  return Array.from(readStore().actions.values());
+}
+function richDocumentSectionId(label) {
+  return `rd:${label.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+}
+let placementCache = null;
+let placementVersion = -1;
+function placementOf(id) {
+  if (placementCache === null || placementVersion !== menuStructureVersion()) {
+    placementVersion = menuStructureVersion();
+    placementCache = buildPlacement();
+  }
+  return placementCache.get(id);
+}
+function buildPlacement() {
+  const map = /* @__PURE__ */ new Map();
+  MENU_STRUCTURE.forEach((section, sectionIndex) => {
+    section.actionIds.forEach((id, index) => {
+      const order = sectionIndex * 100 + index;
+      if (section.submenu === null || section.inline) {
+        map.set(id, { order });
+      } else {
+        const icon = section.icon ? registerAlchemyIcon(section.icon) : void 0;
+        map.set(id, {
+          order,
+          ...section.layoutCategory ? { category: section.layoutCategory } : {},
+          section: {
+            id: richDocumentSectionId(section.submenu),
+            label: section.submenu,
+            ...icon ? { icon } : {},
+            ...section.target ? { kind: "target" } : {}
+          }
+        });
+      }
+    });
+  });
+  return map;
+}
+const MENU_ALIASES = {
+  "regenerate-latest": "regenerate-response"
+};
+function hostOf(target) {
+  const host = target.host;
+  if (!host) return null;
+  if (host.kind === "rich-document") return host;
+  return host.richDocument?.kind === "rich-document" ? host.richDocument : null;
+}
+function richDocumentTargetHost(ctx, options = {}) {
+  return { kind: "rich-document", ctx, getCtx: options.getCtx ?? (() => ctx), extra: options.extra ?? [] };
+}
+function richDocumentClickTarget(ctx, options = {}) {
+  const readOnly = Boolean(ctx.source.readOnly);
+  const host = {
+    kind: "rich-document",
+    ctx,
+    getCtx: options.getCtx ?? (() => ctx),
+    extra: options.extra ?? []
+  };
+  return createClickTarget({
+    readOnly,
+    writable: readOnly ? [] : [SOURCE_WRITE_TARGET],
+    excludedActionIds: options.exclude ?? [],
+    organizationId: ctx.organizationId,
+    auth: { authenticated: ctx.isAuthenticated, admin: ctx.isAdmin, creator: ctx.isCreator },
+    payloadKinds: ["markdown"],
+    host
+  });
+}
+function eligibleFor(rd, target) {
+  const host = hostOf(target);
+  if (!host) return { status: "absent" };
+  const ctx = host.ctx;
+  if (rd.supportedSources !== "*" && !rd.supportedSources.includes(ctx.source.type)) {
+    return { status: "absent" };
+  }
+  if (rd.visible && !rd.visible(ctx)) return { status: "absent" };
+  const disabled = rd.disabled?.(ctx);
+  if (disabled === true || typeof disabled === "object" && disabled !== null) {
+    return { status: "absent" };
+  }
+  return { status: "available" };
+}
+const converted = /* @__PURE__ */ new WeakMap();
+function toAlchemyAction(rd) {
+  const cached = converted.get(rd);
+  if (cached) return cached;
+  const place = placementOf(rd.id);
+  const ctxOf = (t) => hostOf(t)?.ctx;
+  const action = {
+    id: rd.id,
+    provider: RICH_DOCUMENT_PROVIDER_ID,
+    label: (t) => {
+      const ctx = ctxOf(t);
+      return ctx ? resolveActionLabel(rd.label, ctx) : typeof rd.label === "string" ? rd.label : rd.id;
+    },
+    icon: registerAlchemyIcon(rd.icon),
+    ...rd.iconColor ? { iconTone: rd.iconColor } : {},
+    ...rd.stateIcon ? {
+      stateIcon: (t) => {
+        const ctx = ctxOf(t);
+        const live = ctx ? rd.stateIcon?.(ctx) : null;
+        return live ? { icon: registerAlchemyIcon(live.icon), ...live.spin ? { spin: true } : {} } : null;
+      }
+    } : {},
+    category: place?.category ?? rd.category,
+    order: place?.order ?? 1e4 + (rd.order ?? 0),
+    placement: rd.renderSlot ?? "overflow",
+    ...place?.section ? { section: place.section } : {},
+    ...rd.requiresAuth ? { requiresAuth: true } : {},
+    ...rd.writesSource ? { writes: [RICH_DOCUMENT_SOURCE_TARGET] } : {},
+    ...rd.preserveSelection ? { preserveSelection: true } : {},
+    ...rd.active ? {
+      pressed: (t) => {
+        const ctx = ctxOf(t);
+        return ctx ? Boolean(rd.active?.(ctx)) : false;
+      }
+    } : {},
+    ...rd.subscribe ? {
+      subscribe: (onChange, t) => {
+        const ctx = ctxOf(t);
+        if (!ctx || !rd.subscribe) return () => void 0;
+        let subscribing = true;
+        const off = rd.subscribe(() => {
+          if (!subscribing) onChange();
+        }, ctx);
+        subscribing = false;
+        return off;
+      }
+    } : {},
+    eligible: (t) => eligibleFor(rd, t),
+    run: async (t) => {
+      const host = hostOf(t);
+      if (!host) return;
+      await holdDeliberateIntent(() => rd.run(host.getCtx()));
+    }
+  };
+  converted.set(rd, action);
+  return action;
+}
+function candidates(target) {
+  const host = hostOf(target);
+  if (!host) return [];
+  const ACTIONS = readStore().actions;
+  const all = [...ACTIONS.values(), ...host.extra.filter((a) => !ACTIONS.has(a.id))];
+  const present = new Set(all.map((a) => a.id));
+  return all.filter((a) => {
+    const canonical = MENU_ALIASES[a.id];
+    return !(canonical && present.has(canonical));
+  });
+}
+const REGISTERED = /* @__PURE__ */ new WeakSet();
+function ensureRichDocumentProvider(registry) {
+  if (REGISTERED.has(registry)) return;
+  REGISTERED.add(registry);
+  registry.register(richDocumentActionProvider);
+}
+const richDocumentActionProvider = {
+  id: RICH_DOCUMENT_PROVIDER_ID,
+  tier: "T0",
+  declaredIds: () => [...readStore().actions.keys()],
+  actions: (target) => candidates(target).map(toAlchemyAction)
+};
+function subscribeRichDocumentActions(listener) {
+  const { listeners } = store();
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function resolveActions(ctx, options) {
+  const target = richDocumentClickTarget(ctx, {
+    exclude: options?.exclude ?? [],
+    extra: options?.extra ?? []
+  });
+  return candidates(target).filter((rd) => computeEligibility(toAlchemyAction(rd), target, { authResumable: false }).status === "available").sort((a, b) => {
+    if (a.category !== b.category) return a.category.localeCompare(b.category);
+    return (a.order ?? 0) - (b.order ?? 0);
+  });
+}
+export {
+  RICH_DOCUMENT_PROVIDER_ID,
+  RICH_DOCUMENT_SOURCE_TARGET,
+  SOURCE_WRITE_TARGET,
+  ensureRichDocumentProvider,
+  getAction,
+  getAllActions,
+  registerAction,
+  resolveActions,
+  richDocumentActionProvider,
+  richDocumentClickTarget,
+  richDocumentSectionId,
+  richDocumentTargetHost,
+  subscribeRichDocumentActions,
+  toAlchemyAction
+};

package/dist/rich-document/actions/resumePendingAuthAction.d.ts

@@ -0,0 +1,3 @@
+import type { RichDocumentActionContext } from "../types.js";
+/** Replay a stashed action when the context's content matches. Never throws. */
+export declare function resumePendingAuthAction(ctx: RichDocumentActionContext): void;

package/dist/rich-document/actions/resumePendingAuthAction.js

@@ -0,0 +1,31 @@
+import { getAction } from "./provider.js";
+import { PENDING_ACTION_KEY } from "./labels.js";
+function resumePendingAuthAction(ctx) {
+  if (!ctx.isAuthenticated) return;
+  let pending = null;
+  try {
+    const raw = sessionStorage.getItem(PENDING_ACTION_KEY);
+    if (!raw) return;
+    pending = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (!pending || pending.savedContent !== ctx.content) return;
+  try {
+    sessionStorage.removeItem(PENDING_ACTION_KEY);
+  } catch {
+  }
+  const action = typeof pending.action === "string" ? getAction(pending.action) : void 0;
+  if (!action) {
+    console.error(
+      `[RichDocument] post-auth resume: no registered action "${String(pending.action)}" \u2014 the pending request was dropped.`
+    );
+    return;
+  }
+  void Promise.resolve(action.run(ctx)).catch((err) => {
+    console.error(`[RichDocument] post-auth resume of ${action.id} threw`, err);
+  });
+}
+export {
+  resumePendingAuthAction
+};

package/dist/rich-document/actions/sources/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ContentSourceType → ContentSourceAdapter. The engine ships `raw`; the host registers the rest
+ * (matrx-frontend: chat-message, note, prompt-result, artifact, scraper-result, working-document)
+ * through `registerSourceAdapter`, on import of its registration module.
+ */
+import type { ContentSourceAdapter, ContentSourceType } from "../../types.js";
+/** Register (or replace) the adapter for one source type. */
+export declare function registerSourceAdapter(sourceType: ContentSourceType, adapter: ContentSourceAdapter): void;
+export declare function getSourceAdapter(sourceType: ContentSourceType): ContentSourceAdapter;

package/dist/rich-document/actions/sources/index.js

@@ -0,0 +1,22 @@
+import { rawAdapter } from "./raw.js";
+import { ensureRichDocumentRegistrations } from "../../registrations.js";
+const KEY = /* @__PURE__ */ Symbol.for("ai-matrx.rich-content.rich-document.source-adapters");
+function adapters() {
+  const g = globalThis;
+  return g[KEY] ??= /* @__PURE__ */ new Map([["raw", rawAdapter]]);
+}
+function registerSourceAdapter(sourceType, adapter) {
+  adapters().set(sourceType, adapter);
+}
+function getSourceAdapter(sourceType) {
+  ensureRichDocumentRegistrations();
+  const adapter = adapters().get(sourceType);
+  if (!adapter) {
+    throw new Error(`No source adapter registered for type: ${sourceType}`);
+  }
+  return adapter;
+}
+export {
+  getSourceAdapter,
+  registerSourceAdapter
+};

package/dist/rich-document/actions/sources/raw.d.ts

@@ -0,0 +1,4 @@
+import type { ContentSourceAdapter } from "../../types.js";
+declare function shortHash(input: string): string;
+export declare const rawAdapter: ContentSourceAdapter;
+export { shortHash };

package/dist/rich-document/actions/sources/raw.js

@@ -0,0 +1,35 @@
+const LONG_INPUT = 4096;
+const recent = /* @__PURE__ */ new Map();
+function shortHash(input) {
+  if (input.length >= LONG_INPUT) {
+    const hit = recent.get(input);
+    if (hit !== void 0) return hit;
+    const computed = fnv1a(input);
+    if (recent.size >= 8) recent.delete(recent.keys().next().value);
+    recent.set(input, computed);
+    return computed;
+  }
+  return fnv1a(input);
+}
+function fnv1a(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+const rawAdapter = {
+  instanceKeyPrefix: (source) => {
+    if (source.type !== "raw") {
+      throw new Error(
+        `rawAdapter received non-raw source: ${source.type}`
+      );
+    }
+    return "raw";
+  }
+};
+export {
+  rawAdapter,
+  shortHash
+};

package/dist/rich-document/actions/useRichDocumentProvider.d.ts

@@ -0,0 +1 @@
+export declare function useRichDocumentProvider(): void;