@immediately-run/sdk 0.29.0 → 0.30.0

package/dist/index.cjs

@@ -49,6 +49,7 @@ __reExport(index_exports, require("./ready"), module.exports);
 __reExport(index_exports, require("./loading"), module.exports);
 __reExport(index_exports, require("./protocolStream"), module.exports);
 __reExport(index_exports, require("./sandboxTypes"), module.exports);
+__reExport(index_exports, require("./safeContent"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./MDXProvider"),
@@ -84,6 +85,7 @@ __reExport(index_exports, require("./sandboxTypes"), module.exports);
   ...require("./ready"),
   ...require("./loading"),
   ...require("./protocolStream"),
-  ...require("./sandboxTypes")
+  ...require("./sandboxTypes"),
+  ...require("./safeContent")
 });
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from \"./MDXProvider\";\nexport * from \"./routing\";\nexport * from \"./boot\";\nexport * from './components/Include';\nexport * from './components/MDXComponents';\nexport * from './components/MountImage';\nexport * from './components/Routes';\nexport * from './hooks'\nexport * from './auth';\nexport * from './theme';\nexport * from './editorContext';\nexport * from './editor';\nexport * from './formFactor';\nexport * from './region';\nexport * from './mounts';\nexport * from './contribute';\nexport * from './catalog';\nexport * from './ipc';\nexport * from './dnd';\nexport * from './netFetch';\nexport * from './secrets';\nexport * from './llm';\nexport * from './diagnostics';\nexport * from './vcs';\nexport * from './onFsChange';\nexport * from './fs';\nexport * from './debug';\nexport * from './tasks';\nexport * from './runtime';\nexport * from './irMarkers';\nexport * from './ready';\nexport * from './loading';\nexport * from './protocolStream';\nexport * from './sandboxTypes';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,0BAAd;AACA,0BAAc,sBADd;AAEA,0BAAc,mBAFd;AAGA,0BAAc,iCAHd;AAIA,0BAAc,uCAJd;AAKA,0BAAc,oCALd;AAMA,0BAAc,gCANd;AAOA,0BAAc,oBAPd;AAQA,0BAAc,mBARd;AASA,0BAAc,oBATd;AAUA,0BAAc,4BAVd;AAWA,0BAAc,qBAXd;AAYA,0BAAc,yBAZd;AAaA,0BAAc,qBAbd;AAcA,0BAAc,qBAdd;AAeA,0BAAc,yBAfd;AAgBA,0BAAc,sBAhBd;AAiBA,0BAAc,kBAjBd;AAkBA,0BAAc,kBAlBd;AAmBA,0BAAc,uBAnBd;AAoBA,0BAAc,sBApBd;AAqBA,0BAAc,kBArBd;AAsBA,0BAAc,0BAtBd;AAuBA,0BAAc,kBAvBd;AAwBA,0BAAc,yBAxBd;AAyBA,0BAAc,iBAzBd;AA0BA,0BAAc,oBA1Bd;AA2BA,0BAAc,oBA3Bd;AA4BA,0BAAc,sBA5Bd;AA6BA,0BAAc,wBA7Bd;AA8BA,0BAAc,oBA9Bd;AA+BA,0BAAc,sBA/Bd;AAgCA,0BAAc,6BAhCd;AAiCA,0BAAc,2BAjCd;","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from \"./MDXProvider\";\nexport * from \"./routing\";\nexport * from \"./boot\";\nexport * from './components/Include';\nexport * from './components/MDXComponents';\nexport * from './components/MountImage';\nexport * from './components/Routes';\nexport * from './hooks'\nexport * from './auth';\nexport * from './theme';\nexport * from './editorContext';\nexport * from './editor';\nexport * from './formFactor';\nexport * from './region';\nexport * from './mounts';\nexport * from './contribute';\nexport * from './catalog';\nexport * from './ipc';\nexport * from './dnd';\nexport * from './netFetch';\nexport * from './secrets';\nexport * from './llm';\nexport * from './diagnostics';\nexport * from './vcs';\nexport * from './onFsChange';\nexport * from './fs';\nexport * from './debug';\nexport * from './tasks';\nexport * from './runtime';\nexport * from './irMarkers';\nexport * from './ready';\nexport * from './loading';\nexport * from './protocolStream';\nexport * from './sandboxTypes';\nexport * from './safeContent';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,0BAAd;AACA,0BAAc,sBADd;AAEA,0BAAc,mBAFd;AAGA,0BAAc,iCAHd;AAIA,0BAAc,uCAJd;AAKA,0BAAc,oCALd;AAMA,0BAAc,gCANd;AAOA,0BAAc,oBAPd;AAQA,0BAAc,mBARd;AASA,0BAAc,oBATd;AAUA,0BAAc,4BAVd;AAWA,0BAAc,qBAXd;AAYA,0BAAc,yBAZd;AAaA,0BAAc,qBAbd;AAcA,0BAAc,qBAdd;AAeA,0BAAc,yBAfd;AAgBA,0BAAc,sBAhBd;AAiBA,0BAAc,kBAjBd;AAkBA,0BAAc,kBAlBd;AAmBA,0BAAc,uBAnBd;AAoBA,0BAAc,sBApBd;AAqBA,0BAAc,kBArBd;AAsBA,0BAAc,0BAtBd;AAuBA,0BAAc,kBAvBd;AAwBA,0BAAc,yBAxBd;AAyBA,0BAAc,iBAzBd;AA0BA,0BAAc,oBA1Bd;AA2BA,0BAAc,oBA3Bd;AA4BA,0BAAc,sBA5Bd;AA6BA,0BAAc,wBA7Bd;AA8BA,0BAAc,oBA9Bd;AA+BA,0BAAc,sBA/Bd;AAgCA,0BAAc,6BAhCd;AAiCA,0BAAc,2BAjCd;AAkCA,0BAAc,0BAlCd;","names":[]}

package/dist/index.d.cts

@@ -32,6 +32,11 @@ export { ReadyState, __resetReady, __setReadyDeps, getReadyState, onReady, repor
 export { LOADING_TIMINGS, LoadingRegion, Skeleton, SkeletonArchetype, SkeletonRow, Spinner } from './loading.cjs';
 export { StreamError, StreamFrame, StreamTransport, consumeStream, protocolStream } from './protocolStream.cjs';
 export { EvaluationContext, FileQueryResult, FilesMetadata, Metadata, MetadataQueryEntry, MetadataQueryFunction, MetadataQueryResult, ModuleExports } from './sandboxTypes.cjs';
+export { SafeContent, SafeContentProps } from './safeContent/SafeContent.cjs';
+export { RenderMdastOptions, SafeContentComponents, renderMdast } from './safeContent/renderMdast.cjs';
+export { SafeMdastNode, SafeMdxAttribute, parseSafeMdast } from './safeContent/parseSafeMdast.cjs';
+export { sanitizeUrl } from './safeContent/sanitizeUrl.cjs';
+export { WikiLinkToken, WikiPart, parseWikiInner, splitWikiLinks } from './safeContent/wikilink.cjs';
 export { Admonition, AdmonitionType } from './components/Admonition.cjs';
 export { HeadingAnchor } from './components/HeadingAnchor.cjs';
 export { ImmediatelyRunGlobal, getHostRuntime } from './hostRuntime.cjs';

package/dist/index.d.ts

@@ -32,6 +32,11 @@ export { ReadyState, __resetReady, __setReadyDeps, getReadyState, onReady, repor
 export { LOADING_TIMINGS, LoadingRegion, Skeleton, SkeletonArchetype, SkeletonRow, Spinner } from './loading.js';
 export { StreamError, StreamFrame, StreamTransport, consumeStream, protocolStream } from './protocolStream.js';
 export { EvaluationContext, FileQueryResult, FilesMetadata, Metadata, MetadataQueryEntry, MetadataQueryFunction, MetadataQueryResult, ModuleExports } from './sandboxTypes.js';
+export { SafeContent, SafeContentProps } from './safeContent/SafeContent.js';
+export { RenderMdastOptions, SafeContentComponents, renderMdast } from './safeContent/renderMdast.js';
+export { SafeMdastNode, SafeMdxAttribute, parseSafeMdast } from './safeContent/parseSafeMdast.js';
+export { sanitizeUrl } from './safeContent/sanitizeUrl.js';
+export { WikiLinkToken, WikiPart, parseWikiInner, splitWikiLinks } from './safeContent/wikilink.js';
 export { Admonition, AdmonitionType } from './components/Admonition.js';
 export { HeadingAnchor } from './components/HeadingAnchor.js';
 export { ImmediatelyRunGlobal, getHostRuntime } from './hostRuntime.js';

package/dist/index.js

@@ -32,4 +32,5 @@ export * from "./ready";
 export * from "./loading";
 export * from "./protocolStream";
 export * from "./sandboxTypes";
+export * from "./safeContent";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from \"./MDXProvider\";\nexport * from \"./routing\";\nexport * from \"./boot\";\nexport * from './components/Include';\nexport * from './components/MDXComponents';\nexport * from './components/MountImage';\nexport * from './components/Routes';\nexport * from './hooks'\nexport * from './auth';\nexport * from './theme';\nexport * from './editorContext';\nexport * from './editor';\nexport * from './formFactor';\nexport * from './region';\nexport * from './mounts';\nexport * from './contribute';\nexport * from './catalog';\nexport * from './ipc';\nexport * from './dnd';\nexport * from './netFetch';\nexport * from './secrets';\nexport * from './llm';\nexport * from './diagnostics';\nexport * from './vcs';\nexport * from './onFsChange';\nexport * from './fs';\nexport * from './debug';\nexport * from './tasks';\nexport * from './runtime';\nexport * from './irMarkers';\nexport * from './ready';\nexport * from './loading';\nexport * from './protocolStream';\nexport * from './sandboxTypes';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from \"./MDXProvider\";\nexport * from \"./routing\";\nexport * from \"./boot\";\nexport * from './components/Include';\nexport * from './components/MDXComponents';\nexport * from './components/MountImage';\nexport * from './components/Routes';\nexport * from './hooks'\nexport * from './auth';\nexport * from './theme';\nexport * from './editorContext';\nexport * from './editor';\nexport * from './formFactor';\nexport * from './region';\nexport * from './mounts';\nexport * from './contribute';\nexport * from './catalog';\nexport * from './ipc';\nexport * from './dnd';\nexport * from './netFetch';\nexport * from './secrets';\nexport * from './llm';\nexport * from './diagnostics';\nexport * from './vcs';\nexport * from './onFsChange';\nexport * from './fs';\nexport * from './debug';\nexport * from './tasks';\nexport * from './runtime';\nexport * from './irMarkers';\nexport * from './ready';\nexport * from './loading';\nexport * from './protocolStream';\nexport * from './sandboxTypes';\nexport * from './safeContent';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/safeContent/SafeContent.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SafeContent_exports = {};
+__export(SafeContent_exports, {
+  SafeContent: () => SafeContent
+});
+module.exports = __toCommonJS(SafeContent_exports);
+var import_react = require("react");
+var import_parseSafeMdast = require("./parseSafeMdast");
+var import_renderMdast = require("./renderMdast");
+function SafeContent({ source, fallback = null, ...options }) {
+  const [tree, setTree] = (0, import_react.useState)(null);
+  const runId = (0, import_react.useRef)(0);
+  (0, import_react.useEffect)(() => {
+    const id = ++runId.current;
+    setTree(null);
+    let cancelled = false;
+    (0, import_parseSafeMdast.parseSafeMdast)(source).then((parsed) => {
+      if (!cancelled && runId.current === id) setTree(parsed);
+    }).catch(() => {
+      if (!cancelled && runId.current === id) setTree(null);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [source]);
+  const rendered = (0, import_react.useMemo)(
+    () => tree ? (0, import_renderMdast.renderMdast)(tree, options) : null,
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [tree, options.components, options.resolveWikiLink]
+  );
+  return tree ? rendered : fallback;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SafeContent
+});
+//# sourceMappingURL=SafeContent.cjs.map

package/dist/safeContent/SafeContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/safeContent/SafeContent.tsx"],"sourcesContent":["import { useEffect, useMemo, useRef, useState, type ReactNode } from 'react';\nimport { parseSafeMdast } from './parseSafeMdast';\nimport { renderMdast, type RenderMdastOptions } from './renderMdast';\n\n// `<SafeContent>` — the host/SDK-owned safe renderer (TRUST_MODES_SPEC §5.1,\n// AGENT_AUTHORING §10). An interpreter app renders untrusted Markdown/MDX-syntax\n// content — a shared board's body, a multi-writer wiki entry — through THIS component\n// so **no author JavaScript ever executes** while `<Component/>` syntax still reaches\n// the app's own safe components. It is the mandatory terminal for the MDX-from-mount\n// gate: a shared board is a multi-writer (M3) source, and compiled/executable MDX\n// would run board-author code with the app's authority (the WHITEBOARD §8 blast\n// radius this gate bounds).\n//\n// The parse (no-acorn, ESM-only deps) is async, so this renders a small placeholder\n// until the tree is ready, then the pure synchronous `renderMdast`. Parsing is keyed\n// on the source string; a changed source re-parses, and a stale async result is\n// discarded (the ref guard) so a fast source swap can't paint the wrong content.\n\nexport interface SafeContentProps extends RenderMdastOptions {\n  /** The untrusted Markdown/MDX-syntax source to render as data. */\n  source: string;\n  /** Rendered while the async parse is in flight (default: nothing). */\n  fallback?: ReactNode;\n}\n\nexport function SafeContent({ source, fallback = null, ...options }: SafeContentProps): ReactNode {\n  const [tree, setTree] = useState<Awaited<ReturnType<typeof parseSafeMdast>> | null>(null);\n  const runId = useRef(0);\n\n  useEffect(() => {\n    const id = ++runId.current;\n    setTree(null);\n    let cancelled = false;\n    parseSafeMdast(source)\n      .then((parsed) => {\n        // Discard a stale result (source changed / unmounted) so we never paint the\n        // wrong tree — the render-as-data guarantee also needs the RIGHT data shown.\n        if (!cancelled && runId.current === id) setTree(parsed);\n      })\n      .catch(() => {\n        if (!cancelled && runId.current === id) setTree(null);\n      });\n    return () => {\n      cancelled = true;\n    };\n  }, [source]);\n\n  // `renderMdast` is pure; memoise on the tree + the option identities the caller\n  // passes. (Callers should memoise `components`/`resolveWikiLink` themselves for a\n  // stable identity; changing them re-renders, which is correct.)\n  const rendered = useMemo(\n    () => (tree ? renderMdast(tree, options) : null),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [tree, options.components, options.resolveWikiLink],\n  );\n\n  return tree ? rendered : fallback;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAqE;AACrE,4BAA+B;AAC/B,yBAAqD;AAuB9C,SAAS,YAAY,EAAE,QAAQ,WAAW,MAAM,GAAG,QAAQ,GAAgC;AAChG,QAAM,CAAC,MAAM,OAAO,QAAI,uBAA4D,IAAI;AACxF,QAAM,YAAQ,qBAAO,CAAC;AAEtB,8BAAU,MAAM;AACd,UAAM,KAAK,EAAE,MAAM;AACnB,YAAQ,IAAI;AACZ,QAAI,YAAY;AAChB,8CAAe,MAAM,EAClB,KAAK,CAAC,WAAW;AAGhB,UAAI,CAAC,aAAa,MAAM,YAAY,GAAI,SAAQ,MAAM;AAAA,IACxD,CAAC,EACA,MAAM,MAAM;AACX,UAAI,CAAC,aAAa,MAAM,YAAY,GAAI,SAAQ,IAAI;AAAA,IACtD,CAAC;AACH,WAAO,MAAM;AACX,kBAAY;AAAA,IACd;AAAA,EACF,GAAG,CAAC,MAAM,CAAC;AAKX,QAAM,eAAW;AAAA,IACf,MAAO,WAAO,gCAAY,MAAM,OAAO,IAAI;AAAA;AAAA,IAE3C,CAAC,MAAM,QAAQ,YAAY,QAAQ,eAAe;AAAA,EACpD;AAEA,SAAO,OAAO,WAAW;AAC3B;","names":[]}

package/dist/safeContent/SafeContent.d.cts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { RenderMdastOptions } from './renderMdast.cjs';
+import './parseSafeMdast.cjs';
+
+interface SafeContentProps extends RenderMdastOptions {
+    /** The untrusted Markdown/MDX-syntax source to render as data. */
+    source: string;
+    /** Rendered while the async parse is in flight (default: nothing). */
+    fallback?: ReactNode;
+}
+declare function SafeContent({ source, fallback, ...options }: SafeContentProps): ReactNode;
+
+export { SafeContent, type SafeContentProps };

package/dist/safeContent/SafeContent.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { RenderMdastOptions } from './renderMdast.js';
+import './parseSafeMdast.js';
+
+interface SafeContentProps extends RenderMdastOptions {
+    /** The untrusted Markdown/MDX-syntax source to render as data. */
+    source: string;
+    /** Rendered while the async parse is in flight (default: nothing). */
+    fallback?: ReactNode;
+}
+declare function SafeContent({ source, fallback, ...options }: SafeContentProps): ReactNode;
+
+export { SafeContent, type SafeContentProps };

package/dist/safeContent/SafeContent.js

@@ -0,0 +1,30 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { parseSafeMdast } from "./parseSafeMdast";
+import { renderMdast } from "./renderMdast";
+function SafeContent({ source, fallback = null, ...options }) {
+  const [tree, setTree] = useState(null);
+  const runId = useRef(0);
+  useEffect(() => {
+    const id = ++runId.current;
+    setTree(null);
+    let cancelled = false;
+    parseSafeMdast(source).then((parsed) => {
+      if (!cancelled && runId.current === id) setTree(parsed);
+    }).catch(() => {
+      if (!cancelled && runId.current === id) setTree(null);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [source]);
+  const rendered = useMemo(
+    () => tree ? renderMdast(tree, options) : null,
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [tree, options.components, options.resolveWikiLink]
+  );
+  return tree ? rendered : fallback;
+}
+export {
+  SafeContent
+};
+//# sourceMappingURL=SafeContent.js.map

package/dist/safeContent/SafeContent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/safeContent/SafeContent.tsx"],"sourcesContent":["import { useEffect, useMemo, useRef, useState, type ReactNode } from 'react';\nimport { parseSafeMdast } from './parseSafeMdast';\nimport { renderMdast, type RenderMdastOptions } from './renderMdast';\n\n// `<SafeContent>` — the host/SDK-owned safe renderer (TRUST_MODES_SPEC §5.1,\n// AGENT_AUTHORING §10). An interpreter app renders untrusted Markdown/MDX-syntax\n// content — a shared board's body, a multi-writer wiki entry — through THIS component\n// so **no author JavaScript ever executes** while `<Component/>` syntax still reaches\n// the app's own safe components. It is the mandatory terminal for the MDX-from-mount\n// gate: a shared board is a multi-writer (M3) source, and compiled/executable MDX\n// would run board-author code with the app's authority (the WHITEBOARD §8 blast\n// radius this gate bounds).\n//\n// The parse (no-acorn, ESM-only deps) is async, so this renders a small placeholder\n// until the tree is ready, then the pure synchronous `renderMdast`. Parsing is keyed\n// on the source string; a changed source re-parses, and a stale async result is\n// discarded (the ref guard) so a fast source swap can't paint the wrong content.\n\nexport interface SafeContentProps extends RenderMdastOptions {\n  /** The untrusted Markdown/MDX-syntax source to render as data. */\n  source: string;\n  /** Rendered while the async parse is in flight (default: nothing). */\n  fallback?: ReactNode;\n}\n\nexport function SafeContent({ source, fallback = null, ...options }: SafeContentProps): ReactNode {\n  const [tree, setTree] = useState<Awaited<ReturnType<typeof parseSafeMdast>> | null>(null);\n  const runId = useRef(0);\n\n  useEffect(() => {\n    const id = ++runId.current;\n    setTree(null);\n    let cancelled = false;\n    parseSafeMdast(source)\n      .then((parsed) => {\n        // Discard a stale result (source changed / unmounted) so we never paint the\n        // wrong tree — the render-as-data guarantee also needs the RIGHT data shown.\n        if (!cancelled && runId.current === id) setTree(parsed);\n      })\n      .catch(() => {\n        if (!cancelled && runId.current === id) setTree(null);\n      });\n    return () => {\n      cancelled = true;\n    };\n  }, [source]);\n\n  // `renderMdast` is pure; memoise on the tree + the option identities the caller\n  // passes. (Callers should memoise `components`/`resolveWikiLink` themselves for a\n  // stable identity; changing them re-renders, which is correct.)\n  const rendered = useMemo(\n    () => (tree ? renderMdast(tree, options) : null),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [tree, options.components, options.resolveWikiLink],\n  );\n\n  return tree ? rendered : fallback;\n}\n"],"mappings":"AAAA,SAAS,WAAW,SAAS,QAAQ,gBAAgC;AACrE,SAAS,sBAAsB;AAC/B,SAAS,mBAA4C;AAuB9C,SAAS,YAAY,EAAE,QAAQ,WAAW,MAAM,GAAG,QAAQ,GAAgC;AAChG,QAAM,CAAC,MAAM,OAAO,IAAI,SAA4D,IAAI;AACxF,QAAM,QAAQ,OAAO,CAAC;AAEtB,YAAU,MAAM;AACd,UAAM,KAAK,EAAE,MAAM;AACnB,YAAQ,IAAI;AACZ,QAAI,YAAY;AAChB,mBAAe,MAAM,EAClB,KAAK,CAAC,WAAW;AAGhB,UAAI,CAAC,aAAa,MAAM,YAAY,GAAI,SAAQ,MAAM;AAAA,IACxD,CAAC,EACA,MAAM,MAAM;AACX,UAAI,CAAC,aAAa,MAAM,YAAY,GAAI,SAAQ,IAAI;AAAA,IACtD,CAAC;AACH,WAAO,MAAM;AACX,kBAAY;AAAA,IACd;AAAA,EACF,GAAG,CAAC,MAAM,CAAC;AAKX,QAAM,WAAW;AAAA,IACf,MAAO,OAAO,YAAY,MAAM,OAAO,IAAI;AAAA;AAAA,IAE3C,CAAC,MAAM,QAAQ,YAAY,QAAQ,eAAe;AAAA,EACpD;AAEA,SAAO,OAAO,WAAW;AAC3B;","names":[]}

package/dist/safeContent/index.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var safeContent_exports = {};
+__export(safeContent_exports, {
+  SafeContent: () => import_SafeContent.SafeContent,
+  parseSafeMdast: () => import_parseSafeMdast.parseSafeMdast,
+  parseWikiInner: () => import_wikilink.parseWikiInner,
+  renderMdast: () => import_renderMdast.renderMdast,
+  sanitizeUrl: () => import_sanitizeUrl.sanitizeUrl,
+  splitWikiLinks: () => import_wikilink.splitWikiLinks
+});
+module.exports = __toCommonJS(safeContent_exports);
+var import_SafeContent = require("./SafeContent");
+var import_renderMdast = require("./renderMdast");
+var import_parseSafeMdast = require("./parseSafeMdast");
+var import_sanitizeUrl = require("./sanitizeUrl");
+var import_wikilink = require("./wikilink");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SafeContent,
+  parseSafeMdast,
+  parseWikiInner,
+  renderMdast,
+  sanitizeUrl,
+  splitWikiLinks
+});
+//# sourceMappingURL=index.cjs.map

package/dist/safeContent/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/safeContent/index.ts"],"sourcesContent":["// Safe content rendering — non-executable MDX (TRUST_MODES_SPEC §5.1, AGENT_AUTHORING\n// §10). The host/SDK-owned renderer an INTERPRETER app uses to render untrusted\n// Markdown/MDX-syntax content as data, with **no evaluator anywhere in the pipeline**.\n// This is the mandatory terminal for the MDX-from-mount gate (§10 delta 1) — a shared\n// (multi-writer / M3) board or wiki entry MUST render through here, never compiled MDX.\n//\n// It is a **T2 tool, not a platform gate**: it stops content executing as code; it does\n// not certify anything to the host, and CO-4 data-fencing is still required for anything\n// that *reads* the content (the agent case).\n\nexport { SafeContent } from './SafeContent';\nexport type { SafeContentProps } from './SafeContent';\nexport { renderMdast } from './renderMdast';\nexport type {\n  RenderMdastOptions,\n  SafeContentComponents,\n} from './renderMdast';\nexport { parseSafeMdast } from './parseSafeMdast';\nexport type { SafeMdastNode, SafeMdxAttribute } from './parseSafeMdast';\nexport { sanitizeUrl } from './sanitizeUrl';\nexport { splitWikiLinks, parseWikiInner } from './wikilink';\nexport type { WikiLinkToken, WikiPart } from './wikilink';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,yBAA4B;AAE5B,yBAA4B;AAK5B,4BAA+B;AAE/B,yBAA4B;AAC5B,sBAA+C;","names":[]}

package/dist/safeContent/index.d.cts

@@ -0,0 +1,6 @@
+export { SafeContent, SafeContentProps } from './SafeContent.cjs';
+export { RenderMdastOptions, SafeContentComponents, renderMdast } from './renderMdast.cjs';
+export { SafeMdastNode, SafeMdxAttribute, parseSafeMdast } from './parseSafeMdast.cjs';
+export { sanitizeUrl } from './sanitizeUrl.cjs';
+export { WikiLinkToken, WikiPart, parseWikiInner, splitWikiLinks } from './wikilink.cjs';
+import 'react';

package/dist/safeContent/index.d.ts

@@ -0,0 +1,6 @@
+export { SafeContent, SafeContentProps } from './SafeContent.js';
+export { RenderMdastOptions, SafeContentComponents, renderMdast } from './renderMdast.js';
+export { SafeMdastNode, SafeMdxAttribute, parseSafeMdast } from './parseSafeMdast.js';
+export { sanitizeUrl } from './sanitizeUrl.js';
+export { WikiLinkToken, WikiPart, parseWikiInner, splitWikiLinks } from './wikilink.js';
+import 'react';

package/dist/safeContent/index.js

@@ -0,0 +1,14 @@
+import { SafeContent } from "./SafeContent";
+import { renderMdast } from "./renderMdast";
+import { parseSafeMdast } from "./parseSafeMdast";
+import { sanitizeUrl } from "./sanitizeUrl";
+import { splitWikiLinks, parseWikiInner } from "./wikilink";
+export {
+  SafeContent,
+  parseSafeMdast,
+  parseWikiInner,
+  renderMdast,
+  sanitizeUrl,
+  splitWikiLinks
+};
+//# sourceMappingURL=index.js.map

package/dist/safeContent/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/safeContent/index.ts"],"sourcesContent":["// Safe content rendering — non-executable MDX (TRUST_MODES_SPEC §5.1, AGENT_AUTHORING\n// §10). The host/SDK-owned renderer an INTERPRETER app uses to render untrusted\n// Markdown/MDX-syntax content as data, with **no evaluator anywhere in the pipeline**.\n// This is the mandatory terminal for the MDX-from-mount gate (§10 delta 1) — a shared\n// (multi-writer / M3) board or wiki entry MUST render through here, never compiled MDX.\n//\n// It is a **T2 tool, not a platform gate**: it stops content executing as code; it does\n// not certify anything to the host, and CO-4 data-fencing is still required for anything\n// that *reads* the content (the agent case).\n\nexport { SafeContent } from './SafeContent';\nexport type { SafeContentProps } from './SafeContent';\nexport { renderMdast } from './renderMdast';\nexport type {\n  RenderMdastOptions,\n  SafeContentComponents,\n} from './renderMdast';\nexport { parseSafeMdast } from './parseSafeMdast';\nexport type { SafeMdastNode, SafeMdxAttribute } from './parseSafeMdast';\nexport { sanitizeUrl } from './sanitizeUrl';\nexport { splitWikiLinks, parseWikiInner } from './wikilink';\nexport type { WikiLinkToken, WikiPart } from './wikilink';\n"],"mappings":"AAUA,SAAS,mBAAmB;AAE5B,SAAS,mBAAmB;AAK5B,SAAS,sBAAsB;AAE/B,SAAS,mBAAmB;AAC5B,SAAS,gBAAgB,sBAAsB;","names":[]}

package/dist/safeContent/parseSafeMdast.cjs

@@ -0,0 +1,69 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parseSafeMdast_exports = {};
+__export(parseSafeMdast_exports, {
+  parseSafeMdast: () => parseSafeMdast
+});
+module.exports = __toCommonJS(parseSafeMdast_exports);
+let depsPromise = null;
+function loadDeps() {
+  if (!depsPromise) {
+    depsPromise = Promise.all([
+      import("mdast-util-from-markdown"),
+      import("micromark-extension-mdx-jsx"),
+      import("mdast-util-mdx-jsx"),
+      import("micromark-extension-gfm"),
+      import("mdast-util-gfm")
+    ]).then(
+      ([fromMd, mdxJsxExt, mdxJsxMdast, gfmExt, gfmMdast]) => ({
+        fromMarkdown: fromMd.fromMarkdown,
+        mdxJsx: mdxJsxExt.mdxJsx,
+        mdxJsxFromMarkdown: mdxJsxMdast.mdxJsxFromMarkdown,
+        gfm: gfmExt.gfm,
+        gfmFromMarkdown: gfmMdast.gfmFromMarkdown
+      })
+    );
+  }
+  return depsPromise;
+}
+async function parseSafeMdast(source) {
+  const { fromMarkdown, mdxJsx, mdxJsxFromMarkdown, gfm, gfmFromMarkdown } = await loadDeps();
+  return fromMarkdown(source, {
+    // `mdxJsx()` WITHOUT an acorn option → JSX tags + literal attrs; expressions are
+    // raw strings, never estree. The mdx *expression* extension is intentionally
+    // absent, so `{…}` in body text stays literal. GFM for tables/task-lists.
+    extensions: [mdxJsx(), gfm()],
+    mdastExtensions: [mdxJsxFromMarkdown(), gfmFromMarkdown()]
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseSafeMdast
+});
+//# sourceMappingURL=parseSafeMdast.cjs.map

package/dist/safeContent/parseSafeMdast.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/safeContent/parseSafeMdast.ts"],"sourcesContent":["// The no-acorn parse pipeline for the safe content renderer (TRUST_MODES_SPEC §5.1,\n// empirically verified 2026-07-07 against `@mdx-js/mdx` v3 / `micromark-extension-\n// mdx-jsx`). This is the load-bearing half of the fail-safe: `<Component/>` syntax\n// parses to an element node with **literal** attributes, and every expression\n// (`n={1+1}`, `f={fetch(\"/x\")}`, `{...spread}`) is captured as an **inert raw string\n// with no estree** — because we pass **NO acorn option** to `micromark-extension-mdx-\n// jsx`. There is therefore no evaluator anywhere in the pipeline (fail-safe), unlike\n// `@mdx-js/mdx`'s `compile({format:'mdx'})` which always wires acorn.\n//\n// The §5.1 residual guarantees are also here: the expression micromark extension is\n// **not** enabled (body `{…}` stays literal text), and **no `rehype-raw`** / raw-HTML\n// passthrough exists — raw HTML blocks arrive as inert `html` mdast nodes the renderer\n// prints as text, never injected.\n//\n// `micromark`/`mdast` are ESM-only. They are loaded with a memoised dynamic `import()`\n// (the transpiler's `compile.ts` pattern) so this module sits in the package's CJS\n// build too — a CJS consumer that never renders untrusted content never `require()`s\n// an ESM-only package, and one that does gets it via Node's ESM-from-CJS import. The\n// dynamic load changes only *when* the deps resolve, never the produced tree.\n\n// A minimal structural mdast shape — we deliberately avoid a type dependency on the\n// ESM-only `mdast`/`unist` packages (which would break the CJS build's type surface).\nexport interface SafeMdastNode {\n  type: string;\n  value?: string;\n  name?: string | null;\n  url?: string;\n  alt?: string | null;\n  title?: string | null;\n  depth?: number;\n  ordered?: boolean;\n  lang?: string | null;\n  children?: SafeMdastNode[];\n  attributes?: SafeMdxAttribute[];\n  [key: string]: unknown;\n}\n\nexport interface SafeMdxAttribute {\n  type: 'mdxJsxAttribute' | 'mdxJsxExpressionAttribute';\n  name?: string;\n  // A literal attribute carries a string; an expression attribute carries an\n  // `mdxJsxAttributeValueExpression` object (a raw string, NO estree) or a string.\n  value?: string | { type: string; value?: string } | null;\n}\n\ntype Deps = {\n  fromMarkdown: (\n    value: string,\n    options: { extensions: unknown[]; mdastExtensions: unknown[] },\n  ) => SafeMdastNode;\n  mdxJsx: () => unknown;\n  mdxJsxFromMarkdown: () => unknown;\n  gfm: () => unknown;\n  gfmFromMarkdown: () => unknown;\n};\n\nlet depsPromise: Promise<Deps> | null = null;\n\nfunction loadDeps(): Promise<Deps> {\n  if (!depsPromise) {\n    depsPromise = Promise.all([\n      import('mdast-util-from-markdown'),\n      import('micromark-extension-mdx-jsx'),\n      import('mdast-util-mdx-jsx'),\n      import('micromark-extension-gfm'),\n      import('mdast-util-gfm'),\n    ]).then(\n      ([fromMd, mdxJsxExt, mdxJsxMdast, gfmExt, gfmMdast]) =>\n        ({\n          fromMarkdown: (fromMd as unknown as { fromMarkdown: Deps['fromMarkdown'] }).fromMarkdown,\n          mdxJsx: (mdxJsxExt as unknown as { mdxJsx: Deps['mdxJsx'] }).mdxJsx,\n          mdxJsxFromMarkdown: (mdxJsxMdast as unknown as { mdxJsxFromMarkdown: Deps['mdxJsxFromMarkdown'] })\n            .mdxJsxFromMarkdown,\n          gfm: (gfmExt as unknown as { gfm: Deps['gfm'] }).gfm,\n          gfmFromMarkdown: (gfmMdast as unknown as { gfmFromMarkdown: Deps['gfmFromMarkdown'] }).gfmFromMarkdown,\n        }) as Deps,\n    );\n  }\n  return depsPromise;\n}\n\n/**\n * Parse untrusted Markdown/MDX-syntax source to an mdast tree with **no evaluator in\n * the pipeline**: JSX-as-data (no acorn), GFM on, the expression extension OFF, no\n * raw-HTML re-parse. The returned tree is safe to hand to `renderMdast` — expression\n * attributes are inert strings and raw HTML is inert `html` nodes.\n */\nexport async function parseSafeMdast(source: string): Promise<SafeMdastNode> {\n  const { fromMarkdown, mdxJsx, mdxJsxFromMarkdown, gfm, gfmFromMarkdown } = await loadDeps();\n  return fromMarkdown(source, {\n    // `mdxJsx()` WITHOUT an acorn option → JSX tags + literal attrs; expressions are\n    // raw strings, never estree. The mdx *expression* extension is intentionally\n    // absent, so `{…}` in body text stays literal. GFM for tables/task-lists.\n    extensions: [mdxJsx(), gfm()],\n    mdastExtensions: [mdxJsxFromMarkdown(), gfmFromMarkdown()],\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAwDA,IAAI,cAAoC;AAExC,SAAS,WAA0B;AACjC,MAAI,CAAC,aAAa;AAChB,kBAAc,QAAQ,IAAI;AAAA,MACxB,OAAO,0BAA0B;AAAA,MACjC,OAAO,6BAA6B;AAAA,MACpC,OAAO,oBAAoB;AAAA,MAC3B,OAAO,yBAAyB;AAAA,MAChC,OAAO,gBAAgB;AAAA,IACzB,CAAC,EAAE;AAAA,MACD,CAAC,CAAC,QAAQ,WAAW,aAAa,QAAQ,QAAQ,OAC/C;AAAA,QACC,cAAe,OAA6D;AAAA,QAC5E,QAAS,UAAoD;AAAA,QAC7D,oBAAqB,YAClB;AAAA,QACH,KAAM,OAA2C;AAAA,QACjD,iBAAkB,SAAqE;AAAA,MACzF;AAAA,IACJ;AAAA,EACF;AACA,SAAO;AACT;AAQA,eAAsB,eAAe,QAAwC;AAC3E,QAAM,EAAE,cAAc,QAAQ,oBAAoB,KAAK,gBAAgB,IAAI,MAAM,SAAS;AAC1F,SAAO,aAAa,QAAQ;AAAA;AAAA;AAAA;AAAA,IAI1B,YAAY,CAAC,OAAO,GAAG,IAAI,CAAC;AAAA,IAC5B,iBAAiB,CAAC,mBAAmB,GAAG,gBAAgB,CAAC;AAAA,EAC3D,CAAC;AACH;","names":[]}

package/dist/safeContent/parseSafeMdast.d.cts

@@ -0,0 +1,31 @@
+interface SafeMdastNode {
+    type: string;
+    value?: string;
+    name?: string | null;
+    url?: string;
+    alt?: string | null;
+    title?: string | null;
+    depth?: number;
+    ordered?: boolean;
+    lang?: string | null;
+    children?: SafeMdastNode[];
+    attributes?: SafeMdxAttribute[];
+    [key: string]: unknown;
+}
+interface SafeMdxAttribute {
+    type: 'mdxJsxAttribute' | 'mdxJsxExpressionAttribute';
+    name?: string;
+    value?: string | {
+        type: string;
+        value?: string;
+    } | null;
+}
+/**
+ * Parse untrusted Markdown/MDX-syntax source to an mdast tree with **no evaluator in
+ * the pipeline**: JSX-as-data (no acorn), GFM on, the expression extension OFF, no
+ * raw-HTML re-parse. The returned tree is safe to hand to `renderMdast` — expression
+ * attributes are inert strings and raw HTML is inert `html` nodes.
+ */
+declare function parseSafeMdast(source: string): Promise<SafeMdastNode>;
+
+export { type SafeMdastNode, type SafeMdxAttribute, parseSafeMdast };

package/dist/safeContent/parseSafeMdast.d.ts

@@ -0,0 +1,31 @@
+interface SafeMdastNode {
+    type: string;
+    value?: string;
+    name?: string | null;
+    url?: string;
+    alt?: string | null;
+    title?: string | null;
+    depth?: number;
+    ordered?: boolean;
+    lang?: string | null;
+    children?: SafeMdastNode[];
+    attributes?: SafeMdxAttribute[];
+    [key: string]: unknown;
+}
+interface SafeMdxAttribute {
+    type: 'mdxJsxAttribute' | 'mdxJsxExpressionAttribute';
+    name?: string;
+    value?: string | {
+        type: string;
+        value?: string;
+    } | null;
+}
+/**
+ * Parse untrusted Markdown/MDX-syntax source to an mdast tree with **no evaluator in
+ * the pipeline**: JSX-as-data (no acorn), GFM on, the expression extension OFF, no
+ * raw-HTML re-parse. The returned tree is safe to hand to `renderMdast` — expression
+ * attributes are inert strings and raw HTML is inert `html` nodes.
+ */
+declare function parseSafeMdast(source: string): Promise<SafeMdastNode>;
+
+export { type SafeMdastNode, type SafeMdxAttribute, parseSafeMdast };

package/dist/safeContent/parseSafeMdast.js

@@ -0,0 +1,35 @@
+let depsPromise = null;
+function loadDeps() {
+  if (!depsPromise) {
+    depsPromise = Promise.all([
+      import("mdast-util-from-markdown"),
+      import("micromark-extension-mdx-jsx"),
+      import("mdast-util-mdx-jsx"),
+      import("micromark-extension-gfm"),
+      import("mdast-util-gfm")
+    ]).then(
+      ([fromMd, mdxJsxExt, mdxJsxMdast, gfmExt, gfmMdast]) => ({
+        fromMarkdown: fromMd.fromMarkdown,
+        mdxJsx: mdxJsxExt.mdxJsx,
+        mdxJsxFromMarkdown: mdxJsxMdast.mdxJsxFromMarkdown,
+        gfm: gfmExt.gfm,
+        gfmFromMarkdown: gfmMdast.gfmFromMarkdown
+      })
+    );
+  }
+  return depsPromise;
+}
+async function parseSafeMdast(source) {
+  const { fromMarkdown, mdxJsx, mdxJsxFromMarkdown, gfm, gfmFromMarkdown } = await loadDeps();
+  return fromMarkdown(source, {
+    // `mdxJsx()` WITHOUT an acorn option → JSX tags + literal attrs; expressions are
+    // raw strings, never estree. The mdx *expression* extension is intentionally
+    // absent, so `{…}` in body text stays literal. GFM for tables/task-lists.
+    extensions: [mdxJsx(), gfm()],
+    mdastExtensions: [mdxJsxFromMarkdown(), gfmFromMarkdown()]
+  });
+}
+export {
+  parseSafeMdast
+};
+//# sourceMappingURL=parseSafeMdast.js.map

package/dist/safeContent/parseSafeMdast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/safeContent/parseSafeMdast.ts"],"sourcesContent":["// The no-acorn parse pipeline for the safe content renderer (TRUST_MODES_SPEC §5.1,\n// empirically verified 2026-07-07 against `@mdx-js/mdx` v3 / `micromark-extension-\n// mdx-jsx`). This is the load-bearing half of the fail-safe: `<Component/>` syntax\n// parses to an element node with **literal** attributes, and every expression\n// (`n={1+1}`, `f={fetch(\"/x\")}`, `{...spread}`) is captured as an **inert raw string\n// with no estree** — because we pass **NO acorn option** to `micromark-extension-mdx-\n// jsx`. There is therefore no evaluator anywhere in the pipeline (fail-safe), unlike\n// `@mdx-js/mdx`'s `compile({format:'mdx'})` which always wires acorn.\n//\n// The §5.1 residual guarantees are also here: the expression micromark extension is\n// **not** enabled (body `{…}` stays literal text), and **no `rehype-raw`** / raw-HTML\n// passthrough exists — raw HTML blocks arrive as inert `html` mdast nodes the renderer\n// prints as text, never injected.\n//\n// `micromark`/`mdast` are ESM-only. They are loaded with a memoised dynamic `import()`\n// (the transpiler's `compile.ts` pattern) so this module sits in the package's CJS\n// build too — a CJS consumer that never renders untrusted content never `require()`s\n// an ESM-only package, and one that does gets it via Node's ESM-from-CJS import. The\n// dynamic load changes only *when* the deps resolve, never the produced tree.\n\n// A minimal structural mdast shape — we deliberately avoid a type dependency on the\n// ESM-only `mdast`/`unist` packages (which would break the CJS build's type surface).\nexport interface SafeMdastNode {\n  type: string;\n  value?: string;\n  name?: string | null;\n  url?: string;\n  alt?: string | null;\n  title?: string | null;\n  depth?: number;\n  ordered?: boolean;\n  lang?: string | null;\n  children?: SafeMdastNode[];\n  attributes?: SafeMdxAttribute[];\n  [key: string]: unknown;\n}\n\nexport interface SafeMdxAttribute {\n  type: 'mdxJsxAttribute' | 'mdxJsxExpressionAttribute';\n  name?: string;\n  // A literal attribute carries a string; an expression attribute carries an\n  // `mdxJsxAttributeValueExpression` object (a raw string, NO estree) or a string.\n  value?: string | { type: string; value?: string } | null;\n}\n\ntype Deps = {\n  fromMarkdown: (\n    value: string,\n    options: { extensions: unknown[]; mdastExtensions: unknown[] },\n  ) => SafeMdastNode;\n  mdxJsx: () => unknown;\n  mdxJsxFromMarkdown: () => unknown;\n  gfm: () => unknown;\n  gfmFromMarkdown: () => unknown;\n};\n\nlet depsPromise: Promise<Deps> | null = null;\n\nfunction loadDeps(): Promise<Deps> {\n  if (!depsPromise) {\n    depsPromise = Promise.all([\n      import('mdast-util-from-markdown'),\n      import('micromark-extension-mdx-jsx'),\n      import('mdast-util-mdx-jsx'),\n      import('micromark-extension-gfm'),\n      import('mdast-util-gfm'),\n    ]).then(\n      ([fromMd, mdxJsxExt, mdxJsxMdast, gfmExt, gfmMdast]) =>\n        ({\n          fromMarkdown: (fromMd as unknown as { fromMarkdown: Deps['fromMarkdown'] }).fromMarkdown,\n          mdxJsx: (mdxJsxExt as unknown as { mdxJsx: Deps['mdxJsx'] }).mdxJsx,\n          mdxJsxFromMarkdown: (mdxJsxMdast as unknown as { mdxJsxFromMarkdown: Deps['mdxJsxFromMarkdown'] })\n            .mdxJsxFromMarkdown,\n          gfm: (gfmExt as unknown as { gfm: Deps['gfm'] }).gfm,\n          gfmFromMarkdown: (gfmMdast as unknown as { gfmFromMarkdown: Deps['gfmFromMarkdown'] }).gfmFromMarkdown,\n        }) as Deps,\n    );\n  }\n  return depsPromise;\n}\n\n/**\n * Parse untrusted Markdown/MDX-syntax source to an mdast tree with **no evaluator in\n * the pipeline**: JSX-as-data (no acorn), GFM on, the expression extension OFF, no\n * raw-HTML re-parse. The returned tree is safe to hand to `renderMdast` — expression\n * attributes are inert strings and raw HTML is inert `html` nodes.\n */\nexport async function parseSafeMdast(source: string): Promise<SafeMdastNode> {\n  const { fromMarkdown, mdxJsx, mdxJsxFromMarkdown, gfm, gfmFromMarkdown } = await loadDeps();\n  return fromMarkdown(source, {\n    // `mdxJsx()` WITHOUT an acorn option → JSX tags + literal attrs; expressions are\n    // raw strings, never estree. The mdx *expression* extension is intentionally\n    // absent, so `{…}` in body text stays literal. GFM for tables/task-lists.\n    extensions: [mdxJsx(), gfm()],\n    mdastExtensions: [mdxJsxFromMarkdown(), gfmFromMarkdown()],\n  });\n}\n"],"mappings":"AAwDA,IAAI,cAAoC;AAExC,SAAS,WAA0B;AACjC,MAAI,CAAC,aAAa;AAChB,kBAAc,QAAQ,IAAI;AAAA,MACxB,OAAO,0BAA0B;AAAA,MACjC,OAAO,6BAA6B;AAAA,MACpC,OAAO,oBAAoB;AAAA,MAC3B,OAAO,yBAAyB;AAAA,MAChC,OAAO,gBAAgB;AAAA,IACzB,CAAC,EAAE;AAAA,MACD,CAAC,CAAC,QAAQ,WAAW,aAAa,QAAQ,QAAQ,OAC/C;AAAA,QACC,cAAe,OAA6D;AAAA,QAC5E,QAAS,UAAoD;AAAA,QAC7D,oBAAqB,YAClB;AAAA,QACH,KAAM,OAA2C;AAAA,QACjD,iBAAkB,SAAqE;AAAA,MACzF;AAAA,IACJ;AAAA,EACF;AACA,SAAO;AACT;AAQA,eAAsB,eAAe,QAAwC;AAC3E,QAAM,EAAE,cAAc,QAAQ,oBAAoB,KAAK,gBAAgB,IAAI,MAAM,SAAS;AAC1F,SAAO,aAAa,QAAQ;AAAA;AAAA;AAAA;AAAA,IAI1B,YAAY,CAAC,OAAO,GAAG,IAAI,CAAC;AAAA,IAC5B,iBAAiB,CAAC,mBAAmB,GAAG,gBAAgB,CAAC;AAAA,EAC3D,CAAC;AACH;","names":[]}

package/dist/safeContent/renderMdast.cjs

@@ -0,0 +1,138 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var renderMdast_exports = {};
+__export(renderMdast_exports, {
+  renderMdast: () => renderMdast
+});
+module.exports = __toCommonJS(renderMdast_exports);
+var import_react = require("react");
+var import_sanitizeUrl = require("./sanitizeUrl");
+var import_wikilink = require("./wikilink");
+function literalProps(attributes) {
+  const props = {};
+  for (const attr of attributes ?? []) {
+    if (attr.type !== "mdxJsxAttribute") continue;
+    if (typeof attr.name !== "string") continue;
+    if (typeof attr.value === "string") props[attr.name] = attr.value;
+    else if (attr.value === null || attr.value === void 0) props[attr.name] = "";
+  }
+  return props;
+}
+let keyCounter = 0;
+const nextKey = () => `sc-${keyCounter++}`;
+function renderWiki(token, resolve) {
+  const label = token.label ?? token.target;
+  const href = resolve?.(token.target);
+  const safe = href !== void 0 ? (0, import_sanitizeUrl.sanitizeUrl)(href) : void 0;
+  if (safe === void 0) return label;
+  return (0, import_react.createElement)("a", { href: safe, "data-wikilink": token.target, key: nextKey() }, label);
+}
+function renderText(value, opts) {
+  const parts = (0, import_wikilink.splitWikiLinks)(value);
+  if (!parts) return value;
+  return parts.map(
+    (p, i) => "text" in p ? (0, import_react.createElement)(import_react.Fragment, { key: `t${i}` }, p.text) : (0, import_react.createElement)(import_react.Fragment, { key: `w${i}` }, renderWiki(p.wiki, opts.resolveWikiLink))
+  );
+}
+function renderChildren(node, opts) {
+  return (node.children ?? []).map((c, i) => renderNode(c, opts, i));
+}
+const HEADING_TAGS = ["h1", "h2", "h3", "h4", "h5", "h6"];
+function renderNode(node, opts, index = 0) {
+  const key = `n${index}`;
+  switch (node.type) {
+    case "root":
+      return (0, import_react.createElement)(import_react.Fragment, { key }, ...renderChildren(node, opts));
+    case "text":
+      return renderText(node.value ?? "", opts);
+    case "paragraph":
+      return (0, import_react.createElement)("p", { key }, ...renderChildren(node, opts));
+    case "heading": {
+      const tag = HEADING_TAGS[Math.min(Math.max((node.depth ?? 1) - 1, 0), 5)];
+      return (0, import_react.createElement)(tag, { key }, ...renderChildren(node, opts));
+    }
+    case "strong":
+      return (0, import_react.createElement)("strong", { key }, ...renderChildren(node, opts));
+    case "emphasis":
+      return (0, import_react.createElement)("em", { key }, ...renderChildren(node, opts));
+    case "delete":
+      return (0, import_react.createElement)("del", { key }, ...renderChildren(node, opts));
+    case "inlineCode":
+      return (0, import_react.createElement)("code", { key }, node.value ?? "");
+    case "code":
+      return (0, import_react.createElement)("pre", { key }, (0, import_react.createElement)("code", null, node.value ?? ""));
+    case "blockquote":
+      return (0, import_react.createElement)("blockquote", { key }, ...renderChildren(node, opts));
+    case "list":
+      return (0, import_react.createElement)(node.ordered ? "ol" : "ul", { key }, ...renderChildren(node, opts));
+    case "listItem":
+      return (0, import_react.createElement)("li", { key }, ...renderChildren(node, opts));
+    case "thematicBreak":
+      return (0, import_react.createElement)("hr", { key });
+    case "break":
+      return (0, import_react.createElement)("br", { key });
+    case "link": {
+      const href = (0, import_sanitizeUrl.sanitizeUrl)(node.url);
+      if (href === void 0) return (0, import_react.createElement)(import_react.Fragment, { key }, ...renderChildren(node, opts));
+      return (0, import_react.createElement)("a", { key, href, title: node.title ?? void 0 }, ...renderChildren(node, opts));
+    }
+    case "image": {
+      const src = (0, import_sanitizeUrl.sanitizeUrl)(node.url);
+      if (src === void 0) return node.alt ? (0, import_react.createElement)(import_react.Fragment, { key }, node.alt) : null;
+      return (0, import_react.createElement)("img", { key, src, alt: node.alt ?? "", title: node.title ?? void 0 });
+    }
+    // GFM tables.
+    case "table":
+      return (0, import_react.createElement)("table", { key }, (0, import_react.createElement)("tbody", null, ...renderChildren(node, opts)));
+    case "tableRow":
+      return (0, import_react.createElement)("tr", { key }, ...renderChildren(node, opts));
+    case "tableCell":
+      return (0, import_react.createElement)("td", { key }, ...renderChildren(node, opts));
+    // Raw HTML (`<script>`, `<div onclick>` at block level) → INERT TEXT. No
+    // `rehype-raw`, never `dangerouslySetInnerHTML`. The literal markup is shown, not run.
+    case "html":
+      return (0, import_react.createElement)(import_react.Fragment, { key }, node.value ?? "");
+    // JSX `<Component/>` syntax → registry lookup by NAME, literal props only.
+    case "mdxJsxFlowElement":
+    case "mdxJsxTextElement": {
+      const name = typeof node.name === "string" ? node.name : "";
+      const Component = name ? opts.components?.[name] : void 0;
+      const children = renderChildren(node, opts);
+      if (!Component) return (0, import_react.createElement)(import_react.Fragment, { key }, ...children);
+      return (0, import_react.createElement)(Component, { key, ...literalProps(node.attributes) }, ...children);
+    }
+    // Inert expression nodes (should not occur — expression extension is off — but be
+    // defensive if a tree from elsewhere carries them): render nothing.
+    case "mdxFlowExpression":
+    case "mdxTextExpression":
+    case "mdxjsEsm":
+      return null;
+    default:
+      return node.children ? (0, import_react.createElement)(import_react.Fragment, { key }, ...renderChildren(node, opts)) : null;
+  }
+}
+function renderMdast(tree, options = {}) {
+  keyCounter = 0;
+  return renderNode(tree, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderMdast
+});
+//# sourceMappingURL=renderMdast.cjs.map