@gogitcms/editor 0.23.0

package/app/vendor/markdown-editor/src/theme.ts

@@ -0,0 +1,249 @@
+// Self-contained CSS for the editor. Injected once into the document head by
+// <MarkdownEditor>. Colors are driven by CSS variables scoped to the editor
+// root and switched by a `data-theme` attribute — the host passes "light"/"dark"
+// as a prop (theme context can't cross the Expo DOM-component bridge).
+
+export const EDITOR_STYLE_ID = "cms-editor-styles";
+
+export const EDITOR_CSS = `
+.cms-editor {
+  --cms-ed-bg: #ffffff;
+  --cms-ed-fg: #1a1a1a;
+  --cms-ed-muted: #6b7280;
+  --cms-ed-border: #e2e4e8;
+  --cms-ed-accent: #2563eb;
+  --cms-ed-code-bg: #f3f4f6;
+  --cms-ed-selection: #cfe0ff;
+  position: relative;
+  color: var(--cms-ed-fg);
+  background: var(--cms-ed-bg);
+  font: 14px/1.6 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  border: 1px solid var(--cms-ed-border);
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+/* Formatting toolbar — pinned to the top of the editor (and the pane in focus
+   mode) so it stays visible while the content scrolls. */
+.cms-editor__toolbar {
+  position: sticky;
+  top: 0;
+  z-index: 4;
+  display: flex;
+  align-items: center;
+  gap: 2px;
+  flex-wrap: nowrap;
+  padding: 5px 8px;
+  border-bottom: 1px solid var(--cms-ed-border);
+  background: var(--cms-ed-bg);
+}
+.cms-editor__toolbar-sep {
+  width: 1px;
+  align-self: stretch;
+  margin: 4px 4px;
+  background: var(--cms-ed-border);
+}
+.cms-editor__tool {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  height: 28px;
+  padding: 0;
+  border: none;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--cms-ed-muted);
+  cursor: pointer;
+  transition: background 120ms ease, color 120ms ease;
+}
+.cms-editor__tool:hover:not(:disabled) {
+  background: var(--cms-ed-code-bg);
+  color: var(--cms-ed-fg);
+}
+.cms-editor__tool[aria-pressed="true"] {
+  background: var(--cms-ed-code-bg);
+  color: var(--cms-ed-accent);
+}
+.cms-editor__tool:disabled {
+  opacity: 0.4;
+  cursor: default;
+}
+/* The expand toggle sits at the far right of the toolbar. */
+.cms-editor__tool--expand {
+  margin-left: auto;
+}
+
+/* Focus mode: take over the viewport, not the pane the editor sits in. */
+.cms-editor--expanded {
+  position: fixed;
+  inset: 0;
+  z-index: 1000;
+  height: 100%;
+  max-height: none;
+  border: none;
+  border-radius: 0;
+  overflow-y: auto;
+}
+.cms-editor--expanded .ProseMirror {
+  max-width: 720px;
+  margin: 0 auto;
+  min-height: calc(100% - 40px);
+  padding: 32px 24px 25vh;
+}
+.cms-editor[data-theme="dark"] {
+  --cms-ed-bg: #16181d;
+  --cms-ed-fg: #e6e6e6;
+  --cms-ed-muted: #9aa1ad;
+  --cms-ed-border: #2c2f36;
+  --cms-ed-accent: #6ea8ff;
+  --cms-ed-code-bg: #22252c;
+  --cms-ed-selection: #24406b;
+}
+.cms-editor .ProseMirror {
+  padding: 12px 16px;
+  min-height: 120px;
+  outline: none;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+}
+.cms-editor .ProseMirror[contenteditable="false"] { opacity: 0.85; }
+.cms-editor .ProseMirror p { margin: 0 0 0.75em; }
+.cms-editor .ProseMirror > :last-child { margin-bottom: 0; }
+.cms-editor .ProseMirror h1,
+.cms-editor .ProseMirror h2,
+.cms-editor .ProseMirror h3,
+.cms-editor .ProseMirror h4 { line-height: 1.25; margin: 1em 0 0.5em; font-weight: 600; }
+.cms-editor .ProseMirror h1 { font-size: 1.7em; }
+.cms-editor .ProseMirror h2 { font-size: 1.4em; }
+.cms-editor .ProseMirror h3 { font-size: 1.2em; }
+.cms-editor .ProseMirror a { color: var(--cms-ed-accent); }
+.cms-editor .ProseMirror code {
+  background: var(--cms-ed-code-bg);
+  border-radius: 4px;
+  padding: 0.1em 0.35em;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 0.9em;
+}
+.cms-editor .ProseMirror pre {
+  background: var(--cms-ed-code-bg);
+  border-radius: 6px;
+  padding: 10px 12px;
+  overflow-x: auto;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 0.9em;
+}
+.cms-editor .ProseMirror pre code { background: none; padding: 0; }
+.cms-editor .ProseMirror blockquote {
+  border-left: 3px solid var(--cms-ed-border);
+  margin: 0 0 0.75em;
+  padding-left: 12px;
+  color: var(--cms-ed-muted);
+}
+.cms-editor .ProseMirror hr {
+  border: none;
+  border-top: 1px solid var(--cms-ed-border);
+  margin: 1em 0;
+}
+.cms-editor .ProseMirror ul,
+.cms-editor .ProseMirror ol { padding-left: 1.4em; margin: 0 0 0.75em; }
+
+/* Task lists */
+.cms-editor .ProseMirror li.task-list-item { list-style: none; position: relative; }
+.cms-editor .ProseMirror li.task-list-item .task-list-item-checkbox {
+  position: absolute;
+  left: -1.5em;
+  top: 0.2em;
+  width: 1em;
+  height: 1em;
+  border: 1px solid var(--cms-ed-muted);
+  border-radius: 3px;
+  background: var(--cms-ed-bg);
+  cursor: pointer;
+  box-sizing: border-box;
+  user-select: none;
+}
+.cms-editor .ProseMirror li.task-list-item[data-checked="true"] .task-list-item-checkbox {
+  background: var(--cms-ed-accent);
+  border-color: var(--cms-ed-accent);
+}
+.cms-editor .ProseMirror li.task-list-item[data-checked="true"] .task-list-item-checkbox::after {
+  content: "";
+  position: absolute;
+  left: 0.28em;
+  top: 0.08em;
+  width: 0.28em;
+  height: 0.55em;
+  border: solid #fff;
+  border-width: 0 2px 2px 0;
+  transform: rotate(45deg);
+}
+.cms-editor .ProseMirror li.task-list-item .task-list-item-content { display: inline; }
+
+/* Tables */
+.cms-editor .ProseMirror table {
+  border-collapse: collapse;
+  width: 100%;
+  margin: 0 0 0.75em;
+  overflow: hidden;
+}
+.cms-editor .ProseMirror th,
+.cms-editor .ProseMirror td {
+  border: 1px solid var(--cms-ed-border);
+  padding: 6px 10px;
+  vertical-align: top;
+  text-align: left;
+}
+.cms-editor .ProseMirror th { background: var(--cms-ed-code-bg); font-weight: 600; }
+.cms-editor .ProseMirror .selectedCell::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background: var(--cms-ed-selection);
+  opacity: 0.3;
+  pointer-events: none;
+}
+.cms-editor .ProseMirror .column-resize-handle {
+  position: absolute;
+  right: -2px; top: 0; bottom: 0;
+  width: 4px;
+  background: var(--cms-ed-accent);
+  cursor: col-resize;
+}
+
+/* Placeholder (empty doc) */
+.cms-editor .ProseMirror .cms-editor-placeholder::before {
+  content: attr(data-placeholder);
+  color: var(--cms-ed-muted);
+  pointer-events: none;
+  height: 0;
+  float: left;
+}
+
+/* Gap cursor (prosemirror-gapcursor) */
+.cms-editor .ProseMirror-gapcursor {
+  display: none;
+  pointer-events: none;
+  position: absolute;
+}
+.cms-editor .ProseMirror-gapcursor:after {
+  content: "";
+  display: block;
+  position: absolute;
+  top: -2px;
+  width: 20px;
+  border-top: 1px solid var(--cms-ed-fg);
+  animation: cms-ed-blink 1.1s steps(2, start) infinite;
+}
+@keyframes cms-ed-blink { to { visibility: hidden; } }
+.cms-editor .ProseMirror-focused .ProseMirror-gapcursor { display: block; }
+`;
+
+// Inject the stylesheet once per document (safe to call repeatedly).
+export function ensureEditorStyles(doc: Document | undefined): void {
+  if (!doc || doc.getElementById(EDITOR_STYLE_ID)) return;
+  const style = doc.createElement("style");
+  style.id = EDITOR_STYLE_ID;
+  style.textContent = EDITOR_CSS;
+  doc.head.appendChild(style);
+}

package/app/vendor/markdown-editor/src/types.ts

@@ -0,0 +1,58 @@
+import type { EditorFormat, MarkdownFlavor } from "./formats/registry";
+
+export type { EditorFormat, MarkdownFlavor };
+
+// Where the edited value comes from — a frontmatter field or the file body.
+// Carried through for host symmetry; the editor itself treats both the same.
+export type EditorSource = "field" | "body";
+
+// Light/dark selection. Passed explicitly because React context (and the
+// design-system theme) cannot cross the Expo DOM-component WebView bridge.
+export type EditorTheme = "light" | "dark";
+
+// Props for <MarkdownEditor>. Every prop is JSON-serializable and `onChange` is
+// an async "native action" so the same component works both inline on the web
+// and inside a WebView on native (Expo DOM components).
+export interface MarkdownEditorProps {
+  // Markdown source (controlled).
+  value: string;
+  // Called with serialized markdown after edits (debounced). Async on native.
+  onChange?: (markdown: string) => void | Promise<void>;
+  format?: EditorFormat;
+  flavor?: MarkdownFlavor;
+  source?: EditorSource;
+  readOnly?: boolean;
+  placeholder?: string;
+  theme?: EditorTheme;
+  // Milliseconds to debounce serialization + onChange. Default 200.
+  debounceMs?: number;
+  // Show the expand button that toggles full-panel focus mode. Default true.
+  expandable?: boolean;
+  // Show the formatting toolbar at the top of the editor. Default true.
+  toolbar?: boolean;
+  // Expo DOM-component WebView props on native; ignored on web. Typed loosely so
+  // the package need not depend on expo/react-native types.
+  dom?: unknown;
+  // Live collaboration binding (web/desktop only — the Yjs objects are not
+  // serializable across the native DOM bridge). When present the editor mirrors
+  // a shared Y.XmlFragment instead of the local `value`, shows remote cursors,
+  // and uses per-client collaborative undo. `ydoc`/`awareness` are typed loosely
+  // (unknown) so this package needn't re-export yjs types to callers.
+  collab?: EditorCollab;
+}
+
+export type EditorCollab = {
+  ydoc: unknown; // Y.Doc
+  awareness: unknown; // y-protocols Awareness
+  // Top-level Y.XmlFragment name for this body field, e.g. "body:content".
+  fragmentName: string;
+  // Called with true/false as the editor gains/loses focus, so the host can
+  // publish presence (which field this user is editing).
+  onFocusChange?: (focused: boolean) => void;
+  // Whether the provider has completed its initial sync with the server room,
+  // plus a change subscription. When present, the editor defers its seed-the-
+  // fragment decision until sync — an unsynced local doc always looks empty,
+  // which is not evidence the room is. Optional for hosts without the notion.
+  synced?: () => boolean;
+  subscribeSynced?: (cb: () => void) => () => void;
+};

package/app/vendor/plugin-sdk/src/__tests__/documentActions.test.ts

@@ -0,0 +1,108 @@
+import { PluginRegistry } from "../registry";
+import type { PluginDocument } from "../types";
+
+const doc = (over: Partial<PluginDocument> = {}): PluginDocument => ({
+  id: "doc-1",
+  collection: "posts",
+  path: "content/blog/a.md",
+  fields: { slug: "a" },
+  ...over,
+});
+
+describe("addDocumentAction", () => {
+  let registry: PluginRegistry;
+  let errors: string[];
+
+  beforeEach(() => {
+    registry = new PluginRegistry();
+    errors = [];
+    jest.spyOn(console, "error").mockImplementation((m: unknown) => void errors.push(String(m)));
+    jest.spyOn(console, "warn").mockImplementation(() => {});
+  });
+  afterEach(() => jest.restoreAllMocks());
+
+  const action = (over: Record<string, unknown> = {}) => ({
+    id: "preview",
+    label: "Preview",
+    onSelect: () => {},
+    ...over,
+  });
+
+  it("registers an action and attributes it to the plugin", () => {
+    registry.api("@acme/preview").addDocumentAction(action());
+    const [a] = registry.documentActionsFor(doc());
+    expect(a).toMatchObject({ id: "preview", label: "Preview", pluginId: "@acme/preview" });
+    expect(a.key).toBe("@acme/preview:preview");
+  });
+
+  it("keys actions by plugin, so two plugins may both add a 'preview'", () => {
+    registry.api("@acme/one").addDocumentAction(action());
+    registry.api("@acme/two").addDocumentAction(action());
+    expect(registry.documentActionsFor(doc()).map((a) => a.key)).toEqual([
+      "@acme/one:preview",
+      "@acme/two:preview",
+    ]);
+  });
+
+  it("ignores a duplicate id within one plugin", () => {
+    const api = registry.api("@acme/preview");
+    api.addDocumentAction(action());
+    api.addDocumentAction(action({ label: "Second" }));
+    expect(registry.documentActionsFor(doc())).toHaveLength(1);
+    expect(errors.join()).toMatch(/duplicate id/);
+  });
+
+  it.each([
+    ["a missing id", { id: "" }],
+    ["an id with spaces", { id: "my action" }],
+    ["a missing label", { label: "" }],
+    ["a non-function onSelect", { onSelect: "nope" }],
+  ])("rejects %s without throwing into the loader", (_label, bad) => {
+    registry.api("@acme/preview").addDocumentAction(action(bad));
+    expect(registry.documentActionsFor(doc())).toHaveLength(0);
+    expect(errors).toHaveLength(1);
+  });
+
+  describe("filtering", () => {
+    it("shows an unrestricted action on every collection", () => {
+      registry.api("p").addDocumentAction(action());
+      expect(registry.documentActionsFor(doc({ collection: "pages" }))).toHaveLength(1);
+    });
+
+    it("restricts to the declared collections", () => {
+      // The behaviour the preview plugin depends on: collections with no URL
+      // template must not get a Preview button.
+      registry.api("p").addDocumentAction(action({ collections: ["posts"] }));
+      expect(registry.documentActionsFor(doc({ collection: "posts" }))).toHaveLength(1);
+      expect(registry.documentActionsFor(doc({ collection: "pages" }))).toHaveLength(0);
+    });
+
+    it("honours the available predicate", () => {
+      registry.api("p").addDocumentAction(
+        action({ available: (d: PluginDocument) => Boolean(d.fields.slug) })
+      );
+      expect(registry.documentActionsFor(doc())).toHaveLength(1);
+      expect(registry.documentActionsFor(doc({ fields: {} }))).toHaveLength(0);
+    });
+
+    it("hides an action whose available() throws, and keeps the others", () => {
+      const api = registry.api("p");
+      api.addDocumentAction(action({ id: "bad", available: () => { throw new Error("boom"); } }));
+      api.addDocumentAction(action({ id: "good" }));
+      expect(registry.documentActionsFor(doc()).map((a) => a.id)).toEqual(["good"]);
+    });
+  });
+
+  it("bumps the version so hosts re-render", () => {
+    const before = registry.getVersion();
+    registry.api("p").addDocumentAction(action());
+    expect(registry.getVersion()).toBeGreaterThan(before);
+  });
+
+  it("copies the collections array so a plugin cannot mutate it later", () => {
+    const collections = ["posts"];
+    registry.api("p").addDocumentAction(action({ collections }));
+    collections.push("pages");
+    expect(registry.documentActionsFor(doc({ collection: "pages" }))).toHaveLength(0);
+  });
+});

package/app/vendor/plugin-sdk/src/__tests__/loader.test.ts

@@ -0,0 +1,75 @@
+import { loadPlugins } from "../loader";
+import { PluginRegistry } from "../registry";
+import type { CmsPluginApi } from "../types";
+
+let errorSpy: jest.SpyInstance;
+beforeEach(() => {
+  errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+});
+afterEach(() => errorSpy.mockRestore());
+
+test("loads plugins, runs setup with a scoped api and options", async () => {
+  const reg = new PluginRegistry();
+  const seen: Array<{ id: string; options: unknown }> = [];
+  await loadPlugins(
+    [
+      {
+        id: "@acme/a",
+        options: { palette: "brand" },
+        load: async () => ({
+          default: (cms: CmsPluginApi, options: unknown) => {
+            seen.push({ id: cms.id, options });
+            cms.addSidebarLink({ label: "A", to: "a" });
+          },
+        }),
+      },
+    ],
+    reg
+  );
+  expect(seen).toEqual([{ id: "@acme/a", options: { palette: "brand" } }]);
+  expect(reg.status("@acme/a")).toBe("ready");
+  expect(reg.sidebar()).toHaveLength(1);
+});
+
+test("a plugin that fails to import is failed without affecting others", async () => {
+  const reg = new PluginRegistry();
+  await loadPlugins(
+    [
+      { id: "bad", load: async () => { throw new Error("network"); } },
+      { id: "good", load: async () => ({ default: () => {} }) },
+    ],
+    reg
+  );
+  expect(reg.status("bad")).toBe("failed");
+  expect(reg.plugins().find((p) => p.id === "bad")?.error).toBe("network");
+  expect(reg.status("good")).toBe("ready");
+});
+
+test("a module without a default-exported function fails", async () => {
+  const reg = new PluginRegistry();
+  await loadPlugins([{ id: "no-default", load: async () => ({}) }], reg);
+  expect(reg.status("no-default")).toBe("failed");
+  expect(reg.plugins()[0].error).toMatch(/no default-exported setup function/);
+});
+
+test("a setup function that throws (sync or async) fails the plugin", async () => {
+  const reg = new PluginRegistry();
+  await loadPlugins(
+    [
+      { id: "sync-throw", load: async () => ({ default: () => { throw new Error("sync"); } }) },
+      { id: "async-throw", load: async () => ({ default: async () => { throw new Error("async"); } }) },
+    ],
+    reg
+  );
+  expect(reg.status("sync-throw")).toBe("failed");
+  expect(reg.status("async-throw")).toBe("failed");
+});
+
+test("duplicate ids load once", async () => {
+  const reg = new PluginRegistry();
+  let calls = 0;
+  const entry = { id: "dup", load: async () => ({ default: () => { calls++; } }) };
+  await loadPlugins([entry, entry], reg);
+  expect(calls).toBe(1);
+  expect(reg.plugins()).toHaveLength(1);
+});

package/app/vendor/plugin-sdk/src/__tests__/registry.test.ts

@@ -0,0 +1,148 @@
+import { PluginRegistry } from "../registry";
+
+// Registrations that are rejected report via console.error; keep tests quiet
+// and let them assert on the spy.
+let errorSpy: jest.SpyInstance;
+beforeEach(() => {
+  errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+});
+afterEach(() => errorSpy.mockRestore());
+
+const loader = async () => ({ default: () => null });
+
+test("registrations are scoped to the plugin that made them", () => {
+  const reg = new PluginRegistry();
+  reg.api("a").addRoute({ path: "dash", component: loader });
+  reg.api("b").addRoute({ path: "dash", component: loader });
+  expect(reg.routesFor("a")).toHaveLength(1);
+  expect(reg.routesFor("b")).toHaveLength(1);
+  expect(reg.routesFor("a")[0].pluginId).toBe("a");
+});
+
+test("duplicate route paths within one plugin are ignored", () => {
+  const reg = new PluginRegistry();
+  const api = reg.api("a");
+  api.addRoute({ path: "/dash/", component: loader });
+  api.addRoute({ path: "dash", component: loader }); // same after normalization
+  expect(reg.routesFor("a")).toHaveLength(1);
+  expect(errorSpy).toHaveBeenCalled();
+});
+
+test("field components register under plugin: and first registration wins", () => {
+  const reg = new PluginRegistry();
+  const first = async () => ({ default: () => null });
+  reg.api("a").registerFieldComponent({ name: "color", types: ["string"], component: first });
+  reg.api("b").registerFieldComponent({ name: "color", types: ["string"], component: loader });
+  const rec = reg.fieldComponent("plugin:color");
+  expect(rec?.pluginId).toBe("a");
+  expect(rec?.component).toBe(first);
+  expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('already registered by plugin a'));
+});
+
+test("field component names outside the allowed shape are rejected", () => {
+  const reg = new PluginRegistry();
+  reg.api("a").registerFieldComponent({ name: "has space", types: ["string"], component: loader });
+  reg.api("a").registerFieldComponent({ name: "", types: ["string"], component: loader });
+  expect(reg.fieldComponent("plugin:has space")).toBeUndefined();
+  expect(errorSpy).toHaveBeenCalledTimes(2);
+});
+
+test("user menu links require exactly one of to/onSelect", () => {
+  const reg = new PluginRegistry();
+  const api = reg.api("a");
+  api.addUserMenuLink({ label: "Both", to: "x", onSelect: () => {} });
+  api.addUserMenuLink({ label: "Neither" });
+  api.addUserMenuLink({ label: "Good", to: "settings" });
+  expect(reg.userMenu()).toHaveLength(1);
+  expect(reg.userMenu()[0].label).toBe("Good");
+});
+
+test("sidebar links default to the Plugins section and keep plugin attribution", () => {
+  const reg = new PluginRegistry();
+  reg.api("a").addSidebarLink({ label: "Analytics", to: "/dash" });
+  reg.api("b").addSidebarLink({ label: "SEO", to: "audit", section: "Tools" });
+  expect(reg.sidebar()).toEqual([
+    expect.objectContaining({ pluginId: "a", section: "Plugins", to: "dash" }),
+    expect.objectContaining({ pluginId: "b", section: "Tools", to: "audit" }),
+  ]);
+});
+
+describe("matchRoute", () => {
+  const reg = new PluginRegistry();
+  const api = reg.api("a");
+  api.addRoute({ path: "reports/:kind", component: loader });
+  api.addRoute({ path: "reports/summary", component: loader });
+  api.addRoute({ path: "dash", component: loader });
+
+  test("captures :params", () => {
+    const m = reg.matchRoute("a", "reports/weekly");
+    expect(m?.record.path).toBe("reports/:kind");
+    expect(m?.params).toEqual({ kind: "weekly" });
+  });
+
+  test("prefers the route with more static segments", () => {
+    expect(reg.matchRoute("a", "reports/summary")?.record.path).toBe("reports/summary");
+  });
+
+  test("does not match across plugins or lengths", () => {
+    expect(reg.matchRoute("b", "dash")).toBeNull();
+    expect(reg.matchRoute("a", "dash/extra")).toBeNull();
+  });
+});
+
+test("load state: pending → ready/failed, settled(), plugins()", () => {
+  const reg = new PluginRegistry();
+  reg.markPending("a");
+  reg.markPending("b");
+  expect(reg.settled()).toBe(false);
+  reg.markReady("a");
+  reg.markFailed("b", new Error("boom"));
+  expect(reg.settled()).toBe(true);
+  expect(reg.plugins()).toEqual([
+    { id: "a", status: "ready", error: undefined },
+    { id: "b", status: "failed", error: "boom" },
+  ]);
+});
+
+test("subscribers are notified and version is monotonic", () => {
+  const reg = new PluginRegistry();
+  const seen: number[] = [];
+  const unsub = reg.subscribe(() => seen.push(reg.getVersion()));
+  reg.api("a").addSidebarLink({ label: "X", to: "x" });
+  reg.markPending("a");
+  unsub();
+  reg.markReady("a");
+  expect(seen).toEqual([1, 2]);
+  expect(reg.getVersion()).toBe(3);
+});
+
+describe("host capabilities", () => {
+  it("passes a preview-token request to the host, scoped to the repository", async () => {
+    const asked: string[] = [];
+    const registry = new PluginRegistry({
+      getPreviewToken: async (repositoryId) => {
+        asked.push(repositoryId);
+        return "preview-token";
+      },
+    });
+
+    const token = await registry.api("@acme/preview").getPreviewToken("repo-1");
+
+    expect(token).toBe("preview-token");
+    expect(asked).toEqual(["repo-1"]);
+  });
+
+  it("tells a plugin plainly when the host cannot mint one", async () => {
+    // Otherwise this surfaces as the preview service refusing a session, which
+    // sends whoever is debugging it to the wrong end entirely.
+    const registry = new PluginRegistry();
+    await expect(registry.api("@acme/preview").getPreviewToken("repo-1")).rejects.toThrow(
+      /does not provide preview tokens/,
+    );
+  });
+
+  it("refuses an empty repository id rather than minting something unscoped", async () => {
+    const registry = new PluginRegistry({ getPreviewToken: async () => "t" });
+    await expect(registry.api("@acme/preview").getPreviewToken("")).rejects.toThrow(/repositoryId is required/);
+  });
+});

package/app/vendor/plugin-sdk/src/index.ts

@@ -0,0 +1,33 @@
+export type {
+  CmsPluginApi,
+  PluginComponentLoader,
+  PluginDocument,
+  PluginDocumentAction,
+  PluginDocumentActionContext,
+  PluginFieldComponent,
+  PluginFieldProps,
+  PluginFieldType,
+  PluginLoadEntry,
+  PluginRoute,
+  PluginScreenProps,
+  PluginSetup,
+  PluginSidebarLink,
+  PluginStatus,
+  PluginTabContext,
+  PluginTabSpec,
+  PluginUserMenuLink,
+} from "./types";
+export {
+  PLUGIN_COMPONENT_PREFIX,
+  PluginRegistry,
+  type PluginDocumentActionRecord,
+  type PluginFieldComponentRecord,
+  type PluginInfo,
+  type PluginRouteRecord,
+  type PluginSidebarLinkRecord,
+  type PluginUserMenuLinkRecord,
+  type RouteMatch,
+} from "./registry";
+export { loadPlugins } from "./loader";
+export { pluginNavKey, parsePluginNavKey } from "./navkeys";
+export { PluginScreenHost, createPluginRenderField, getLazyComponent, usePluginRegistry } from "./react";