@jini-ai/cms 0.3.11 → 0.4.0

package/dist/entries/agent-tools.js

@@ -30,22 +30,22 @@
  *
  * Deliberate absences (the point of a catalog, not an oversight):
  * - There is no delete/purge tool: `write-service.ts` exposes no delete function at all (confirmed
- *   by reading the whole file) — there is nothing to wrap or exclude on that front.
+ * by reading the whole file) — there is nothing to wrap or exclude on that front.
  * - `collections_entry_update`'s schema omits `bodyJson` even though `updateEntry` itself accepts an
- *   optional `bodyJson` (REQ-44/45, used internally by `widgets/embed-service.ts`'s own guardrailed
- *   mutation path). The generic Collections admin route (`entries/update.ts`) never forwards
- *   `body.bodyJson` at all — only `title`/`fieldsJson`/`expectedVersion` — so exposing it here would
- *   invent capability beyond what the human admin UI's own Collections editor exposes. Omitting it
- *   from the input is enough: `updateEntry` leaves `bodyJson` unchanged whenever the field is
- *   `undefined`, so this exclusion changes nothing about what a call can still do.
+ * optional `bodyJson` (used internally by `widgets/embed-service.ts`'s own guardrailed
+ * mutation path). The generic Collections admin route (`entries/update.ts`) never forwards
+ * `body.bodyJson` at all — only `title`/`fieldsJson`/`expectedVersion` — so exposing it here would
+ * invent capability beyond what the human admin UI's own Collections editor exposes. Omitting it
+ * from the input is enough: `updateEntry` leaves `bodyJson` unchanged whenever the field is
+ * `undefined`, so this exclusion changes nothing about what a call can still do.
  * - `collections_entry_list`'s schema omits `status`/`orderBy`/`limit` even though
- *   `EntryListPort.listByWorkspace` supports all three (added for `widgets/resolvers/recent-entries.ts`'s
- *   own bounded-query need) — `server/routes/admin/entries/list.ts` only ever forwards `type` from
- *   its query string, so the other three are not part of what the Collections admin list screen
- *   itself can do; adding them here would again exceed the human surface this catalog mirrors.
+ * `EntryListPort.listByWorkspace` supports all three (added for `widgets/resolvers/recent-entries.ts`'s
+ * own bounded-query need) — `server/routes/admin/entries/list.ts` only ever forwards `type` from
+ * its query string, so the other three are not part of what the Collections admin list screen
+ * itself can do; adding them here would again exceed the human surface this catalog mirrors.
  *
  * What IS included, and why it is safe: all four write-service functions are `admin.collections.*`
- * self-enforcing (each opens with its own `deps.authorize()` call before any other side effect —
+ * self-enforcing (each opens with its own `deps.authorize` call before any other side effect —
  * confirmed by reading `write-service.ts` directly), and `publishEntry`/`unpublishEntry` are ordinary,
  * fully reversible status flips with a full revision trail (`entryRepo.appendRevision`) — publishing
  * and unpublishing are each other's own undo.
@@ -55,7 +55,13 @@
  *
  * Architectural role:
  * `features/entries` domain declaration. No dependencies.
- */
+ * See docs/decisions/DR-002-content-lifecycle-and-cleanup.md.
+ *
+ *
+   * JSON Schema for this tool's `input`, published to the model via `ToolDescriptor.inputSchema`
+   * (`@jini-ai/core`'s `registration-kit.ts`'s `buildDomainRegistrations`, which refuses to wire any
+   * tool lacking one).
+   */
 const ENTRY_ID_SCHEMA = {
     type: "string",
     minLength: 1,

package/dist/entries/errors.d.ts

@@ -9,35 +9,49 @@
  * `features/entries` domain logic. No dependencies.
  */
 export declare class ForbiddenError extends Error {
-    constructor(message: string);
+    constructor({ message }: {
+        message: string;
+    }, _optional?: Record<string, never>);
 }
 export declare class EntryNotFoundError extends Error {
-    constructor(message: string);
+    constructor(requiredArgs: {
+        message: string;
+    }, optionalArgs?: Record<string, never>);
 }
-/** REQ-29/AC-29 — the owning content type does not exist, or (INV-01) exists only in a different workspace. */
+/** — the owning content type does not exist, or exists only in a different workspace. See docs/decisions/DR-002-content-lifecycle-and-cleanup.md. */
 export declare class ContentTypeNotFoundError extends Error {
-    constructor(message: string);
+    constructor(requiredArgs: {
+        message: string;
+    }, optionalArgs?: Record<string, never>);
 }
-/** REQ-10 (create) / REQ-28 (update/publish/unpublish) — the owning content type's status forbids this write. */
+/** (create) / (update/publish/unpublish) — the owning content type's status forbids this write. See docs/decisions/DR-002-content-lifecycle-and-cleanup.md. */
 export declare class ContentTypeNotActiveError extends Error {
-    constructor(message: string);
+    constructor(requiredArgs: {
+        message: string;
+    }, optionalArgs?: Record<string, never>);
 }
-/** AC-21 — a second entry submitted with an identical `(workspaceId, type, slug)`. */
+/** — a second entry submitted with an identical `(workspaceId, type, slug)`. See docs/decisions/DR-002-content-lifecycle-and-cleanup.md. */
 export declare class EntrySlugConflictError extends Error {
-    constructor(message: string);
+    constructor(requiredArgs: {
+        message: string;
+    }, optionalArgs?: Record<string, never>);
 }
 export declare class VersionConflictError extends Error {
-    constructor(message: string);
+    constructor(requiredArgs: {
+        message: string;
+    }, optionalArgs?: Record<string, never>);
 }
-/** REQ-14/15 — `fieldsJson` failed `validateFieldsAgainstSchema` against the owning type's current schema. */
+/** — `fieldsJson` failed `validateFieldsAgainstSchema` against the owning type's current schema. See docs/decisions/DR-002-content-lifecycle-and-cleanup.md. */
 export declare class EntryFieldValidationError extends Error {
     readonly fieldErrors: Array<{
         field: string;
         reason: string;
     }>;
-    constructor(fieldErrors: Array<{
-        field: string;
-        reason: string;
-    }>);
+    constructor(requiredArgs: {
+        fieldErrors: Array<{
+            field: string;
+            reason: string;
+        }>;
+    }, optionalArgs?: Record<string, never>);
 }
 //# sourceMappingURL=errors.d.ts.map

package/dist/entries/errors.js

@@ -9,48 +9,54 @@
  * `features/entries` domain logic. No dependencies.
  */
 export class ForbiddenError extends Error {
-    constructor(message) {
+    constructor({ message }, _optional = {}) {
         super(message);
         this.name = "ForbiddenError";
     }
 }
 export class EntryNotFoundError extends Error {
-    constructor(message) {
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { message } = requiredArgs;
         super(message);
         this.name = "ENTRY_NOT_FOUND";
     }
 }
-/** REQ-29/AC-29 — the owning content type does not exist, or (INV-01) exists only in a different workspace. */
+/** — the owning content type does not exist, or exists only in a different workspace. See docs/decisions/DR-002-content-lifecycle-and-cleanup.md. */
 export class ContentTypeNotFoundError extends Error {
-    constructor(message) {
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { message } = requiredArgs;
         super(message);
         this.name = "CONTENT_TYPE_NOT_FOUND";
     }
 }
-/** REQ-10 (create) / REQ-28 (update/publish/unpublish) — the owning content type's status forbids this write. */
+/** (create) / (update/publish/unpublish) — the owning content type's status forbids this write. See docs/decisions/DR-002-content-lifecycle-and-cleanup.md. */
 export class ContentTypeNotActiveError extends Error {
-    constructor(message) {
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { message } = requiredArgs;
         super(message);
         this.name = "ContentTypeNotActiveError";
     }
 }
-/** AC-21 — a second entry submitted with an identical `(workspaceId, type, slug)`. */
+/** — a second entry submitted with an identical `(workspaceId, type, slug)`. See docs/decisions/DR-002-content-lifecycle-and-cleanup.md. */
 export class EntrySlugConflictError extends Error {
-    constructor(message) {
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { message } = requiredArgs;
         super(message);
         this.name = "ENTRY_SLUG_CONFLICT";
     }
 }
 export class VersionConflictError extends Error {
-    constructor(message) {
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { message } = requiredArgs;
         super(message);
         this.name = "VersionConflictError";
     }
 }
-/** REQ-14/15 — `fieldsJson` failed `validateFieldsAgainstSchema` against the owning type's current schema. */
+/** — `fieldsJson` failed `validateFieldsAgainstSchema` against the owning type's current schema. See docs/decisions/DR-002-content-lifecycle-and-cleanup.md. */
 export class EntryFieldValidationError extends Error {
     fieldErrors;
-    constructor(fieldErrors) {
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { fieldErrors } = requiredArgs;
         super(`fieldsJson failed schema validation: ${fieldErrors.map((e) => `${e.field}: ${e.reason}`).join("; ")}`);
         this.name = "EntryFieldValidationError";
         this.fieldErrors = fieldErrors;

package/dist/entries/field-validation.d.ts

@@ -37,16 +37,18 @@ export interface ValidateFieldsResult {
     fieldErrors: FieldValidationError[];
 }
 /**
- * REQ-14/15 — validates a candidate `fieldsJson` payload against a content type's current field
- * schema: envelope shape first (AC-50), then per-key unrecognized-field rejection (AC-22) and
- * kind-conformance (AC-49), then a required-field-missing pass (AC-23).
+ * — validates a candidate `fieldsJson` payload against a content type's current field
+ * schema: envelope shape first, then per-key unrecognized-field rejection and
+ * kind-conformance, then a required-field-missing pass.
  *
  * @complexity O(f) in the number of schema fields plus O(k) in the number of submitted keys.
  * @overallScore 100
+ * See docs/decisions/DR-002-content-lifecycle-and-cleanup.md.
  */
 export declare function validateFieldsAgainstSchema(required: {
     schema: ContentTypeFieldDef[];
     fieldsJson: unknown;
+}, optional?: {
     /** The `ext` sub-key this content type's fields live under. Defaults to `"site"` — every existing caller keeps identical behavior unless it opts into a different owner namespace. */
     owner?: string | undefined;
 }): ValidateFieldsResult;

package/dist/entries/field-validation.js

@@ -120,15 +120,17 @@ function conformsToKind(value, kind) {
     }
 }
 /**
- * REQ-14/15 — validates a candidate `fieldsJson` payload against a content type's current field
- * schema: envelope shape first (AC-50), then per-key unrecognized-field rejection (AC-22) and
- * kind-conformance (AC-49), then a required-field-missing pass (AC-23).
+ * — validates a candidate `fieldsJson` payload against a content type's current field
+ * schema: envelope shape first, then per-key unrecognized-field rejection and
+ * kind-conformance, then a required-field-missing pass.
  *
  * @complexity O(f) in the number of schema fields plus O(k) in the number of submitted keys.
  * @overallScore 100
+ * See docs/decisions/DR-002-content-lifecycle-and-cleanup.md.
  */
-export function validateFieldsAgainstSchema(required) {
-    const { schema, fieldsJson, owner = "site" } = required;
+export function validateFieldsAgainstSchema(required, optional = {}) {
+    const { schema, fieldsJson } = required;
+    const { owner = "site" } = optional;
     const ext = isPlainObject(fieldsJson) ? fieldsJson.ext : undefined;
     const ownerBag = isPlainObject(ext) ? ext[owner] : undefined;
     if (!isPlainObject(fieldsJson) || !isPlainObject(ext) || !isPlainObject(ownerBag)) {

package/dist/entries/index.d.ts

@@ -10,7 +10,7 @@
  * them is type-only and one-directional, and keeping the entry points separate is what makes that
  * checkable rather than merely intended.
  */
-export type { EntryStatus, EntryFieldsJson, EntryRecord, OwningContentType, ActorIdentityInput, Result, } from "./types.js";
+export type { EntryStatus, EntryFieldsJson, EntryRecord, OwningContentType, ActorIdentityInput, } from "./types.js";
 export type { EntryListPort } from "./list.js";
 export { listEntries } from "./list.js";
 export type { FieldValidationError, ValidateFieldsResult, } from "./field-validation.js";
@@ -37,7 +37,7 @@ export { createEntry, updateEntry, publishEntry, unpublishEntry, importEntry } f
  */
 export { InMemoryEntryRepo, toEntryOutbox } from "./repo.memory.js";
 /** The agent-tool surface for this domain (see `agent-tools.ts` for what is deliberately omitted). */
-export { entriesAgentToolCatalog, type AgentToolDefinition as EntriesAgentToolDefinition, type AgentToolSideEffect as EntriesAgentToolSideEffect, } from "./agent-tools.js";
+export { entriesAgentToolCatalog, } from "./agent-tools.js";
 /**
  * The agent-tool wiring for this domain.
  *

package/dist/entries/lifecycle-dispatch.d.ts

@@ -1,5 +1,6 @@
 import { type PublishUnpublishEntryRequired } from "./write-service.js";
-import type { EntryRecord, Result } from "./types.js";
+import type { Result } from "@jini-ai/core/primitives";
+import type { EntryRecord } from "./types.js";
 /**
  * @file Entry publish/unpublish `op` dispatch (the closed-union-dispatch convention, same
  * shape as `features/content-types/lifecycle-dispatch.ts`).
@@ -7,7 +8,9 @@ import type { EntryRecord, Result } from "./types.js";
 export declare const ENTRY_LIFECYCLE_OP_NAMES: readonly ["publish", "unpublish"];
 export type EntryLifecycleOp = (typeof ENTRY_LIFECYCLE_OP_NAMES)[number];
 /** Narrows an untrusted `op` string to {@link EntryLifecycleOp}, or `null` if it isn't one. */
-export declare function parseEntryLifecycleOp(op: unknown): EntryLifecycleOp | null;
+export declare function parseEntryLifecycleOp(requiredArgs: {
+    op: unknown;
+}, optionalArgs?: Record<string, never>): EntryLifecycleOp | null;
 export type EntryLifecycleHandler = (required: PublishUnpublishEntryRequired) => Promise<Result<{
     entry: EntryRecord;
 }, Error>>;

package/dist/entries/lifecycle-dispatch.js

@@ -5,7 +5,8 @@ import { publishEntry, unpublishEntry } from "./write-service.js";
  */
 export const ENTRY_LIFECYCLE_OP_NAMES = ["publish", "unpublish"];
 /** Narrows an untrusted `op` string to {@link EntryLifecycleOp}, or `null` if it isn't one. */
-export function parseEntryLifecycleOp(op) {
+export function parseEntryLifecycleOp(requiredArgs, optionalArgs = {}) {
+    const { op } = requiredArgs;
     return typeof op === "string" && ENTRY_LIFECYCLE_OP_NAMES.includes(op) ? op : null;
 }
 const entryLifecycleOps = {

package/dist/entries/list.d.ts

@@ -22,8 +22,9 @@ export interface EntryListPort {
      * `limit` are pushed down into the query itself (not applied client-side after a full scan) by
      * every real adapter — a caller needing a bounded, sorted read (e.g. a resolver's cost clamp)
      * must supply them rather than fetching everything and truncating in memory. */
-    listByWorkspace(params: {
+    listByWorkspace(required: {
         workspaceId: string;
+    }, optional?: {
         type?: string | undefined;
         status?: EntryStatus | undefined;
         orderBy?: "updatedAt" | undefined;
@@ -40,8 +41,9 @@ export interface EntryListPort {
 export declare function listEntries(required: {
     repo: EntryListPort;
     workspaceId: string;
+}, optional?: {
     type?: string | undefined;
-}, _optional?: Record<string, never>): Promise<{
+}): Promise<{
     items: EntryRecord[];
 }>;
 //# sourceMappingURL=list.d.ts.map

package/dist/entries/list.js

@@ -4,9 +4,10 @@
  * @complexity O(1) plus one `EntryListPort.listByWorkspace()` call.
  * @overallScore 100
  */
-export async function listEntries(required, _optional = {}) {
-    const { repo, workspaceId, type } = required;
-    const items = await repo.listByWorkspace({ workspaceId, type });
+export async function listEntries(required, optional = {}) {
+    const { repo, workspaceId } = required;
+    const { type } = optional;
+    const items = await repo.listByWorkspace({ workspaceId }, { type });
     return { items };
 }
 //# sourceMappingURL=list.js.map

package/dist/entries/repo.memory.d.ts

@@ -1,3 +1,4 @@
+import type { Clock } from "@jini-ai/core/primitives";
 import type { EntryRepoPort, EntryRevisionInput, OutboxPort } from "./write-service.js";
 import type { EntryListPort } from "./list.js";
 import type { EntryRecord, EntryStatus } from "./types.js";
@@ -21,14 +22,17 @@ export declare class InMemoryEntryRepo implements EntryRepoPort, EntryListPort {
     }): Promise<EntryRecord | null>;
     save(row: EntryRecord): Promise<void>;
     appendRevision(revision: EntryRevisionInput): Promise<void>;
-    transaction<T>(fn: () => Promise<T>): Promise<T>;
-    listByWorkspace(params: {
+    transaction<T>({ fn }: {
+        fn: () => Promise<T>;
+    }): Promise<T>;
+    listByWorkspace(required: {
         workspaceId: string;
-        type?: string;
-        status?: EntryStatus;
-        orderBy?: "updatedAt";
-        orderDirection?: "asc" | "desc";
-        limit?: number;
+    }, optional?: {
+        type?: string | undefined;
+        status?: EntryStatus | undefined;
+        orderBy?: "updatedAt" | undefined;
+        orderDirection?: "asc" | "desc" | undefined;
+        limit?: number | undefined;
     }): Promise<EntryRecord[]>;
 }
 /** Adapts a real `core/ports` `OutboxPort` into the narrower `{enqueue({name,payload})}` shape
@@ -53,9 +57,7 @@ export declare function toEntryOutbox(deps: {
             payload: Record<string, unknown>;
         }): Promise<void>;
     };
-    clock: {
-        nowIso(): string;
-    };
+    clock: Clock;
     idGen: {
         newId(): string;
     };

package/dist/entries/repo.memory.js

@@ -1,3 +1,4 @@
+import { nowIso as kernelNowIso } from "@jini-ai/core/primitives";
 /**
  * @file In-memory `EntryRepoPort` + `EntryListPort` double (same disclosed rule-of-two-until-a-
  * real-adapter-exists precedent as `features/content-types/repo.memory.ts` — see that file's
@@ -27,20 +28,20 @@ export class InMemoryEntryRepo {
     async appendRevision(revision) {
         this.revisions.push(revision);
     }
-    async transaction(fn) {
+    async transaction({ fn }) {
         return fn();
     }
-    async listByWorkspace(params) {
+    async listByWorkspace(required, optional = {}) {
         let rows = [...this.byId.values()]
-            .filter((row) => row.workspaceId === params.workspaceId)
-            .filter((row) => !params.type || row.type === params.type)
-            .filter((row) => !params.status || row.status === params.status);
-        if (params.orderBy === "updatedAt") {
-            const dir = params.orderDirection === "asc" ? 1 : -1;
+            .filter((row) => row.workspaceId === required.workspaceId)
+            .filter((row) => !optional.type || row.type === optional.type)
+            .filter((row) => !optional.status || row.status === optional.status);
+        if (optional.orderBy === "updatedAt") {
+            const dir = optional.orderDirection === "asc" ? 1 : -1;
             rows = rows.sort((a, b) => (a.updatedAt < b.updatedAt ? -dir : a.updatedAt > b.updatedAt ? dir : 0));
         }
-        if (typeof params.limit === "number") {
-            rows = rows.slice(0, params.limit);
+        if (typeof optional.limit === "number") {
+            rows = rows.slice(0, optional.limit);
         }
         return rows.map((row) => ({ ...row }));
     }
@@ -64,7 +65,7 @@ export function toEntryOutbox(deps) {
                 id: deps.idGen.newId(),
                 workspaceId: deps.workspaceId,
                 name: event.name,
-                occurredAt: deps.clock.nowIso(),
+                occurredAt: kernelNowIso({ clock: deps.clock }),
                 payload: event.payload,
             });
         },

package/dist/entries/tool-registrations.d.ts

@@ -1,3 +1,5 @@
+import type { IdGenerator } from "@jini-ai/core/primitives";
+import type { Clock } from "@jini-ai/core/primitives";
 /**
  * @file Entries' half of the shared agent-tool-registration convention: maps `agent-tools.ts`'s 5
  * catalog entries onto `write-service.ts`'s create/update/publish/unpublish and `list.ts`'s read, as
@@ -15,14 +17,14 @@
  */
 import type { AuthorizeFn } from "../core/commands/command.js";
 import type { OutboxPort } from "../core/ports.js";
-import { type DerivedRiskByToolId, type ToolRegistration } from "../core/tools/registration-kit.js";
+import { type DerivedRiskByToolId, type ToolRegistration } from "@jini-ai/core";
 import { type EntryListPort } from "./list.js";
 import { type ContentTypeLookupPort, type EntryRepoPort } from "./write-service.js";
 /**
  * The exact slice of the route-deps bag Entries' tool handlers read. Declared structurally (rather
  * than importing `server/routes/types`'s `RouteDeps`) so this module carries no back-edge into the
  * composition root. `server/routes/*` satisfies this structurally by passing its existing
- * `RouteDeps` object; nothing there changes.
+ * `RouteDeps` object with the kernel clock/ID contracts.
  *
  * `contentTypeRepo` is typed as `write-service.ts`'s own `ContentTypeLookupPort` — the narrow
  * lookup contract Entries itself declares, not content-types' full `ContentTypeRepoPort` — mirroring
@@ -32,12 +34,8 @@ import { type ContentTypeLookupPort, type EntryRepoPort } from "./write-service.
 export interface EntriesToolDeps {
     authorize: AuthorizeFn;
     workspaceId: string;
-    clock: {
-        nowIso(): string;
-    };
-    idGen: {
-        newId(): string;
-    };
+    clock: Clock;
+    idGen: IdGenerator;
     outbox: OutboxPort;
     entryRepo: EntryRepoPort & EntryListPort;
     contentTypeRepo: ContentTypeLookupPort;

package/dist/entries/tool-registrations.js

@@ -1,10 +1,11 @@
-import { AGENT_TOOL_PRINCIPAL_KIND, buildDomainRegistrations, fromResult, indexCatalogById, optionalString, requireInputRecord, requireNumber, requireString, requireToolPermission, withSchemaOnRejection, } from "../core/tools/registration-kit.js";
+import { AGENT_TOOL_PRINCIPAL_KIND, buildDomainRegistrations, fromResult, indexCatalogById, optionalString, requireInputRecord, requireNumber, requireString, withSchemaOnRejection } from "@jini-ai/core";
+import { adaptLegacyAuthorize, requireToolPermission } from "../core/tools/index.js";
 import { entriesAgentToolCatalog } from "./agent-tools.js";
 import { EntryFieldValidationError } from "./errors.js";
 import { listEntries } from "./list.js";
 import { createEntry, publishEntry, unpublishEntry, updateEntry } from "./write-service.js";
 import { toEntryOutbox } from "./repo.memory.js";
-const CATALOG_BY_ID = indexCatalogById(entriesAgentToolCatalog);
+const CATALOG_BY_ID = indexCatalogById({ catalog: entriesAgentToolCatalog });
 /**
  * This wiring layer's OWN risk classification, authored from what each handler below actually
  * calls. See `DerivedRiskByToolId` in the kit for why it is independent of the catalog's own
@@ -27,7 +28,7 @@ export const entriesDerivedRisk = new Map([
  * only. A not-found, a tombstoned-type rejection, or a version conflict is not a shape problem
  * retrying the SAME input would ever resolve.
  */
-function isEntriesShapeRejection(error) {
+function isEntriesShapeRejection({ error }) {
     return error instanceof EntryFieldValidationError;
 }
 /** Shared dependency bag for `write-service.ts` calls — every mutating handler here takes this
@@ -39,7 +40,7 @@ function entriesDeps(routeDeps) {
         contentTypeRepo: routeDeps.contentTypeRepo,
         clock: routeDeps.clock,
         ids: routeDeps.idGen,
-        authorize: routeDeps.authorize,
+        authorize: adaptLegacyAuthorize({ authorize: routeDeps.authorize }),
         outbox: toEntryOutbox(routeDeps),
     };
 }
@@ -61,70 +62,70 @@ function toEntryToolView(entry) {
     };
 }
 function fromEntryResult(fn) {
-    return fromResult(fn).then(({ entry }) => ({ entry: toEntryToolView(entry) }));
+    return fromResult({ fn: fn }).then(({ entry }) => ({ entry: toEntryToolView(entry) }));
 }
 export function buildEntriesRegistrations(routeDeps) {
     const handlers = {
         collections_entry_list: async (ctx) => {
-            const input = ctx.input !== undefined ? requireInputRecord(ctx.input) : {};
-            await requireToolPermission(routeDeps, { principalId: ctx.principal.id, permission: "admin.collections.read", entityType: "entry" });
-            const { items } = await listEntries({ repo: routeDeps.entryRepo, workspaceId: routeDeps.workspaceId, type: optionalString(input, "type") });
+            const input = ctx.input !== undefined ? requireInputRecord({ input: ctx.input }) : {};
+            await requireToolPermission({ authorize: adaptLegacyAuthorize({ authorize: routeDeps.authorize }), workspaceId: routeDeps.workspaceId, principalId: ctx.principal.id, permission: "admin.collections.read" }, { entityType: "entry" });
+            const { items } = await listEntries({ repo: routeDeps.entryRepo, workspaceId: routeDeps.workspaceId }, { type: optionalString({ input, key: "type" }) });
             return { items: items.map(toEntryToolView) };
         },
         collections_entry_create: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
-            return withSchemaOnRejection({ toolId: "collections_entry_create", catalog: CATALOG_BY_ID, isShapeRejection: isEntriesShapeRejection }, () => fromEntryResult(() => createEntry({
-                deps: entriesDeps(routeDeps),
-                input: {
-                    actorId: ctx.principal.id,
-                    principalKind: AGENT_TOOL_PRINCIPAL_KIND,
-                    workspaceId: routeDeps.workspaceId,
-                    type: requireString(input, "type"),
-                    slug: requireString(input, "slug"),
-                    title: requireString(input, "title"),
-                    fieldsJson: input.fieldsJson ?? { ext: { site: {} } },
-                    bodyJson: input.bodyJson,
-                },
-            })));
+            const input = requireInputRecord({ input: ctx.input });
+            return withSchemaOnRejection({ toolId: "collections_entry_create", catalog: CATALOG_BY_ID, isShapeRejection: isEntriesShapeRejection, fn: () => fromEntryResult(() => createEntry({
+                    deps: entriesDeps(routeDeps),
+                    input: {
+                        actorId: ctx.principal.id,
+                        principalKind: AGENT_TOOL_PRINCIPAL_KIND,
+                        workspaceId: routeDeps.workspaceId,
+                        type: requireString({ input, key: "type" }),
+                        slug: requireString({ input, key: "slug" }),
+                        title: requireString({ input, key: "title" }),
+                        fieldsJson: input.fieldsJson ?? { ext: { site: {} } },
+                        bodyJson: input.bodyJson,
+                    },
+                })) });
         },
         collections_entry_update: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
-            return withSchemaOnRejection({ toolId: "collections_entry_update", catalog: CATALOG_BY_ID, isShapeRejection: isEntriesShapeRejection }, () => fromEntryResult(() => updateEntry({
-                deps: entriesDeps(routeDeps),
-                input: {
-                    actorId: ctx.principal.id,
-                    principalKind: AGENT_TOOL_PRINCIPAL_KIND,
-                    workspaceId: routeDeps.workspaceId,
-                    id: requireString(input, "id"),
-                    title: typeof input.title === "string" ? input.title : undefined,
-                    fieldsJson: input.fieldsJson,
-                    expectedVersion: requireNumber(input, "expectedVersion"),
-                },
-            })));
+            const input = requireInputRecord({ input: ctx.input });
+            return withSchemaOnRejection({ toolId: "collections_entry_update", catalog: CATALOG_BY_ID, isShapeRejection: isEntriesShapeRejection, fn: () => fromEntryResult(() => updateEntry({
+                    deps: entriesDeps(routeDeps),
+                    input: {
+                        actorId: ctx.principal.id,
+                        principalKind: AGENT_TOOL_PRINCIPAL_KIND,
+                        workspaceId: routeDeps.workspaceId,
+                        id: requireString({ input, key: "id" }),
+                        title: typeof input.title === "string" ? input.title : undefined,
+                        fieldsJson: input.fieldsJson,
+                        expectedVersion: requireNumber({ input, key: "expectedVersion" }),
+                    },
+                })) });
         },
         collections_entry_publish: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
+            const input = requireInputRecord({ input: ctx.input });
             return fromEntryResult(() => publishEntry({
                 deps: entriesDeps(routeDeps),
                 input: {
                     actorId: ctx.principal.id,
                     principalKind: AGENT_TOOL_PRINCIPAL_KIND,
                     workspaceId: routeDeps.workspaceId,
-                    id: requireString(input, "id"),
-                    expectedVersion: requireNumber(input, "expectedVersion"),
+                    id: requireString({ input, key: "id" }),
+                    expectedVersion: requireNumber({ input, key: "expectedVersion" }),
                 },
             }));
         },
         collections_entry_unpublish: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
+            const input = requireInputRecord({ input: ctx.input });
             return fromEntryResult(() => unpublishEntry({
                 deps: entriesDeps(routeDeps),
                 input: {
                     actorId: ctx.principal.id,
                     principalKind: AGENT_TOOL_PRINCIPAL_KIND,
                     workspaceId: routeDeps.workspaceId,
-                    id: requireString(input, "id"),
-                    expectedVersion: requireNumber(input, "expectedVersion"),
+                    id: requireString({ input, key: "id" }),
+                    expectedVersion: requireNumber({ input, key: "expectedVersion" }),
                 },
             }));
         },

package/dist/entries/types.d.ts

@@ -45,11 +45,4 @@ export interface ActorIdentityInput {
     delegatedByWorkspaceId?: string | null;
     delegatedById?: string | null;
 }
-export type Result<T, E> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    error: E;
-};
 //# sourceMappingURL=types.d.ts.map