@plumix/core 0.1.0

package/dist/plugin/manifest.js

@@ -0,0 +1,913 @@
+import { DEFAULT_BREAKPOINTS } from "@plumix/blocks";
+import { labelSourceText } from "../i18n/label.js";
+import { DuplicateAdminSlugError, PluginDefinitionError } from "./errors.js";
+export function resolveEntryTypeVisibility(options) {
+    const isPublic = options.isPublic ?? true;
+    const showUI = options.showUI ?? isPublic;
+    return {
+        isPublic,
+        showUI,
+        showInSidebar: options.showInSidebar ?? showUI,
+        excludeFromGenericRpc: options.excludeFromGenericRpc ?? !isPublic,
+        excludeFromSearch: options.excludeFromSearch ?? !isPublic,
+    };
+}
+export function resolveTermTaxonomyVisibility(options) {
+    const isPublic = options.isPublic ?? true;
+    const showUI = options.showUI ?? isPublic;
+    return {
+        isPublic,
+        showUI,
+        showInSidebar: options.showInSidebar ?? showUI,
+        excludeFromGenericRpc: options.excludeFromGenericRpc ?? !isPublic,
+    };
+}
+export function manifestEntryVisibility(entry) {
+    const isPublic = entry.isPublic ?? true;
+    const showUI = entry.showUI ?? isPublic;
+    return {
+        isPublic,
+        showUI,
+        showInSidebar: entry.showInSidebar ?? showUI,
+    };
+}
+// Subset of `CoreIconName` plugins may emit on `EntryTypeOptions.menuIcon`
+// or `TermTaxonomyOptions.menuIcon`. Names outside this set fall back to
+// a sensible default at projection time.
+const ENTRY_MENU_ICONS = new Set([
+    "content",
+    "file-text",
+    "layout",
+    "image",
+    "calendar",
+]);
+const TAXONOMY_MENU_ICONS = new Set([
+    "tag",
+    "folder",
+]);
+/**
+ * Built-in nav groups core ships. Plugins target their items at these
+ * ids via `nav.group`, and can interleave their own groups by picking
+ * priorities between or around these defaults. Labels are
+ * `MessageDescriptor`s so the sidebar localizes at render time via
+ * the admin's `useLabel` hook.
+ *
+ * Convention: plugin-declared groups keep their label descriptor id
+ * under the same `core.adminNav.<groupId>` namespace (see
+ * `@plumix/plugin-menu` → `appearance`, `@plumix/plugin-media` →
+ * `library`, `@plumix/plugin-audit-log` → `tools`). The id space is
+ * the concept, not the owner — translators see one "Appearance"
+ * entry rather than one per plugin sharing the group.
+ */
+export const CORE_NAV_GROUPS = [
+    {
+        id: "overview",
+        label: { id: "core.adminNav.overview", message: "Overview" },
+        priority: 0,
+    },
+    {
+        id: "content",
+        label: { id: "core.adminNav.content", message: "Entries" },
+        priority: 100,
+    },
+    {
+        id: "term-taxonomies",
+        label: { id: "core.adminNav.termTaxonomies", message: "Taxonomies" },
+        priority: 200,
+    },
+    {
+        id: "management",
+        label: { id: "core.adminNav.management", message: "Management" },
+        priority: 1000,
+    },
+];
+export function createPluginRegistry() {
+    return {
+        entryTypes: new Map(),
+        termTaxonomies: new Map(),
+        entryMetaBoxes: new Map(),
+        termMetaBoxes: new Map(),
+        userMetaBoxes: new Map(),
+        capabilities: new Map(),
+        settingsGroups: new Map(),
+        settingsPages: new Map(),
+        rewriteRules: [],
+        rpcRouters: new Map(),
+        mcpTools: new Map(),
+        rawRoutes: [],
+        restResources: [],
+        loginLinks: [],
+        adminPages: new Map(),
+        dashboardWidgets: new Map(),
+        fieldTypes: new Map(),
+        blockSpecs: new Map(),
+        markSpecs: new Map(),
+        patternSpecs: new Map(),
+        shortcodeSpecs: new Map(),
+        lookupAdapters: new Map(),
+        scheduledTasks: [],
+        templateDeps: new Map(),
+    };
+}
+/**
+ * Look up the `MetaBoxField` declaration for a meta key within the
+ * entry meta surface, scoped to a given entry type. Returns the first
+ * matching field across all registered entry meta boxes — key
+ * uniqueness per (entryType, key) is enforced at registration time,
+ * so "first match" is the only match.
+ */
+export function findEntryMetaField(registry, entryType, key) {
+    for (const box of registry.entryMetaBoxes.values()) {
+        if (!box.entryTypes.includes(entryType))
+            continue;
+        const field = box.fields.find((f) => f.key === key);
+        if (field)
+            return field;
+    }
+    return undefined;
+}
+/**
+ * Like `findEntryMetaField`, but for term meta. Scoped by termTaxonomy.
+ */
+export function findTermMetaField(registry, termTaxonomy, key) {
+    for (const box of registry.termMetaBoxes.values()) {
+        if (!box.termTaxonomies.includes(termTaxonomy))
+            continue;
+        const field = box.fields.find((f) => f.key === key);
+        if (field)
+            return field;
+    }
+    return undefined;
+}
+/**
+ * Like `findEntryMetaField`, but for user meta. Users have a flat
+ * keyspace (no entry-type / termTaxonomy analogue), so no scope argument —
+ * key uniqueness across all user meta boxes is enforced at manifest-
+ * build time.
+ */
+export function findUserMetaField(registry, key) {
+    for (const box of registry.userMetaBoxes.values()) {
+        const field = box.fields.find((f) => f.key === key);
+        if (field)
+            return field;
+    }
+    return undefined;
+}
+/** URL the admin runtime fetches to load a plugin's compiled catalog
+ *  for a given locale. Same-origin under `/_plumix/admin/...` so the
+ *  default CSP `script-src 'self'` covers the dynamic import. Widening
+ *  to absolute URLs (CDN-hosted catalogs) would need a CSP review.
+ *
+ *  Paired with `pluginCatalogStagedPath` — the plumix Vite plugin stages
+ *  each plugin's `.mjs` at that filesystem path so the URL resolves. */
+export function pluginCatalogUrl(pluginId, locale) {
+    return `/_plumix/admin/${pluginCatalogStagedPath(pluginId, locale)}`;
+}
+/** Filesystem path (relative to the admin asset root) where the plumix
+ *  Vite plugin must stage `<plugin.i18n.catalogPath>/<locale>.mjs`.
+ *  Mirrors `pluginCatalogUrl` so a single edit retargets both ends of
+ *  the runtime fetch. */
+export function pluginCatalogStagedPath(pluginId, locale) {
+    return `plugins/${pluginId}/locales/${locale}.mjs`;
+}
+/** Script tag id that carries the JSON-encoded manifest in the admin HTML. */
+export const MANIFEST_SCRIPT_ID = "plumix-manifest";
+export function emptyManifest() {
+    return {
+        entryTypes: [],
+        termTaxonomies: [],
+        entryMetaBoxes: [],
+        termMetaBoxes: [],
+        userMetaBoxes: [],
+        settingsGroups: [],
+        settingsPages: [],
+        adminNav: [],
+        dashboardWidgets: [],
+        fieldTypes: [],
+        blocks: [],
+        marks: [],
+        patterns: [],
+        tokens: {},
+        i18n: { defaultLocale: "en", locales: [] },
+        pluginI18n: {},
+    };
+}
+/**
+ * Project a registry snapshot into its manifest form — the subset that ships
+ * to the admin bundle. Every surface with a `priority?: number` field —
+ * entry types, entry/term/user meta boxes, settings pages, settings groups —
+ * is sorted by `priority` ascending; ties break by `name` / `id`
+ * alphabetical so the shipped order is deterministic regardless of
+ * plugin install order.
+ *
+ * Throws `DuplicateAdminSlugError` if two post types resolve to the same
+ * admin slug — the admin router can't disambiguate `/entries/$slug` in that
+ * case, and catching it at build time is cheaper than a 404 at runtime.
+ */
+export function buildManifest(registry, options) {
+    const entries = Array.from(registry.entryTypes.values())
+        .map(toEntryTypeManifest)
+        .sort(byPriorityThen((e) => e.name));
+    assertUniqueAdminSlugs(entries);
+    const termTaxonomies = Array.from(registry.termTaxonomies.values()).map(toTermTaxonomyEntry);
+    const entryMetaBoxes = Array.from(registry.entryMetaBoxes.values())
+        .map(toEntryMetaBoxEntry)
+        .sort(byPriorityThen((b) => b.id));
+    const termMetaBoxes = Array.from(registry.termMetaBoxes.values())
+        .map(toTermMetaBoxEntry)
+        .sort(byPriorityThen((b) => b.id));
+    const userMetaBoxes = Array.from(registry.userMetaBoxes.values())
+        .map(toUserMetaBoxEntry)
+        .sort(byPriorityThen((b) => b.id));
+    assertMetaBoxScopesExist(entryMetaBoxes, (box) => box.entryTypes, new Set(entries.map((e) => e.name)), "entry meta box", "entry type");
+    assertMetaBoxScopesExist(termMetaBoxes, (box) => box.termTaxonomies, new Set(termTaxonomies.map((t) => t.name)), "term meta box", "termTaxonomy");
+    assertUniqueFieldKeysPerScope(entryMetaBoxes, (box) => box.entryTypes, "entry");
+    assertUniqueFieldKeysPerScope(termMetaBoxes, (box) => box.termTaxonomies, "term");
+    // User meta is a flat keyspace — one synthetic "user" scope keeps
+    // the shared helper honest without inventing a second code path.
+    assertUniqueFieldKeysPerScope(userMetaBoxes, getUserScope, "user");
+    const settingsGroups = Array.from(registry.settingsGroups.values())
+        .map(toSettingsGroupEntry)
+        .sort(byPriorityThen((g) => g.name));
+    const settingsPages = Array.from(registry.settingsPages.values())
+        .map(toSettingsPageEntry)
+        .sort(byPriorityThen((p) => p.name));
+    assertSettingsPageGroupsExist(settingsPages, registry.settingsGroups);
+    const adminNav = projectAdminNav(registry, entries, termTaxonomies);
+    const dashboardWidgets = Array.from(registry.dashboardWidgets.values())
+        .map(toDashboardWidgetEntry)
+        .sort(byPriorityThen((w) => w.id));
+    const fieldTypes = Array.from(registry.fieldTypes.values())
+        .map(toFieldTypeEntry)
+        .sort((a, b) => a.type.localeCompare(b.type));
+    const blocks = Array.from(registry.blockSpecs.values())
+        .map(toBlockEntry)
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const marks = Array.from(registry.markSpecs.values())
+        .map(toMarkEntry)
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const patterns = Array.from(registry.patternSpecs.values())
+        .map(toPatternEntry)
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return {
+        entryTypes: entries,
+        termTaxonomies,
+        entryMetaBoxes,
+        termMetaBoxes,
+        userMetaBoxes,
+        settingsGroups,
+        settingsPages,
+        adminNav,
+        dashboardWidgets,
+        fieldTypes,
+        blocks,
+        marks,
+        patterns,
+        tokens: options?.tokens ?? {},
+        breakpoints: options?.breakpoints ?? DEFAULT_BREAKPOINTS,
+        i18n: {
+            defaultLocale: options?.i18n?.defaultLocale.code ?? "en",
+            // Wire-filtered to enabled entries — the admin dropdown ships exactly
+            // what's available, and a "disabled in catalog but visible in UI"
+            // affordance can be re-introduced when there's a consumer.
+            locales: (options?.i18n?.locales ?? []).filter((l) => l.enabled),
+        },
+        pluginI18n: projectPluginI18n(options?.plugins, options?.i18n, options?.adminBundledPluginIds),
+    };
+}
+function projectPluginI18n(plugins, siteI18n, adminBundledPluginIds) {
+    if (!plugins)
+        return {};
+    const siteLocales = new Set((siteI18n?.locales ?? []).filter((l) => l.enabled).map((l) => l.code));
+    const out = {};
+    for (const plugin of plugins) {
+        if (!plugin.i18n)
+            continue;
+        // Workspace plugins are baked into admin via `import.meta.glob` —
+        // emitting URLs would mean admin double-loads at boot.
+        if (adminBundledPluginIds?.has(plugin.id))
+            continue;
+        const catalogs = {};
+        for (const locale of plugin.i18n.locales) {
+            if (locale === plugin.i18n.sourceLocale)
+                continue;
+            // Site-locale intersection: when the site declares i18n,
+            // emit URLs only for locales it has enabled. With no site
+            // i18n configured, trust the plugin's list so tests without
+            // site config still exercise the URL shape.
+            if (siteLocales.size > 0 && !siteLocales.has(locale))
+                continue;
+            catalogs[locale] = pluginCatalogUrl(plugin.id, locale);
+        }
+        // Skip plugins whose entire locale set was intersected/dropped —
+        // a manifest entry with empty catalogs is wire noise that admin's
+        // boot loop would still iterate.
+        if (Object.keys(catalogs).length > 0)
+            out[plugin.id] = { catalogs };
+    }
+    return out;
+}
+// Built-in items core seeds into the projection. Each row is keyed by
+// the group id it lands in; capability gating is admin-side at render
+// time (the manifest projection ships every item, the sidebar drops
+// what the user can't see).
+const CORE_NAV_ITEMS = [
+    {
+        groupId: "overview",
+        item: {
+            to: "/",
+            label: { id: "core.adminNav.item.dashboard", message: "Dashboard" },
+            coreIcon: "dashboard",
+            order: 0,
+            exact: true,
+            keywords: [
+                { id: "core.adminNav.keyword.home", message: "home" },
+                { id: "core.adminNav.keyword.overview", message: "overview" },
+            ],
+        },
+    },
+    {
+        groupId: "management",
+        item: {
+            to: "/users",
+            label: { id: "core.adminNav.item.users", message: "Users" },
+            coreIcon: "users",
+            order: 100,
+            capability: "user:list",
+            keywords: [
+                { id: "core.adminNav.keyword.accounts", message: "accounts" },
+                { id: "core.adminNav.keyword.team", message: "team" },
+                { id: "core.adminNav.keyword.people", message: "people" },
+            ],
+        },
+    },
+    {
+        groupId: "management",
+        item: {
+            to: "/allowed-domains",
+            label: {
+                id: "core.adminNav.item.allowedDomains",
+                message: "Allowed domains",
+            },
+            coreIcon: "users",
+            order: 150,
+            capability: "settings:manage",
+            keywords: [
+                { id: "core.adminNav.keyword.domains", message: "domains" },
+                { id: "core.adminNav.keyword.email", message: "email" },
+                { id: "core.adminNav.keyword.signups", message: "signups" },
+            ],
+        },
+    },
+    {
+        groupId: "management",
+        item: {
+            to: "/mailer",
+            label: { id: "core.adminNav.item.mailer", message: "Mailer" },
+            coreIcon: "mail",
+            order: 175,
+            capability: "settings:manage",
+            keywords: [
+                { id: "core.adminNav.keyword.email", message: "email" },
+                { id: "core.adminNav.keyword.smtp", message: "smtp" },
+            ],
+        },
+    },
+    {
+        groupId: "management",
+        item: {
+            to: "/settings",
+            label: { id: "core.adminNav.item.settings", message: "Settings" },
+            coreIcon: "settings",
+            order: 200,
+            capability: "settings:manage",
+            keywords: [
+                { id: "core.adminNav.keyword.configuration", message: "configuration" },
+                { id: "core.adminNav.keyword.preferences", message: "preferences" },
+                { id: "core.adminNav.keyword.options", message: "options" },
+            ],
+        },
+    },
+];
+// Default priority for plugin-declared custom groups — sits between
+// `term-taxonomies` (200) and `management` (1000). Plugin authors who
+// need a different position pass `priority` in the inline group form
+// on `registerAdminPage`.
+const CUSTOM_NAV_GROUP_PRIORITY = 500;
+// Title-case a kebab/snake id when a plugin doesn't declare a label
+// inline. `appearance` → `Appearance`, `my-custom-group` → `My custom
+// group`. Plugins can override by passing the rich group form.
+function humanizeGroupId(id) {
+    const spaced = id.replace(/[-_]+/g, " ").trim();
+    if (spaced.length === 0)
+        return id;
+    return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+function seedNavGroups() {
+    const groups = new Map();
+    for (const g of CORE_NAV_GROUPS) {
+        groups.set(g.id, {
+            id: g.id,
+            label: g.label,
+            priority: g.priority,
+            items: [],
+        });
+    }
+    for (const { groupId, item } of CORE_NAV_ITEMS) {
+        groups.get(groupId)?.items.push(item);
+    }
+    return groups;
+}
+function addEntryNavItems(groups, entries) {
+    for (const entry of entries) {
+        if (entry.showInSidebar !== true)
+            continue;
+        groups.get("content")?.items.push({
+            to: `/entries/${entry.adminSlug}`,
+            label: entry.labels?.plural ?? entry.label,
+            order: entry.priority,
+            coreIcon: resolveEntryMenuIcon(entry.menuIcon),
+            capability: `entry:${entry.capabilityType ?? entry.name}:edit_own`,
+            ...(entry.keywords ? { keywords: entry.keywords } : {}),
+        });
+    }
+}
+function addTaxonomyNavItems(groups, taxonomies) {
+    for (const tax of taxonomies) {
+        if (tax.showInSidebar !== true)
+            continue;
+        groups.get("term-taxonomies")?.items.push({
+            to: `/terms/${tax.name}`,
+            label: tax.label,
+            coreIcon: resolveTaxonomyMenuIcon(tax.menuIcon, tax.isHierarchical),
+            capability: `term:${tax.name}:read`,
+            ...(tax.keywords ? { keywords: tax.keywords } : {}),
+        });
+    }
+}
+function ensureNavGroup(groups, groupRef) {
+    const groupId = typeof groupRef === "string" ? groupRef : groupRef.id;
+    const existing = groups.get(groupId);
+    if (existing)
+        return existing;
+    // Custom group, first occurrence — derive metadata from the inline
+    // form when present, else humanize the id.
+    const meta = typeof groupRef === "object" ? groupRef : null;
+    const created = {
+        id: groupId,
+        label: meta?.label ?? humanizeGroupId(groupId),
+        priority: meta?.priority ?? CUSTOM_NAV_GROUP_PRIORITY,
+        items: [],
+    };
+    groups.set(groupId, created);
+    return created;
+}
+function addAdminPageNavItems(groups, registry) {
+    for (const page of registry.adminPages.values()) {
+        if (!page.nav)
+            continue;
+        ensureNavGroup(groups, page.nav.group).items.push({
+            to: `/pages${page.path}`,
+            label: page.nav.label,
+            order: page.nav.order,
+            icon: page.nav.icon,
+            coreIcon: page.nav.icon ? undefined : "puzzle",
+            component: page.component,
+            capability: page.capability,
+            ...(page.nav.keywords ? { keywords: page.nav.keywords } : {}),
+        });
+    }
+}
+function compareByOrderThenLabel(a, b) {
+    const ao = a.order ?? Number.POSITIVE_INFINITY;
+    const bo = b.order ?? Number.POSITIVE_INFINITY;
+    return (ao - bo || labelSourceText(a.label).localeCompare(labelSourceText(b.label)));
+}
+function compareByPriorityThenId(a, b) {
+    const ap = a.priority ?? Number.POSITIVE_INFINITY;
+    const bp = b.priority ?? Number.POSITIVE_INFINITY;
+    return ap - bp || a.id.localeCompare(b.id);
+}
+function projectAdminNav(registry, entries, termTaxonomies) {
+    const groups = seedNavGroups();
+    addEntryNavItems(groups, entries);
+    addTaxonomyNavItems(groups, termTaxonomies);
+    addAdminPageNavItems(groups, registry);
+    return Array.from(groups.values())
+        .filter((g) => g.items.length > 0)
+        .map((g) => ({
+        ...g,
+        items: g.items.slice().sort(compareByOrderThenLabel),
+    }))
+        .sort(compareByPriorityThenId);
+}
+/**
+ * Shared comparator: `priority` ascending (unspecified sorts last),
+ * ties broken by a caller-supplied stable key (id / name) in
+ * alphabetical order. Used by `buildManifest` server-side AND the
+ * admin's in-memory filter helpers so the shipped manifest and the
+ * admin filter paths agree on order regardless of registration
+ * sequence.
+ */
+export function byPriorityThen(getKey) {
+    return (a, b) => {
+        const ap = a.priority ?? Number.POSITIVE_INFINITY;
+        const bp = b.priority ?? Number.POSITIVE_INFINITY;
+        if (ap !== bp)
+            return ap - bp;
+        return getKey(a).localeCompare(getKey(b));
+    };
+}
+/**
+ * Seed per-field values from a server meta bag, falling back to each
+ * field's registered `default`. Shared by every admin form that owns
+ * meta state (entry editor, term edit route, user edit route, settings
+ * group card) — one shape, one behaviour.
+ */
+export function seedFromMetaBoxes(boxes, stored) {
+    const bag = stored ?? {};
+    const seed = {};
+    for (const box of boxes) {
+        for (const field of box.fields) {
+            seed[field.key] = bag[field.key] ?? field.default;
+        }
+    }
+    return seed;
+}
+// Synthetic flat-keyspace scope for user meta. Hoisted so the
+// `assertUniqueFieldKeysPerScope` callback doesn't re-allocate per
+// buildManifest call.
+const USER_SCOPE = ["user"];
+const getUserScope = () => USER_SCOPE;
+/**
+ * Two meta boxes on the same `(scope, field.key)` pair would silently
+ * write to the same storage key — a plugin-author footgun. Fail loudly
+ * at manifest-build time. `scope` is the entry type (for entry boxes)
+ * or termTaxonomy (for term boxes); user boxes collapse to one synthetic
+ * scope because the user keyspace is flat.
+ */
+function assertUniqueFieldKeysPerScope(boxes, getScopes, kind) {
+    const seen = new Map();
+    for (const box of boxes) {
+        for (const scope of getScopes(box)) {
+            for (const field of box.fields) {
+                const scopedKey = `${scope}:${field.key}`;
+                const existing = seen.get(scopedKey);
+                if (existing !== undefined && existing !== box.id) {
+                    throw PluginDefinitionError.metaFieldClashAcrossBoxes({
+                        kind,
+                        fieldKey: field.key,
+                        firstBoxId: existing,
+                        secondBoxId: box.id,
+                        scope,
+                    });
+                }
+                seen.set(scopedKey, box.id);
+            }
+        }
+    }
+}
+// A meta box referencing an unregistered scope ("catagory" typo, a
+// termTaxonomy removed behind the plugin's back, etc.) is dead code — the
+// box never renders and never writes. Fail at manifest build so the
+// plugin author sees it on boot, not at first admin click. Matches the
+// settings-page→group reference check.
+function assertMetaBoxScopesExist(boxes, getScopes, known, boxKind, scopeKind) {
+    for (const box of boxes) {
+        for (const scope of getScopes(box)) {
+            if (!known.has(scope)) {
+                throw PluginDefinitionError.metaBoxReferencesUnknownScope({
+                    boxKind,
+                    boxId: box.id,
+                    scopeKind,
+                    scope,
+                });
+            }
+        }
+    }
+}
+// Surfacing a clear error at manifest-build time beats a runtime
+// "unknown group" in the admin route. Pages reference groups by name;
+// if a group name doesn't resolve, the plugin author has a typo or
+// order-of-registration problem.
+function assertSettingsPageGroupsExist(pages, groups) {
+    for (const page of pages) {
+        for (const groupName of page.groups) {
+            if (!groups.has(groupName)) {
+                throw PluginDefinitionError.settingsPageReferencesUnknownGroup({
+                    pageName: page.name,
+                    groupName,
+                });
+            }
+        }
+    }
+}
+function assertUniqueAdminSlugs(entries) {
+    const seen = new Map();
+    for (const entry of entries) {
+        const existing = seen.get(entry.adminSlug);
+        if (existing !== undefined) {
+            throw DuplicateAdminSlugError.slugCollision({
+                firstPostType: existing,
+                secondPostType: entry.name,
+                slug: entry.adminSlug,
+            });
+        }
+        seen.set(entry.adminSlug, entry.name);
+    }
+}
+/**
+ * Derive the URL-safe admin slug for a post type. Prefers `plural` when
+ * set (allows "fish" → `fish`, "children" → `children`, etc.), falls back
+ * to `${name}s` which is English-biased but matches the common case.
+ * Non-alphanumerics collapse to single dashes; leading/trailing dashes
+ * are trimmed. Empty results throw — an empty slug would shadow
+ * `/entries/` itself in TanStack Router.
+ */
+export function deriveAdminSlug(name, plural) {
+    const source = plural ?? `${name}s`;
+    const slug = slugify(source);
+    if (slug.length === 0) {
+        const from = plural === undefined ? "its name" : `plural="${plural}"`;
+        throw PluginDefinitionError.adminSlugDerivationFailed({
+            entryTypeName: name,
+            from,
+        });
+    }
+    return slug;
+}
+// Hand-rolled single-pass slugifier rather than chained `.replace()` calls.
+// The regex form (`/[^a-z0-9]+/g` plus a trim) trips CodeQL's polynomial-
+// regex detector on library-exposed inputs; this loop is provably O(n),
+// regex-free, and produces the same output: lowercase ASCII alphanumerics
+// separated by single dashes, no leading/trailing dashes.
+function slugify(input) {
+    const lower = input.toLowerCase();
+    let result = "";
+    let pendingDash = false;
+    for (let i = 0; i < lower.length; i++) {
+        const code = lower.charCodeAt(i);
+        const isAlphaNum = (code >= 97 && code <= 122) || (code >= 48 && code <= 57);
+        if (isAlphaNum) {
+            if (pendingDash && result.length > 0)
+                result += "-";
+            result += lower[i];
+            pendingDash = false;
+        }
+        else {
+            pendingDash = true;
+        }
+    }
+    return result;
+}
+// Explicit allowlist — only the destructured keys ship to the browser.
+// Adding a field to `EntryTypeOptions` / `RegisteredEntryType` does NOT
+// automatically leak it; it must be added here AND to `EntryTypeManifestEntry`
+// to surface in the admin. `registeredBy`, `rewrite`, `capabilities`, and
+// the raw per-surface visibility inputs are intentionally excluded — the
+// resolved `isPublic` / `showUI` / `showInSidebar` triple is what the
+// admin consumes, and `capabilities` is server-side authorization metadata.
+function toEntryTypeManifest(pt) {
+    const { name, label, labels, description, supports, termTaxonomies, isHierarchical, hasArchive, capabilityType, priority, menuIcon, keywords, versioning, } = pt;
+    const visibility = resolveEntryTypeVisibility(pt);
+    return {
+        name,
+        adminSlug: deriveAdminSlug(name, labels?.plural !== undefined ? labelSourceText(labels.plural) : undefined),
+        label,
+        labels,
+        description,
+        supports,
+        termTaxonomies,
+        isHierarchical,
+        isPublic: visibility.isPublic,
+        showUI: visibility.showUI,
+        showInSidebar: visibility.showInSidebar,
+        hasArchive,
+        capabilityType,
+        priority,
+        menuIcon,
+        keywords,
+        versioning: deriveVersioning(supports, versioning),
+    };
+}
+// Versioning is derived: if the type opts into `supports: ['revisions']`,
+// fill in defaults the admin can read without nil-checking. If the
+// type doesn't support revisions, `versioning` stays undefined and
+// the editor knows to skip the Revisions Sheet entirely.
+function deriveVersioning(supports, declared) {
+    if (!supports?.includes("revisions"))
+        return undefined;
+    return {
+        maxRevisions: declared?.maxRevisions ?? 25,
+        autosaveIntervalSeconds: declared?.autosaveIntervalSeconds ?? 60,
+    };
+}
+// Allowlist for termTaxonomy entries — same rationale as `toEntryTypeManifest`.
+// `registeredBy`, `capabilities`, `isInQuickEdit`, `hasAdminColumn`, and
+// `rewrite` stay server-side. Visibility is projected via the resolver so
+// the admin sees the same resolved triple as for entry types.
+function toTermTaxonomyEntry(tax) {
+    const { name, label, labels, description, isHierarchical, entryTypes, menuIcon, keywords, } = tax;
+    const visibility = resolveTermTaxonomyVisibility(tax);
+    return {
+        name,
+        label,
+        labels,
+        description,
+        isHierarchical,
+        entryTypes,
+        isPublic: visibility.isPublic,
+        showUI: visibility.showUI,
+        showInSidebar: visibility.showInSidebar,
+        menuIcon,
+        keywords,
+    };
+}
+function resolveEntryMenuIcon(menuIcon) {
+    if (menuIcon !== undefined &&
+        ENTRY_MENU_ICONS.has(menuIcon)) {
+        return menuIcon;
+    }
+    return "content";
+}
+function resolveTaxonomyMenuIcon(menuIcon, isHierarchical) {
+    if (menuIcon !== undefined &&
+        TAXONOMY_MENU_ICONS.has(menuIcon)) {
+        return menuIcon;
+    }
+    return isHierarchical === true ? "folder" : "tag";
+}
+// Allowlist for entry meta box entries — same rationale as
+// `toEntryTypeManifest`. `registeredBy` is intentionally excluded
+// (server-only debug metadata). `sanitize` on each field is stripped
+// via `toEntryMetaBoxFieldEntry` — it's a server-side callback. `span`
+// is also stripped: the editor rail renders every entry field at full
+// width, and shipping a hint the renderer ignores just bloats the wire.
+function toEntryMetaBoxEntry(box) {
+    const { id, label, description, location, priority, entryTypes, capability, fields, } = box;
+    return {
+        id,
+        label,
+        description,
+        location,
+        priority,
+        entryTypes,
+        capability,
+        fields: fields.map(toEntryMetaBoxFieldEntry),
+    };
+}
+// Term meta boxes are always stacked top-to-bottom on the termTaxonomy
+// edit form — no `location` hint applies.
+function toTermMetaBoxEntry(box) {
+    const { id, label, description, priority, termTaxonomies, capability, fields, } = box;
+    return {
+        id,
+        label,
+        description,
+        priority,
+        termTaxonomies,
+        capability,
+        fields: fields.map(toMetaBoxFieldEntry),
+    };
+}
+// User meta boxes are stacked like term boxes — no scope / location.
+function toUserMetaBoxEntry(box) {
+    const { id, label, description, priority, capability, fields } = box;
+    return {
+        id,
+        label,
+        description,
+        priority,
+        capability,
+        fields: fields.map(toMetaBoxFieldEntry),
+    };
+}
+// Allowlist for settings group entries — same rationale as the other
+// `to*Entry` projections. `registeredBy` is server-only debug metadata.
+// Fields ship through `toMetaBoxFieldEntry` — same projection as every
+// other meta surface.
+function toSettingsGroupEntry(group) {
+    const { name, label, description, priority, capability, fields } = group;
+    return {
+        name,
+        label,
+        description,
+        priority,
+        capability,
+        fields: fields.map(toMetaBoxFieldEntry),
+    };
+}
+function toSettingsPageEntry(page) {
+    const { name, label, description, groups, priority } = page;
+    return { name, label, description, groups, priority };
+}
+function toFieldTypeEntry(fieldType) {
+    const { type, component } = fieldType;
+    return { type, component };
+}
+function toDashboardWidgetEntry(widget) {
+    const { id, title, capability, component, priority } = widget;
+    return { id, title, capability, component, priority };
+}
+function toBlockEntry(block) {
+    const { name, title, category, icon, description, keywords, inserter, variations, } = block.spec;
+    return {
+        name: name,
+        title: title ?? name,
+        category,
+        icon,
+        description,
+        keywords,
+        inserter,
+        variations,
+    };
+}
+function toPatternEntry(pattern) {
+    const { name, title, category, keywords, content, insert, preview, target, entryTypes, priority, } = pattern.spec;
+    return {
+        name,
+        title,
+        category,
+        keywords,
+        insert: insert ?? "copy",
+        preview,
+        target,
+        entryTypes,
+        priority,
+        content,
+    };
+}
+function toMarkEntry(mark) {
+    const { name, title, description, keyboardShortcut, bubbleMenuLabel, bubbleMenuIcon, adminSchema, } = mark.spec;
+    return {
+        name,
+        title,
+        description,
+        keyboardShortcut,
+        bubbleMenuLabel,
+        bubbleMenuIcon,
+        adminSchema,
+    };
+}
+function toEntryMetaBoxFieldEntry(field) {
+    const view = field;
+    return {
+        key: field.key,
+        label: field.label,
+        type: field.type,
+        inputType: field.inputType,
+        description: field.description,
+        required: field.required,
+        placeholder: view.placeholder,
+        maxLength: view.maxLength,
+        min: view.min,
+        max: view.max,
+        step: view.step,
+        options: view.options,
+        default: field.default,
+        referenceTarget: view.referenceTarget,
+        marks: view.marks,
+        nodes: view.nodes,
+        blocks: view.blocks,
+        capability: field.capability,
+        // Repeater subfields recurse through the same projection — the
+        // wire shape is uniform end to end, span dropped (rows are
+        // full-width), sanitize callbacks stripped (server-only).
+        subFields: view.subFields?.map((sf) => toEntryMetaBoxFieldEntry(sf)),
+    };
+}
+function toMetaBoxFieldEntry(field) {
+    return { ...toEntryMetaBoxFieldEntry(field), span: field.span };
+}
+/**
+ * Serialise a manifest into the `<script>` markup injected into the admin
+ * `index.html`. The payload lives inside a `type="application/json"` block,
+ * so it isn't executed — but a stray `</script>` sequence would still end
+ * the tag and leak the remainder into the document. Escape the slash to
+ * neutralise that, which is the standard JSON-in-HTML-script hardening.
+ */
+export function serializeManifestScript(manifest) {
+    const safe = JSON.stringify(manifest).replaceAll("</", "<\\/");
+    return `<script id="${MANIFEST_SCRIPT_ID}" type="application/json">${safe}</script>`;
+}
+// Case-insensitive match on the script tag — Vite's bundler today emits
+// lowercase tags and we control the placeholder, but minifiers upstream
+// could normalise to uppercase and we'd rather match than silently fall
+// through to the fail-fast branch.
+const MANIFEST_SCRIPT_RE = new RegExp(`<script id="${MANIFEST_SCRIPT_ID}"[^>]*>[\\s\\S]*?</script>`, "i");
+/**
+ * Replace the `<script id="plumix-manifest">` placeholder in the admin's
+ * `index.html` with a freshly serialised manifest. Throws if the placeholder
+ * is missing — that's an indicator that the admin bundle is out of date
+ * (was built without the placeholder), and silently appending would mask
+ * the staleness.
+ */
+export function injectManifestIntoHtml(html, manifest) {
+    if (!MANIFEST_SCRIPT_RE.test(html)) {
+        throw PluginDefinitionError.adminManifestPlaceholderMissing({
+            scriptId: MANIFEST_SCRIPT_ID,
+        });
+    }
+    return html.replace(MANIFEST_SCRIPT_RE, serializeManifestScript(manifest));
+}
+//# sourceMappingURL=manifest.js.map