@jini-ai/cms 0.5.1 → 0.5.3

package/dist/widgets/resolvers/contact-form.d.ts

@@ -0,0 +1,26 @@
+import type { FormDefinitionReadPort } from "./ports.js";
+import type { WidgetResolver } from "../types.js";
+/**
+ * @file `contact-form` widget resolver (SPEC-043 REQ-36..39, ADR-047 Debate Fold-In Amendment 4).
+ *
+ * Purpose:
+ * A thin, READ-ONLY adapter over `src/forms/`'s definition read side. Imports ONLY the read-only
+ * `FormDefinitionRepoPort` type, through `forms/index.ts` (ADR-009 §1's barrel; the type is
+ * declared in `forms/ports.ts`) — never the Forms library's own submission write path or its
+ * outbox-driven mail-notification module — so this file can never persist a submission, send
+ * mail, rate-limit, or duplicate any part of the Forms pipeline (INV-08, hard invariant; verified
+ * by a code-review-level grep over this whole package for those two module names, which must
+ * return nothing).
+ *
+ * REQ-37 ("reads the referenced Forms definition's declared field vocabulary — never a hardcoded
+ * field-type list") is honored here: `definition.fields` (Forms' own `FieldDescriptor[]`) is passed
+ * through as IR props verbatim, not re-enumerated against a widget-local field-kind switch. The
+ * actual submission still posts to Forms' existing public route unmodified (REQ-37's second half) —
+ * that is a render-component/route concern, out of this resolver's scope (no HTTP route exists yet
+ * for widgets in this slice; see the implementation report's scope-boundary notes).
+ */
+export interface ContactFormResolverDeps {
+    formDefinitionRepo: FormDefinitionReadPort;
+}
+export declare function createContactFormResolver(deps: ContactFormResolverDeps, _optional?: {}): WidgetResolver;
+//# sourceMappingURL=contact-form.d.ts.map

package/dist/widgets/resolvers/contact-form.js

@@ -0,0 +1,54 @@
+export function createContactFormResolver(deps, _optional = {}) {
+    return {
+        async resolveMany(instances, context) {
+            const results = new Map();
+            for (const instance of instances) {
+                const formDefinitionId = typeof instance.config.formDefinitionId === "string" ? instance.config.formDefinitionId : undefined;
+                const formDefinitionRef = typeof instance.config.formDefinitionRef === "string" ? instance.config.formDefinitionRef : undefined;
+                if (!formDefinitionId && !formDefinitionRef) {
+                    results.set(instance.id, { ok: false, reason: "invalid-config" });
+                    continue;
+                }
+                const byId = await deps.formDefinitionRepo.findById({
+                    workspaceId: context.workspaceId,
+                    id: formDefinitionId ?? formDefinitionRef,
+                });
+                const definition = byId ?? (formDefinitionRef ? await deps.formDefinitionRepo.findBySlug({
+                    workspaceId: context.workspaceId, slug: formDefinitionRef,
+                }) : null);
+                // REQ-38/EC-05: a disabled, trashed (`findById` hides it) or purged definition is the same
+                // failure-isolation placeholder, never an error.
+                if (!definition || definition.status !== "active") {
+                    results.set(instance.id, { ok: false, reason: "target-disabled" });
+                    continue;
+                }
+                results.set(instance.id, {
+                    ok: true,
+                    ir: {
+                        componentId: "contact-form",
+                        props: {
+                            formDefinitionId: definition.id,
+                            // Closes this file's own previously-disclosed deferral ("the actual submission still
+                            // posts to Forms' existing public route unmodified... that is a render-component/route
+                            // concern, out of this resolver's scope") — the render component built for SPEC-043's
+                            // routes/UI slice (`server/http/site/render.ts`'s `renderWidgetContactForm`) needs the
+                            // definition's `slug` to build `POST /forms/:slug/submit`'s URL (REQ-37's second half).
+                            slug: definition.slug,
+                            // REQ-37: Forms' own declared field vocabulary, passed through verbatim — never a
+                            // hardcoded field-type list. Cast: FieldDescriptor[] has no index signature of its
+                            // own, but every field is plain JSON-serializable data (SPEC-010 forms/types.ts).
+                            fields: definition.fields,
+                            ...(definition.mode === "html" ? {
+                                mode: "html", html: definition.html ?? "",
+                            } : {}),
+                            successMessage: typeof instance.config.successMessage === "string" ? instance.config.successMessage : null,
+                        },
+                    },
+                    dependencyKeys: [definition.id],
+                });
+            }
+            return results;
+        },
+    };
+}
+//# sourceMappingURL=contact-form.js.map

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

@@ -0,0 +1,34 @@
+import type { EntryDisplayListPort, EntryListExcludingTypesPort, CollectionListPort, MenusPort, FormDefinitionReadPort } from "./ports.js";
+import type { EntryListPort } from "../../entries/index.js";
+import type { NavMenuReadModel, ResolveTargetHrefFn } from "../../navigation/index.js";
+import type { WidgetResolver, WidgetTypeKey } from "../types.js";
+import { type ContentTypeLookup } from "./recent-entries.js";
+/**
+ * @file Assembles the real, DI'd v1 dynamic resolvers against real infrastructure deps.
+ *
+ * Purpose:
+ * The one place that turns "real repo adapters" into "the closed `CORE_RESOLVERS` map"
+ * (`resolvers/index.ts`'s `wireCoreResolvers` calls this). Kept separate from `index.ts` itself so
+ * the dispatch module (`resolveWidgetType`, exercised by every test in this slice) has no
+ * import-time dependency on `features/entries`/`navigation`/`forms` deps that a pure dispatch unit
+ * test would otherwise need to construct.
+ */
+export interface CoreResolverDeps {
+    menus: MenusPort;
+    collectionList: CollectionListPort;
+    resolveMenuTargetHref?: ResolveTargetHrefFn;
+    /** Widened by collections plan R1 with `EntryDisplayListPort` — the `recent-entries` widget's
+     * "Collection list" mode shares `EntryDisplayListPort.listPublishedForDisplay` with the
+     * `{"type":"collection"}` marker (C2). Widened again by review fix 3b with
+     * `EntryListExcludingTypesPort`, the legacy (no-`collection`) path's query-level
+     * `SYSTEM_CONTENT_TYPES` exclusion. Both composition roots' real `entryRepo` already implements
+     * all three (`server/runtime/composition/{app,deps}.ts`'s `TrashAwareInMemoryEntryRepo`/`SqliteEntryRepo`). */
+    entryList: EntryListPort & EntryDisplayListPort & EntryListExcludingTypesPort;
+    navMenuReadModel: NavMenuReadModel;
+    formDefinitionRepo: FormDefinitionReadPort;
+    /** R1 addition — resolves a `collection` config's target content type. See `recent-entries.ts`'s
+     * `ContentTypeLookup` for why this is its own narrow port rather than `ContentTypeRepoPort`. */
+    contentTypes: ContentTypeLookup;
+}
+export declare function createCoreResolvers(deps: CoreResolverDeps, _optional?: Record<string, never>): Partial<Record<WidgetTypeKey, WidgetResolver>>;
+//# sourceMappingURL=create-core-resolvers.d.ts.map

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

@@ -0,0 +1,11 @@
+import { createContactFormResolver } from "./contact-form.js";
+import { createMenuResolver } from "./menu.js";
+import { createRecentEntriesResolver } from "./recent-entries.js";
+export function createCoreResolvers(deps, _optional = {}) {
+    return {
+        "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 }),
+    };
+}
+//# sourceMappingURL=create-core-resolvers.js.map

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

@@ -0,0 +1,65 @@
+/**
+ * @file `CORE_RESOLVERS` — the closed, core-owned resolver dispatch map (SPEC-043 REQ-08/09/10/23;
+ * ADR-047 Debate Fold-In Amendment 2/3).
+ *
+ * Purpose:
+ * The ONE place a registry's `resolverId` string resolves against real, executable code. A
+ * `WidgetTypeRegistration.resolverId` is never used as a dynamic import path, `eval`-style
+ * reference, or arbitrary function lookup anywhere else in this codebase (REQ-08) — this map is
+ * the sole allowlist. `resolveWidgetType` is the dispatcher every page render goes through
+ * (`resolver-service.ts`'s `resolvePageWidgets` calls this, once per distinct type present),
+ * and it owns the try/catch + timeout boundary so a resolver's exception or hang can never
+ * propagate past a widget's placement boundary (REQ-27, INV-05).
+ *
+ * Architectural role:
+ * TDD-certified implementation (implementation outline C-003). The dispatcher's failure-isolation
+ * contract is design-frozen from SPEC-043; `resolveWidgetType()` dispatches to the closed
+ * `CORE_RESOLVERS` map (or the static path for a resolver-less type), wrapping every call in the
+ * shared try/catch + timeout boundary so a resolver failure never propagates past REQ-27/INV-05.
+ * Verified against `__tests__/integration/resolver-service.integration.test.ts`.
+ */
+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 { createRecentEntriesResolver } from "./recent-entries.js";
+export { createMenuResolver } from "./menu.js";
+export { createContactFormResolver } from "./contact-form.js";
+/**
+ * The closed map. Adding a resolver = adding one entry here, never a dynamic import. Types with
+ * capability `static` (no `resolverId`) never appear here — `resolveWidgetType` takes the static
+ * path for those instead of consulting this map.
+ *
+ * Typed `Readonly<...>` so every ordinary caller gets a compile-time guarantee this map is never
+ * mutated ad hoc from outside `registerCoreResolver`/`wireCoreResolvers` — the certified test
+ * suite's direct-assignment test-double seam (`CORE_RESOLVERS["recent-entries"] = resolver`)
+ * deliberately overrides that guarantee with `@ts-expect-error`, since at runtime this is the same
+ * plain, mutable object `mutableResolvers` is (TypeScript's `readonly` has no runtime effect) —
+ * this is intentional, not a bug: it lets the test suite swap in failure-injecting test doubles
+ * without a second, parallel test-only export.
+ */
+export declare const CORE_RESOLVERS: Readonly<Partial<Record<WidgetTypeKey, WidgetResolver>>>;
+/** Registers (or replaces) one resolver in the closed map — the one typed, non-test way to populate it. */
+export declare function registerCoreResolver(required: {
+    typeKey: WidgetTypeKey;
+    resolver: WidgetResolver;
+}, _optional?: Record<string, never>): void;
+/**
+ * Assembles and registers every real, DI'd v1 dynamic resolver (`recent-entries`, `menu`,
+ * `contact-form` — see the sibling files in this directory) against the given infrastructure
+ * deps. Not called automatically at module load (these resolvers need injected repos that don't
+ * exist yet at pure import time — see each resolver factory's own doc) — a future boot-wiring
+ * pass (`server/app.ts`/`server/deps.ts`, out of this task's scope) is expected to call this once,
+ * with real adapters, before the app serves traffic. Left uncalled here is a disclosed gap, not an
+ * oversight — no test in this slice exercises real dynamic-resolver behavior (see
+ * `resolvers/{recent-entries,menu,contact-form}.ts`'s own file headers).
+ */
+export declare function wireCoreResolvers(deps: CoreResolverDeps, _optional?: Record<string, never>): void;
+export declare function resolveWidgetType(required: {
+    typeKey: WidgetTypeKey;
+    instances: readonly WidgetInstanceView[];
+    context: WidgetResolveContext;
+}, _optional?: Record<string, never>): Promise<ReadonlyMap<UUID, WidgetResolveResult>>;
+export * from "./ports.js";
+export { createCoreResolvers, type CoreResolverDeps } from "./create-core-resolvers.js";
+export { resolveTaxonomyEmbeds } from "./taxonomy.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/widgets/resolvers/index.js

@@ -0,0 +1,155 @@
+import { findWidgetTypeRegistration } from "../registry.js";
+import { createCoreResolvers } from "./create-core-resolvers.js";
+// `create-core-resolvers.ts` is the only production caller of the three factories below — they're
+// wired into `CORE_RESOLVERS` via `wireCoreResolvers`, never invoked directly outside this module.
+// Each also has its own dedicated unit/integration test exercising the resolver's own logic in
+// 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 { createRecentEntriesResolver } from "./recent-entries.js";
+// `createMenuResolver` — `widgets/__tests__/unit/resolvers-menu.unit.test.ts`.
+export { createMenuResolver } from "./menu.js";
+// `createContactFormResolver` — `widgets/__tests__/integration/resolve-html-page-embeds.integration.test.ts`.
+export { createContactFormResolver } from "./contact-form.js";
+/**
+ * The mutable backing store `CORE_RESOLVERS` (below) exposes only a readonly view over — see that
+ * export's own doc for why the map itself must stay assignable at runtime despite its readonly TS
+ * type (the certified test suite mutates it directly, via `@ts-expect-error`, as its test-double
+ * seam). `registerCoreResolver`/`wireCoreResolvers` are the two real, typed ways production code
+ * populates it; nothing else in this module writes to it.
+ */
+const mutableResolvers = {};
+/**
+ * The closed map. Adding a resolver = adding one entry here, never a dynamic import. Types with
+ * capability `static` (no `resolverId`) never appear here — `resolveWidgetType` takes the static
+ * path for those instead of consulting this map.
+ *
+ * Typed `Readonly<...>` so every ordinary caller gets a compile-time guarantee this map is never
+ * mutated ad hoc from outside `registerCoreResolver`/`wireCoreResolvers` — the certified test
+ * suite's direct-assignment test-double seam (`CORE_RESOLVERS["recent-entries"] = resolver`)
+ * deliberately overrides that guarantee with `@ts-expect-error`, since at runtime this is the same
+ * plain, mutable object `mutableResolvers` is (TypeScript's `readonly` has no runtime effect) —
+ * this is intentional, not a bug: it lets the test suite swap in failure-injecting test doubles
+ * without a second, parallel test-only export.
+ */
+export const CORE_RESOLVERS = mutableResolvers;
+/** Registers (or replaces) one resolver in the closed map — the one typed, non-test way to populate it. */
+export function registerCoreResolver(required, _optional = {}) {
+    mutableResolvers[required.typeKey] = required.resolver;
+}
+/**
+ * Assembles and registers every real, DI'd v1 dynamic resolver (`recent-entries`, `menu`,
+ * `contact-form` — see the sibling files in this directory) against the given infrastructure
+ * deps. Not called automatically at module load (these resolvers need injected repos that don't
+ * exist yet at pure import time — see each resolver factory's own doc) — a future boot-wiring
+ * pass (`server/app.ts`/`server/deps.ts`, out of this task's scope) is expected to call this once,
+ * with real adapters, before the app serves traffic. Left uncalled here is a disclosed gap, not an
+ * oversight — no test in this slice exercises real dynamic-resolver behavior (see
+ * `resolvers/{recent-entries,menu,contact-form}.ts`'s own file headers).
+ */
+export function wireCoreResolvers(deps, _optional = {}) {
+    for (const [typeKey, resolver] of Object.entries(createCoreResolvers(deps))) {
+        registerCoreResolver({ typeKey, resolver });
+    }
+}
+/** Converts a resolver exception/hang into a typed failure — never propagates (REQ-27, INV-05). */
+class ResolverTimeoutError extends Error {
+}
+async function withResolverTimeout(promise, timeoutMs) {
+    if (!timeoutMs || timeoutMs <= 0)
+        return promise;
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new ResolverTimeoutError(`resolver exceeded ${timeoutMs}ms`)), timeoutMs);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+/**
+ * REQ-25 — re-enforces a type's registered `maxItems` clamp at the orchestration layer,
+ * independent of the resolver's own discipline (defense in depth, not redundant — see
+ * `registry.ts`'s own doc on this point). Applies to any IR node carrying `children` (the shape a
+ * list-like resolved widget uses).
+ */
+function clampResolveResult(result, registration) {
+    if (!result.ok)
+        return result;
+    const maxItems = registration.clamps.maxItems;
+    if (maxItems === undefined || !result.ir.children || result.ir.children.length <= maxItems)
+        return result;
+    return { ...result, ir: { ...result.ir, children: result.ir.children.slice(0, maxItems) } };
+}
+/**
+ * Dispatches to `CORE_RESOLVERS[typeKey].resolveMany` (batch-first, REQ-24), or the static path
+ * (REQ-10) for a type with no registered resolver. Owns the sole try/catch + timeout wrapper
+ * around every resolver invocation (REQ-26/27) — never throws itself; every failure mode in
+ * REQ-27's closed taxonomy converts to a typed `{ ok: false, reason }` result per affected
+ * instance.
+ *
+ * @complexity O(1) dispatch plus whatever the resolver's own `resolveMany` costs (bounded by the
+ * registration's `timeoutMs` clamp).
+ * @overallScore 100
+ */
+/** Sets every instance to the same typed failure — the shared shape behind each "reject the whole batch" branch below. */
+function fillFailure(results, instances, reason) {
+    for (const instance of instances)
+        results.set(instance.id, { ok: false, reason });
+}
+/** REQ-10: static capability — validated config renders directly, no resolver invocation. */
+function fillStaticResults(results, instances, registration) {
+    for (const instance of instances) {
+        results.set(instance.id, {
+            ok: true,
+            ir: { componentId: registration.typeKey, props: instance.config },
+            dependencyKeys: [instance.id],
+        });
+    }
+}
+/** Invokes the resolver under the shared try/catch + timeout boundary (REQ-26/27) and fills `results` per instance. */
+async function fillResolverResults(results, resolver, instances, context, registration) {
+    try {
+        const resolved = await withResolverTimeout(resolver.resolveMany(instances, context), registration.clamps.timeoutMs);
+        for (const instance of instances) {
+            const result = resolved.get(instance.id);
+            results.set(instance.id, result ? clampResolveResult(result, registration) : { ok: false, reason: "resolver-error" });
+        }
+    }
+    catch (error) {
+        const reason = error instanceof ResolverTimeoutError ? "timeout" : "resolver-error";
+        fillFailure(results, instances, reason);
+    }
+}
+export async function resolveWidgetType(required, _optional = {}) {
+    const { typeKey, instances, context } = required;
+    const results = new Map();
+    if (instances.length === 0)
+        return results;
+    // `typeKey` is typed `WidgetTypeKey` but only ASSERTED to be one — it's grouped off stored
+    // widget-instance data (`resolver-service.ts`'s `payload.widgetType`, itself an
+    // `entry-payload.ts` cast over decoded JSON), so `findWidgetTypeRegistration` is the correct,
+    // honestly-partial accessor: `"unknown-type"` below is a real, reachable failure mode (REQ-27).
+    const registration = findWidgetTypeRegistration({ raw: typeKey });
+    if (!registration) {
+        fillFailure(results, instances, "unknown-type");
+        return results;
+    }
+    if (!registration.resolverId) {
+        fillStaticResults(results, instances, registration);
+        return results;
+    }
+    const resolver = CORE_RESOLVERS[registration.resolverId];
+    if (!resolver) {
+        fillFailure(results, instances, "resolver-error");
+        return results;
+    }
+    await fillResolverResults(results, resolver, instances, context, registration);
+    return results;
+}
+export * from "./ports.js";
+export { createCoreResolvers } from "./create-core-resolvers.js";
+export { resolveTaxonomyEmbeds } from "./taxonomy.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,42 @@
+import type { NavMenuReadModel, ResolveTargetHrefFn } from "../../navigation/index.js";
+import type { MenusPort } from "./ports.js";
+import type { WidgetResolver } from "../types.js";
+/**
+ * @file `menu` (menu-as-widget) resolver (SPEC-043 REQ-09, ADR-047 §1/§9 — "the primary menu as a
+ * widget in the footer region costs nothing new").
+ *
+ * Purpose:
+ * Delegates to `navigation`'s own read model — zero menu STORAGE logic duplicated in `widgets/`
+ * (`getMenu`, a real `NavMenuReadModel` call, not a reimplementation of `MenuRepoPort`) — and now
+ * also zero menu-HREF-RESOLUTION logic duplicated, via `navigation/resolver.ts`'s exported
+ * `resolveMenuDoc` (the doc-level building block `resolveForLocation` itself composes on top of).
+ * `resolveItemList`/`resolveItem` stay module-private in `navigation/resolver.ts`; `resolveMenuDoc`
+ * is the one exported entry point to their behavior, added specifically so this resolver would not
+ * need either an export-widening of those internals or a location-shaped call it doesn't have.
+ *
+ * Historical limitation (retained to explain the fallback): real href resolution for non-`url` targets (`entryRef`/`termRef`/
+ * `route`) needs `src/platform/routing` (ADR-039), which is being built in parallel and is not running code
+ * yet anywhere in this codebase — not even `navigation`'s own production callers have a real
+ * `ResolveTargetHrefFn` today (`resolveForLocation` takes it as an injected dependency precisely so
+ * a fake can stand in until routing lands, per `navigation/resolver.ts`'s own header). This resolver
+ * is in the same honest position as the rest of the system, not a special-cased worse one: `url`-kind
+ * targets (already-resolved hrefs, no injected dependency needed) now resolve to real, concrete
+ * `href`/`available`/`isActive` data; `entryRef`/`termRef`/`route` targets resolve to
+ * `available: false, href: null` via the placeholder `resolveTargetHref` below, exactly the outcome
+ * `navigation/resolver.ts`'s own doc describes for "cannot resolve" — swap the placeholder for the
+ * real routing-backed implementation in one place (`DEFAULT_RESOLVE_TARGET_HREF` below) once
+ * `src/platform/routing` ships; no other change needed here.
+ * 2026-10-04: runtime roots now inject the routing-backed page/entry resolver. The default remains
+ * useful for diagnostics; public widget assembly omits unavailable leaves while retaining parents
+ * that still contain visible descendants, matching the static menu's availability contract.
+ */
+export interface MenuResolverDeps {
+    menus: MenusPort;
+    navMenuReadModel: NavMenuReadModel;
+    /** Public widgets omit unavailable leaves; diagnostics may retain the complete resolved tree. */
+    publicOnly?: boolean;
+    /** Host routing injection; callers without it retain the diagnostic placeholder documented above. */
+    resolveTargetHref?: ResolveTargetHrefFn;
+}
+export declare function createMenuResolver(deps: MenuResolverDeps, _optional?: Record<string, never>): WidgetResolver;
+//# sourceMappingURL=menu.d.ts.map

package/dist/widgets/resolvers/menu.js

@@ -0,0 +1,43 @@
+/** Before host routing was wired every non-URL target was unresolved; retain that safe null fallback. */
+const DEFAULT_RESOLVE_TARGET_HREF = async () => null;
+function toMenuItemProps(items, publicOnly) {
+    // Cast: ResolvedNavItem is a plain, JSON-serializable read model (navigation/types.ts) with no
+    // index signature of its own — the resolved IR contract only requires structural JSON-compatibility.
+    const visible = publicOnly ? items.flatMap((item) => {
+        const children = toMenuItemProps(item.children, true);
+        return item.available || children.length ? [{ ...item, children }] : [];
+    }) : items;
+    return visible;
+}
+export function createMenuResolver(deps, _optional = {}) {
+    const resolveTargetHref = deps.resolveTargetHref ?? DEFAULT_RESOLVE_TARGET_HREF;
+    return {
+        async resolveMany(instances, context) {
+            const results = new Map();
+            for (const instance of instances) {
+                const menuRef = typeof instance.config.menuRef === "string" ? instance.config.menuRef : undefined;
+                if (!menuRef) {
+                    results.set(instance.id, { ok: false, reason: "invalid-config" });
+                    continue;
+                }
+                const menu = await deps.navMenuReadModel.getMenu({ workspaceId: context.workspaceId, menuId: menuRef });
+                if (!menu) {
+                    results.set(instance.id, { ok: false, reason: "target-disabled" });
+                    continue;
+                }
+                const items = await deps.menus.resolveMenuDoc({
+                    doc: menu.doc,
+                    context: { workspaceId: context.workspaceId },
+                    resolveTargetHref,
+                });
+                results.set(instance.id, {
+                    ok: true,
+                    ir: { componentId: "menu", props: { title: menu.title, items: toMenuItemProps(items, deps.publicOnly === true) } },
+                    dependencyKeys: [menu.id],
+                });
+            }
+            return results;
+        },
+    };
+}
+//# sourceMappingURL=menu.js.map

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

@@ -0,0 +1,82 @@
+import type { ContentTypeFieldDef, ContentTypeRecord } from "../../content-types/index.js";
+import type { EntryRecord, EntryStatus } from "../../entries/index.js";
+import type { resolveMenuDoc } from "../../navigation/index.js";
+/** The host's navigation resolver, retained as its owning function's type. */
+export interface MenusPort {
+    resolveMenuDoc: typeof resolveMenuDoc;
+}
+export type CollectionListLayout = "cards" | "list" | "accordion" | "carousel";
+export interface CollectionListQuery {
+    readonly type: string;
+    readonly where: readonly {
+        readonly field: string;
+        readonly value: string | number | boolean;
+    }[];
+    readonly sort: {
+        readonly by: "published" | "updated" | "title" | {
+            readonly field: string;
+        };
+        readonly dir: "asc" | "desc";
+    };
+    readonly limit: number;
+}
+export interface EntryDisplayListPort {
+    listPublishedForDisplay(required: {
+        readonly workspaceId: string;
+        readonly query: CollectionListQuery;
+    }): Promise<EntryRecord[]>;
+}
+export interface EntryListExcludingTypesPort {
+    listByWorkspaceExcludingTypes(required: {
+        readonly workspaceId: string;
+        readonly excludeTypes: readonly string[];
+        readonly status?: EntryStatus;
+        readonly orderBy?: "updatedAt";
+        readonly orderDirection?: "asc" | "desc";
+        readonly limit?: number;
+    }): Promise<EntryRecord[]>;
+}
+/** Collection parsing, routing and display policy remain with the host's existing public-list owner. */
+export interface CollectionListPort {
+    parseCollectionListConfig(config: unknown, contentType: ContentTypeRecord, options?: {
+        readonly defaultSort?: string;
+        readonly limitKey?: string;
+    }): {
+        readonly ok: false;
+        readonly reason: string;
+    } | {
+        readonly ok: true;
+        readonly query: CollectionListQuery;
+        readonly display: {
+            readonly columns: number;
+            readonly layout: CollectionListLayout;
+            readonly fields: readonly ContentTypeFieldDef[];
+            readonly structuredData?: "faq-page";
+        };
+    };
+    entryPublicHref(type: string, slug: string): string | null;
+    humanizeFieldName(name: string): string;
+    isCollectionListLayout(value: unknown): value is CollectionListLayout;
+    readonly systemContentTypes: readonly string[];
+}
+/** Definitions are opaque read snapshots. Submission and notification behavior stays with Forms. */
+export interface FormDefinitionView {
+    readonly id: string;
+    readonly slug: string;
+    readonly status: string;
+    readonly fields: readonly unknown[];
+    readonly mode?: string;
+    readonly html?: string | null;
+}
+/** Both lookup methods are used by today's resolver (id first, then authored slug). */
+export interface FormDefinitionReadPort {
+    findById(required: {
+        workspaceId: string;
+        id: string;
+    }): Promise<FormDefinitionView | null>;
+    findBySlug(required: {
+        workspaceId: string;
+        slug: string;
+    }): Promise<FormDefinitionView | null>;
+}
+//# sourceMappingURL=ports.d.ts.map

package/dist/widgets/resolvers/ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ports.js.map

package/dist/widgets/resolvers/recent-entries.d.ts

@@ -0,0 +1,71 @@
+import type { ContentTypeRecord } from "../../content-types/index.js";
+import type { CollectionListPort, EntryDisplayListPort, EntryListExcludingTypesPort } from "./ports.js";
+import type { EntryListPort } from "../../entries/index.js";
+import type { WidgetResolver } from "../types.js";
+/**
+ * @file `recent-entries` widget resolver (SPEC-043 REQ-25, ADR-047 §9) — extended by the
+ * collections plan (R1, 2026-09-23) into "Collection list": the same widget type now ALSO accepts
+ * `collection`/`where`/`sort`/`fields`/`layout`/`columns`, reusing C1's `parseCollectionListConfig`
+ * parser and C2's `EntryDisplayListPort.listPublishedForDisplay` query — the exact parser/query the
+ * `{"type":"collection"}` marker already uses (`pages.ts`'s `resolveOneCollectionMarker`), not a
+ * second implementation of either.
+ *
+ * Two independent per-instance paths, split by whether `config.collection` names a content type:
+ *
+ * - **No `collection` (D7, the historical/default shape):** unchanged from before this plan —
+ *   ONE shared bounded query for the whole batch (`status: 'published'`, `orderBy: 'updatedAt'
+ *   desc`, `limit: registryMax` — REQ-24/REQ-25, fixed 2026-07-21), across every content type
+ *   except `SYSTEM_CONTENT_TYPES` (D8) — `widget`/`widget_area`/nav-menu entries were never meant
+ *   to appear in a "recent entries" feed. That exclusion runs `EntryListExcludingTypesPort.
+ *   listByWorkspaceExcludingTypes` (review fix 3b, `public-list.ts`) INSIDE the query, not as an
+ *   in-memory filter on an already limit-bounded `listByWorkspace` result — the earlier
+ *   filter-after-limit shape could return fewer entries than asked for, or none, whenever
+ *   `registryMax` system rows were newer than the real content. Nothing else about this path's
+ *   ordering changed. `layout`/`columns` are still read from the
+ *   instance's own config (new, additive keys — an old config never set them, so they fall back to
+ *   `"list"`/`3`, byte-identical to before), but `where`/`sort`/`fields` don't apply — there is no
+ *   single content type here to validate field names against.
+ * - **`collection` set:** `parseCollectionListConfig` validates the config against that content
+ *   type's declared fields and clamps `limit`/`columns`; `listPublishedForDisplay` runs the bounded,
+ *   filtered, sorted query. `limitKey: "maxItems"` and `defaultSort: "updated"` are this widget's own
+ *   legacy aliases (D7) — same parser, different defaults than the marker's `"newest"`/`limit`. The
+ *   registered clamp is re-applied on top of the parser's own bound (REQ-25 defense in depth: the
+ *   parser's own ceiling is 24, wider than this registration's 20).
+ *
+ * Both paths produce the SAME per-item IR shape (`{title, href, dateIso, dateLabel, fields}`,
+ * mirroring `entry-list-render.ts`'s `EntryListItem`) under the NEW `"entry-list-item"` componentId
+ * — deliberately not the old `"entry-summary"` id (still real, still dispatched, kept for its own
+ * `render.test.ts` open-redirect regression — see that file — but no longer emitted by this
+ * resolver, so a stray recursive dispatch on these children fails loudly as an unknown component
+ * rather than silently mis-rendering the new shape through the old one). `render.ts`'s
+ * `renderWidgetRecentEntries` reads these children directly and calls C3's `renderEntryList` for
+ * `"cards"` layout.
+ *
+ * `href` is always `null` today (D1 seam, `entryPublicHref`) — entry pages are off. This is also the
+ * fix for the previously-broken `href="/<slug>"` link (`entry-summary`'s own `renderWidgetEntrySummary`
+ * built it and it 404s): a `null` href renders the title as plain text (`render.ts`), never a dead
+ * link.
+ *
+ * `categoryTermId` (REQ-32/EC-03) remains a documented soft reference — this resolver does not
+ * filter by it (no taxonomy dependency wired here), matching EC-03's explicit "may render as if the
+ * filter is empty/unset" allowance.
+ */
+/**
+ * The narrow read port this resolver needs to look up a `collection` config's target content type —
+ * `findByKey` only, not `ContentTypeRepoPort`'s full write/transaction surface (port segregation,
+ * same shape-discipline as `EntryDisplayListPort` itself). Both composition roots' real
+ * `contentTypeRepo` (`InMemoryContentTypeRepo`/`SqliteContentTypeRepo`) satisfy this structurally.
+ */
+export interface ContentTypeLookup {
+    findByKey(params: {
+        workspaceId: string;
+        key: string;
+    }): Promise<ContentTypeRecord | null>;
+}
+export interface RecentEntriesResolverDeps {
+    collectionList: CollectionListPort;
+    entryList: EntryListPort & EntryDisplayListPort & EntryListExcludingTypesPort;
+    contentTypes: ContentTypeLookup;
+}
+export declare function createRecentEntriesResolver(deps: RecentEntriesResolverDeps, _optional?: Record<string, never>): WidgetResolver;
+//# sourceMappingURL=recent-entries.d.ts.map