@jini-ai/admin 0.4.2 → 0.4.4

package/dist/widgets/react/pages/WidgetRegions.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useWidgetRegionsView } from '../hooks/page-views.hooks.js';
+import { useWidgetsOptions } from '../hooks/WidgetsPorts.hooks.js';
+import { DataTable } from "../../../react/components/DataTable.js";
+import { agentHandle } from "@jini-ai/agentic";
+import { useWiredWidgetRegions } from "../hooks/use-widget-regions.hooks.js";
+export function WidgetRegions({ useWidgetRegionsHook = useWiredWidgetRegions } = {}) {
+    const { headerActions } = useWidgetsOptions();
+    const { regions, error, newRegionKey, setNewRegionKey, binding, bind, t, rowHandleByKey } = useWidgetRegionsView({ useWidgetRegionsHook });
+    if (error && !regions)
+        return _jsx("div", { className: "notice error", children: error });
+    if (!regions)
+        return _jsx("div", { className: "notice", children: t("Loading regions…") });
+    return (_jsxs("div", { className: "page", children: [_jsxs("div", { className: "page-header page-header-split", ...agentHandle({ handle: "widget-regions-header" }, {
+                    role: "region",
+                    label: "Widget Regions header — the back link, the screen's title, and the bind-a-region control",
+                }), children: [_jsx("div", { className: "page-header-lead", children: _jsxs("a", { className: "btn-secondary", href: "/admin/widgets", "aria-label": `${t("Back")}: ${t("Widgets")}`, ...agentHandle({ handle: "widget-regions-back" }, { role: "link", label: "Back to Widgets" }), children: ["\u2190 ", t("Back")] }) }), _jsxs("div", { className: "page-header-text", children: [_jsx("p", { className: "page-kicker", children: t("Content") }), _jsx("h1", { className: "page-title", children: t("Widget Regions") }), _jsx("p", { className: "page-description", children: t('A region is a theme-declared placement area (e.g. "header", "footer", "sidebar"). Bind a region by its key to start placing widgets in it.') })] }), _jsxs("div", { className: "page-header-actions page-actions", children: [headerActions, _jsxs("div", { className: "widget-regions-bind", children: [_jsx("input", { value: newRegionKey, onChange: (e) => setNewRegionKey(e.target.value), placeholder: "e.g. footer", ...agentHandle({ handle: "widget-regions-new-key" }, { role: "field", label: "New region key to bind, e.g. footer" }) }), _jsx("button", { onClick: bind, disabled: binding || !newRegionKey.trim(), ...agentHandle({ handle: "widget-regions-bind" }, { role: "button", label: "Bind this region key" }), children: binding ? t("Binding…") : t("Bind region") })] })] })] }), error ? _jsx("div", { className: "notice error", children: error }) : null, _jsx(DataTable, { rows: regions, rowKey: (region) => region.regionKey, empty: _jsx("div", { className: "card", children: _jsx("div", { className: "empty-state", children: _jsx("p", { children: t("No regions bound yet.") }) }) }), columns: [
+                    {
+                        key: "region-key",
+                        header: t("Region key"),
+                        cell: (region) => (_jsx("a", { href: `/admin/widgets/regions/${region.regionKey}`, ...agentHandle({ handle: `${rowHandleByKey.get(region.regionKey)}-key` }, { role: "link", label: `Manage the "${region.regionKey}" region` }), children: region.regionKey })),
+                    },
+                    { key: "placements", header: t("Placements"), cell: (region) => region.placementCount },
+                    {
+                        key: "manage",
+                        cell: (region) => (_jsx("a", { className: "btn-primary", href: `/admin/widgets/regions/${region.regionKey}`, ...agentHandle({ handle: `${rowHandleByKey.get(region.regionKey)}-manage` }, { role: "link", label: `Manage the "${region.regionKey}" region` }), children: t("Manage") })),
+                    },
+                ] })] }));
+}
+export default WidgetRegions;
+//# sourceMappingURL=WidgetRegions.js.map

package/dist/widgets/react/pages/WidgetsLibrary.d.ts

@@ -0,0 +1,24 @@
+import { useWiredWidgetsLibrary } from "../hooks/use-widgets-library.hooks.js";
+/**
+ * @file `WidgetsLibraryScreen` (`ui.spec.md` §2.1/§3.1/§4.1) — the widget library/list screen,
+ * `/admin/widgets` — markup only. Mirrors `Menus.tsx`'s list-table/status-badge/header-action
+ * shape exactly.
+ *
+ * State and the fetch live in `../hooks/use-widgets-library.hooks.ts`; the shared type-label
+ * derivation lives in `../../rules.ts`. Delete always confirms first (`pendingTrash`/`ConfirmDialog`
+ * below) and moves the widget to the Trash — there is no purge/force-purge escalation here any
+ * more (2026-09-21, `trash-delete-architecture.md`): the server's widget purge route was removed,
+ * a trashed widget is hidden from this list by the server, and the Trash screen owns
+ * restore/purge from here.
+ */
+export interface WidgetsLibraryProps {
+    /**
+     * Dependency injection seam for tests — the same convention `Posts.tsx`'s `usePostsHook` uses.
+     * Defaulted to the real hook, so production callers pass nothing and behave exactly as before.
+     */
+    useWidgetsLibraryHook?: typeof useWiredWidgetsLibrary | undefined;
+}
+export { WidgetsLibraryNotices } from '../components/WidgetsLibraryNotices.js';
+export declare function WidgetsLibrary({ useWidgetsLibraryHook }?: WidgetsLibraryProps): import("react").JSX.Element;
+export default WidgetsLibrary;
+//# sourceMappingURL=WidgetsLibrary.d.ts.map

package/dist/widgets/react/pages/WidgetsLibrary.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useWidgetsLibraryView } from '../hooks/page-views.hooks.js';
+import { useWidgetsOptions } from '../hooks/WidgetsPorts.hooks.js';
+import {} from "../../models.js";
+import { ConfirmDialog } from "../../../react/components/ConfirmDialog/ConfirmDialog.js";
+import { DataTable } from "../../../react/components/DataTable.js";
+import { agentHandle } from "@jini-ai/agentic";
+import { widgetTypeLabel } from "../../rules.js";
+import { useWiredWidgetsLibrary } from "../hooks/use-widgets-library.hooks.js";
+export { WidgetsLibraryNotices } from '../components/WidgetsLibraryNotices.js';
+import { WidgetsLibraryNotices } from '../components/WidgetsLibraryNotices.js';
+export function WidgetsLibrary({ useWidgetsLibraryHook = useWiredWidgetsLibrary } = {}) {
+    const { widgetTypes, headerActions, statusLabel } = useWidgetsOptions();
+    const { widgets, error, skippedCount, skippedIds, createType, setCreateType, pendingTrash, trashing, requestTrash, confirmTrash, cancelTrash, t, locale, rowHandleById, } = useWidgetsLibraryView({ useWidgetsLibraryHook });
+    if (error && !widgets)
+        return _jsx("div", { className: "notice error", children: error });
+    if (!widgets)
+        return _jsx("div", { className: "notice", children: t("Loading widgets…") });
+    return (_jsxs("div", { className: "page", children: [_jsxs("div", { className: "page-header", children: [_jsxs("div", { className: "page-header-text", children: [_jsx("p", { className: "page-kicker", children: t("Content") }), _jsx("h1", { className: "page-title", children: t("Widgets") }), _jsx("p", { className: "page-description", children: t("Create reusable content blocks and place them into your theme's widget regions.") })] }), _jsxs("div", { className: "page-actions", children: [headerActions, _jsx("a", { href: "/admin/widgets/regions", ...agentHandle({ handle: "widgets-regions-link" }, { role: "link", label: "Go to Widget Regions" }), children: t("Regions →") }), _jsx("select", { value: createType, onChange: (e) => setCreateType(e.target.value), "aria-label": t("Widget type to create"), ...agentHandle({ handle: "widgets-create-type" }, { role: "field", label: "Widget type to create" }), children: widgetTypes.map((o) => (_jsx("option", { value: o.value, children: widgetTypeLabel({ widgetType: o.value, types: widgetTypes }, { t }) }, o.value))) }), _jsx("a", { className: "btn-primary", href: `/admin/widgets/new?type=${createType}`, ...agentHandle({ handle: "widgets-add-new" }, { role: "link", label: "Create a new widget of the selected type" }), children: t("Add New") })] })] }), _jsx(WidgetsLibraryNotices, { error: error, skippedCount: skippedCount, skippedIds: skippedIds, t: t }), _jsx(DataTable, { rows: widgets, rowKey: (widget) => widget.id, empty: _jsx("div", { className: "card", children: _jsxs("div", { className: "empty-state", children: [_jsx("p", { children: t("No widgets yet.") }), _jsx("p", { className: "page-description", children: t("Create one above to get started.") })] }) }), columns: [
+                    {
+                        key: "title",
+                        header: t("Title"),
+                        cell: (widget) => (_jsx("a", { 
+                            // Slug, not id (2026-09-22, URL-uses-slug — mirrors `FormsList.tsx`'s
+                            // `/admin/forms/${form.slug}` row link): the editor resolves either
+                            // (`read-service.ts`'s `getWidgetInstance`), but the slug is the readable one.
+                            href: `/admin/widgets/${widget.slug}`, ...agentHandle({ handle: `${rowHandleById.get(widget.id)}-edit` }, { role: "link", label: `Edit the "${widget.title}" widget` }), children: widget.title })),
+                    },
+                    {
+                        key: "type",
+                        header: t("Type"),
+                        cell: (widget) => widgetTypeLabel({ widgetType: widget.widgetType, types: widgetTypes }, { t }),
+                    },
+                    {
+                        key: "slug",
+                        header: t("Slug"),
+                        // Monospace like Collections' "Key" column (`Collections.tsx`) — a slug is an
+                        // identifier, not prose.
+                        cell: (widget) => _jsx("code", { children: widget.slug }),
+                    },
+                    {
+                        key: "status",
+                        header: t("Status"),
+                        cell: (widget) => _jsx("span", { className: `status status-${widget.status}`, children: (statusLabel ?? t)(widget.status) }),
+                    },
+                    {
+                        key: "actions",
+                        // Not converted to a `RowMenu` — this is the row's only action (see report: a menu
+                        // with one item is pure overhead over a direct button). Still labeled for
+                        // accessibility, matching `Roles.tsx`/`Users.tsx`'s existing pattern for an actions
+                        // column that isn't a bare `<th></th>`.
+                        headerLabel: t("Actions"),
+                        cell: (widget) => (_jsx("button", { onClick: () => requestTrash(widget), ...agentHandle({ handle: `${rowHandleById.get(widget.id)}-trash` }, {
+                                role: "button",
+                                label: `Move "${widget.title}" to trash`,
+                            }), children: t("Trash") })),
+                    },
+                ] }), _jsx(ConfirmDialog, { open: pendingTrash !== null, agentHandle: "widgets-trash", title: t("Move to trash?"), body: pendingTrash ? _jsx("p", { children: t('Move "{title}" to trash?').replace("{title}", pendingTrash.title) }) : null, confirmLabel: t("Move to trash"), destructive: true, pending: trashing, onConfirm: confirmTrash, onCancel: cancelTrash })] }));
+}
+export default WidgetsLibrary;
+//# sourceMappingURL=WidgetsLibrary.js.map

package/dist/widgets/rules.d.ts

@@ -0,0 +1,94 @@
+import { AdminApiError } from '../core/transport/errors.js';
+import type { AdminWidget, AdminWidgetPlacement, AdminWidgetType, WidgetTypeOption, WidgetsTranslate, WidgetSlugRedirectPath, WidgetEditorParams } from './models.js';
+export declare const WIDGETS_LIBRARY_RESOURCE = "widgets-library";
+export declare const WIDGETS_REGIONS_RESOURCE = "widgets-regions";
+/** Normalize only the documented host API error shape; preserve the existing shared error owner. */
+export declare function widgetApiError({ error }: {
+    error: unknown;
+}, _optional?: Record<string, never>): AdminApiError | null;
+/** Resolve the host catalog's label, then translate; unknown stored types retain their raw value. */
+export declare function widgetTypeLabel({ widgetType, types }: {
+    widgetType: string;
+    types: readonly WidgetTypeOption[];
+}, { t }?: {
+    t?: WidgetsTranslate | undefined;
+}): string;
+/** Creation accepts only the host catalog; stored types remain an open vocabulary. */
+export declare function isKnownWidgetType({ widgetType, types }: {
+    widgetType: string;
+    types: readonly WidgetTypeOption[];
+}, _optional?: Record<string, never>): boolean;
+export declare function widgetConfigFieldErrors({ error }: {
+    error: unknown;
+}, _optional?: Record<string, never>): Array<{
+    field: string;
+    reason: string;
+}>;
+/** Missing loaded data deliberately resolves to undefined, matching the original editor. */
+export declare function resolveEditorWidgetType({ isNew, queryWidgetType, widget }: {
+    isNew: boolean;
+    queryWidgetType: string | null;
+    widget: AdminWidget | null;
+}, _optional?: Record<string, never>): AdminWidgetType | null | undefined;
+/** Copy before swapping; an out-of-bounds move retains the original reference. O(n) per move. */
+export declare function movePlacement<T>({ items, index, direction }: {
+    items: T[];
+    index: number;
+    direction: -1 | 1;
+}, _optional?: Record<string, never>): T[];
+/** Draft identity survives reorder/remove/toggle until the server accepts the ordered placements. */
+export declare function buildDraftPlacement({ widgetInstanceId }: {
+    widgetInstanceId: string;
+}, { id }?: {
+    id?: (() => string) | undefined;
+}): AdminWidgetPlacement;
+export interface WidgetSaveErrorOutcome {
+    error: string;
+    fieldErrors: Array<{
+        field: string;
+        reason: string;
+    }>;
+}
+/** Conflict copy is domain-specific; other failures use the existing admin error describer. */
+export declare function resolveWidgetSaveError({ error }: {
+    error: unknown;
+}, { t }?: {
+    t?: WidgetsTranslate | undefined;
+}): WidgetSaveErrorOutcome;
+export declare function resolveWidgetRegionSaveError({ error }: {
+    error: unknown;
+}, { t }?: {
+    t?: WidgetsTranslate | undefined;
+}): string;
+/** The general slug rule remains host-owned and optional; no parallel slug policy is introduced. */
+export declare function widgetSlugRedirectPath({ requestedId, widget }: {
+    requestedId: string;
+    widget: Pick<AdminWidget, 'id' | 'slug'>;
+}, { slugRedirectPath }?: {
+    slugRedirectPath?: WidgetSlugRedirectPath | undefined;
+}): string | null;
+export type WidgetInstanceGuard = {
+    kind: 'fetch-error';
+    message: string;
+} | {
+    kind: 'loading';
+} | {
+    kind: 'no-type';
+} | {
+    kind: 'unknown-type';
+    widgetType: string;
+};
+/** Catch a garbage ?type= before a live create editor can save it; existing types are server-validated. */
+export declare function widgetInstanceGuard({ error, isNew, widget, loading, widgetType, types }: {
+    error: string | null;
+    isNew: boolean;
+    widget: AdminWidget | null;
+    loading: boolean;
+    widgetType: string | null | undefined;
+    types: readonly WidgetTypeOption[];
+}, _optional?: Record<string, never>): WidgetInstanceGuard | null;
+/** Match the original save identity, including the query type on /new. */
+export declare function widgetEntityKey({ params }: {
+    params: WidgetEditorParams;
+}, _optional?: Record<string, never>): string;
+//# sourceMappingURL=rules.d.ts.map

package/dist/widgets/rules.js

@@ -0,0 +1,83 @@
+import { AdminApiError, describeApiError } from '../core/transport/errors.js';
+import { widgetsEnglish } from './messages.en.js';
+export const WIDGETS_LIBRARY_RESOURCE = 'widgets-library';
+// Regions are a separate list; placement editors use baseVersion rather than live refresh.
+export const WIDGETS_REGIONS_RESOURCE = 'widgets-regions';
+/** Normalize only the documented host API error shape; preserve the existing shared error owner. */
+export function widgetApiError({ error }, _optional = {}) {
+    if (error instanceof AdminApiError)
+        return error;
+    if (error instanceof Error && 'status' in error && typeof error.status === 'number') {
+        const host = error;
+        return new AdminApiError({ message: host.message, status: host.status }, { code: host.code, body: host.body });
+    }
+    return null;
+}
+/** Resolve the host catalog's label, then translate; unknown stored types retain their raw value. */
+export function widgetTypeLabel({ widgetType, types }, { t = widgetsEnglish } = {}) {
+    return t(types.find(o => o.value === widgetType)?.label ?? widgetType);
+}
+/** Creation accepts only the host catalog; stored types remain an open vocabulary. */
+export function isKnownWidgetType({ widgetType, types }, _optional = {}) {
+    return types.some(o => o.value === widgetType);
+}
+export function widgetConfigFieldErrors({ error }, _optional = {}) {
+    const e = widgetApiError({ error });
+    if (e?.code !== 'WIDGETS_CONFIG_VALIDATION_ERROR')
+        return [];
+    const details = e.body?.details;
+    return details?.fieldErrors ?? [];
+}
+/** Missing loaded data deliberately resolves to undefined, matching the original editor. */
+export function resolveEditorWidgetType({ isNew, queryWidgetType, widget }, _optional = {}) {
+    return isNew ? queryWidgetType : widget?.widgetType;
+}
+/** Copy before swapping; an out-of-bounds move retains the original reference. O(n) per move. */
+export function movePlacement({ items, index, direction }, _optional = {}) {
+    const target = index + direction;
+    if (target < 0 || target >= items.length)
+        return items;
+    const next = [...items];
+    [next[index], next[target]] = [next[target], next[index]];
+    return next;
+}
+// Distinguishes draft keys created in the same millisecond without randomUUID.
+let draftPlacementSequence = 0;
+/** Draft identity survives reorder/remove/toggle until the server accepts the ordered placements. */
+export function buildDraftPlacement({ widgetInstanceId }, { id = () => globalThis.crypto?.randomUUID?.() ?? `p-${Date.now()}-${++draftPlacementSequence}` } = {}) {
+    return { placementId: id(), widgetEntryId: widgetInstanceId, enabled: true, widgetTitle: null, widgetType: null, broken: false };
+}
+/** Conflict copy is domain-specific; other failures use the existing admin error describer. */
+export function resolveWidgetSaveError({ error }, { t = widgetsEnglish } = {}) {
+    const e = widgetApiError({ error });
+    if (e?.code === 'WIDGETS_VERSION_CONFLICT')
+        return { error: t('This widget changed since you loaded it, refresh and try again.'), fieldErrors: [] };
+    return { error: describeApiError({ e: e ?? error, fallback: t('save failed') }), fieldErrors: widgetConfigFieldErrors({ error }) };
+}
+export function resolveWidgetRegionSaveError({ error }, { t = widgetsEnglish } = {}) {
+    const e = widgetApiError({ error });
+    if (e?.code === 'WIDGETS_AREA_CONFLICT')
+        return t('This region changed since you loaded it, refresh and try again.');
+    return describeApiError({ e: e ?? error, fallback: t('save failed') });
+}
+/** The general slug rule remains host-owned and optional; no parallel slug policy is introduced. */
+export function widgetSlugRedirectPath({ requestedId, widget }, { slugRedirectPath } = {}) {
+    return slugRedirectPath?.('/widgets', requestedId, widget) ?? null;
+}
+/** Catch a garbage ?type= before a live create editor can save it; existing types are server-validated. */
+export function widgetInstanceGuard({ error, isNew, widget, loading, widgetType, types }, _optional = {}) {
+    if (error && !isNew && !widget)
+        return { kind: 'fetch-error', message: error };
+    if (loading)
+        return { kind: 'loading' };
+    if (!widgetType)
+        return { kind: 'no-type' };
+    if (isNew && !isKnownWidgetType({ widgetType, types }))
+        return { kind: 'unknown-type', widgetType };
+    return null;
+}
+/** Match the original save identity, including the query type on /new. */
+export function widgetEntityKey({ params }, _optional = {}) {
+    return `${params.widgetId ?? ''}::${params.widgetType ?? ''}::${params.widgetId === null}`;
+}
+//# sourceMappingURL=rules.js.map

package/dist/widgets/widgets.module.d.ts

@@ -0,0 +1,122 @@
+export declare const widgetsAgentPageIds: {
+    readonly library: "widgets";
+    readonly editor: "widgets";
+    readonly regions: "widget-regions";
+    readonly region: "widget-regions";
+};
+export declare const widgetsEditorPaths: readonly ["/widgets/new", "/widgets/:widgetId"];
+/** No client permissions are declared, matching the host panels; servers authorize widgets.*. */
+export declare const widgetsModule: {
+    readonly id: "widgets";
+    readonly requires: {
+        readonly widgetsApi: import("../core/module/token.js").AdminPortToken<import("./ports.js").AdminWidgetsPort, "admin.widgets.api">;
+    };
+    readonly optional: {
+        readonly widgetsEvents: import("../core/module/token.js").AdminPortToken<import("./ports.js").WidgetsEventsPort, "admin.widgets.events">;
+        readonly widgetsNavigation: import("../core/module/token.js").AdminPortToken<import("./ports.js").WidgetsNavigationPort, "admin.widgets.navigation">;
+    };
+    readonly messages: {
+        readonly Back: "Back";
+        readonly "Widget type to create": "Widget type to create";
+        readonly Content: "Content";
+        readonly Text: "Text";
+        readonly "Social Links": "Social Links";
+        readonly "Collection list": "Collection list";
+        readonly Menu: "Menu";
+        readonly "Contact Form": "Contact Form";
+        readonly Widgets: "Widgets";
+        readonly "Widget Regions": "Widget Regions";
+        readonly "A region is a theme-declared placement area (e.g. \"header\", \"footer\", \"sidebar\"). Bind a region by its key to start placing widgets in it.": "A region is a theme-declared placement area (e.g. \"header\", \"footer\", \"sidebar\"). Bind a region by its key to start placing widgets in it.";
+        readonly "Binding\u2026": "Binding…";
+        readonly "Bind region": "Bind region";
+        readonly "No regions bound yet.": "No regions bound yet.";
+        readonly "Region key": "Region key";
+        readonly Placements: "Placements";
+        readonly Manage: "Manage";
+        readonly "Create reusable content blocks and place them into your theme's widget regions.": "Create reusable content blocks and place them into your theme's widget regions.";
+        readonly "Regions \u2192": "Regions →";
+        readonly "Add New": "Add New";
+        readonly "1 widget record in this workspace could not be read.": "1 widget record in this workspace could not be read.";
+        readonly "{n} widget records in this workspace could not be read.": "{n} widget records in this workspace could not be read.";
+        readonly "Show ids": "Show ids";
+        readonly "No widgets yet.": "No widgets yet.";
+        readonly "Create one above to get started.": "Create one above to get started.";
+        readonly Title: "Title";
+        readonly Type: "Type";
+        readonly Slug: "Slug";
+        readonly Status: "Status";
+        readonly Actions: "Actions";
+        readonly Trash: "Trash";
+        readonly "Move to trash?": "Move to trash?";
+        readonly "Move to trash": "Move to trash";
+        readonly "Move \"{title}\" to trash?": "Move \"{title}\" to trash?";
+        readonly Regions: "Regions";
+        readonly "Saving\u2026": "Saving…";
+        readonly Save: "Save";
+        readonly "Region:": "Region:";
+        readonly "Manage which widgets appear in this region and their order.": "Manage which widgets appear in this region and their order.";
+        readonly "No widgets placed in this region yet.": "No widgets placed in this region yet.";
+        readonly Enabled: "Enabled";
+        readonly "\u26A0 Broken reference": "⚠ Broken reference";
+        readonly "+ Add widget": "+ Add widget";
+        readonly "New widget": "New widget";
+        readonly "Edit widget": "Edit widget";
+        readonly "Configure this widget's title and settings.": "Configure this widget's title and settings.";
+        readonly "Widget title": "Widget title";
+        readonly "Type:": "Type:";
+        readonly "Region area": "Region area";
+        readonly "Inline embed": "Inline embed";
+        readonly "Used in 1 place:": "Used in 1 place:";
+        readonly "Used in {count} places:": "Used in {count} places:";
+        readonly "failed to load widget": "failed to load widget";
+        readonly "save failed": "save failed";
+        readonly "This widget changed since you loaded it, refresh and try again.": "This widget changed since you loaded it, refresh and try again.";
+        readonly "This region changed since you loaded it, refresh and try again.": "This region changed since you loaded it, refresh and try again.";
+        readonly "failed to load region": "failed to load region";
+        readonly "failed to load widgets": "failed to load widgets";
+        readonly "delete failed": "delete failed";
+        readonly "This item changed since you loaded it. Reload and try again.": "This item changed since you loaded it. Reload and try again.";
+        readonly "failed to load regions": "failed to load regions";
+        readonly "bind failed": "bind failed";
+        readonly "Loading widget\u2026": "Loading widget…";
+        readonly "No widget type specified.": "No widget type specified.";
+        readonly "Unknown widget type \"": "Unknown widget type \"";
+        readonly "Loading region\u2026": "Loading region…";
+        readonly "Move up": "Move up";
+        readonly "Move down": "Move down";
+        readonly Remove: "Remove";
+        readonly "Loading regions\u2026": "Loading regions…";
+        readonly "Loading widgets\u2026": "Loading widgets…";
+        readonly "Saved \u00B7 version {version}": "Saved · version {version}";
+    };
+    readonly pages: {
+        readonly library: {
+            readonly path: "/widgets";
+            readonly label: "Widgets";
+            readonly agentReachable: true;
+            readonly nav: {
+                readonly group: "Content";
+            };
+            readonly tabs: {};
+        };
+        readonly editor: {
+            readonly path: "/widgets/:widgetId";
+            readonly label: "Edit widget";
+            readonly agentReachable: true;
+            readonly tabs: {};
+        };
+        readonly regions: {
+            readonly path: "/widgets/regions";
+            readonly label: "Widget Regions";
+            readonly agentReachable: true;
+            readonly tabs: {};
+        };
+        readonly region: {
+            readonly path: "/widgets/regions/:regionKey";
+            readonly label: "Region:";
+            readonly agentReachable: true;
+            readonly tabs: {};
+        };
+    };
+};
+//# sourceMappingURL=widgets.module.d.ts.map

package/dist/widgets/widgets.module.js

@@ -0,0 +1,21 @@
+import { defineAdminModule } from '../core/module/index.js';
+import { widgetsApiToken, widgetsEventsToken, widgetsNavigationToken } from './ports.js';
+import { widgetsMessagesEn } from './messages.en.js';
+// Region pages share the host agent id; route-specific module page ids do not replace it.
+export const widgetsAgentPageIds = { library: 'widgets', editor: 'widgets', regions: 'widget-regions', region: 'widget-regions' };
+export const widgetsEditorPaths = ['/widgets/new', '/widgets/:widgetId'];
+/** No client permissions are declared, matching the host panels; servers authorize widgets.*. */
+export const widgetsModule = defineAdminModule({
+    id: 'widgets',
+    requires: { widgetsApi: widgetsApiToken },
+    optional: { widgetsEvents: widgetsEventsToken, widgetsNavigation: widgetsNavigationToken },
+    messages: widgetsMessagesEn,
+    pages: {
+        library: { path: '/widgets', label: 'Widgets', agentReachable: true, nav: { group: 'Content' }, tabs: {} },
+        // core currently supports one path per page; /new is dispatched to this same editor by the host.
+        editor: { path: '/widgets/:widgetId', label: 'Edit widget', agentReachable: true, tabs: {} },
+        regions: { path: '/widgets/regions', label: 'Widget Regions', agentReachable: true, tabs: {} },
+        region: { path: '/widgets/regions/:regionKey', label: 'Region:', agentReachable: true, tabs: {} },
+    },
+});
+//# sourceMappingURL=widgets.module.js.map