@jini-ai/admin 0.4.2 → 0.4.4

package/dist/seo/conformance/seo-api.conformance.d.ts

@@ -0,0 +1,8 @@
+import type { AdminSeoPort } from '../ports.js';
+/** Destructive framework-free checklist; use an isolated seed containing the requested entry. */
+export declare function runSeoApiConformance({ api }: {
+    api: AdminSeoPort;
+}, { entryId }?: {
+    entryId?: string;
+}): Promise<readonly string[]>;
+//# sourceMappingURL=seo-api.conformance.d.ts.map

package/dist/seo/conformance/seo-api.conformance.js

@@ -0,0 +1,44 @@
+/** Destructive framework-free checklist; use an isolated seed containing the requested entry. */
+export async function runSeoApiConformance({ api }, { entryId = 'conformance-entry' } = {}) {
+    const checks = [];
+    function assert(condition, name) {
+        if (!condition)
+            throw new Error(`SEO API conformance: ${name}`);
+        checks.push(name);
+    }
+    const before = await api.getSeoSettings({});
+    const original = await api.getSeoEntry({ entryId });
+    const saved = await api.putSeoSettings({}, { defaultDescription: 'conformance-description' });
+    assert(saved.defaultDescription === 'conformance-description', 'settings write returns saved value');
+    const merged = await api.putSeoSettings({}, { twitterSite: '@conformance' });
+    assert(merged.defaultDescription === saved.defaultDescription, 'omitted default survives merge');
+    const cleared = await api.putSeoSettings({}, { defaultDescription: null });
+    assert(cleared.defaultDescription === undefined, 'null default clears to absent');
+    assert(before.defaultDescription !== 'conformance-description', 'settings snapshots remain unchanged');
+    await api.putSeoSettings({}, { ...before, defaultDescription: before.defaultDescription ?? null, defaultOgImage: before.defaultOgImage ?? null, twitterSite: before.twitterSite ?? null });
+    const changed = await api.putSeoEntry({ entryId }, { title: 'Conformance title', noindex: true });
+    assert(changed.title === 'Conformance title' && changed.robots.noindex, 'entry patch returns effective meta');
+    const retained = await api.putSeoEntry({ entryId }, { description: 'Conformance description' });
+    assert(retained.title === 'Conformance title', 'entry omission preserves previous overrides');
+    const reset = await api.putSeoEntry({ entryId }, { title: null, description: null, noindex: null });
+    assert(reset.title === original.title, 'null entry override restores fallback');
+    assert(original.title !== 'Conformance title', 'entry snapshots remain unchanged');
+    const analysis = await api.analyzeSeoEntry({ entryId });
+    assert(analysis.entryId === entryId && Array.isArray(analysis.issues), 'analysis returns entry issues');
+    assert((await api.regenerateSeoSitemap({})).accepted, 'regeneration accepts request');
+    assert(Array.isArray(await api.listSeoPosts({})) && Array.isArray(await api.listSeoPages({})), 'entry choices remain arrays');
+    assert(typeof (await api.fetchSitemapXml({})).text === 'string', 'sitemap returns exact text');
+    assert(typeof api.mediaOriginalUrl({ id: 'conformance-asset' }) === 'string', 'preview URL is synchronous');
+    const abort = new AbortController();
+    abort.abort();
+    let rejected = false;
+    try {
+        await api.fetchSitemapXml({}, { signal: abort.signal });
+    }
+    catch {
+        rejected = true;
+    }
+    assert(rejected, 'aborted sitemap request rejects');
+    return checks;
+}
+//# sourceMappingURL=seo-api.conformance.js.map

package/dist/seo/controllers/entry-picker.controller.d.ts

@@ -0,0 +1,21 @@
+import type { AdminSeoPort } from '../ports.js';
+import type { EntryPickerController, SeoTranslator, SeoErrorFormatter } from '../models.js';
+/** Two existing reads, combined posts first then pages; no new content repository. */
+export declare function createEntryPickerController({ api }: {
+    api: AdminSeoPort;
+}, { t, describeError }?: {
+    t?: SeoTranslator | undefined;
+    describeError?: SeoErrorFormatter | undefined;
+}): {
+    load: (_required?: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+    getSnapshot: () => Readonly<EntryPickerController>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    set: ({ patch }: {
+        patch: Partial<EntryPickerController>;
+    }) => void;
+    signal: AbortSignal;
+    dispose: () => void;
+};
+//# sourceMappingURL=entry-picker.controller.d.ts.map

package/dist/seo/controllers/entry-picker.controller.js

@@ -0,0 +1,17 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { initialEntryPickerState, describeSeoError } from '../models.js';
+/** Two existing reads, combined posts first then pages; no new content repository. */
+export function createEntryPickerController({ api }, { t = key => key, describeError = describeSeoError } = {}) {
+    const store = createControllerStore({ initial: initialEntryPickerState });
+    async function load(_required = {}, _optional = {}) {
+        try {
+            const [posts, pages] = await Promise.all([api.listSeoPosts({}), api.listSeoPages({})]);
+            store.set({ patch: { entries: [...posts, ...pages] } });
+        }
+        catch (error) {
+            store.set({ patch: { error: describeError({ error, fallback: t('failed to load entries') }) } });
+        }
+    }
+    return { ...store, load };
+}
+//# sourceMappingURL=entry-picker.controller.js.map

package/dist/seo/controllers/entry-section.controller.d.ts

@@ -0,0 +1,20 @@
+/** Selection belongs to the section; changing tabs unmounts and resets it. */
+export declare function createSeoEntrySectionController(_required?: Record<string, never>, _optional?: Record<string, never>): {
+    setEntryId({ entryId }: {
+        entryId: string;
+    }, _optional?: Record<string, never>): void;
+    getSnapshot: () => Readonly<{
+        entryId: string;
+    }>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    set: ({ patch }: {
+        patch: Partial<{
+            entryId: string;
+        }>;
+    }) => void;
+    signal: AbortSignal;
+    dispose: () => void;
+};
+//# sourceMappingURL=entry-section.controller.d.ts.map

package/dist/seo/controllers/entry-section.controller.js

@@ -0,0 +1,7 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+/** Selection belongs to the section; changing tabs unmounts and resets it. */
+export function createSeoEntrySectionController(_required = {}, _optional = {}) {
+    const store = createControllerStore({ initial: { entryId: '' } });
+    return { ...store, setEntryId({ entryId }, _optional = {}) { store.set({ patch: { entryId } }); } };
+}
+//# sourceMappingURL=entry-section.controller.js.map

package/dist/seo/controllers/media-ref.controller.d.ts

@@ -0,0 +1,26 @@
+import type { SeoMediaSelection } from '../models.js';
+/** The parent owns the controlled value; this controller owns only picker visibility. */
+export declare function createMediaRefController({ onChange }: {
+    onChange: (value: string) => void;
+}, _optional?: Record<string, never>): {
+    openPicker(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+    closePicker(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+    handleSelect({ item }: {
+        item: SeoMediaSelection;
+    }, _optional?: Record<string, never>): void;
+    clear(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+    getSnapshot: () => Readonly<{
+        pickerOpen: boolean;
+    }>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    set: ({ patch }: {
+        patch: Partial<{
+            pickerOpen: boolean;
+        }>;
+    }) => void;
+    signal: AbortSignal;
+    dispose: () => void;
+};
+//# sourceMappingURL=media-ref.controller.d.ts.map

package/dist/seo/controllers/media-ref.controller.js

@@ -0,0 +1,14 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { buildMediaRef } from '../rules.js';
+/** The parent owns the controlled value; this controller owns only picker visibility. */
+export function createMediaRefController({ onChange }, _optional = {}) {
+    const store = createControllerStore({ initial: { pickerOpen: false } });
+    return {
+        ...store,
+        openPicker(_required = {}, _optional = {}) { store.set({ patch: { pickerOpen: true } }); },
+        closePicker(_required = {}, _optional = {}) { store.set({ patch: { pickerOpen: false } }); },
+        handleSelect({ item }, _optional = {}) { onChange(buildMediaRef({ item })); store.set({ patch: { pickerOpen: false } }); },
+        clear(_required = {}, _optional = {}) { onChange(''); },
+    };
+}
+//# sourceMappingURL=media-ref.controller.js.map

package/dist/seo/controllers/seo-entry.controller.d.ts

@@ -0,0 +1,31 @@
+import type { AdminSeoPort } from '../ports.js';
+import type { SeoEntryState, SeoEntryOverridesPatch, SeoTranslator, SeoErrorFormatter } from '../models.js';
+/** Partial edits remain distinct from resolved values, including explicit null clears. */
+export declare function createSeoEntryController({ api, entryId }: {
+    api: AdminSeoPort;
+    entryId: string;
+}, { t, describeError }?: {
+    t?: SeoTranslator | undefined;
+    describeError?: SeoErrorFormatter | undefined;
+}): {
+    load: (_required?: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+    fieldValue: <K extends keyof SeoEntryOverridesPatch>({ key, resolvedValue }: {
+        key: K;
+        resolvedValue: SeoEntryOverridesPatch[K];
+    }, _optional?: Record<string, never>) => SeoEntryOverridesPatch[K];
+    setField: <K extends keyof SeoEntryOverridesPatch>({ key, value }: {
+        key: K;
+        value: SeoEntryOverridesPatch[K];
+    }, _optional?: Record<string, never>) => void;
+    save: (_required?: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+    getSnapshot: () => Readonly<SeoEntryState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    set: ({ patch }: {
+        patch: Partial<SeoEntryState>;
+    }) => void;
+    signal: AbortSignal;
+    dispose: () => void;
+};
+//# sourceMappingURL=seo-entry.controller.d.ts.map

package/dist/seo/controllers/seo-entry.controller.js

@@ -0,0 +1,52 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { initialSeoEntryState, describeSeoError } from '../models.js';
+import { overrideOrClear } from '../rules.js';
+/** Partial edits remain distinct from resolved values, including explicit null clears. */
+export function createSeoEntryController({ api, entryId }, { t = key => key, describeError = describeSeoError } = {}) {
+    const store = createControllerStore({ initial: initialSeoEntryState });
+    let analyzeGeneration = 0;
+    async function load(_required = {}, _optional = {}) {
+        store.set({ patch: initialSeoEntryState });
+        try {
+            const [resolved, analysis] = await Promise.all([api.getSeoEntry({ entryId }), api.analyzeSeoEntry({ entryId })]);
+            store.set({ patch: { resolved, analysis } });
+        }
+        catch (error) {
+            store.set({ patch: { loadError: describeError({ error, fallback: t('failed to load entry SEO data') }) } });
+        }
+    }
+    function fieldValue({ key, resolvedValue }, _optional = {}) {
+        const { touched } = store.getSnapshot();
+        return key in touched ? touched[key] : resolvedValue;
+    }
+    // Normalize at the single sink rather than the eleven input handlers: a future field cannot
+    // silently miss the clear-override behavior. An untouched field remains absent from the PUT.
+    function setField({ key, value }, _optional = {}) {
+        store.set({ patch: { touched: { ...store.getSnapshot().touched, [key]: overrideOrClear({ value }) } } });
+    }
+    async function save(_required = {}, _optional = {}) {
+        const { touched } = store.getSnapshot();
+        if (Object.keys(touched).length === 0)
+            return;
+        store.set({ patch: { saving: true, saveError: null, notice: null } });
+        try {
+            const resolved = await api.putSeoEntry({ entryId }, touched);
+            store.set({ patch: { resolved, touched: {}, notice: t('Saved.') } });
+            // Saving finishes with the PUT, before this best-effort analysis settles. A newer save's
+            // analysis must supersede an earlier slow response (the source's 2026-09-07 race fix).
+            const ticket = ++analyzeGeneration;
+            void api.analyzeSeoEntry({ entryId }).then(analysis => {
+                if (ticket === analyzeGeneration)
+                    store.set({ patch: { analysis } });
+            }).catch(() => { });
+        }
+        catch (error) {
+            store.set({ patch: { saveError: describeError({ error, fallback: t('failed to save SEO overrides') }) } });
+        }
+        finally {
+            store.set({ patch: { saving: false } });
+        }
+    }
+    return { ...store, load, fieldValue, setField, save };
+}
+//# sourceMappingURL=seo-entry.controller.js.map

package/dist/seo/controllers/seo.controller.d.ts

@@ -0,0 +1,29 @@
+import type { AdminSeoPort } from '../ports.js';
+import type { SeoState, SeoTranslator, SeoSettingsPatch } from '../models.js';
+/** One settings write owner; image drafts rebaseline only on accepted server settings. */
+export declare function createSeoController({ api }: {
+    api: AdminSeoPort;
+}, { t }?: {
+    t?: SeoTranslator | undefined;
+}): {
+    load: (_required?: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+    save: ({ patch }: {
+        patch: SeoSettingsPatch;
+    }, _optional?: Record<string, never>) => Promise<void>;
+    regenerateSitemap: (_required?: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+    setDefaultOgImage({ value }: {
+        value: string;
+    }, _optional?: Record<string, never>): void;
+    openSitemapModal(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+    closeSitemapModal(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+    getSnapshot: () => Readonly<SeoState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    set: ({ patch }: {
+        patch: Partial<SeoState>;
+    }) => void;
+    signal: AbortSignal;
+    dispose: () => void;
+};
+//# sourceMappingURL=seo.controller.d.ts.map

package/dist/seo/controllers/seo.controller.js

@@ -0,0 +1,50 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { initialSeoState, describeSeoError } from '../models.js';
+/** One settings write owner; image drafts rebaseline only on accepted server settings. */
+export function createSeoController({ api }, { t = (key) => key } = {}) {
+    const store = createControllerStore({ initial: initialSeoState });
+    async function load(_required = {}, _optional = {}) {
+        try {
+            const settings = await api.getSeoSettings({});
+            store.set({ patch: { settings, defaultOgImage: settings.defaultOgImage ?? '' } });
+        }
+        catch (error) {
+            store.set({ patch: { error: describeSeoError({ error, fallback: t('failed to load SEO settings') }) } });
+        }
+    }
+    async function save({ patch }, _optional = {}) {
+        store.set({ patch: { saving: true, error: null, notice: null } });
+        try {
+            const settings = await api.putSeoSettings({}, patch);
+            store.set({ patch: { settings, defaultOgImage: settings.defaultOgImage ?? '', notice: t('Saved.') } });
+        }
+        catch (error) {
+            store.set({ patch: { error: describeSeoError({ error, fallback: t('failed to save SEO settings') }) } });
+        }
+        finally {
+            store.set({ patch: { saving: false } });
+        }
+    }
+    async function regenerateSitemap(_required = {}, _optional = {}) {
+        store.set({ patch: { saving: true, error: null, notice: null } });
+        try {
+            await api.regenerateSeoSitemap({});
+            store.set({ patch: { notice: t('Sitemap regeneration accepted.') } });
+            return true;
+        }
+        catch (error) {
+            store.set({ patch: { error: describeSeoError({ error, fallback: t('failed to regenerate sitemap') }) } });
+            return false;
+        }
+        finally {
+            store.set({ patch: { saving: false } });
+        }
+    }
+    return {
+        ...store, load, save, regenerateSitemap,
+        setDefaultOgImage({ value }, _optional = {}) { store.set({ patch: { defaultOgImage: value } }); },
+        openSitemapModal(_required = {}, _optional = {}) { store.set({ patch: { sitemapModalOpen: true } }); },
+        closeSitemapModal(_required = {}, _optional = {}) { store.set({ patch: { sitemapModalOpen: false } }); },
+    };
+}
+//# sourceMappingURL=seo.controller.js.map

package/dist/seo/controllers/sitemap.controller.d.ts

@@ -0,0 +1,25 @@
+import type { AdminSeoPort } from '../ports.js';
+import type { SitemapState, SitemapModalView } from '../models.js';
+/** Disabled is terminal, distinct from loading. Refetch generations ignore older responses. */
+export declare function createSitemapController({ api, enabled }: {
+    api: AdminSeoPort;
+    enabled: boolean;
+}, _optional?: Record<string, never>): {
+    load: (_required?: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+    setFilter({ value }: {
+        value: string;
+    }, _optional?: Record<string, never>): void;
+    setView({ view }: {
+        view: SitemapModalView;
+    }, _optional?: Record<string, never>): void;
+    getSnapshot: () => Readonly<SitemapState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    set: ({ patch }: {
+        patch: Partial<SitemapState>;
+    }) => void;
+    signal: AbortSignal;
+    dispose: () => void;
+};
+//# sourceMappingURL=sitemap.controller.d.ts.map

package/dist/seo/controllers/sitemap.controller.js

@@ -0,0 +1,27 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+/** Disabled is terminal, distinct from loading. Refetch generations ignore older responses. */
+export function createSitemapController({ api, enabled }, _optional = {}) {
+    const store = createControllerStore({ initial: { status: enabled ? 'loading' : 'disabled', error: null, xmlText: '', filter: '', view: 'table' } });
+    let generation = 0;
+    async function load(_required = {}, _optional = {}) {
+        if (!enabled)
+            return;
+        const ticket = ++generation;
+        store.set({ patch: { status: 'loading', error: null } });
+        try {
+            const { text } = await api.fetchSitemapXml({}, { signal: store.signal });
+            if (ticket === generation)
+                store.set({ patch: { xmlText: text, status: 'ready' } });
+        }
+        catch (error) {
+            if (ticket === generation)
+                store.set({ patch: { error: error instanceof Error ? error.message : 'failed to load the sitemap', status: 'error' } });
+        }
+    }
+    return {
+        ...store, load,
+        setFilter({ value }, _optional = {}) { store.set({ patch: { filter: value } }); },
+        setView({ view }, _optional = {}) { store.set({ patch: { view } }); },
+    };
+}
+//# sourceMappingURL=sitemap.controller.js.map

package/dist/seo/index.d.ts

@@ -0,0 +1,14 @@
+export { seoModule } from './seo.module.js';
+export { seoApiToken, seoEventsToken } from './ports.js';
+export type { AdminSeoPort, SeoEventsPort } from './ports.js';
+export type { AdminSeoOverridesPatch, AdminSeoSettingsPatch, AdminSeoEntryChoice } from '../core/ports/seo.js';
+export * from './models.js';
+export * from './rules.js';
+export { seoMessagesEn } from './messages.en.js';
+export { createSeoController } from './controllers/seo.controller.js';
+export { createSeoEntryController } from './controllers/seo-entry.controller.js';
+export { createEntryPickerController } from './controllers/entry-picker.controller.js';
+export { createSeoEntrySectionController } from './controllers/entry-section.controller.js';
+export { createSitemapController } from './controllers/sitemap.controller.js';
+export { createMediaRefController } from './controllers/media-ref.controller.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/seo/index.js

@@ -0,0 +1,12 @@
+export { seoModule } from './seo.module.js';
+export { seoApiToken, seoEventsToken } from './ports.js';
+export * from './models.js';
+export * from './rules.js';
+export { seoMessagesEn } from './messages.en.js';
+export { createSeoController } from './controllers/seo.controller.js';
+export { createSeoEntryController } from './controllers/seo-entry.controller.js';
+export { createEntryPickerController } from './controllers/entry-picker.controller.js';
+export { createSeoEntrySectionController } from './controllers/entry-section.controller.js';
+export { createSitemapController } from './controllers/sitemap.controller.js';
+export { createMediaRefController } from './controllers/media-ref.controller.js';
+//# sourceMappingURL=index.js.map

package/dist/seo/messages.en.d.ts

@@ -0,0 +1,79 @@
+/** English strings are also the host dictionary keys. */
+export declare const seoMessagesEn: {
+    readonly "Site defaults": "Site defaults";
+    readonly Sitemap: "Sitemap";
+    readonly "Pages & posts": "Pages & posts";
+    readonly "This site publishes a sitemap.": "This site publishes a sitemap.";
+    readonly "This site does not publish a sitemap. Turn it on under Site defaults.": "This site does not publish a sitemap. Turn it on under Site defaults.";
+    readonly "Loading entries\u2026": "Loading entries…";
+    readonly Entry: "Entry";
+    readonly "Choose an entry\u2026": "Choose an entry…";
+    readonly Analysis: "Analysis";
+    readonly "Score:": "Score:";
+    readonly "No issues.": "No issues.";
+    readonly "Loading entry SEO\u2026": "Loading entry SEO…";
+    readonly "Per-entry overrides": "Per-entry overrides";
+    readonly "Fields show the currently-effective value (author override, or site default, or derived from the entry). Only fields you change here are saved as overrides.": "Fields show the currently-effective value (author override, or site default, or derived from the entry). Only fields you change here are saved as overrides.";
+    readonly "Empty a field and save to remove its override \u2014 the entry falls back to the site default.": "Empty a field and save to remove its override — the entry falls back to the site default.";
+    readonly Title: "Title";
+    readonly Description: "Description";
+    readonly "Canonical URL": "Canonical URL";
+    readonly Noindex: "Noindex";
+    readonly Nofollow: "Nofollow";
+    readonly "OG title": "OG title";
+    readonly "OG description": "OG description";
+    readonly "OG image": "OG image";
+    readonly "Twitter title": "Twitter title";
+    readonly "Twitter description": "Twitter description";
+    readonly "Twitter image": "Twitter image";
+    readonly "Saving\u2026": "Saving…";
+    readonly "Save overrides": "Save overrides";
+    readonly "Per-entry SEO": "Per-entry SEO";
+    readonly "Search appearance": "Search appearance";
+    readonly "Title template (must contain %s)": "Title template (must contain %s)";
+    readonly "Default meta description": "Default meta description";
+    readonly "Social sharing": "Social sharing";
+    readonly "Default Open Graph / Twitter image": "Default Open Graph / Twitter image";
+    readonly "Twitter @site handle": "Twitter @site handle";
+    readonly Crawling: "Crawling";
+    readonly "Default noindex": "Default noindex";
+    readonly "Default nofollow": "Default nofollow";
+    readonly "Sitemap enabled": "Sitemap enabled";
+    readonly "Save settings": "Save settings";
+    readonly "Cached sitemap": "Cached sitemap";
+    readonly "Rebuild the sitemap now to include the latest published content.": "Rebuild the sitemap now to include the latest published content.";
+    readonly "Working\u2026": "Working…";
+    readonly "Regenerate sitemap": "Regenerate sitemap";
+    readonly "View sitemap": "View sitemap";
+    readonly "Loading SEO settings\u2026": "Loading SEO settings…";
+    readonly Marketing: "Marketing";
+    readonly "Site-wide defaults for meta titles, descriptions, Open Graph/Twitter cards, and robots directives.": "Site-wide defaults for meta titles, descriptions, Open Graph/Twitter cards, and robots directives.";
+    readonly "Choose image": "Choose image";
+    readonly Remove: "Remove";
+    readonly "Sitemap \u00B7 {count} URLs": "Sitemap · {count} URLs";
+    readonly "sitemap.xml \u2197": "sitemap.xml ↗";
+    readonly Table: "Table";
+    readonly "Raw XML": "Raw XML";
+    readonly "The sitemap has no URLs yet.": "The sitemap has no URLs yet.";
+    readonly "Filter sitemap URLs": "Filter sitemap URLs";
+    readonly "Filter by URL\u2026": "Filter by URL…";
+    readonly "No URLs match this filter.": "No URLs match this filter.";
+    readonly URL: "URL";
+    readonly "Last modified": "Last modified";
+    readonly "\u2014": "—";
+    readonly "Sitemap is off. Turn on \"Sitemap enabled\" above to publish one.": "Sitemap is off. Turn on \"Sitemap enabled\" above to publish one.";
+    readonly "Loading sitemap\u2026": "Loading sitemap…";
+    readonly Close: "Close";
+    readonly "failed to load entries": "failed to load entries";
+    readonly "failed to load entry SEO data": "failed to load entry SEO data";
+    readonly "Saved.": "Saved.";
+    readonly "failed to save SEO overrides": "failed to save SEO overrides";
+    readonly "failed to load SEO settings": "failed to load SEO settings";
+    readonly "failed to save SEO settings": "failed to save SEO settings";
+    readonly "Sitemap regeneration accepted.": "Sitemap regeneration accepted.";
+    readonly "failed to regenerate sitemap": "failed to regenerate sitemap";
+    readonly "failed to load the sitemap": "failed to load the sitemap";
+    readonly "Could not load the sitemap (HTTP {status}).": "Could not load the sitemap (HTTP {status}).";
+    readonly "Selected image": "Selected image";
+};
+//# sourceMappingURL=messages.en.d.ts.map

package/dist/seo/messages.en.js

@@ -0,0 +1,79 @@
+/** English strings are also the host dictionary keys. */
+export const seoMessagesEn = {
+    "Site defaults": "Site defaults",
+    "Sitemap": "Sitemap",
+    "Pages & posts": "Pages & posts",
+    "This site publishes a sitemap.": "This site publishes a sitemap.",
+    "This site does not publish a sitemap. Turn it on under Site defaults.": "This site does not publish a sitemap. Turn it on under Site defaults.",
+    "Loading entries…": "Loading entries…",
+    "Entry": "Entry",
+    "Choose an entry…": "Choose an entry…",
+    "Analysis": "Analysis",
+    "Score:": "Score:",
+    "No issues.": "No issues.",
+    "Loading entry SEO…": "Loading entry SEO…",
+    "Per-entry overrides": "Per-entry overrides",
+    "Fields show the currently-effective value (author override, or site default, or derived from the entry). Only fields you change here are saved as overrides.": "Fields show the currently-effective value (author override, or site default, or derived from the entry). Only fields you change here are saved as overrides.",
+    "Empty a field and save to remove its override — the entry falls back to the site default.": "Empty a field and save to remove its override — the entry falls back to the site default.",
+    "Title": "Title",
+    "Description": "Description",
+    "Canonical URL": "Canonical URL",
+    "Noindex": "Noindex",
+    "Nofollow": "Nofollow",
+    "OG title": "OG title",
+    "OG description": "OG description",
+    "OG image": "OG image",
+    "Twitter title": "Twitter title",
+    "Twitter description": "Twitter description",
+    "Twitter image": "Twitter image",
+    "Saving…": "Saving…",
+    "Save overrides": "Save overrides",
+    "Per-entry SEO": "Per-entry SEO",
+    "Search appearance": "Search appearance",
+    "Title template (must contain %s)": "Title template (must contain %s)",
+    "Default meta description": "Default meta description",
+    "Social sharing": "Social sharing",
+    "Default Open Graph / Twitter image": "Default Open Graph / Twitter image",
+    "Twitter @site handle": "Twitter @site handle",
+    "Crawling": "Crawling",
+    "Default noindex": "Default noindex",
+    "Default nofollow": "Default nofollow",
+    "Sitemap enabled": "Sitemap enabled",
+    "Save settings": "Save settings",
+    "Cached sitemap": "Cached sitemap",
+    "Rebuild the sitemap now to include the latest published content.": "Rebuild the sitemap now to include the latest published content.",
+    "Working…": "Working…",
+    "Regenerate sitemap": "Regenerate sitemap",
+    "View sitemap": "View sitemap",
+    "Loading SEO settings…": "Loading SEO settings…",
+    "Marketing": "Marketing",
+    "Site-wide defaults for meta titles, descriptions, Open Graph/Twitter cards, and robots directives.": "Site-wide defaults for meta titles, descriptions, Open Graph/Twitter cards, and robots directives.",
+    "Choose image": "Choose image",
+    "Remove": "Remove",
+    "Sitemap · {count} URLs": "Sitemap · {count} URLs",
+    "sitemap.xml ↗": "sitemap.xml ↗",
+    "Table": "Table",
+    "Raw XML": "Raw XML",
+    "The sitemap has no URLs yet.": "The sitemap has no URLs yet.",
+    "Filter sitemap URLs": "Filter sitemap URLs",
+    "Filter by URL…": "Filter by URL…",
+    "No URLs match this filter.": "No URLs match this filter.",
+    "URL": "URL",
+    "Last modified": "Last modified",
+    "—": "—",
+    "Sitemap is off. Turn on \"Sitemap enabled\" above to publish one.": "Sitemap is off. Turn on \"Sitemap enabled\" above to publish one.",
+    "Loading sitemap…": "Loading sitemap…",
+    "Close": "Close",
+    "failed to load entries": "failed to load entries",
+    "failed to load entry SEO data": "failed to load entry SEO data",
+    "Saved.": "Saved.",
+    "failed to save SEO overrides": "failed to save SEO overrides",
+    "failed to load SEO settings": "failed to load SEO settings",
+    "failed to save SEO settings": "failed to save SEO settings",
+    "Sitemap regeneration accepted.": "Sitemap regeneration accepted.",
+    "failed to regenerate sitemap": "failed to regenerate sitemap",
+    "failed to load the sitemap": "failed to load the sitemap",
+    "Could not load the sitemap (HTTP {status}).": "Could not load the sitemap (HTTP {status}).",
+    "Selected image": "Selected image",
+};
+//# sourceMappingURL=messages.en.js.map