@ai-matrx/rich-content 0.0.0 → 0.2.3

package/dist/display/types.d.ts

@@ -0,0 +1,32 @@
+import { DisplayTheme } from "./themes.js";
+export interface MarkdownTableData {
+    headers: string[];
+    rows: string[][];
+    originalContent?: string;
+}
+export interface MarkdownTableProps {
+    data: MarkdownTableData;
+    className?: string;
+    fontSize?: number;
+    theme?: DisplayTheme;
+    onSave?: (data: MarkdownTableData) => void;
+}
+export interface SectionItem {
+    name: string;
+}
+export interface MarkdownTable {
+    title: string;
+    data: MarkdownTableData;
+}
+export interface Section {
+    title: string;
+    intro: string;
+    items: SectionItem[];
+    tables: MarkdownTable[];
+    outro: string;
+}
+export interface ParsedContent {
+    intro: string;
+    sections: Section[];
+    outro: string;
+}

package/dist/host/ContentIrHostBoundary.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The content-IR render host for content-ir-react, from `configureRichContent({ contentIrHost })`.
+ * A bare host renders children without a host provider (announced).
+ */
+import type { ReactNode } from "react";
+export declare function ContentIrHostBoundary({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/host/ContentIrHostBoundary.js

@@ -0,0 +1,15 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { ContentIrRenderProvider } from "@ai-matrx/content-ir-react";
+import { announceBareHost, hostCapability } from "./registry.js";
+function ContentIrHostBoundary({ children }) {
+  const host = hostCapability("contentIrHost");
+  if (!host) {
+    announceBareHost("contentIrHost", "kinds render without the host's render seams");
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  }
+  return /* @__PURE__ */ jsx(ContentIrRenderProvider, { host, children });
+}
+export {
+  ContentIrHostBoundary
+};

package/dist/host/ErrorActions.d.ts

@@ -0,0 +1,4 @@
+export declare function ErrorAlchemyMenu({ error }: {
+    error: unknown;
+}): import("react").JSX.Element | null;
+export { ErrorAlchemyMenu as ErrorActions };

package/dist/host/ErrorActions.js

@@ -0,0 +1,11 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { hostCapability } from "./registry.js";
+function ErrorAlchemyMenu({ error }) {
+  const Actions = hostCapability("ErrorActions");
+  return Actions ? /* @__PURE__ */ jsx(Actions, { error }) : null;
+}
+export {
+  ErrorAlchemyMenu as ErrorActions,
+  ErrorAlchemyMenu
+};

package/dist/host/NestedContent.d.ts

@@ -0,0 +1,3 @@
+export declare function NestedRichContent({ source }: {
+    source: string;
+}): import("react").JSX.Element;

package/dist/host/NestedContent.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { announceBareHost, BARE_HOST_ATTR, hostCapability } from "./registry.js";
+function NestedRichContent({ source }) {
+  const Nested = hostCapability("NestedContent");
+  if (Nested) return /* @__PURE__ */ jsx(Nested, { source });
+  announceBareHost("NestedContent", "nested content shows as plain text");
+  return /* @__PURE__ */ jsx("div", { ...BARE_HOST_ATTR, className: "whitespace-pre-wrap", children: source });
+}
+export {
+  NestedRichContent
+};

package/dist/host/ResourcePeek.d.ts

@@ -0,0 +1,6 @@
+export declare function ResourcePeekHost(props: {
+    kind: string;
+    id: string;
+    onClose: () => void;
+}): import("react").JSX.Element | null;
+export declare function hasResourcePeek(): boolean;

package/dist/host/ResourcePeek.js

@@ -0,0 +1,14 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { hostCapability } from "./registry.js";
+function ResourcePeekHost(props) {
+  const Peek = hostCapability("ResourcePeek");
+  return Peek ? /* @__PURE__ */ jsx(Peek, { ...props }) : null;
+}
+function hasResourcePeek() {
+  return Boolean(hostCapability("ResourcePeek"));
+}
+export {
+  ResourcePeekHost,
+  hasResourcePeek
+};

package/dist/host/component-registry.d.ts

@@ -0,0 +1,2 @@
+import type { RichContentComponentRegistry } from "./types.js";
+export declare const componentRegistry: RichContentComponentRegistry;

package/dist/host/component-registry.js

@@ -0,0 +1,25 @@
+import { ComponentResolver } from "@ai-matrx/content-ir-react";
+import { announceBareHost, hostCapability } from "./registry.js";
+const EMPTY_KEY = /* @__PURE__ */ Symbol.for("ai-matrx.rich-content.empty-component-resolver");
+function empty() {
+  const g = globalThis;
+  return g[EMPTY_KEY] ??= Object.assign(new ComponentResolver({}), {
+    wasRefused: () => false,
+    debugSnapshot: () => ({ host: "bare" })
+  });
+}
+function current() {
+  const r = hostCapability("componentRegistry");
+  if (!r) announceBareHost("componentRegistry", "no kind components resolve beyond the compiled floor");
+  return r ?? empty();
+}
+const componentRegistry = new Proxy({}, {
+  get(_t, key) {
+    const r = current();
+    const v = r[key];
+    return typeof v === "function" ? v.bind(r) : v;
+  }
+});
+export {
+  componentRegistry
+};

package/dist/host/diagnostics.d.ts

@@ -0,0 +1,2 @@
+import type { RichContentErrorReport } from "./types.js";
+export declare function captureError(report: RichContentErrorReport): void;

package/dist/host/diagnostics.js

@@ -0,0 +1,15 @@
+import { hostCapability } from "./registry.js";
+function captureError(report) {
+  const sink = hostCapability("captureError");
+  if (sink) {
+    try {
+      sink(report);
+      return;
+    } catch {
+    }
+  }
+  console.error(`[rich-content:${report.source}] ${report.message}`, report);
+}
+export {
+  captureError
+};

package/dist/host/index.d.ts

@@ -0,0 +1,3 @@
+/** `@ai-matrx/rich-content/host` — configure the engine once at the app root. */
+export { configureRichContent, resetRichContentHost, hostCapability, subscribeRichContentHost, richContentHostVersion, announceBareHost, BARE_HOST_ATTR, } from "./registry.js";
+export type { RichContentHost, RichContentToast, RichContentErrorReport, RichContentWikilinks, RichContentPerson, RichContentSplitterEnvelopes, WikiResolution, } from "./types.js";

package/dist/host/index.js

@@ -0,0 +1,18 @@
+import {
+  configureRichContent,
+  resetRichContentHost,
+  hostCapability,
+  subscribeRichContentHost,
+  richContentHostVersion,
+  announceBareHost,
+  BARE_HOST_ATTR
+} from "./registry.js";
+export {
+  BARE_HOST_ATTR,
+  announceBareHost,
+  configureRichContent,
+  hostCapability,
+  resetRichContentHost,
+  richContentHostVersion,
+  subscribeRichContentHost
+};

package/dist/host/kind-incident.d.ts

@@ -0,0 +1,3 @@
+import type { RichContentKindIncident } from "./types.js";
+export type KindComponentIncidentInput = RichContentKindIncident;
+export declare function reportKindComponentIncident(input: RichContentKindIncident): void;

package/dist/host/kind-incident.js

@@ -0,0 +1,12 @@
+import { hostCapability } from "./registry.js";
+function reportKindComponentIncident(input) {
+  const report = hostCapability("reportKindComponentIncident");
+  if (report) {
+    report(input);
+    return;
+  }
+  console.warn(`[rich-content] kind component incident (${input.errorType}) for "${input.kind}": ${input.message}`);
+}
+export {
+  reportKindComponentIncident
+};

package/dist/host/kind-registry.d.ts

@@ -0,0 +1,2 @@
+import type { RichContentKindRegistry } from "./types.js";
+export declare const kindRegistry: RichContentKindRegistry;

package/dist/host/kind-registry.js

@@ -0,0 +1,35 @@
+import { announceBareHost, hostCapability } from "./registry.js";
+const noop = () => {
+};
+const EMPTY = {
+  getDefinition: () => void 0,
+  getSchema: () => void 0,
+  getEmittedJsonSchema: () => void 0,
+  getDeclaredLoadingComponent: () => null,
+  isKnownKind: () => false,
+  isRenderableKind: () => false,
+  listDefinitions: () => [],
+  getKindVersion: () => 0,
+  subscribeKind: () => noop,
+  getVersion: () => 0,
+  subscribeVersion: () => noop,
+  ensureWarm: () => Promise.resolve(),
+  requestSchema: noop,
+  onSchemaArrived: () => noop,
+  resolver: () => ({ get: () => void 0 })
+};
+function current() {
+  const r = hostCapability("kindRegistry");
+  if (!r) announceBareHost("kindRegistry", "no kinds are known (kind JSON renders through the generic structured floor)");
+  return r ?? EMPTY;
+}
+const kindRegistry = new Proxy({}, {
+  get(_t, key) {
+    const r = current();
+    const v = r[key];
+    return typeof v === "function" ? v.bind(r) : v;
+  }
+});
+export {
+  kindRegistry
+};

package/dist/host/people.d.ts

@@ -0,0 +1,3 @@
+import type { RichContentPerson } from "./types.js";
+export declare function resolveVisiblePerson(id: string): Promise<RichContentPerson | null>;
+export type VisiblePerson = RichContentPerson;

package/dist/host/people.js

@@ -0,0 +1,12 @@
+import { announceBareHost, hostCapability } from "./registry.js";
+async function resolveVisiblePerson(id) {
+  const resolve = hostCapability("resolvePerson");
+  if (!resolve) {
+    announceBareHost("resolvePerson", "@mentions stay unresolved");
+    return null;
+  }
+  return resolve(id);
+}
+export {
+  resolveVisiblePerson
+};

package/dist/host/registry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * THE HOST of @ai-matrx/rich-content — one object, configured once at the app root.
+ *
+ * The engine renders without any host: every capability below has an honest default that
+ * announces itself (a console line once per capability, and `data-rich-content-host="bare"`
+ * on the elements it degrades). A host fills in only what it has — identity, sinks,
+ * navigation, its own windows and records.
+ *
+ * State lives on `globalThis` under a `Symbol.for` key: a dual-loader graph (Next.js server +
+ * client, Jest module registries) splits module state, and a second empty host would silently
+ * downgrade every surface it rendered.
+ */
+import type { RichContentHost } from "./types.js";
+/** Register (or extend) the host. Later calls merge over earlier ones, capability by capability. */
+export declare function configureRichContent(partial: Partial<RichContentHost>): void;
+/** Test seam: forget every registration. */
+export declare function resetRichContentHost(): void;
+/** The registered capability, or undefined (callers apply their own documented default). */
+export declare function hostCapability<K extends keyof RichContentHost>(key: K): RichContentHost[K] | undefined;
+export declare function subscribeRichContentHost(listener: () => void): () => void;
+export declare function richContentHostVersion(): number;
+/** Announce ONCE that a capability fell back to its default (never silently). */
+export declare function announceBareHost(capability: string, degraded: string): void;
+/** The DOM marker every degraded element carries. */
+export declare const BARE_HOST_ATTR: {
+    readonly "data-rich-content-host": "bare";
+};

package/dist/host/registry.js

@@ -0,0 +1,55 @@
+const HOST_KEY = /* @__PURE__ */ Symbol.for("ai-matrx.rich-content.host");
+const ANNOUNCED_KEY = /* @__PURE__ */ Symbol.for("ai-matrx.rich-content.host.announced");
+function store() {
+  const g = globalThis;
+  let s = g[HOST_KEY];
+  if (!s) {
+    s = { host: {}, version: 0, listeners: /* @__PURE__ */ new Set() };
+    g[HOST_KEY] = s;
+  }
+  return s;
+}
+function configureRichContent(partial) {
+  const s = store();
+  s.host = { ...s.host, ...partial };
+  s.version += 1;
+  for (const l of s.listeners) l();
+}
+function resetRichContentHost() {
+  const s = store();
+  s.host = {};
+  s.version += 1;
+  for (const l of s.listeners) l();
+}
+function hostCapability(key) {
+  return store().host[key];
+}
+function subscribeRichContentHost(listener) {
+  const s = store();
+  s.listeners.add(listener);
+  return () => s.listeners.delete(listener);
+}
+function richContentHostVersion() {
+  return store().version;
+}
+function announceBareHost(capability, degraded) {
+  const g = globalThis;
+  let seen = g[ANNOUNCED_KEY];
+  if (!seen) {
+    seen = /* @__PURE__ */ new Set();
+    g[ANNOUNCED_KEY] = seen;
+  }
+  if (seen.has(capability)) return;
+  seen.add(capability);
+  console.warn(`[@ai-matrx/rich-content] The host registered no "${capability}", so ${degraded}.`);
+}
+const BARE_HOST_ATTR = { "data-rich-content-host": "bare" };
+export {
+  BARE_HOST_ATTR,
+  announceBareHost,
+  configureRichContent,
+  hostCapability,
+  resetRichContentHost,
+  richContentHostVersion,
+  subscribeRichContentHost
+};

package/dist/host/splitter-envelopes.d.ts

@@ -0,0 +1,2 @@
+import type { RichContentSplitterEnvelopes } from "./types.js";
+export declare function hostSplitterEnvelopes(): RichContentSplitterEnvelopes | undefined;

package/dist/host/splitter-envelopes.js

@@ -0,0 +1,7 @@
+import { hostCapability } from "./registry.js";
+function hostSplitterEnvelopes() {
+  return hostCapability("splitterEnvelopes");
+}
+export {
+  hostSplitterEnvelopes
+};

package/dist/host/tables.d.ts

@@ -0,0 +1,6 @@
+export declare function useOpenSaveToTable(): ((options: {
+    grid: {
+        headers: string[];
+        rows: string[][];
+    };
+}) => unknown) | null;

package/dist/host/tables.js

@@ -0,0 +1,8 @@
+import { hostCapability } from "./registry.js";
+const none = () => null;
+function useOpenSaveToTable() {
+  return (hostCapability("useOpenSaveToTable") ?? none)();
+}
+export {
+  useOpenSaveToTable
+};

package/dist/host/toast.d.ts

@@ -0,0 +1,2 @@
+import type { RichContentToast } from "./types.js";
+export declare const toast: RichContentToast;

package/dist/host/toast.js

@@ -0,0 +1,57 @@
+import { announceBareHost, hostCapability } from "./registry.js";
+function text(message) {
+  return typeof message === "string" ? message : typeof message === "function" ? "[toast]" : String(message);
+}
+const consoleToast = Object.assign(
+  (message) => {
+    announceBareHost("toast", "notices go to the console");
+    console.info(`[rich-content] ${text(message)}`);
+    return Date.now();
+  },
+  {
+    success: (m) => {
+      announceBareHost("toast", "notices go to the console");
+      console.info(`[rich-content] \u2713 ${text(m)}`);
+      return Date.now();
+    },
+    error: (m) => {
+      announceBareHost("toast", "notices go to the console");
+      console.error(`[rich-content] ${text(m)}`);
+      return Date.now();
+    },
+    info: (m) => {
+      announceBareHost("toast", "notices go to the console");
+      console.info(`[rich-content] ${text(m)}`);
+      return Date.now();
+    },
+    warning: (m) => {
+      announceBareHost("toast", "notices go to the console");
+      console.warn(`[rich-content] ${text(m)}`);
+      return Date.now();
+    },
+    loading: (m) => {
+      announceBareHost("toast", "notices go to the console");
+      console.info(`[rich-content] \u2026 ${text(m)}`);
+      return Date.now();
+    },
+    dismiss: () => {
+    }
+  }
+);
+function current() {
+  return hostCapability("toast") ?? consoleToast;
+}
+const toast = Object.assign(
+  ((message, data) => current()(message, data)),
+  {
+    success: ((m, d) => current().success(m, d)),
+    error: ((m, d) => current().error(m, d)),
+    info: ((m, d) => current().info(m, d)),
+    warning: ((m, d) => current().warning(m, d)),
+    loading: ((m, d) => current().loading(m, d)),
+    dismiss: ((id) => current().dismiss(id))
+  }
+);
+export {
+  toast
+};

package/dist/host/types.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Every capability the engine may ask of its host. All optional: each has a documented default
+ * in the module that reads it. Add a capability here, never an import of the app.
+ */
+import type { ComponentType, ReactNode } from "react";
+import type { KindDefinition, KindSchema } from "@ai-matrx/content-ir";
+import type { ComponentResolver, ContentIrHost } from "@ai-matrx/content-ir-react";
+/** The host's kind registry (matrx-frontend: features/content-ir/registry/kind-registry `kindRegistry`). */
+export interface RichContentKindRegistry {
+    getDefinition(kind: string): KindDefinition | undefined;
+    getSchema(kind: string): KindSchema | undefined;
+    getEmittedJsonSchema(kind: string): unknown;
+    getDeclaredLoadingComponent(kind: string): string | null;
+    isKnownKind(kind: string): boolean;
+    isRenderableKind(kind: string): boolean;
+    listDefinitions(): KindDefinition[];
+    getKindVersion(kind: string): number;
+    subscribeKind(kind: string, listener: () => void): () => void;
+    getVersion(): number;
+    subscribeVersion(listener: () => void): () => void;
+    ensureWarm(): Promise<void>;
+    requestSchema(kind: string): void;
+    onSchemaArrived(listener: (kind: string, schema: KindSchema | null) => void): () => void;
+    resolver(): {
+        get(kind: string): KindSchema | undefined;
+        request?(kind: string): void;
+    };
+}
+/** The host's component registry: content-ir-react's resolver plus its refusal + debug reads. */
+export type RichContentComponentRegistry = ComponentResolver & {
+    wasRefused(kind: string): boolean;
+    debugSnapshot(kind: string | null): Record<string, unknown>;
+};
+/** One kind-component render incident (matrx-frontend files it to `log_kind_component_incident`). */
+export interface RichContentKindIncident {
+    kind: string;
+    errorType: string;
+    message: string;
+    platform?: string;
+    role?: string;
+    componentKey?: string | null;
+    componentUpdatedAt?: string | null;
+    stack?: string | null;
+    data?: unknown;
+}
+/** The structural toast the host passes in (matrx-frontend: `lib/toast` `toast`). */
+export interface RichContentToast {
+    (message: ReactNode, data?: Record<string, unknown>): string | number;
+    success(message: ReactNode, data?: Record<string, unknown>): string | number;
+    error(message: ReactNode, data?: Record<string, unknown>): string | number;
+    info(message: ReactNode, data?: Record<string, unknown>): string | number;
+    warning(message: ReactNode, data?: Record<string, unknown>): string | number;
+    loading(message: ReactNode, data?: Record<string, unknown>): string | number;
+    dismiss(id?: string | number): void;
+}
+/** An error report (shape of matrx-frontend's Error Inspector `captureError` input). */
+export interface RichContentErrorReport {
+    source: string;
+    message: string;
+    [field: string]: unknown;
+}
+/** A wikilink target resolved against the host's records. */
+export type WikiResolution = {
+    status: "found";
+    token: string;
+    id: string;
+    title: string;
+    href: string | null;
+    typeLabel: string;
+} | {
+    status: "missing";
+    title: string;
+} | {
+    status: "unavailable";
+    title: string;
+    message: string;
+};
+/** The host's records behind `[[wikilinks]]` and `![[embeds]]`. */
+export interface RichContentWikilinks {
+    resolve(target: string): Promise<WikiResolution>;
+    /** Create the missing page named `title` in the host's active organization. */
+    create(title: string): Promise<{
+        ok: true;
+        href: string | null;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    /** The markdown body of a found record, for an embed on its own line. */
+    loadBody(token: string, id: string): Promise<{
+        body: string;
+    } | {
+        error: string;
+    }>;
+}
+/** A person visible to the viewer, for an `@mention`. */
+export interface RichContentPerson {
+    userId: string;
+    name: string;
+    role?: string | null;
+    [field: string]: unknown;
+}
+/** The splitter's content-IR envelope hooks (matrx-frontend binds its kind registry). */
+export interface RichContentSplitterEnvelopes {
+    withIrEnvelope(source: string, metadata: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+    fenceRegion(language: string, regionText: string): unknown;
+    xmlRegion(tag: string, regionText: string): unknown;
+}
+export interface RichContentHost {
+    /** User-visible notices. Default: the console (announced). */
+    toast: RichContentToast;
+    /** The Error Inspector sink. Default: `console.error`. */
+    captureError: (report: RichContentErrorReport) => void;
+    /** An error notice with the host's error actions. Default: the message in a bordered box. */
+    ErrorNotice: ComponentType<{
+        error: unknown;
+        title?: string;
+        className?: string;
+        children?: ReactNode;
+        [prop: string]: unknown;
+    }>;
+    /** Extra actions beside an error message (matrx-frontend: the Alchemy error menu). Default: none — the message itself always shows. */
+    ErrorActions: ComponentType<{
+        error: unknown;
+    }>;
+    /** Renders nested markdown at the `standard` level, one depth deeper. Default: the source as plain text. */
+    NestedContent: ComponentType<{
+        source: string;
+    }>;
+    /** `[[wikilinks]]` against the host's records. Default: every link reads "unavailable". */
+    wikilinks: RichContentWikilinks;
+    /** `@mentions` of people. Default: the label as written, unresolved. */
+    resolvePerson: (id: string) => Promise<RichContentPerson | null>;
+    /** The host's record peek for a person or resource. Default: none (the chip is not clickable). */
+    ResourcePeek: ComponentType<{
+        kind: string;
+        id: string;
+        onClose: () => void;
+    }>;
+    /** The splitter's kind-envelope hooks. Default: no envelopes (regions carry no `metadata.__ir`). */
+    splitterEnvelopes: RichContentSplitterEnvelopes;
+    /** A hook returning the host's "save these rows as a table" opener, or null. Default: no opener (the button is absent). */
+    useOpenSaveToTable: () => ((options: {
+        grid: {
+            headers: string[];
+            rows: string[][];
+        };
+    }) => unknown) | null;
+    /** The kind registry. Default: no kinds known (kind JSON renders through the generic structured floor). */
+    kindRegistry: RichContentKindRegistry;
+    /** The (kind, platform, role) component resolver. Default: a resolver with no rows. */
+    componentRegistry: RichContentComponentRegistry;
+    /** The content-IR render host (seams + registries) for content-ir-react. Default: none — kinds render without host seams. */
+    contentIrHost: ContentIrHost;
+    /** Files a kind-component render incident. Default: the console. */
+    reportKindComponentIncident: (incident: RichContentKindIncident) => void;
+}

package/dist/host/wikilinks.d.ts

@@ -0,0 +1,15 @@
+import type { WikiResolution } from "./types.js";
+export declare function resolveWikiTarget(target: string): Promise<WikiResolution>;
+export declare function createWikiPage(title: string): Promise<{
+    ok: true;
+    href: string | null;
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare function loadWikiBody(token: string, id: string): Promise<{
+    body: string;
+} | {
+    error: string;
+}>;
+export type { WikiResolution };

package/dist/host/wikilinks.js

@@ -0,0 +1,23 @@
+import { announceBareHost, hostCapability } from "./registry.js";
+const BARE = "This document is not connected to any records.";
+function resolveWikiTarget(target) {
+  const w = hostCapability("wikilinks");
+  if (!w) {
+    announceBareHost("wikilinks", "every [[link]] reads unavailable");
+    return Promise.resolve({ status: "unavailable", title: target, message: BARE });
+  }
+  return w.resolve(target);
+}
+function createWikiPage(title) {
+  const w = hostCapability("wikilinks");
+  return w ? w.create(title) : Promise.resolve({ ok: false, error: BARE });
+}
+function loadWikiBody(token, id) {
+  const w = hostCapability("wikilinks");
+  return w ? w.loadBody(token, id) : Promise.resolve({ error: BARE });
+}
+export {
+  createWikiPage,
+  loadWikiBody,
+  resolveWikiTarget
+};