@orion-studios/cms 0.5.0

package/README.md

@@ -0,0 +1,96 @@
+# @orion-studios/cms
+
+Orion Studios' CMS engine: a single package that turns a custom Next.js site
+into a client-editable site. JSONB content on Supabase, a self-contained
+Studio admin, and a block system where one definition drives everything.
+
+- **No schema migrations for content changes.** Pages are JSONB layouts; the
+  eight `cms_` tables never change when you add or edit block types.
+- **`defineBlock()` is the single source of truth.** A Zod schema + a React
+  component per section type produces: TypeScript types, validation, defaults,
+  the builder palette, the editing panel, inline click-to-edit, and the
+  public-site renderer.
+- **Three runtime modes**, chosen by env: `supabase` (production),
+  `memory` (zero-setup dev/demo, in-process store), `static` (no CMS at all —
+  renders from `site-content.ts`; how sites launch before a client buys the CMS).
+
+## Install
+
+```bash
+npm install @orion-studios/cms
+```
+
+Requires Next.js (App Router), React 19, Zod 3. Supabase only in supabase mode.
+
+## Entry points
+
+| Import | Contents |
+| --- | --- |
+| `@orion-studios/cms/blocks` | `defineBlock`, `defineGlobal`, `createBlockRegistry`, `createGlobalRegistry`, field helpers (`link`, `mediaRef`, `paragraphs`), `BlockPreviewProps`, `BlockData` |
+| `@orion-studios/cms/server` | `createCmsRoutes` (the whole API as one catch-all route), `getServiceClient`, `resolveUser`, `runContentSync`, `getMemoryCms`, permission matrix (`can`, roles) |
+| `@orion-studios/cms/studio` | `Studio` (the full admin UI), `LoginView`, `PasswordInput`, `UsersView`, `createStudioApi` |
+| `@orion-studios/cms/content` | `createContentClient` — anon-key reads for the public site (`getPageByPath`, `listPublishedPaths`, `getGlobal`) |
+| `@orion-studios/cms/forms` | Form config types, `processSubmission` (validation, honeypot, rate limiting), shared `SiteForm` renderer |
+| `@orion-studios/cms/sql/bootstrap.sql` | The complete idempotent schema (tables, RPCs, RLS, grants) |
+| `@orion-studios/cms/studio/styles.css` | Studio styles (self-contained, `ost-` prefixed) |
+
+## The 5-minute wiring (already done in the site template)
+
+```tsx
+// src/app/api/cms/[...path]/route.ts — the entire CMS API
+import { createCmsRoutes } from '@orion-studios/cms/server'
+import { registry } from '@/cms/registry'
+export const { GET, POST, PATCH, DELETE } = createCmsRoutes({
+  registry, syncToken: process.env.CMS_SYNC_TOKEN,
+})
+
+// src/app/studio/page.tsx — the admin
+import { Studio } from '@orion-studios/cms/studio'
+import '@orion-studios/cms/studio/styles.css'
+export default function Page() {
+  return <Studio registry={registry} globals={globals} siteName="Client Co" logoUrl="/logo.png" />
+}
+```
+
+Don't start here for a new site — copy `templates/site` from the
+`orion-cms-packages` repo instead; it has all of this wired plus the scripts
+(`bootstrap`, `create-admin`, `sync`). See `NEW-SITE-PLAYBOOK.md` at the repo
+root for the full procedure.
+
+## Roles
+
+Four tiers, enforced in the API (`src/server/permissions.ts`), UI adapts:
+
+- `content` — edit text/images on existing sections (no add/remove/reorder)
+- `editor` — full content control: structure, new pages, publish
+- `admin` — everything + user management (Users panel in the Studio)
+- `developer` — full access; the tier Orion Studios keeps for itself
+
+Rank rules: you can only assign roles at or below your own, never change your
+own role, never delete yourself.
+
+## Environment
+
+| Variable | Where | Purpose |
+| --- | --- | --- |
+| `NEXT_PUBLIC_SUPABASE_URL` | local + Vercel | project URL (also selects supabase mode) |
+| `NEXT_PUBLIC_SUPABASE_ANON_KEY` | local + Vercel | public reads (RLS: published content only) |
+| `SUPABASE_SERVICE_ROLE_KEY` | local + Vercel | server-only; powers the API layer |
+| `DATABASE_URL` | local + Vercel | Postgres for bootstrap (use the transaction pooler on Vercel) |
+| `CMS_SYNC_TOKEN` | local + Vercel | authorizes `POST /api/cms/sync` |
+| `CMS_STATIC=true` | optional | static mode (no CMS) |
+| `CMS_MEMORY=true` | optional | force memory mode |
+
+## Development
+
+```bash
+npm run typecheck && npm test   # 24 node:test suites
+npm run build                    # tsup → dist/
+npm pack                         # tarball for vendoring / inspection
+```
+
+The SQL bootstrap is idempotent and runs under restricted Postgres roles: it
+avoids `auth`-schema privileges and explicitly grants the PostgREST roles
+(`service_role`, `anon`, `authenticated`) table access — RLS policies filter
+rows but do not grant access, and Supabase's default privileges only cover
+`postgres`-created tables.

package/dist/analytics/react.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The site-side analytics tracker: small, first-party, and zero dependency.
+ * Mount <Analytics /> once in the site layout. It captures:
+ *
+ * - pageviews on every App Router route change (+ referrer/UTM on entry)
+ * - clicks via one document-level listener: tel: ("call"), mailto: ("email"),
+ *   the configured portal host ("portal"), other external links ("outbound"),
+ *   and anything carrying data-analytics="name" ("cta")
+ * - form funnel events emitted by FormRenderer through the window bridge
+ *
+ * Events queue in memory and flush with sendBeacon so a phone tap that
+ * navigates away is never lost. Visiting /studio flags the browser and
+ * permanently excludes it (the owner's own clicks don't pollute the data).
+ */
+declare const EXCLUDE_FLAG = "orion-analytics-exclude";
+declare const ANALYTICS_CONSENT_COOKIE = "orion_analytics_consent";
+declare const ANALYTICS_VISITOR_COOKIE = "orion_visitor_id";
+declare const ANALYTICS_CONSENT_EVENT = "orion-analytics-consent";
+type AnalyticsConsent = 'accepted' | 'declined' | null;
+type QueuedEvent = {
+    type: 'pageview' | 'click' | 'form' | 'not_found';
+    name?: string;
+    path: string;
+    referrer?: string;
+    utm?: Record<string, string>;
+    meta?: Record<string, unknown>;
+};
+declare global {
+    interface Window {
+        __orionTrack?: (type: QueuedEvent['type'], name: string, meta?: Record<string, unknown>) => void;
+    }
+}
+type AnalyticsProps = {
+    /** Hostnames counted as "portal" clicks (e.g. the client-portal domain). */
+    portalHosts?: string[];
+    /** Skip visitors with Do Not Track enabled. Off by default. */
+    respectDNT?: boolean;
+    /** Wait for an explicit accepted consent cookie before collecting events. */
+    requireConsent?: boolean;
+    /** Add a pseudonymous first-party visitor cookie for multi-day analytics. */
+    visitorCookie?: boolean;
+    /** Defaults to /api/cms. */
+    basePath?: string;
+};
+declare function getAnalyticsConsent(): AnalyticsConsent;
+declare function setAnalyticsConsent(value: Exclude<AnalyticsConsent, null>): void;
+declare function Analytics({ portalHosts, respectDNT, requireConsent, visitorCookie, basePath, }: AnalyticsProps): null;
+/** Mount inside the site's not-found page to record 404 hits. */
+declare function AnalyticsNotFound(): null;
+/** Programmatic tracking for custom site components. No-op when analytics is off. */
+declare function trackEvent(name: string, meta?: Record<string, unknown>): void;
+
+export { ANALYTICS_CONSENT_COOKIE, ANALYTICS_CONSENT_EVENT, ANALYTICS_VISITOR_COOKIE, Analytics, type AnalyticsConsent, AnalyticsNotFound, type AnalyticsProps, EXCLUDE_FLAG, getAnalyticsConsent, setAnalyticsConsent, trackEvent };

package/dist/analytics/react.js

@@ -0,0 +1,195 @@
+'use client';
+"use client";
+
+// src/analytics/react.tsx
+import { useEffect, useRef, useState } from "react";
+import { usePathname } from "next/navigation";
+var EXCLUDE_FLAG = "orion-analytics-exclude";
+var ANALYTICS_CONSENT_COOKIE = "orion_analytics_consent";
+var ANALYTICS_VISITOR_COOKIE = "orion_visitor_id";
+var ANALYTICS_CONSENT_EVENT = "orion-analytics-consent";
+var readCookie = (name) => {
+  if (typeof document === "undefined") return "";
+  const prefix = `${encodeURIComponent(name)}=`;
+  const match = document.cookie.split("; ").find((entry) => entry.startsWith(prefix));
+  return match ? decodeURIComponent(match.slice(prefix.length)) : "";
+};
+var writeCookie = (name, value, maxAge) => {
+  if (typeof document === "undefined") return;
+  const secure = window.location.protocol === "https:" ? "; Secure" : "";
+  document.cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}; Path=/; Max-Age=${maxAge}; SameSite=Lax${secure}`;
+};
+function getAnalyticsConsent() {
+  const value = readCookie(ANALYTICS_CONSENT_COOKIE);
+  return value === "accepted" || value === "declined" ? value : null;
+}
+function setAnalyticsConsent(value) {
+  writeCookie(ANALYTICS_CONSENT_COOKIE, value, 365 * 24 * 60 * 60);
+  if (value === "declined") writeCookie(ANALYTICS_VISITOR_COOKIE, "", 0);
+  window.dispatchEvent(new CustomEvent(ANALYTICS_CONSENT_EVENT, { detail: value }));
+}
+var visitorId = () => {
+  const existing = readCookie(ANALYTICS_VISITOR_COOKIE);
+  if (/^[0-9a-f-]{36}$/i.test(existing)) return existing;
+  const created = crypto.randomUUID();
+  writeCookie(ANALYTICS_VISITOR_COOKIE, created, 365 * 24 * 60 * 60);
+  return created;
+};
+var isExcluded = (respectDNT) => {
+  try {
+    if (localStorage.getItem(EXCLUDE_FLAG)) return true;
+  } catch {
+  }
+  if (respectDNT && navigator.doNotTrack === "1") return true;
+  return false;
+};
+function Analytics({
+  portalHosts = [],
+  respectDNT = false,
+  requireConsent = false,
+  visitorCookie = false,
+  basePath = "/api/cms"
+}) {
+  const pathname = usePathname();
+  const [consent, setConsentState] = useState(null);
+  const queueRef = useRef([]);
+  const firstLoadRef = useRef(true);
+  const excludedRef = useRef(false);
+  const visitorIdRef = useRef("");
+  useEffect(() => {
+    setConsentState(getAnalyticsConsent());
+    const onConsent = (event) => {
+      setConsentState(event.detail);
+    };
+    window.addEventListener(ANALYTICS_CONSENT_EVENT, onConsent);
+    return () => window.removeEventListener(ANALYTICS_CONSENT_EVENT, onConsent);
+  }, []);
+  const flush = () => {
+    const queue = queueRef.current;
+    if (queue.length === 0) return;
+    queueRef.current = [];
+    const body = JSON.stringify({
+      events: queue,
+      ...visitorIdRef.current ? { visitorId: visitorIdRef.current } : {}
+    });
+    const url = `${basePath}/events`;
+    try {
+      if (navigator.sendBeacon && navigator.sendBeacon(url, new Blob([body], { type: "application/json" }))) {
+        return;
+      }
+    } catch {
+    }
+    fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body,
+      keepalive: true
+    }).catch(() => void 0);
+  };
+  const track = (event) => {
+    if (excludedRef.current) return;
+    queueRef.current.push(event);
+    if (queueRef.current.length >= 10) flush();
+  };
+  useEffect(() => {
+    const consentGranted = !requireConsent || consent === "accepted";
+    excludedRef.current = !consentGranted || isExcluded(respectDNT);
+    if (excludedRef.current) {
+      queueRef.current = [];
+      visitorIdRef.current = "";
+      delete window.__orionTrack;
+      return;
+    }
+    visitorIdRef.current = visitorCookie && consent === "accepted" ? visitorId() : "";
+    window.__orionTrack = (type, name, meta) => {
+      track({ type, name, path: window.location.pathname, meta });
+      if (type === "form" || type === "not_found") flush();
+    };
+    const onClick = (event) => {
+      const target = event.target;
+      const tagged = target?.closest("[data-analytics]");
+      const anchor = target?.closest("a");
+      let name = "";
+      let meta;
+      if (tagged?.dataset.analytics) {
+        name = "cta";
+        meta = { label: tagged.dataset.analytics.slice(0, 100) };
+      } else if (anchor?.href) {
+        const href = anchor.getAttribute("href") || "";
+        if (href.startsWith("tel:")) name = "call";
+        else if (href.startsWith("mailto:")) name = "email";
+        else {
+          try {
+            const url = new URL(anchor.href);
+            if (url.origin !== window.location.origin) {
+              name = portalHosts.includes(url.hostname) ? "portal" : "outbound";
+              meta = { href: url.hostname };
+            }
+          } catch {
+          }
+        }
+      }
+      if (!name) return;
+      track({ type: "click", name, path: window.location.pathname, meta });
+      flush();
+    };
+    const onHide = () => {
+      if (document.visibilityState === "hidden") flush();
+    };
+    document.addEventListener("click", onClick, { capture: true, passive: true });
+    document.addEventListener("visibilitychange", onHide);
+    window.addEventListener("pagehide", flush);
+    const interval = window.setInterval(flush, 8e3);
+    return () => {
+      document.removeEventListener("click", onClick, { capture: true });
+      document.removeEventListener("visibilitychange", onHide);
+      window.removeEventListener("pagehide", flush);
+      window.clearInterval(interval);
+      delete window.__orionTrack;
+    };
+  }, [respectDNT, requireConsent, visitorCookie, consent, basePath, portalHosts.join(",")]);
+  useEffect(() => {
+    if (!pathname || excludedRef.current) return;
+    const event = { type: "pageview", path: pathname };
+    if (firstLoadRef.current) {
+      firstLoadRef.current = false;
+      if (document.referrer) {
+        try {
+          if (new URL(document.referrer).origin !== window.location.origin) {
+            event.referrer = document.referrer;
+          }
+        } catch {
+        }
+      }
+      const params = new URLSearchParams(window.location.search);
+      const utm = {};
+      for (const key of ["source", "medium", "campaign", "term", "content"]) {
+        const value = params.get(`utm_${key}`);
+        if (value) utm[key] = value;
+      }
+      if (Object.keys(utm).length > 0) event.utm = utm;
+    }
+    track(event);
+  }, [pathname, consent, requireConsent]);
+  return null;
+}
+function AnalyticsNotFound() {
+  useEffect(() => {
+    window.__orionTrack?.("not_found", "", { referrer: document.referrer.slice(0, 200) });
+  }, []);
+  return null;
+}
+function trackEvent(name, meta) {
+  if (typeof window !== "undefined") window.__orionTrack?.("click", name, meta);
+}
+export {
+  ANALYTICS_CONSENT_COOKIE,
+  ANALYTICS_CONSENT_EVENT,
+  ANALYTICS_VISITOR_COOKIE,
+  Analytics,
+  AnalyticsNotFound,
+  EXCLUDE_FLAG,
+  getAnalyticsConsent,
+  setAnalyticsConsent,
+  trackEvent
+};

package/dist/blocks/index.d.ts

@@ -0,0 +1,222 @@
+import { ComponentType } from 'react';
+import { z } from 'zod';
+
+/**
+ * Editor field derivation: turns a block's Zod schema into a default editor
+ * field list so blocks are editable with zero editor configuration. Explicit
+ * `editor.fields` entries in defineBlock() override the derived ones per key.
+ */
+type EditorInput = 'text' | 'textarea' | 'number' | 'checkbox' | 'select' | 'link' | 'media' | 'file' | 'paragraphs' | 'stringList' | 'itemList';
+type EditorField = {
+    key: string;
+    label: string;
+    input: EditorInput;
+    /** Editable inline in the preview (text/textarea only). */
+    inline?: boolean;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    /** For itemList: fields of each item, derived recursively. */
+    itemFields?: EditorField[];
+    /** For itemList: a new-item template from the item schema's defaults. */
+    itemTemplate?: Record<string, unknown>;
+    /** For itemList: item property used as the collapsed label. */
+    itemLabelKey?: string;
+};
+declare const labelForKey: (key: string) => string;
+
+/** A call-to-action link: label + href + visual variant. */
+declare function link(): z.ZodObject<{
+    label: z.ZodDefault<z.ZodString>;
+    href: z.ZodDefault<z.ZodString>;
+    variant: z.ZodDefault<z.ZodEnum<["solid", "outline", "line"]>>;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    href: string;
+    variant: "solid" | "outline" | "line";
+}, {
+    label?: string | undefined;
+    href?: string | undefined;
+    variant?: "solid" | "outline" | "line" | undefined;
+}>;
+type LinkValue = z.infer<ReturnType<typeof link>>;
+/**
+ * A media reference. `mediaId` points at cms_media; `src` is a resolved
+ * fallback path (e.g. a public/ asset) used when no media doc is linked.
+ * Renderers prefer the transform URL of `mediaId` when present.
+ */
+declare function mediaRef(): z.ZodObject<{
+    mediaId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    src: z.ZodDefault<z.ZodString>;
+    alt: z.ZodDefault<z.ZodString>;
+    caption: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    mediaId: string | null;
+    src: string;
+    alt: string;
+    caption: string;
+}, {
+    mediaId?: string | null | undefined;
+    src?: string | undefined;
+    alt?: string | undefined;
+    caption?: string | undefined;
+}>;
+type MediaRefValue = z.infer<ReturnType<typeof mediaRef>>;
+/** Multi-paragraph text stored as a string array (one entry per paragraph). */
+declare function paragraphs(): z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+/**
+ * A non-image file reference (PDF service agreement, price sheet, …).
+ * `src` is the resolved public URL; `filename` is the display name.
+ */
+declare function fileRef(): z.ZodObject<{
+    mediaId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    src: z.ZodDefault<z.ZodString>;
+    filename: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    mediaId: string | null;
+    src: string;
+    filename: string;
+}, {
+    mediaId?: string | null | undefined;
+    src?: string | undefined;
+    filename?: string | undefined;
+}>;
+type FileRefValue = z.infer<ReturnType<typeof fileRef>>;
+
+/**
+ * Globals follow the same single-source-of-truth pattern as blocks: one
+ * `defineGlobal()` call yields the schema, defaults, validation, and the
+ * Studio's editor fields.
+ */
+type GlobalDefinition<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> = {
+    key: string;
+    label: string;
+    description?: string;
+    schema: TSchema;
+    editor: {
+        fields: EditorField[];
+    };
+    defaultData: z.infer<TSchema>;
+};
+type DefineGlobalArgs<TSchema extends z.ZodObject<z.ZodRawShape>> = {
+    key: string;
+    label?: string;
+    description?: string;
+    schema: TSchema;
+    editor?: {
+        fields: Array<Partial<EditorField> & {
+            key: string;
+        }>;
+    };
+};
+declare function defineGlobal<TSchema extends z.ZodObject<z.ZodRawShape>>(args: DefineGlobalArgs<TSchema>): GlobalDefinition<TSchema>;
+type AnyGlobalDefinition = GlobalDefinition<any>;
+type GlobalRegistry = {
+    list(): GlobalDefinition[];
+    get(key: string): GlobalDefinition | undefined;
+    /** Parses stored data through the schema (defaults applied, unknown keys stripped). */
+    normalize(key: string, data: unknown): Record<string, unknown>;
+};
+declare function createGlobalRegistry(globals: ReadonlyArray<AnyGlobalDefinition>): GlobalRegistry;
+
+/**
+ * The Orion CMS block system.
+ *
+ * One `defineBlock()` call is the single source of truth for a section type.
+ * Everything else — TypeScript types, default data, server-side validation,
+ * the builder palette, the inspector fields, and rendering — derives from it.
+ */
+/** A block instance as stored inside a page's JSONB layout. */
+type BlockInstance<TData = Record<string, unknown>> = {
+    id: string;
+    type: string;
+    data: TData;
+    /** Presentation settings (spacing, background, visibility) — builder-owned. */
+    settings?: Record<string, unknown>;
+};
+type PageLayout = BlockInstance[];
+type BlockPreviewProps<TData> = {
+    data: TData;
+    /** True when rendering inside the Studio builder (enables inline editing affordances). */
+    editing?: boolean;
+    /** Inline-commit callback available in the builder. */
+    onChange?: (patch: Partial<TData>) => void;
+};
+type BlockDefinition<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> = {
+    type: string;
+    label: string;
+    description?: string;
+    /** Palette grouping in the builder. */
+    category?: string;
+    schema: TSchema;
+    /** Derived from the schema; entries here override per key and set order. */
+    editor: {
+        fields: EditorField[];
+    };
+    defaultData: z.infer<TSchema>;
+    preview?: ComponentType<BlockPreviewProps<z.infer<TSchema>>>;
+};
+type DefineBlockArgs<TSchema extends z.ZodObject<z.ZodRawShape>> = {
+    type: string;
+    label?: string;
+    description?: string;
+    category?: string;
+    schema: TSchema;
+    editor?: {
+        fields: Array<Partial<EditorField> & {
+            key: string;
+        }>;
+    };
+    preview?: ComponentType<BlockPreviewProps<z.infer<TSchema>>>;
+};
+declare function defineBlock<TSchema extends z.ZodObject<z.ZodRawShape>>(args: DefineBlockArgs<TSchema>): BlockDefinition<TSchema>;
+type ValidationIssue = {
+    blockId: string;
+    blockType: string;
+    path: string;
+    message: string;
+};
+type BlockRegistry = {
+    list(): BlockDefinition[];
+    get(type: string): BlockDefinition | undefined;
+    has(type: string): boolean;
+    /** Palette entries for the builder's Add Section panel. */
+    palette(): Array<{
+        type: string;
+        label: string;
+        description?: string;
+        category?: string;
+        defaultData: Record<string, unknown>;
+    }>;
+    /**
+     * Validates and normalizes a layout: unknown block types are rejected,
+     * each block's data is parsed through its schema (applying defaults,
+     * stripping unknown keys), and issues are collected per block.
+     */
+    validateLayout(layout: unknown): {
+        ok: boolean;
+        layout: PageLayout;
+        issues: ValidationIssue[];
+    };
+    /** Creates a new block instance of the given type with schema defaults. */
+    createInstance(type: string): BlockInstance;
+};
+/**
+ * Registry input is intentionally loose on the schema generic: block
+ * definitions carry per-block data types for authoring, while the registry
+ * operates on the erased form (preview props are contravariant).
+ */
+type AnyBlockDefinition = BlockDefinition<any>;
+declare function createBlockRegistry(blocks: ReadonlyArray<AnyBlockDefinition>): BlockRegistry;
+/** Infer the data type of a block definition: `BlockData<typeof pageHero>`. */
+type BlockData<TDefinition> = TDefinition extends BlockDefinition<infer TSchema> ? z.infer<TSchema> : never;
+/**
+ * Typed content-as-code authoring: builds a block instance from a definition
+ * with compile-time checking and schema validation (defaults applied).
+ *
+ *   blockInstance(pageHero, { title: 'Welcome' })
+ */
+declare function blockInstance<TSchema extends z.ZodObject<z.ZodRawShape>>(definition: BlockDefinition<TSchema>, data?: Partial<z.infer<TSchema>>, id?: string): BlockInstance<z.infer<TSchema>>;
+
+export { type AnyBlockDefinition, type AnyGlobalDefinition, type BlockData, type BlockDefinition, type BlockInstance, type BlockPreviewProps, type BlockRegistry, type DefineBlockArgs, type DefineGlobalArgs, type EditorField, type EditorInput, type FileRefValue, type GlobalDefinition, type GlobalRegistry, type LinkValue, type MediaRefValue, type PageLayout, type ValidationIssue, blockInstance, createBlockRegistry, createGlobalRegistry, defineBlock, defineGlobal, fileRef, labelForKey, link, mediaRef, paragraphs };