@jini-ai/cms 0.5.5 → 0.5.7

package/dist/widgets/registry.d.ts

@@ -28,17 +28,151 @@
  *   module load time.
  */
 import type { WidgetTypeKey, WidgetTypeRegistration } from "./types.js";
-/**
- * The complete v1 widget-type registry (REQ-09), keyed by the closed `WidgetTypeKey` union rather
- * than held as an array. Declared with `satisfies` rather than a `: Readonly<Record<...>>`
- * annotation — a `:` annotation would widen every entry back to the shared `WidgetTypeRegistration`
- * interface (losing e.g. `RECENT_ENTRIES_REGISTRATION`'s own non-optional `clamps.maxItems`);
- * `satisfies` checks the same shape constraint (every `WidgetTypeKey` has an entry, which is what
- * makes `getWidgetTypeRegistration` below total) while keeping each entry's own literal type intact.
- * Iterate with `Object.values(...)` where the whole table is needed (e.g. `agent-tools.ts`'s
- * published-type-list).
- */
 export declare const WIDGET_TYPE_REGISTRATIONS: {
+    media: {
+        typeKey: "media";
+        capability: "entry-reference";
+        configSchema: {
+            type: string;
+            'x-gallery-config': true;
+            properties: {
+                mode: {
+                    type: string;
+                };
+                html: {
+                    type: string;
+                };
+                items: {
+                    type: string;
+                    maxItems: number;
+                    items: {
+                        type: string;
+                        properties: {
+                            slug: {
+                                type: string;
+                                'x-ref-target': string;
+                            };
+                            alt: {
+                                type: string;
+                            };
+                            caption: {
+                                type: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: false;
+                    };
+                };
+                layout: {
+                    type: string;
+                };
+                columns: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+                aspectRatio: {
+                    type: string;
+                };
+                htmlAttributes: {
+                    type: string;
+                };
+                cssClass: {
+                    type: string;
+                };
+            };
+            additionalProperties: false;
+        };
+        placementContexts: ("region" | "inline")[];
+        clamps: {
+            maxItems: number;
+            timeoutMs: number;
+        };
+        resolverId: string;
+    };
+    gallery: {
+        typeKey: "gallery";
+        capability: "entry-reference";
+        configSchema: {
+            type: string;
+            "x-gallery-config": true;
+            properties: {
+                mode: {
+                    type: string;
+                };
+                html: {
+                    type: string;
+                };
+                htmlAttributes: {
+                    type: string;
+                };
+                cssClass: {
+                    type: string;
+                };
+                items: {
+                    type: string;
+                    maxItems: number;
+                    items: {
+                        type: string;
+                        properties: {
+                            slug: {
+                                type: string;
+                                'x-ref-target': string;
+                            };
+                            alt: {
+                                type: string;
+                            };
+                            caption: {
+                                type: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: false;
+                    };
+                };
+                images: {
+                    type: string;
+                    maxItems: number;
+                    items: {
+                        type: string;
+                        properties: {
+                            mediaId: {
+                                type: string;
+                                "x-ref-target": string;
+                            };
+                            alt: {
+                                type: string;
+                            };
+                            caption: {
+                                type: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: false;
+                    };
+                };
+                layout: {
+                    type: string;
+                    enum: string[];
+                };
+                columns: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+                aspectRatio: {
+                    type: string;
+                };
+            };
+            additionalProperties: false;
+        };
+        placementContexts: ("region" | "inline")[];
+        clamps: {
+            maxItems: number;
+            timeoutMs: number;
+        };
+        resolverId: string;
+    };
     text: {
         typeKey: "text";
         capability: "static";

package/dist/widgets/registry.js

@@ -134,7 +134,47 @@ const CONTACT_FORM_REGISTRATION = {
  * Iterate with `Object.values(...)` where the whole table is needed (e.g. `agent-tools.ts`'s
  * published-type-list).
  */
+/** Gallery owns no media lifecycle: its resolver adapts the existing gallery embed pipeline. */
+const GALLERY_REGISTRATION = {
+    typeKey: "gallery",
+    capability: "entry-reference",
+    configSchema: {
+        type: "object", "x-gallery-config": true,
+        properties: {
+            mode: { type: 'string' }, html: { type: 'string' }, htmlAttributes: { type: 'string' }, cssClass: { type: 'string' },
+            items: { type: 'array', maxItems: 50, items: { type: 'object', properties: {
+                        slug: { type: 'string', 'x-ref-target': 'asset' }, alt: { type: 'string' }, caption: { type: 'string' },
+                    }, required: ['slug'], additionalProperties: false } },
+            images: { type: "array", maxItems: 50, items: { type: "object", properties: {
+                        mediaId: { type: "string", "x-ref-target": "asset" }, alt: { type: "string" }, caption: { type: "string" },
+                    }, required: ["mediaId"], additionalProperties: false } },
+            layout: { type: "string", enum: ["grid", "carousel", "masonry"] },
+            columns: { type: "integer", minimum: 1, maximum: 6 },
+            aspectRatio: { type: "string" },
+        }, additionalProperties: false,
+    },
+    placementContexts: ["region", "inline"],
+    clamps: { maxItems: 50, timeoutMs: 10000 }, resolverId: "gallery",
+};
+/** Generic media content; Gallery is a compatibility preset over the same resolver lifecycle. */
+const MEDIA_REGISTRATION = {
+    typeKey: 'media', capability: 'entry-reference',
+    configSchema: {
+        type: 'object', 'x-gallery-config': true,
+        properties: {
+            mode: { type: 'string' }, html: { type: 'string' },
+            items: { type: 'array', maxItems: 50, items: { type: 'object', properties: {
+                        slug: { type: 'string', 'x-ref-target': 'asset' }, alt: { type: 'string' }, caption: { type: 'string' },
+                    }, required: ['slug'], additionalProperties: false } },
+            layout: { type: 'string' }, columns: { type: 'integer', minimum: 1, maximum: 6 },
+            aspectRatio: { type: 'string' }, htmlAttributes: { type: 'string' }, cssClass: { type: 'string' },
+        }, additionalProperties: false,
+    },
+    placementContexts: ['region', 'inline'], clamps: { maxItems: 50, timeoutMs: 10000 }, resolverId: 'gallery',
+};
 export const WIDGET_TYPE_REGISTRATIONS = {
+    media: MEDIA_REGISTRATION,
+    gallery: GALLERY_REGISTRATION,
     text: TEXT_REGISTRATION,
     "social-links": SOCIAL_LINKS_REGISTRATION,
     "recent-entries": RECENT_ENTRIES_REGISTRATION,

package/dist/widgets/resolver-service.d.ts

@@ -132,6 +132,12 @@ export interface ResolveHtmlPageEmbedsDeps extends WidgetInstanceResolutionDeps
     };
 }
 type HtmlEmbedResolver = (refs: readonly PageHtmlEmbedRef[], deps: ResolveHtmlPageEmbedsDeps, context: WidgetResolveContext) => Promise<ReadonlyMap<string, WidgetRenderIR>>;
+/** Gallery widget adapter over the same media owner used by gallery HTML embeds. */
+export declare function resolveGalleryWidgetMedia({ refs, deps, context }: {
+    refs: readonly PageHtmlEmbedRef[];
+    deps: ResolveHtmlPageEmbedsDeps;
+    context: WidgetResolveContext;
+}, _optional?: Record<string, never>): Promise<ReadonlyMap<string, WidgetRenderIR>>;
 /**
  * Registry of known embed types (SPEC-047, generalized 2026-08-07). Adding a new embed type is
  * registering one more entry here — no other file in `resolveHtmlPageEmbeds`'s call chain changes,
@@ -198,6 +204,10 @@ export declare const HTML_EMBED_RESOLVERS: Readonly<Record<string, HtmlEmbedReso
  *
  * `"featured-image"` (2026-10-05) joins for the identical reason: `static-render.ts`'s
  * `injectFeaturedImage` resolves it (see `FEATURED_IMAGE_MARKER_TYPE`, `core/embeds/marker.ts`).
+ *
+ * `"post-author"` (2026-10-11) joins for the identical reason: `static-render.ts`'s
+ * `injectPostAuthor` fills the byline. Without it this stage warned once per post render while the
+ * byline rendered correctly.
  */
 export declare const THEME_OWNED_MARKER_TYPES: ReadonlySet<string>;
 /**

package/dist/widgets/resolver-service.js

@@ -1,4 +1,6 @@
 import { isNonArrayRecord } from "@jini-ai/core";
+import { resolveGalleryEmbeds } from "./gallery-resolver.js";
+import { isPlausibleMediaRefId } from "./markers/media-reference.js";
 import { resolveTaxonomyEmbeds } from "./resolvers/taxonomy.js";
 import { parseWidgetAreaPayload, parseWidgetInstancePayload } from "./entry-payload.js";
 import { resolveWidgetType } from "./resolvers/index.js";
@@ -27,7 +29,7 @@ function collectWidgetEmbeds(root, out) {
         if (!isNonArrayRecord(candidate))
             continue;
         if (isNonArrayRecord(attrs) && typeof attrs.value.widgetEntryId === "string" && typeof attrs.value.placementId === "string") {
-            out.push({ placementId: attrs.value.placementId, widgetEntryId: attrs.value.widgetEntryId });
+            out.push({ placementId: attrs.value.placementId, widgetEntryId: attrs.value.widgetEntryId, ...(isNonArrayRecord({ value: attrs.value.content }) ? { content: attrs.value.content } : {}) });
         }
         if (Array.isArray(candidate.value.content))
             stack.push(candidate.value.content);
@@ -82,9 +84,19 @@ function groupWidgetInstancesByType(widgetRows, referencedIds) {
     }
     return byType;
 }
-async function resolveWidgetInstances(deps, workspaceId, referencedIds, context) {
+async function resolveWidgetInstances(deps, workspaceId, referencedIds, context, overrides = [], originalIds = referencedIds) {
     const widgetRows = referencedIds.size > 0 ? await deps.entryRepo.listByWorkspace({ workspaceId }, { type: WIDGET_CONTENT_TYPE }) : [];
-    const byType = groupWidgetInstancesByType(widgetRows, referencedIds);
+    const byType = groupWidgetInstancesByType(widgetRows, originalIds);
+    const rowsById = new Map(widgetRows.map(row => [row.id, row]));
+    for (const override of overrides) {
+        const row = rowsById.get(override.widgetEntryId);
+        const saved = row ? parseWidgetInstanceRow(row) : null;
+        if (!saved)
+            continue;
+        const instances = byType.get(saved.widgetType) ?? [];
+        instances.push({ ...saved, id: override.key, config: { ...saved.config, ...override.content } });
+        byType.set(saved.widgetType, instances);
+    }
     const resolvedById = new Map();
     for (const [typeKey, instances] of byType) {
         const results = await resolveWidgetType({ typeKey, instances, context });
@@ -154,21 +166,27 @@ export async function resolvePageWidgets(required, _optional = {}) {
     // handles them as "unresolved", not a crash), at most one `resolveWidgetType` call per distinct
     // type present (REQ-24) — see `resolveWidgetInstances`'s own doc for why this is shared rather
     // than inlined here.
-    const resolvedById = await resolveWidgetInstances(deps, input.workspaceId, referencedIds, context);
+    const allPlacements = [...inlineEmbeds, ...[...regionPlacements.values()].flat()];
+    const originalIds = new Set(allPlacements.filter(placement => !placement.content).map(placement => placement.widgetEntryId));
+    const resolvedById = await resolveWidgetInstances(deps, input.workspaceId, referencedIds, context, inlineContentOverrides(allPlacements), originalIds);
     // 6. Assemble region -> IR[] (missing/failed placements degrade to the REQ-28 placeholder).
     const regions = {};
     for (const [regionKey, placements] of regionPlacements) {
-        regions[regionKey] = placements.map((placement) => toRenderIr(resolvedById.get(placement.widgetEntryId)));
+        regions[regionKey] = placements.map((placement) => toRenderIr(resolvedById.get(placement.content ? placement.placementId : placement.widgetEntryId)));
     }
     // 7. Assemble placementId -> IR for inline embeds.
     return { regions, inlineResolved: assembleInlineResolved(inlineEmbeds, resolvedById) };
 }
+/** Placement config merges before asset resolution; a repeated widget never shares overridden IR. */
+function inlineContentOverrides(embeds) {
+    return embeds.flatMap(embed => embed.content ? [{ key: embed.placementId, widgetEntryId: embed.widgetEntryId, content: embed.content }] : []);
+}
 /** placementId -> IR for every inline embed; a missing/trashed/failed widget degrades to the REQ-28
  *  placeholder IR. Shared by {@link resolvePageWidgets} and {@link resolvePostContentWidgetContext}. */
 function assembleInlineResolved(inlineEmbeds, resolvedById) {
     const inlineResolved = new Map();
     for (const embed of inlineEmbeds) {
-        inlineResolved.set(embed.placementId, toRenderIr(resolvedById.get(embed.widgetEntryId)));
+        inlineResolved.set(embed.placementId, toRenderIr(resolvedById.get(embed.content ? embed.placementId : embed.widgetEntryId)));
     }
     return inlineResolved;
 }
@@ -270,8 +288,22 @@ async function resolveWidgetTypeEmbeds(refs, deps, context) {
     const slugRefs = refs.filter((ref) => ref.id === null && ref.slug !== null);
     const idBySlug = await resolveWidgetSlugsToIds(slugRefs, deps, context);
     const ids = collectWidgetIdsToLoad(refs, idBySlug, context);
-    const resolvedRaw = await resolveWidgetInstances(deps, context.workspaceId, ids, context);
-    return buildResolvedWidgetMap(refs, idBySlug, resolvedRaw);
+    const overrides = refs.flatMap(ref => {
+        const content = ref.config?.content;
+        const widgetEntryId = ref.id ?? (ref.slug ? idBySlug.get(ref.slug) : undefined);
+        return widgetEntryId && ref.placementKey && isNonArrayRecord({ value: content })
+            ? [{ key: ref.placementKey, widgetEntryId, content: content }] : [];
+    });
+    const originalIds = new Set(refs.filter(ref => !ref.placementKey).flatMap(ref => {
+        const id = ref.id ?? (ref.slug ? idBySlug.get(ref.slug) : undefined);
+        return id ? [id] : [];
+    }));
+    const resolvedRaw = await resolveWidgetInstances(deps, context.workspaceId, ids, context, overrides, originalIds);
+    const resolved = buildResolvedWidgetMap(refs, idBySlug, resolvedRaw);
+    for (const override of overrides)
+        if (resolvedRaw.has(override.key))
+            resolved.set(override.key, toRenderIr(resolvedRaw.get(override.key)));
+    return resolved;
 }
 /** A form slug/id is a synthetic contact-form instance, resolved through the widget pipeline. */
 async function resolveFormTypeEmbeds(refs, _deps, context) {
@@ -283,19 +315,6 @@ async function resolveFormTypeEmbeds(refs, _deps, context) {
     });
     return new Map(keys.map((key) => [key, toRenderIr(results.get(key))]));
 }
-/** Mirrors `render.ts`'s own `MAX_MEDIA_REF_ID_LENGTH`/`PLAUSIBLE_MEDIA_REF_ID_PATTERN` shape check
- * for an `assetId`/`transformName` that will eventually become a `/m/` URL path segment —
- * duplicated here rather than imported for the same reason `core/entry-refs/extractor.ts`
- * duplicates `html-embeds.ts`'s scan pattern instead of importing it: `widgets/` (this file) must
- * not depend on `server/http/site/render.ts`, which sits above it in this codebase's layering. Both
- * copies guard the SAME hazard — this copy stops a malformed id/name from being used as a
- * repo-lookup key at resolve time; `render.ts`'s copy (`renderWidgetMediaImage`) re-checks
- * defense-in-depth immediately before URL templating. */
-const MAX_MEDIA_REF_ID_LENGTH = 200;
-const PLAUSIBLE_MEDIA_REF_ID_PATTERN = /^[^\s/]+$/;
-function isPlausibleMediaRefId(value) {
-    return value.length > 0 && value.length <= MAX_MEDIA_REF_ID_LENGTH && PLAUSIBLE_MEDIA_REF_ID_PATTERN.test(value);
-}
 /** The IR's `slug` for a resolved asset: `null` means "has none" (`MediaAssetRenderMeta`'s own
  *  contract), and a pre-backfill row stores that as `""`, so an empty slug is normalized to `null`
  *  rather than passed through. Shared by every media IR builder in this file. */
@@ -318,7 +337,7 @@ function mediaIrSlug(record) {
 function parseMediaEmbedRef(ref, context, host) {
     const assetId = ref.id ?? ref.slug;
     const transformName = ref.variant ?? host.media.publicTransformName;
-    if (assetId === null || !isPlausibleMediaRefId(assetId) || !isPlausibleMediaRefId(transformName)) {
+    if (assetId === null || !isPlausibleMediaRefId({ value: assetId }) || !isPlausibleMediaRefId({ value: transformName })) {
         console.warn('[widgets] resolveHtmlPageEmbeds: unresolved "media" reference — missing or invalid "id"/"slug"/"variant" in data-embed-config', { workspaceId: context.workspaceId });
         return undefined;
     }
@@ -378,8 +397,10 @@ async function resolveOneMediaEmbed(ref, mediaRepo, transformRepo, mediaContentT
     // previously-rendered HTML — that used to be `record.id`'s whole reason for being the emitted
     // value; now it is `media_slug_history` (S2a/S2b) keeping the OLD slug resolving too.
     const { assetId: refAssetId, transformName } = parsed;
-    const record = await host.media.findMediaByIdOrSlug({ deps: { mediaRepo }, input: { workspaceId: context.workspaceId, idOrSlug: refAssetId } });
-    if (!record) {
+    const record = ref.id === null && ref.slug !== null
+        ? await mediaRepo.findBySlug({ workspaceId: context.workspaceId, slug: ref.slug })
+        : await host.media.findMediaByIdOrSlug({ deps: { mediaRepo }, input: { workspaceId: context.workspaceId, idOrSlug: refAssetId } });
+    if (!record || record.status !== "active") {
         console.warn('[widgets] resolveHtmlPageEmbeds: unresolved "media" reference — no such asset', {
             workspaceId: context.workspaceId,
             assetId: refAssetId,
@@ -390,8 +411,8 @@ async function resolveOneMediaEmbed(ref, mediaRepo, transformRepo, mediaContentT
     const contentType = mediaContentTypeStore
         ? (await mediaContentTypeStore.getMany({ workspaceId: context.workspaceId, sha256s: [record.source.sha256] })).get(record.source.sha256)
         : undefined;
-    if (contentType?.startsWith("video/")) {
-        // Video needs no transform lookup at all: `render.ts`'s video branch points straight at
+    if (contentType?.startsWith("video/") || contentType?.startsWith("audio/")) {
+        // Video/audio need no image transform lookup: the shared native-player renderer points at
         // `/m/{assetId}/original` (the byte-passthrough route — see that route's own doc for why
         // video can't go through the image-transform pipeline below), so `transformName`/`version`
         // would be unused props for this IR.
@@ -431,6 +452,10 @@ async function resolveMediaTypeEmbeds(refs, deps, context) {
     }
     return resolved;
 }
+/** Gallery widget adapter over the same media owner used by gallery HTML embeds. */
+export function resolveGalleryWidgetMedia({ refs, deps, context }, _optional = {}) {
+    return resolveMediaTypeEmbeds(refs, deps, context);
+}
 /** Scans a TipTap-shaped `bodyJson` tree for every ref-based `image`/`media` node's `assetId`
  *  (ADR-027 §4's `{assetId, transformName}` shape) — both the legacy image-only ref shape and the
  *  generic `media` node (2026-09-11, `render.ts`'s `renderDocMedia`'s own doc) share this collection,
@@ -586,7 +611,7 @@ async function resolvePostContentWidgetContext(deps, bodyJson, context) {
     if (inlineEmbeds.length === 0)
         return { inlineWidgets: {} };
     const referencedIds = new Set(inlineEmbeds.map((embed) => embed.widgetEntryId));
-    const resolvedById = await resolveWidgetInstances(deps, context.workspaceId, referencedIds, context);
+    const resolvedById = await resolveWidgetInstances(deps, context.workspaceId, referencedIds, context, inlineContentOverrides(inlineEmbeds), new Set(inlineEmbeds.filter(embed => !embed.content).map(embed => embed.widgetEntryId)));
     const inlineResolved = assembleInlineResolved(inlineEmbeds, resolvedById);
     return { inlineWidgets: Object.fromEntries(inlineResolved) };
 }
@@ -845,7 +870,22 @@ export const HTML_EMBED_RESOLVERS = {
     widget: resolveWidgetTypeEmbeds,
     form: resolveFormTypeEmbeds,
     taxonomy: (refs, deps) => resolveTaxonomyEmbeds({ refs, deps }),
-    media: resolveMediaTypeEmbeds,
+    media: async (refs, deps, context) => {
+        const inline = refs.filter(ref => ref.config?.content !== undefined || ref.config?.items !== undefined || ref.config?.html !== undefined);
+        const ordinary = refs.filter(ref => !inline.includes(ref));
+        const media = await resolveMediaTypeEmbeds(ordinary, deps, context);
+        const content = await resolveGalleryEmbeds({
+            refs: inline.map(ref => ({ ...ref, config: (ref.config?.content ?? ref.config) })),
+            resolveMedia: ({ refs }) => resolveMediaTypeEmbeds(refs, deps, context),
+        }, { reportIssue: ({ key, messages }) => console.warn('[widgets] unresolved media content', { key, messages }) });
+        return new Map([...media, ...content]);
+    },
+    gallery: (refs, deps, context) => resolveGalleryEmbeds({
+        refs,
+        resolveMedia: ({ refs: mediaRefs }) => resolveMediaTypeEmbeds(mediaRefs, deps, context),
+    }, {
+        reportIssue: ({ key, messages }) => console.warn('[widgets] unresolved gallery embed', { workspaceId: context.workspaceId, key, messages }),
+    }),
     post: resolvePostTypeEmbeds,
     content: resolveContentTypeEmbeds,
 };
@@ -898,8 +938,12 @@ export const HTML_EMBED_RESOLVERS = {
  *
  * `"featured-image"` (2026-10-05) joins for the identical reason: `static-render.ts`'s
  * `injectFeaturedImage` resolves it (see `FEATURED_IMAGE_MARKER_TYPE`, `core/embeds/marker.ts`).
+ *
+ * `"post-author"` (2026-10-11) joins for the identical reason: `static-render.ts`'s
+ * `injectPostAuthor` fills the byline. Without it this stage warned once per post render while the
+ * byline rendered correctly.
  */
-export const THEME_OWNED_MARKER_TYPES = new Set(["partial", "menu", "post-previews", "collection", "featured-image"]);
+export const THEME_OWNED_MARKER_TYPES = new Set(["partial", "menu", "post-previews", "collection", "featured-image", "post-author"]);
 /**
  * `isPageEmbedType` (the "does this stage OWN the marker type" question, with its own doc) lives in
  * the dependency-free `page-embed-types.ts` so `render.ts` and the theme render workers can ask it

package/dist/widgets/resolvers/create-core-resolvers.d.ts

@@ -2,6 +2,7 @@ import type { EntryDisplayListPort, EntryListExcludingTypesPort, CollectionListP
 import type { EntryListPort } from "../../entries/index.js";
 import type { NavMenuReadModel, ResolveTargetHrefFn } from "../../navigation/index.js";
 import type { WidgetResolver, WidgetTypeKey } from "../types.js";
+import { createGalleryWidgetResolver } from "./gallery.js";
 import { type ContentTypeLookup } from "./recent-entries.js";
 /**
  * @file Assembles the real, DI'd v1 dynamic resolvers against real infrastructure deps.
@@ -14,6 +15,8 @@ import { type ContentTypeLookup } from "./recent-entries.js";
  * test would otherwise need to construct.
  */
 export interface CoreResolverDeps {
+    /** Media remains host-owned. Older hosts degrade nonempty galleries until this port is wired. */
+    galleryMedia?: Parameters<typeof createGalleryWidgetResolver>[0]["resolveMedia"];
     menus: MenusPort;
     collectionList: CollectionListPort;
     resolveMenuTargetHref?: ResolveTargetHrefFn;

package/dist/widgets/resolvers/create-core-resolvers.js

@@ -1,8 +1,10 @@
+import { createGalleryWidgetResolver } from "./gallery.js";
 import { createContactFormResolver } from "./contact-form.js";
 import { createMenuResolver } from "./menu.js";
 import { createRecentEntriesResolver } from "./recent-entries.js";
 export function createCoreResolvers(deps, _optional = {}) {
     return {
+        gallery: createGalleryWidgetResolver({ resolveMedia: deps.galleryMedia ?? (async () => new Map()) }),
         "recent-entries": createRecentEntriesResolver({ collectionList: deps.collectionList, entryList: deps.entryList, contentTypes: deps.contentTypes }),
         menu: createMenuResolver({ menus: deps.menus, navMenuReadModel: deps.navMenuReadModel, ...(deps.resolveMenuTargetHref === undefined ? {} : { resolveTargetHref: deps.resolveMenuTargetHref }), publicOnly: true }),
         "contact-form": createContactFormResolver({ formDefinitionRepo: deps.formDefinitionRepo }),

package/dist/widgets/resolvers/gallery.d.ts

@@ -0,0 +1,12 @@
+import type { WidgetResolver } from '../types.js';
+import type { GalleryMediaResolver } from '../gallery-resolver.js';
+/** Adapt gallery widget instances to the existing embed resolver; one deduplicated media batch.
+ * Empty starter widgets render a note, while malformed stored configs degrade per instance.
+ * @complexity O(w*i) time/space, with i<=50 images and a shared 50-asset budget.
+ */
+export declare function createGalleryWidgetResolver({ resolveMedia }: {
+    resolveMedia: (required: Parameters<GalleryMediaResolver>[0] & {
+        context: Parameters<WidgetResolver['resolveMany']>[1];
+    }, optional?: Record<string, never>) => ReturnType<GalleryMediaResolver>;
+}, _optional?: Record<string, never>): WidgetResolver;
+//# sourceMappingURL=gallery.d.ts.map

package/dist/widgets/resolvers/gallery.js

@@ -0,0 +1,33 @@
+import { validateWidgetConfig } from '../config-validation.js';
+import { getWidgetTypeRegistration } from '../registry.js';
+import { resolveGalleryEmbeds } from '../gallery-resolver.js';
+import { galleryMediaReferences, parseGalleryConfig } from '../markers/gallery.js';
+/** Adapt gallery widget instances to the existing embed resolver; one deduplicated media batch.
+ * Empty starter widgets render a note, while malformed stored configs degrade per instance.
+ * @complexity O(w*i) time/space, with i<=50 images and a shared 50-asset budget.
+ */
+export function createGalleryWidgetResolver({ resolveMedia }, _optional = {}) {
+    return { async resolveMany(instances, context) {
+            const refs = [];
+            const results = new Map();
+            for (const instance of instances) {
+                const parsed = parseGalleryConfig({ config: instance.config }, { allowEmpty: true });
+                if (!parsed.config || !validateWidgetConfig({ schema: getWidgetTypeRegistration({ typeKey: instance.widgetType === 'media' ? 'media' : 'gallery' }).configSchema, config: instance.config }).valid) {
+                    results.set(instance.id, { ok: false, reason: 'resolver-error' });
+                    continue;
+                }
+                if (parsed.config.images.length === 0 && parsed.config.mode !== 'html') {
+                    results.set(instance.id, { ok: true, ir: { componentId: instance.widgetType === 'media' ? 'media' : 'gallery', props: { config: instance.config, media: {} } }, dependencyKeys: [instance.id] });
+                }
+                else
+                    refs.push({ type: instance.widgetType, id: instance.id, slug: null, name: null, variant: null, header: true, config: instance.config });
+            }
+            const resolved = await resolveGalleryEmbeds({ refs, resolveMedia: ({ refs }) => resolveMedia({ refs, context }) });
+            for (const ref of refs) {
+                const ir = resolved.get(ref.id);
+                results.set(ref.id, ir ? { ok: true, ir, dependencyKeys: [ref.id, ...galleryMediaReferences({ config: ref.config }).map(image => image.mediaId)] } : { ok: false, reason: 'resolver-error' });
+            }
+            return results;
+        } };
+}
+//# sourceMappingURL=gallery.js.map

package/dist/widgets/resolvers/index.d.ts

@@ -21,6 +21,7 @@
 import type { UUID } from "@jini-ai/core/primitives";
 import { type CoreResolverDeps } from "./create-core-resolvers.js";
 import type { WidgetInstanceView, WidgetResolveContext, WidgetResolveResult, WidgetResolver, WidgetTypeKey } from "../types.js";
+export { createGalleryWidgetResolver } from "./gallery.js";
 export { createRecentEntriesResolver } from "./recent-entries.js";
 export { createMenuResolver } from "./menu.js";
 export { createContactFormResolver } from "./contact-form.js";

package/dist/widgets/resolvers/index.js

@@ -6,6 +6,7 @@ import { createCoreResolvers } from "./create-core-resolvers.js";
 // isolation (2026-08-18 widgets/resolvers deep-import triage), so each factory is re-exported here
 // narrowly, one line per consumer:
 // `createRecentEntriesResolver` — `widgets/__tests__/unit/resolvers-recent-entries.unit.test.ts`.
+export { createGalleryWidgetResolver } from "./gallery.js";
 export { createRecentEntriesResolver } from "./recent-entries.js";
 // `createMenuResolver` — `widgets/__tests__/unit/resolvers-menu.unit.test.ts`.
 export { createMenuResolver } from "./menu.js";

package/dist/widgets/types.d.ts

@@ -47,7 +47,7 @@ export declare const WIDGET_AREA_FIELD_NAMESPACE: "widgets";
  * a bare `string` so a typo in a registration or a call site is a compile error,
  * not a runtime `unknown-type` surprise.
  */
-export type WidgetTypeKey = "text" | "social-links" | "recent-entries" | "menu" | "contact-form";
+export type WidgetTypeKey = "text" | "social-links" | "recent-entries" | "menu" | "contact-form" | "gallery" | "media";
 /**
  * A widget type's declared capability class (ADR-047 Debate Fold-In Amendment
  * 3). `static` types render validated config directly with no resolver;
@@ -121,6 +121,8 @@ export interface WidgetPlacementNode {
     readonly placementId: UUID;
     readonly widgetEntryId: UUID;
     readonly enabled: boolean;
+    /** Optional per-placement config overlay, resolved before media lookup. */
+    readonly content?: JsonObject;
 }
 /** The full region-composition document stored in a `widget_area` entry's `bodyJson`. */
 export interface WidgetAreaDoc {