@jini-ai/cms 0.5.4 → 0.5.6

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/resolvers/menu.d.ts

@@ -38,5 +38,13 @@ export interface MenuResolverDeps {
     /** Host routing injection; callers without it retain the diagnostic placeholder documented above. */
     resolveTargetHref?: ResolveTargetHrefFn;
 }
+/**
+ * Resolve menu widgets through navigation's read model: stored HTML or resolved items by doc mode.
+ * HTML is trusted and balanced by navigation's save path (`mergeMenuHtml`), like static menus;
+ * forwarding it adds no second parser or sanitization policy. Read failures propagate to dispatch.
+ * @param deps - Navigation read/resolution ports and host routing/public-filter policy.
+ * @returns A resolver producing mode-specific menu IR, or existing typed config/target failures.
+ * @complexity One read per instance; item resolution/filtering scales with the selected item trees.
+ */
 export declare function createMenuResolver(deps: MenuResolverDeps, _optional?: Record<string, never>): WidgetResolver;
 //# sourceMappingURL=menu.d.ts.map

package/dist/widgets/resolvers/menu.js

@@ -9,6 +9,14 @@ function toMenuItemProps(items, publicOnly) {
     }) : items;
     return visible;
 }
+/**
+ * Resolve menu widgets through navigation's read model: stored HTML or resolved items by doc mode.
+ * HTML is trusted and balanced by navigation's save path (`mergeMenuHtml`), like static menus;
+ * forwarding it adds no second parser or sanitization policy. Read failures propagate to dispatch.
+ * @param deps - Navigation read/resolution ports and host routing/public-filter policy.
+ * @returns A resolver producing mode-specific menu IR, or existing typed config/target failures.
+ * @complexity One read per instance; item resolution/filtering scales with the selected item trees.
+ */
 export function createMenuResolver(deps, _optional = {}) {
     const resolveTargetHref = deps.resolveTargetHref ?? DEFAULT_RESOLVE_TARGET_HREF;
     return {
@@ -25,14 +33,21 @@ export function createMenuResolver(deps, _optional = {}) {
                     results.set(instance.id, { ok: false, reason: "target-disabled" });
                     continue;
                 }
-                const items = await deps.menus.resolveMenuDoc({
-                    doc: menu.doc,
-                    context: { workspaceId: context.workspaceId },
-                    resolveTargetHref,
-                });
+                let props;
+                if (menu.doc.mode === "html") {
+                    props = { title: menu.title, mode: "html", html: menu.doc.html ?? "" };
+                }
+                else {
+                    const items = await deps.menus.resolveMenuDoc({
+                        doc: menu.doc,
+                        context: { workspaceId: context.workspaceId },
+                        resolveTargetHref,
+                    });
+                    props = { title: menu.title, items: toMenuItemProps(items, deps.publicOnly === true) };
+                }
                 results.set(instance.id, {
                     ok: true,
-                    ir: { componentId: "menu", props: { title: menu.title, items: toMenuItemProps(items, deps.publicOnly === true) } },
+                    ir: { componentId: "menu", props },
                     dependencyKeys: [menu.id],
                 });
             }

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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/cms",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Content-model capability for Jini-hosted products: framework-free contracts, ports, and domain services in `/core` and per-domain subpaths; Node-bound adapters in domain-specific subpaths.",
   "license": "Apache-2.0",
   "repository": {
@@ -16,6 +16,7 @@
       ".": "universal",
       "./core": "universal",
       "./navigation": "universal",
+      "./routing": "universal",
       "./media": "node",
       "./settings": "universal",
       "./workspace": "universal",
@@ -46,7 +47,12 @@
       "./widgets/markers": "universal",
       "./widgets/html": "node",
       "./widgets/resolvers": "universal",
-      "./widgets/sql": "node"
+      "./widgets/sql": "node",
+      "./consent": "universal",
+      "./consent/html": "node",
+      "./consent/express": "node",
+      "./consent/node": "node",
+      "./listing": "universal"
     },
     "isolation": {
       "domains": {
@@ -65,6 +71,9 @@
         "navigation": [
           "src/navigation"
         ],
+        "routing": [
+          "src/routing"
+        ],
         "presentation": [
           "src/presentation"
         ],
@@ -94,6 +103,12 @@
         ],
         "widgets": [
           "src/widgets"
+        ],
+        "consent": [
+          "src/consent"
+        ],
+        "listing": [
+          "src/listing"
         ]
       },
       "forbidden": {
@@ -134,6 +149,11 @@
       "import": "./dist/navigation/index.js",
       "default": "./dist/navigation/index.js"
     },
+    "./routing": {
+      "types": "./dist/routing/index.d.ts",
+      "import": "./dist/routing/index.js",
+      "default": "./dist/routing/index.js"
+    },
     "./media": {
       "types": "./dist/media/index.d.ts",
       "import": "./dist/media/index.js",
@@ -288,6 +308,31 @@
       "types": "./dist/widgets/sql/index.d.ts",
       "import": "./dist/widgets/sql/index.js",
       "default": "./dist/widgets/sql/index.js"
+    },
+    "./consent": {
+      "types": "./dist/consent/index.d.ts",
+      "import": "./dist/consent/index.js",
+      "default": "./dist/consent/index.js"
+    },
+    "./consent/html": {
+      "types": "./dist/consent/html/index.d.ts",
+      "import": "./dist/consent/html/index.js",
+      "default": "./dist/consent/html/index.js"
+    },
+    "./consent/express": {
+      "types": "./dist/consent/express/index.d.ts",
+      "import": "./dist/consent/express/index.js",
+      "default": "./dist/consent/express/index.js"
+    },
+    "./consent/node": {
+      "types": "./dist/consent/node/index.d.ts",
+      "import": "./dist/consent/node/index.js",
+      "default": "./dist/consent/node/index.js"
+    },
+    "./listing": {
+      "types": "./dist/listing/index.d.ts",
+      "import": "./dist/listing/index.js",
+      "default": "./dist/listing/index.js"
     }
   },
   "files": [
@@ -319,18 +364,18 @@
     "@types/better-sqlite3": "^7.6.13",
     "@electric-sql/pglite": "0.5.8",
     "jsdom": "^25.0.1",
-    "@jini-ai/core": "0.4.2",
     "@jini-ai/http-kit": "0.4.1",
-    "@jini-ai/db": "0.3.1"
+    "@jini-ai/db": "0.3.2",
+    "@jini-ai/core": "0.4.3"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.2"
+    "@jini-ai/core": "^0.4.3"
   },
   "peerDependencies": {
     "sharp": "^0.35.3",
     "express": "^4.21.0",
     "kysely": "^0.29.6",
-    "@jini-ai/db": "^0.3.0",
+    "@jini-ai/db": "^0.3.2",
     "parse5": "^7.3.0",
     "@jini-ai/http-kit": "^0.4.0"
   },

package/dist/http/settings/cms-adapter.d.ts

@@ -1,20 +0,0 @@
-import { type SettingsWriteServiceDeps, type SettingsRepoPort } from "../../settings/index.js";
-import type { SettingsService, SettingsPermissions, SettingsChangeFeed } from "./contracts.js";
-/** Keep the CMS write chokepoint while translating its permission vocabulary to host policy. */
-/** Bind the CMS ledger and write chokepoint without copying their domain logic.
- * Effective reads scan definitions and resolve each namespace key; mutations inherit CMS transactions/errors.
- * @complexity O(1) setup. Per operation: O(definitions + keys) reads, or O(batch size) writes.
- * @example createCmsSettingsService({ deps: cmsPorts, permissions });
- */
-export declare function createCmsSettingsService(required: {
-    deps: SettingsWriteServiceDeps;
-    permissions: SettingsPermissions;
-}): SettingsService;
-/** Adapt the ledger through CMS tenant/principal disclosure rules, returning names and cursors only.
- * @complexity O(1) setup; collect is O(page size), with namespace lookup per visible revision.
- * @example createCmsSettingsChangeFeed({ repo });
- */
-export declare function createCmsSettingsChangeFeed(required: {
-    repo: SettingsRepoPort;
-}): SettingsChangeFeed;
-//# sourceMappingURL=cms-adapter.d.ts.map

package/dist/http/settings/cms-adapter.js

@@ -1,124 +0,0 @@
-import { getEffective, resolveDefinition, set, clear, resetNamespace, registerDefinitions, NON_REGISTER_DEFINITION_OPS, parseNonRegisterDefinitionOp, collectChangedNamespaces, } from "../../settings/index.js";
-/** Keep the CMS write chokepoint while translating its permission vocabulary to host policy. */
-/** Bind the CMS ledger and write chokepoint without copying their domain logic.
- * Effective reads scan definitions and resolve each namespace key; mutations inherit CMS transactions/errors.
- * @complexity O(1) setup. Per operation: O(definitions + keys) reads, or O(batch size) writes.
- * @example createCmsSettingsService({ deps: cmsPorts, permissions });
- */
-export function createCmsSettingsService(required) {
-    const { deps: original, permissions } = required;
-    const permissionMap = new Map([
-        ["settings.definitions.manage", permissions.manageDefinitions],
-        ["settings.global.write", permissions.writeGlobal],
-        ["settings.workspace.write", permissions.writeWorkspace],
-        ["settings.user.self.write", permissions.writeUserSelf],
-        ["settings.user.write", permissions.writeUserOther],
-        ["settings.reset.global", permissions.reset.global],
-        ["settings.reset.workspace", permissions.reset.workspace],
-        ["settings.reset.user", permissions.reset.user],
-    ]);
-    const deps = { ...original,
-        authorize: (input) => {
-            const permission = permissionMap.get(input.permission);
-            if (permission === undefined)
-                return Promise.resolve({ allowed: false, reason: "unknown_settings_permission" });
-            return original.authorize({ ...input, permission });
-        },
-    };
-    const repo = deps.repo;
-    const listDefinitions = async ({ workspaceId }) => {
-        const [platform, workspace] = await Promise.all([
-            repo.listActiveDefinitions({ workspaceId: null }), repo.listActiveDefinitions({ workspaceId }),
-        ]);
-        return [...platform, ...workspace];
-    };
-    return {
-        listDefinitions,
-        effective: async ({ namespace, workspaceId, principalId }) => {
-            const defs = await listDefinitions({ workspaceId });
-            const keys = new Set(defs.filter((d) => d.namespace === namespace).map((d) => d.key));
-            const data = [];
-            for (const key of keys) {
-                const result = await getEffective({ repo }, { namespace, key, scopeContext: { workspaceId, principalId } });
-                if (result)
-                    data.push({ key, value: result.value, sourceLayer: result.sourceLayer, defVersion: result.defVersion });
-            }
-            return data;
-        },
-        raw: async ({ namespace, key, workspaceId, principalId }) => {
-            const definition = await resolveDefinition({ repo }, { namespace, key, workspaceId });
-            if (!definition)
-                return null;
-            const settingId = definition.settingId;
-            const records = await Promise.all([
-                repo.getGlobalValue(settingId), repo.getWorkspaceValue({ workspaceId, settingId }),
-                principalId ? repo.getUserValue({ workspaceId, principalId, settingId }) : Promise.resolve(null),
-            ]);
-            const values = records.map((r) => r?.state === "set" ? r.valueJson : null);
-            return { key: `${namespace}.${key}`, global: values[0], workspace: values[1], user: values[2], default: definition.defaultValue };
-        },
-        set: (input) => set({ deps, input }),
-        clear: (input) => clear({ deps, input }),
-        reset: async (input) => {
-            const definitions = await repo.listActiveDefinitions({ workspaceId: input.scope === "global" ? null : (input.workspaceId ?? input.authWorkspaceId ?? null) });
-            const keys = definitions.filter((d) => d.namespace === input.namespace).map((d) => d.key);
-            return resetNamespace({ deps, input }, keys);
-        },
-        definitions: ({ items, callerPrincipalId, authWorkspaceId }) => applyDefinitions({ deps, items, callerPrincipalId, authWorkspaceId }),
-    };
-}
-/** Preserve register batching and ordered non-register writes over existing CMS operation contracts.
- * Unknown operations return their name. Earlier non-register writes are not rolled back by later failures.
- * @complexity O(item count) time/space plus CMS effects; this batch is not atomic.
- */
-async function applyDefinitions(required) {
-    const { deps, items, callerPrincipalId, authWorkspaceId } = required;
-    const toRegister = [];
-    const applied = [];
-    for (const raw of items) {
-        const item = raw;
-        const op = String(item.op ?? "register");
-        const namespace = String(item.namespace ?? "");
-        const key = String(item.key ?? "");
-        const ownerKind = item.ownerKind;
-        const workspaceId = ownerKind === "site" ? authWorkspaceId : null;
-        const defaultValue = (item.defaultJson ?? null);
-        if (op === "register") {
-            toRegister.push({ namespace, key, ownerKind, workspaceId, schema: item.schemaJson,
-                defaultValue, scopes: Number(item.scopes), secret: Boolean(item.secret ?? false) });
-        }
-        else {
-            const parsedOp = parseNonRegisterDefinitionOp({ op });
-            if (!parsedOp)
-                return { unknownOp: op };
-            const opItem = { namespace, key, ownerKind, workspaceId, defaultJson: defaultValue,
-                ...(item.newNamespace === undefined ? {} : { newNamespace: item.newNamespace }),
-                ...(item.newKey === undefined ? {} : { newKey: item.newKey }),
-                ...(item.schemaJson === undefined ? {} : { schemaJson: item.schemaJson }),
-                ...(item.coercionJson === undefined ? {} : { coercionJson: item.coercionJson }),
-            };
-            await NON_REGISTER_DEFINITION_OPS[parsedOp]({ ctx: { deps, callerPrincipalId, authWorkspaceId }, item: opItem });
-        }
-        applied.push({ key: `${namespace}.${key}`, op, status: "applied" });
-    }
-    if (toRegister.length)
-        await registerDefinitions({ deps, input: { definitions: toRegister, callerPrincipalId, authWorkspaceId } });
-    return { applied };
-}
-/** Adapt the ledger through CMS tenant/principal disclosure rules, returning names and cursors only.
- * @complexity O(1) setup; collect is O(page size), with namespace lookup per visible revision.
- * @example createCmsSettingsChangeFeed({ repo });
- */
-export function createCmsSettingsChangeFeed(required) {
-    const { repo } = required;
-    return {
-        head: () => repo.maxRevisionSeq(),
-        collect: async ({ sinceSeq, limit, viewer }) => {
-            const revisions = await repo.listRevisionsSince({ sinceSeq, limit, workspaceId: viewer.workspaceId });
-            // Resolve afresh each batch: a rename must never leave a stale namespace cached forever.
-            const batch = await collectChangedNamespaces({ revisions, viewer, resolveNamespace: async ({ settingId }) => (await repo.findDefinitionBySettingId({ settingId }))?.namespace ?? null });
-            return { ...batch, examinedCount: revisions.length };
-        },
-    };
-}
-//# sourceMappingURL=cms-adapter.js.map