@batterai/strapi-plugin-canvas 0.1.0

package/dist/server-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@batterai/strapi-plugin-canvas",
+  "version": "0.1.0",
+  "license": "BUSL-1.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./strapi-admin": {
+      "source": "./src/admin/index.tsx",
+      "import": "./dist/admin/index.js",
+      "default": "./dist/admin/index.js"
+    },
+    "./strapi-server": {
+      "source": "./src/server/index.ts",
+      "import": "./dist/server/index.js",
+      "require": "./dist/server-cjs/index.js",
+      "default": "./dist/server/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "check": "tsc --noEmit",
+    "build": "node ../../scripts/build-package.mjs",
+    "build:artifacts": "bun run build:server-cjs",
+    "build:server-cjs": "bun build src/server/index.ts --format=cjs --target=node --outfile=dist/server-cjs/index.js && node -e \"require('fs').writeFileSync('dist/server-cjs/package.json', JSON.stringify({ type: 'commonjs' }, null, 2) + '\\n')\"",
+    "prepack": "bun run build"
+  },
+  "dependencies": {
+    "@batterai/bind-core": "^0.1.0",
+    "@batterai/canvas-blocks": "^0.1.0",
+    "@batterai/collab-protocol": "^0.1.0",
+    "@batterai/collab-server": "^0.1.0",
+    "@batterai/contract": "^0.1.0",
+    "@batterai/editor-shell": "^0.1.0",
+    "@batterai/host": "^0.1.0",
+    "@batterai/trust": "^0.1.0"
+  },
+  "peerDependencies": {
+    "@strapi/admin": ">=5 <6",
+    "@strapi/strapi": ">=5 <6",
+    "react": ">=18.2 <20",
+    "react-dom": ">=18.2 <20",
+    "styled-components": ">=6 <7"
+  },
+  "devDependencies": {
+    "@batterai/block-sdk": "^0.1.0",
+    "@types/node": "^22.13.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "react": "19.2.7",
+    "react-dom": "19.2.7"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20.11"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "strapi": {
+    "displayName": "Canvas",
+    "name": "canvas",
+    "description": "Same-origin Canvas authoring for Strapi admin.",
+    "kind": "plugin"
+  }
+}

package/src/admin/appearance.ts

@@ -0,0 +1,56 @@
+import type { EditorShellAppearance } from "@batterai/editor-shell";
+
+export type StrapiCanvasTheme = Readonly<{
+  colors?: Readonly<Record<string, unknown>>;
+}>;
+
+export type StrapiCanvasAppearance =
+  | EditorShellAppearance
+  | ((theme: StrapiCanvasTheme) => EditorShellAppearance);
+
+let registeredAppearance: StrapiCanvasAppearance | undefined;
+
+/**
+ * Register host-owned Canvas editor chrome colors from `src/admin/app.tsx`.
+ * A resolver is recommended: Strapi calls it again when its light/dark theme changes.
+ */
+export function registerCanvasAppearance(appearance: StrapiCanvasAppearance): void {
+  registeredAppearance = appearance;
+}
+
+export function canvasAppearance(theme: StrapiCanvasTheme): EditorShellAppearance {
+  const colors = theme.colors ?? {};
+  const inherited: EditorShellAppearance = compact({
+    accent: color(colors, "buttonPrimary600", "primary600"),
+    accentStrong: color(colors, "buttonPrimary700", "primary700"),
+    accentSoft: color(colors, "primary100"),
+    background: color(colors, "neutral100"),
+    border: color(colors, "neutral200"),
+    borderSubtle: color(colors, "neutral150", "neutral200"),
+    ink: color(colors, "neutral800"),
+    muted: color(colors, "neutral600"),
+    mutedDisabled: color(colors, "neutral500"),
+    panel: color(colors, "neutral0"),
+    panelStrong: color(colors, "neutral100"),
+  });
+  const custom = typeof registeredAppearance === "function"
+    ? registeredAppearance(theme)
+    : registeredAppearance;
+  const merged = { ...inherited, ...custom };
+  return {
+    ...merged,
+    selection: merged.selection ?? merged.accent ?? "#5d71c7",
+  };
+}
+
+function color(colors: Readonly<Record<string, unknown>>, ...names: string[]): string | undefined {
+  for (const name of names) {
+    const value = colors[name];
+    if (typeof value === "string" && /^#[0-9a-fA-F]{6}$/.test(value)) return value;
+  }
+  return undefined;
+}
+
+function compact(value: Record<string, string | undefined>): EditorShellAppearance {
+  return Object.fromEntries(Object.entries(value).filter((entry): entry is [string, string] => Boolean(entry[1])));
+}

package/src/admin/block-packages.ts

@@ -0,0 +1,16 @@
+import type { BlockPackage } from "@batterai/contract";
+
+const packages: BlockPackage[] = [];
+
+export function registerCanvasBlockPackages(next: readonly BlockPackage[]): void {
+  const existing = new Set(packages.map((pkg) => pkg.manifest.type));
+  for (const pkg of next) {
+    if (existing.has(pkg.manifest.type)) throw new Error(`Duplicate Canvas block package: ${pkg.manifest.type}`);
+    existing.add(pkg.manifest.type);
+    packages.push(pkg);
+  }
+}
+
+export function configuredCanvasBlockPackages(): readonly BlockPackage[] {
+  return Object.freeze([...packages]);
+}

package/src/admin/client/content-model.ts

@@ -0,0 +1,88 @@
+import type {
+  EditorCollectionItemImage,
+  EditorContentModel,
+  EditorReferenceOption,
+  EditorShellCollectionField,
+  EditorShellCollectionItem,
+  EditorShellContent,
+} from "@batterai/editor-shell";
+
+const RESERVED_CONTENT_KEYS = new Set([
+  "media",
+  "routes",
+  "sharedBlocks",
+  "siteMetadata",
+  "theme",
+  "translations",
+]);
+
+function contentCollections(content: EditorShellContent): string[] {
+  return Object.keys(content).filter((key) => {
+    if (RESERVED_CONTENT_KEYS.has(key)) return false;
+    return Array.isArray(content[key]);
+  });
+}
+
+function itemTitle(item: EditorShellCollectionItem): string {
+  return item.title ?? item.slug ?? item.id;
+}
+
+export const strapiContentModel: EditorContentModel<
+  EditorShellContent,
+  EditorShellCollectionItem,
+  EditorShellCollectionField,
+  EditorReferenceOption<string>
+> = {
+  editableCollections: [],
+  defaultSiteTitle: "Strapi site",
+  detailBlock: {
+    blockType: "collection.detail",
+    collectionProp: "collection",
+    defaultCollection: "pages",
+  },
+  listBlock: {
+    blockType: "collection.list",
+    collectionProp: "collection",
+    defaultCollection: "pages",
+  },
+  collectionLabel(collection) {
+    return collection;
+  },
+  collectionItems(content, collection) {
+    const rows = content[collection];
+    return Array.isArray(rows) ? (rows as EditorShellCollectionItem[]) : [];
+  },
+  collectionItemsForBlock(content, blockConfig) {
+    const collection = typeof blockConfig.collection === "string"
+      ? blockConfig.collection
+      : contentCollections(content)[0] ?? "";
+    return collection ? this.collectionItems(content, collection) : [];
+  },
+  collectionItemImage(content, item): EditorCollectionItemImage | null {
+    if (typeof item.imageId !== "string") return null;
+    const media = content.media.find((asset) => asset.id === item.imageId);
+    return media ? { url: media.url, alt: media.alt } : null;
+  },
+  collectionItemHref(_content, item) {
+    return typeof item.slug === "string" ? `/${item.slug}` : `/${item.id}`;
+  },
+  createCollectionItem(collection) {
+    const id = `${collection}-${Date.now().toString(36)}`;
+    return { id, title: "Untitled" };
+  },
+  collectionFieldDef(_content, _collection, fieldName) {
+    return { name: fieldName, label: { en: fieldName } };
+  },
+  resolveOptionItems(content, field) {
+    if (field.valueType !== "reference") return [];
+    const rows = content[String(field.refType ?? "")];
+    if (!Array.isArray(rows)) return [];
+    return (rows as EditorShellCollectionItem[]).map((item) => ({
+      value: item.id,
+      label: itemTitle(item),
+    }));
+  },
+  optionLabel(_content, _field, value) {
+    return value;
+  },
+};

package/src/admin/client/host-services.ts

@@ -0,0 +1,172 @@
+import type {
+  EditorHostServices,
+  EditorMediaListRequest,
+  EditorMediaListResult,
+  EditorMediaUploadRequest,
+  EditorMediaUploadResult,
+  EditorPresetSaveResult,
+  EditorSaveResult,
+  EditorShellBootstrap,
+  EditorShellMediaAsset,
+  EditorShellRoute,
+  EditorShellSharedBlock,
+  EditorShellSiteMetadata,
+  EditorShellTranslations,
+  BlockPreset,
+  BlockLibrary,
+} from "@batterai/editor-shell";
+import {
+  canvasDocumentRef,
+  type CanvasHostError,
+  type CanvasHostResult,
+  type HostPublishReceipt,
+  type HostSaveReceipt,
+  type HostStageReceipt,
+  type HostPageRevisionSnapshot,
+} from "@batterai/contract";
+import type { FetchClient } from "@strapi/strapi/admin";
+
+function unwrap<T>(result: Promise<{ data: T }>): Promise<T> {
+  return result.then((response) => response.data);
+}
+
+function stableSaveResult(): EditorSaveResult {
+  return { saved: true };
+}
+
+export function createStrapiCanvasHostServices(fetchClient: FetchClient): EditorHostServices {
+
+  const capabilities = {
+    canSave: true,
+    canPublish: true,
+    supportsPageStaging: true,
+    canUploadAssets: false,
+    canEditRoutes: true,
+    supportsPreview: true,
+    supportsAtomicMultiPageSave: true,
+  } as const;
+
+  return {
+    documentRef: canvasDocumentRef("strapi:canvas"),
+    document: {
+      async saveDocument(_ref, request) {
+        try {
+          return await unwrap<CanvasHostResult<HostSaveReceipt>>(
+            fetchClient.put("/canvas/document", { changes: request.changes, expected: request.expected }),
+          );
+        } catch (error) {
+          return { ok: false, error: normalizeHostError(error) };
+        }
+      },
+      async publishDocument(_ref, request) {
+        try {
+          return await unwrap<CanvasHostResult<HostPublishReceipt>>(
+            fetchClient.post("/canvas/document/publish", { expected: request.expected }),
+          );
+        } catch (error) {
+          return { ok: false, error: normalizeHostError(error) };
+        }
+      },
+      async stagePage(_ref, request) {
+        try {
+          return await unwrap<CanvasHostResult<HostStageReceipt>>(
+            fetchClient.post(`/canvas/pages/${encodeURIComponent(request.pageId)}/stage`, { expected: request.expected }),
+          );
+        } catch (error) {
+          return { ok: false, error: normalizeHostError(error) };
+        }
+      },
+      async unstagePage(_ref, request) {
+        try {
+          return await unwrap<CanvasHostResult<HostStageReceipt>>(
+            fetchClient.post(`/canvas/pages/${encodeURIComponent(request.pageId)}/unstage`, { expected: request.expected }),
+          );
+        } catch (error) {
+          return { ok: false, error: normalizeHostError(error) };
+        }
+      },
+      async loadPageRevision(_ref, request) {
+        try {
+          return await unwrap<CanvasHostResult<HostPageRevisionSnapshot>>(
+            fetchClient.get(`/canvas/pages/${encodeURIComponent(request.pageId)}/revisions/${request.revision}`),
+          );
+        } catch (error) {
+          return { ok: false, error: normalizeHostError(error) };
+        }
+      },
+      async getCapabilities() {
+        return { ok: true, value: capabilities };
+      },
+    },
+    readLaunchContext() {
+      return {};
+    },
+    createSessionHandshake() {
+      return undefined;
+    },
+    resolveLaunchPageId(pages, _context, fallbackPageId) {
+      return pages.some((page) => page.id === fallbackPageId) ? fallbackPageId : pages[0]?.id ?? fallbackPageId;
+    },
+    async loadBootstrap() {
+      return unwrap<EditorShellBootstrap>(fetchClient.get("/canvas/bootstrap"));
+    },
+    async listMediaAssets(request: EditorMediaListRequest): Promise<EditorMediaListResult<EditorShellMediaAsset>> {
+      const params = new URLSearchParams();
+      params.set("pageSize", String(request.pageSize));
+      if (request.cursor) params.set("cursor", request.cursor);
+      for (const mime of request.allowedMimeTypes ?? []) params.append("allowedMimeTypes", mime);
+      for (const id of request.selectedIds ?? []) params.append("selectedIds", id);
+      return unwrap(fetchClient.get(`/canvas/media?${params}`));
+    },
+    async uploadMediaAsset(request: EditorMediaUploadRequest): Promise<EditorMediaUploadResult<EditorShellMediaAsset>> {
+      const formData = new FormData();
+      formData.set("files", request.file);
+      formData.set("alt", request.alt);
+      for (const mime of request.allowedMimeTypes ?? []) formData.append("allowedMimeTypes", mime);
+      return unwrap(fetchClient.post("/canvas/media", formData));
+    },
+    async saveContentCollection(collection: string, items: unknown[]) {
+      await unwrap(fetchClient.put(`/canvas/content/${encodeURIComponent(collection)}`, { items }));
+      return stableSaveResult();
+    },
+    async saveMediaAssets(media: EditorShellMediaAsset[]) {
+      await unwrap(fetchClient.put("/canvas/media", { media }));
+      return stableSaveResult();
+    },
+    async saveRoutes(routes: EditorShellRoute[]) {
+      await unwrap(fetchClient.put("/canvas/routes", { routes }));
+      return stableSaveResult();
+    },
+    async saveSharedBlocks(sharedBlocks: EditorShellSharedBlock[]) {
+      await unwrap(fetchClient.put("/canvas/shared-blocks", { sharedBlocks }));
+      return stableSaveResult();
+    },
+    async savePreset(preset: BlockPreset): Promise<EditorPresetSaveResult> {
+      const response = await unwrap<{ library: BlockLibrary; preset: BlockPreset }>(
+        fetchClient.post("/canvas/presets", { preset }),
+      );
+      return response;
+    },
+    async saveTranslations(translations: EditorShellTranslations) {
+      await unwrap(fetchClient.put("/canvas/translations", { translations }));
+      return stableSaveResult();
+    },
+    async saveSiteMetadata(siteMetadata: EditorShellSiteMetadata) {
+      await unwrap(fetchClient.put("/canvas/site-metadata", { siteMetadata }));
+      return stableSaveResult();
+    },
+  };
+}
+
+function normalizeHostError(error: unknown): CanvasHostError {
+  const responseError = (error as { readonly response?: { readonly data?: { readonly error?: unknown } } })
+    ?.response?.data?.error;
+  if (responseError && typeof responseError === "object" && "kind" in responseError) {
+    return responseError as CanvasHostError;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (/409|conflict/i.test(message)) return { kind: "conflict" };
+  if (/401|403|forbidden/i.test(message)) return { kind: "forbidden", reason: message };
+  if (/404|not found/i.test(message)) return { kind: "not-found" };
+  return { kind: "unavailable", retryable: true };
+}

package/src/admin/index.tsx

@@ -0,0 +1,56 @@
+import { PLUGIN_ID, PLUGIN_NAME } from "../constants";
+import { translationForLocale } from "./translations";
+
+export { configuredCanvasBlockPackages, registerCanvasBlockPackages } from "./block-packages";
+export {
+  canvasAppearance,
+  registerCanvasAppearance,
+  type StrapiCanvasAppearance,
+  type StrapiCanvasTheme,
+} from "./appearance";
+
+type StrapiAdminApp = {
+  addMenuLink: (link: {
+    to: string;
+    icon?: React.ComponentType;
+    intlLabel: { id: string; defaultMessage: string };
+    permissions?: Array<{ action: string; subject?: string | null }>;
+    Component: () => Promise<{ default: React.ComponentType }>;
+  }) => void;
+  registerPlugin: (plugin: { id: string; name: string }) => void;
+};
+
+function CanvasIcon() {
+  return (
+    <span aria-hidden="true" style={{ color: "currentColor", fontWeight: 800, fontSize: "18px", lineHeight: 1 }}>
+      Ç
+    </span>
+  );
+}
+
+export default {
+  register(app: StrapiAdminApp) {
+    app.addMenuLink({
+      to: `plugins/${PLUGIN_ID}`,
+      icon: CanvasIcon,
+      intlLabel: {
+        id: `${PLUGIN_ID}.menu.label`,
+        defaultMessage: PLUGIN_NAME,
+      },
+      permissions: [{ action: "plugin::canvas.editor.access", subject: null }],
+      Component: () => import("./pages/App"),
+    });
+
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      name: PLUGIN_NAME,
+    });
+  },
+  bootstrap() {},
+  async registerTrads({ locales }: { locales: string[] }) {
+    return locales.map((locale) => ({
+      locale,
+      data: translationForLocale(locale),
+    }));
+  },
+};

package/src/admin/pages/App.tsx

@@ -0,0 +1,56 @@
+import { createEditorElement } from "@batterai/editor-shell";
+import { canvasBlockPackages } from "@batterai/canvas-blocks";
+import "@batterai/editor-shell/styles.css";
+import { useFetchClient } from "@strapi/strapi/admin";
+import { useMemo } from "react";
+import { useTheme } from "styled-components";
+import { strapiContentModel } from "../client/content-model";
+import { createStrapiCanvasHostServices } from "../client/host-services";
+import { configuredCanvasBlockPackages } from "../block-packages";
+import { canvasAppearance, type StrapiCanvasTheme } from "../appearance";
+
+function CanvasPage() {
+  const fetchClient = useFetchClient();
+  const strapiTheme = useTheme() as unknown as StrapiCanvasTheme;
+  const hostServices = useMemo(() => createStrapiCanvasHostServices(fetchClient), [fetchClient]);
+  const appearance = useMemo(() => canvasAppearance(strapiTheme), [strapiTheme]);
+  const collaboration = useMemo(() => {
+    const collabFetch: typeof fetch = async (input, init) => {
+      const url = new URL(String(input), window.location.origin);
+      const requestBody = init?.body ? JSON.parse(String(init.body)) : {};
+      const response = await fetchClient.post(url.pathname, { ...requestBody, __canvasOrigin: window.location.origin });
+      return Response.json(response.data);
+    };
+    return {
+      baseUrl: "/canvas/collab",
+      fetch: collabFetch,
+      tokenProvider: async () => {
+        const response = await fetchClient.post("/canvas/collab-token", {});
+        return (response.data as { token: string }).token;
+      },
+      auditProvider: async (pageId: string) => {
+        const response = await fetchClient.get(`/canvas/collab-audit/${encodeURIComponent(pageId)}`);
+        return (response.data as { events: readonly import("@batterai/editor-shell").EditorCollaborationAuditEvent[] }).events;
+      },
+    };
+  }, [fetchClient]);
+
+  return (
+    <main style={{ height: "100vh", overflow: "hidden", width: "100%" }}>
+      {createEditorElement({
+        contentModel: strapiContentModel,
+        defaultPageId: "home",
+        hostServices,
+        appearance,
+        collaboration,
+        blockPackages: [...canvasBlockPackages, ...configuredCanvasBlockPackages()],
+      })}
+    </main>
+  );
+}
+
+export function ProtectedCanvasPage() {
+  return <CanvasPage />;
+}
+
+export default ProtectedCanvasPage;

package/src/admin/strapi-admin.d.ts

@@ -0,0 +1 @@
+declare module "*.css";

package/src/admin/translations.ts

@@ -0,0 +1,23 @@
+import { PLUGIN_ID } from "../constants";
+
+type TranslationMap = Record<string, string>;
+
+const en: TranslationMap = {
+  "plugin.name": "Canvas",
+  "menu.label": "Canvas",
+};
+
+const nl: TranslationMap = {
+  "plugin.name": "Canvas",
+  "menu.label": "Canvas",
+};
+
+function prefixPluginTranslations(data: TranslationMap): TranslationMap {
+  return Object.fromEntries(
+    Object.entries(data).map(([key, value]) => [`${PLUGIN_ID}.${key}`, value]),
+  );
+}
+
+export function translationForLocale(locale: string): TranslationMap {
+  return prefixPluginTranslations(locale === "nl" ? nl : en);
+}

package/src/constants.ts

@@ -0,0 +1,21 @@
+export const PLUGIN_ID = "canvas";
+export const PLUGIN_NAME = "Canvas";
+
+export const CANVAS_PAGE_UID = "plugin::canvas.canvas-page";
+export const CANVAS_SITE_UID = "plugin::canvas.canvas-site";
+export const DEFAULT_SITE_KEY = "default";
+export const CANVAS_PAGE_PREFIX = "canvas:";
+
+export const CANVAS_PERMISSIONS = {
+  access: "plugin::canvas.editor.access",
+  write: "plugin::canvas.editor.write",
+  audit: "plugin::canvas.editor.audit",
+} as const;
+
+export function canvasPageKey(pageId: string): string {
+  return `${CANVAS_PAGE_PREFIX}${pageId}`;
+}
+
+export function pageIdFromCanvasKey(pageKey: string): string {
+  return pageKey.startsWith(CANVAS_PAGE_PREFIX) ? pageKey.slice(CANVAS_PAGE_PREFIX.length) : pageKey;
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export {
+  CANVAS_PAGE_PREFIX,
+  CANVAS_PAGE_UID,
+  CANVAS_PERMISSIONS,
+  CANVAS_SITE_UID,
+  DEFAULT_SITE_KEY,
+  PLUGIN_ID,
+  PLUGIN_NAME,
+  canvasPageKey,
+  pageIdFromCanvasKey,
+} from "./constants";

package/src/server/bootstrap.ts

@@ -0,0 +1,45 @@
+import { CANVAS_PERMISSIONS, PLUGIN_ID } from "../constants";
+
+const actions = [
+  {
+    section: "plugins",
+    displayName: "Access",
+    uid: "editor.access",
+    subCategory: "editor",
+    pluginName: PLUGIN_ID,
+  },
+  {
+    section: "plugins",
+    displayName: "Write",
+    uid: "editor.write",
+    subCategory: "editor",
+    pluginName: PLUGIN_ID,
+  },
+  {
+    section: "plugins",
+    displayName: "View collaboration audit",
+    uid: "editor.audit",
+    subCategory: "editor",
+    pluginName: PLUGIN_ID,
+  },
+];
+
+export default async function bootstrap({ strapi }: { strapi: any }) {
+  await strapi.service("admin::permission").actionProvider.registerMany(actions);
+
+  // Strapi registers custom plugin actions separately from the permissions held
+  // by its built-in Super Admin role. Grant the Canvas actions explicitly so a
+  // fresh demo (and an existing demo upgraded with this plugin) can surface
+  // the Canvas navigation item immediately.
+  const superAdmin = await strapi.service("admin::role").getSuperAdmin();
+  if (superAdmin?.id) {
+    await strapi.service("admin::role").assignPermissions(
+      superAdmin.id,
+      Object.values(CANVAS_PERMISSIONS).map((action) => ({ action, subject: null, conditions: [] })),
+    );
+  }
+
+  strapi.log?.debug?.(
+    `canvas plugin registered ${CANVAS_PERMISSIONS.access}, ${CANVAS_PERMISSIONS.write}, and ${CANVAS_PERMISSIONS.audit}`,
+  );
+}

package/src/server/config/index.ts

@@ -0,0 +1,46 @@
+export type CanvasPluginConfig = {
+  boundCollections?: Record<string, string>;
+  discoverCollections?: boolean;
+  licenseKey?: string;
+  seedLibrary?: { categories?: unknown[]; blocks?: unknown[]; presets?: unknown[] };
+  collaboration?: {
+    secret: string;
+    origins?: string[];
+    tokenTtlSeconds?: number;
+  };
+};
+
+export default {
+  default: {
+    boundCollections: {},
+    discoverCollections: true,
+  } satisfies CanvasPluginConfig,
+  validator(config: CanvasPluginConfig) {
+    if (config.boundCollections && typeof config.boundCollections !== "object") {
+      throw new Error("plugin::canvas.boundCollections must be an object.");
+    }
+    if (config.discoverCollections !== undefined && typeof config.discoverCollections !== "boolean") {
+      throw new Error("plugin::canvas.discoverCollections must be a boolean.");
+    }
+    if (config.licenseKey !== undefined && typeof config.licenseKey !== "string") {
+      throw new Error("plugin::canvas.licenseKey must be a string.");
+    }
+    if (
+      config.seedLibrary !== undefined &&
+      (typeof config.seedLibrary !== "object" || config.seedLibrary === null || Array.isArray(config.seedLibrary))
+    ) {
+      throw new Error("plugin::canvas.seedLibrary must be an object with categories/blocks/presets arrays.");
+    }
+    if (config.collaboration !== undefined) {
+      if (!config.collaboration || typeof config.collaboration !== "object") {
+        throw new Error("plugin::canvas.collaboration must be an object.");
+      }
+      if (typeof config.collaboration.secret !== "string" || config.collaboration.secret.length < 32) {
+        throw new Error("plugin::canvas.collaboration.secret must contain at least 32 characters.");
+      }
+      if (config.collaboration.origins && !Array.isArray(config.collaboration.origins)) {
+        throw new Error("plugin::canvas.collaboration.origins must be an array.");
+      }
+    }
+  },
+};