@typeroll/mcp-server 0.44.74 → 0.45.1

package/skills/tr-page-template.md

@@ -1,168 +1,57 @@
 ---
 name: tr-page-template
-description: Use when several pages on a Typeroll site share the same outer structure — category pages, service-detail pages, landing-page variants — and the user wants to edit the shared bits in one place. Covers two flows: the HTML-mode pattern with partials + `<x-include>` (works everywhere, recommended for Phase 1), and the formal block-mode PageTemplate (when the site is in block mode).
+description: Create or edit a reusable Page template for articles, checklists, products, directory entries or other Pages that share a layout.
 ---
 
-# Share structure across pages
-
-When you have N pages that follow the same skeleton — say 7 category landing pages, each with `Hero → Intro → Features grid → CTA banner` — you don't want to edit 7 HTML bodies whenever the design changes. There are two ways to share structure in Typeroll, and the right pick depends on the site's content mode.
-
-## Decide which pattern fits
-
-| Site is mostly in… | Use |
-|---|---|
-| **HTML mode** (the Phase 1 default — most sites) | Partials + `<x-include>` — pattern A below |
-| **Block mode** (`supports_blocks_mode=true` and the page's `content_mode='blocks'`) | PageTemplate via `set_page_template` — pattern B below |
-
-You can check the site's mode by reading any existing page — `content_mode` is a top-level field on the page doc.
-
-If unsure, default to **pattern A**. It works on every Typeroll site and the migration to block-mode templates later is mechanical.
-
-## Pattern A — Partials + `<x-include>` (HTML mode)
-
-A partial is a named HTML fragment. Putting `<x-include name="my-partial" />` anywhere in a page body inlines that fragment at build time. Editing the partial updates every page that references it on the next deploy.
-
-### Recipe for "7 category pages with shared structure"
-
-#### 1. Identify the shared chunks
-
-Walk through one category page and mark which sections are the same across all 7:
-
-```
-[Hero: title + tagline + image]            ← varies per category
-[Intro paragraph]                          ← varies per category
-[Common: "Why choose us" three-tile band]  ← identical across 7
-[Common: CTA banner with newsletter form]  ← identical across 7
-[Common: footer testimonials]              ← identical across 7
-```
-
-Three reusable bits: `why-choose-us`, `cta-newsletter`, `footer-testimonials`.
-
-#### 2. Create the partials
-
-```
-create_partial partial_id="why-choose-us" html_content="<section class=\"why\">
-  <div class=\"container\">
-    <h2>Varför oss</h2>
-    <div class=\"why__grid\">
-      <div class=\"why__tile\"><h3>Erfarenhet</h3><p>20 år i branschen.</p></div>
-      <div class=\"why__tile\"><h3>Kvalitet</h3><p>Vi mäter på allt.</p></div>
-      <div class=\"why__tile\"><h3>Närhet</h3><p>Lokala kontor i tre städer.</p></div>
-    </div>
-  </div>
-</section>
-<style>
-.why{padding:4rem 0;background:var(--color-surface)}
-.why__grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:2rem;margin-top:2rem}
-.why__tile h3{font-family:var(--font-heading);margin-bottom:0.5rem}
-</style>"
-```
-
-Same for `cta-newsletter` and `footer-testimonials`.
-
-The partial-id is what `<x-include>` references — keep it kebab-case and descriptive.
-
-#### 3. Build each category page using the partials
-
-```
-create_page title="Tjänster för bostadsrätter" slug="brf" content_mode="html"
-  html_content="<section class=\"hero hero--brf\">
-  <div class=\"container\">
-    <h1>Tjänster för bostadsrättsföreningar</h1>
-    <p class=\"hero__tagline\">Trygg förvaltning, helt utan överraskningar.</p>
-  </div>
-</section>
-
-<section class=\"intro\">
-  <div class=\"container\">
-    <p>Vi har förvaltat över 200 BRF:er i Stockholmsområdet sedan 2005.</p>
-  </div>
-</section>
-
-<x-include name=\"why-choose-us\" />
-<x-include name=\"cta-newsletter\" />
-<x-include name=\"footer-testimonials\" />"
-```
-
-Repeat for the other 6 categories, varying only the `hero` + `intro` sections.
-
-#### 4. Edit once, propagate everywhere
-
-Adding a fourth "Why us" tile? Edit `why-choose-us` once:
-
-```
-replace_partial partial_id="why-choose-us" html_content="<section class=\"why\">
-  ...four tiles instead of three...
-</section>"
-```
-
-All 7 pages pick up the change on the next deploy. No multi-page diff.
-
-### Edge cases
-
-- **`<x-include>` self-closes or has an explicit close.** Both forms work: `<x-include name="x" />` and `<x-include name="x"></x-include>`.
-- **Nested includes are NOT supported.** If `partial-a` references `<x-include name="partial-b" />`, the inner reference is not expanded. Flatten the hierarchy at design time.
-- **Unknown partial → silently empty.** A typo in the `name` attribute removes the tag at expand time with no warning. Verify the partial id matches one returned by `list_partials`.
-- **Partial content is sanitised on save.** `<script>` tags get stripped at partial creation, then the inlined HTML is sanitised again when the page renders. Two passes; both intentional.
-
-## Pattern B — Formal PageTemplate (block mode)
-
-Available when the site is in block mode (`supports_blocks_mode=true` and the page's `content_mode='blocks'`). A PageTemplate is a `Block[]` tree with one or more `template_content_slot` blocks marking where the page's own blocks go.
-
-### Recipe
-
-#### 1. List existing templates
-
-```
-list_page_templates
-```
-
-Returns templates already defined on the site.
-
-#### 2. Create / pick a template
-
-Templates live as `Block[]` trees under `paths.pageTemplate(orgId, siteId, templateId)`. They're created via the portal UI for now (no dedicated MCP `create_page_template` tool yet — the chat-tool surface in `anthropic.ts` exposes list + set, not create).
-
-If the template you want doesn't exist, ask the user to create it via **/app/sites/{id}/templates** in the portal, or use the block-mode-aware AI chat in the portal which knows how to write template trees.
-
-#### 3. Assign it to a page
-
-```
-set_page_template page_id="brf" template_id="category-landing"
-```
-
-The renderer composes the template's blocks with the page's blocks at build time via `composePageWithTemplate` (replacing each `template_content_slot` with the page's own block tree). The page's CSS / theme / SEO settings are unchanged.
-
-#### 4. Editing the template propagates to every page
-
-The same template id can be set on multiple pages. Editing the template updates them all on next deploy.
-
-### When B beats A
-
-- Block-mode editor surfaces template assignment as a dropdown in the page settings.
-- Templates compose with the block tree, so the page author can drop content blocks into named slots rather than writing HTML.
-- The renderer is aware of block CSS / JS bundling — assets per block type are aggregated automatically.
-
-### When A still beats B even in block mode
-
-- Need a small reusable HTML chunk in the middle of a block-mode page → still use `<x-include>` (block-mode bodies can contain free HTML blocks that include partials).
-- One-page change wanted without affecting siblings → just edit the page's blocks; templates are all-or-nothing.
-
-## Refactor: 7 already-existing pages into a shared partial
-
-If the 7 pages already exist as separate HTML bodies with duplicated chunks:
-
-1. `read_page page_id=<one of them>` and identify the shared HTML literally — character-for-character chunks that repeat across all 7.
-2. `create_partial partial_id=<descriptive-name> html_content="<the shared chunk>"`.
-3. For each of the 7 pages, `update_page` with the shared chunk replaced by `<x-include name="<name>" />`.
-4. Deploy. The rendered output should be byte-identical to before; only the source pages got shorter.
-
-Don't try to abstract first time and hand-write the partials. Refactor from real, working duplication.
-
-## Pitfalls
-
-- **Don't put hero / page-specific content into a shared partial.** A partial is for things that are *truly identical* across uses. The moment you want it to vary by page, lift the differing parts back into the page body.
-- **Header and footer already use partials.** Don't recreate them inside a category-page shared partial — they're injected by the layout, not by the page body.
-- **CSS scoping.** Partials carrying `<style>` blocks merge into every page that includes them. If two partials define `.tile` differently, the last one wins. Either namespace classes per partial (`.why__tile`, `.feature__tile`) or move shared styles into the site's global CSS via `update_site_settings` → `custom_css`.
-- **Don't migrate to block-mode templates just because you can.** Phase 1 sites are HTML-mode by design; partials + includes give you 90% of the value with zero risk.
-- **`<x-include>` in a partial body referencing another partial.** Won't expand (see edge cases). If you find yourself wanting this, you're building a layout system inside the partial system — at that point the site probably wants block mode.
+# Share a layout across Pages
+
+Read capabilities, available block types, content types and Page templates first.
+Use a site version for substantial design changes. The Page owns its body blocks;
+the template owns the shared layout around that body. The content type selects a
+default template, and an individual Page can override it.
+
+1. `create_page_template name="article-layout" label="Article" starter="article" status="published"`.
+   Alternatively supply `blocks` instead of `starter`. Presets include article,
+   blog, checklist, team, events, products and custom.
+2. `update_content_type name="articles" patch={template:"article-layout"}`.
+   For a single-page override, `update_page page_id=... patch={template:"article-layout"} save=true`.
+3. Read and edit the template through `read_page_template` or block tools with
+   `target: { kind: "template", id: "article-layout" }`. Template edits save
+   immediately; content-type and template changes are isolated by `version`.
+4. Keep a `template_content_slot` where the Page's body belongs. Its `max_width`
+   can be full, narrow, normal or wide. Use native columns/containers for layout.
+5. Metadata blocks include `template/page_title`, `template/page_date`,
+   `template/page_featured_image`, `template/page_breadcrumbs` and
+   `template/page_navigation`. The outline block reads the rendered body headings.
+6. Use `{{page.title}}` or `{{page.custom_field}}` in template bindings.
+   A repeater's children use `{{item.title}}` for the current listed Page.
+   Custom fields can be typed objects, arrays or Page references; preserve those
+   structures instead of storing hand-generated list HTML.
+7. Preview several Pages using the template: long title, short body, missing
+   optional image, populated reference list. Inspect desktop and mobile output.
+   Verify the authorized static build as well as the live database preview.
+
+Prefer native image, table, list, heading and content blocks. A rare specialized
+widget can use a reviewed HTML/embed block. Reusable custom behavior belongs in
+one custom block type rather than repeated HTML bodies. Existing HTML-mode pages
+may share fragments through partials and `<x-include>`, but use block templates
+for new content families.
+
+Header/footer partials are global and remain separate from content types. Keep
+site-level design tokens in settings and shared layout changes in the template.
+Page body edits stay specific to that Page. Read the template before mutation;
+never replace it with a starter merely because an import is being retried.
+
+
+Content types also own `sort_field`/`sort_dir` and optional `allowed_templates`.
+Types define content; templates define presentation. Multiple compatible Page
+templates can be allowed, with `template` selecting the default. Null/absent
+`allowed_templates` is unrestricted, `[]` allows none, and a configured default
+must be in an explicit allowed list. Page overrides must be allowed; null/empty
+`Page.template` restores inheritance. Page template changes use Save/Discard.
+
+Listings inherit type sorting unless explicitly overridden. `Page.sort_order`
+is the manual numeric order; null clears it. Missing sort values come last and
+IDs break ties. Explicit ID lists keep their order. Typed `list_pages` queries
+inherit type sorting and accept `sort_by`/`sort_order`; unfiltered API lists
+default to stable IDs. See the public Content types guide for editor steps.

package/skills/tr-redesign-branch.md

@@ -6,7 +6,7 @@ description: Use when the user asks to redesign, modernize, or restructure a Typ
 # Redesign a site without breaking the live one
 
 > **The buffer model (draft writes).** Every content write in this recipe
-> (pages, blocks, partials, collection items) lands in an unsaved per-doc
+> (pages, blocks and partials) lands in an unsaved per-doc
 > DRAFT — deploys and plain previews only see SAVED content. For recipe-style
 > build work, pass `save: true` on write calls (the work is pre-approved by
 > the task itself), or run `commit_working_copy` per doc before any
@@ -59,7 +59,7 @@ read_partial partial_id="footer"
 list_pages limit=20
 batch_read_pages page_ids=[<top 3-5 pages>]   # see actual conventions
 list_partials                                  # what free blocks exist
-list_collections                               # any data we need to consider
+list_content_types                               # any data we need to consider
 ```
 
 Write the user a short read-back: *"This is a 12-page agency site

package/skills/tr-responsive.md

@@ -25,7 +25,7 @@ Use `set_block_responsive` (or pass the object form directly in `add_block` /
 
 The breakpoint object belongs on the responsive field inside `block.data`,
 for example `data.cols`. Do not add a top-level `block.responsive` object: it
-is not a rendered field, and page, partial and collection-template writes
+is not a rendered field, and page, partial and Page-template writes
 reject it instead of silently storing an inert value.
 
 ```
@@ -46,7 +46,7 @@ Pass a scalar to collapse a field back to one value everywhere.
 iPad, 1/row icon-on-top on a phone":
 
 1. `core/grid` containing `core/icon_box` cards (or a `core/repeater` with
-   `item_block: core/icon_box` for a collection-driven list).
+   `item_block: core/icon_box` for a Page-driven list).
 2. On the grid: `cols = { mobile: 1, tablet: 2, desktop: 4 }`.
 3. On each icon_box (or the repeater's item defaults):
    `layout = { mobile: "icon-top", tablet: "icon-left", desktop: "icon-top" }`.

package/skills/tr-seo.md

@@ -6,7 +6,7 @@ description: Use when the user asks to improve SEO, fix meta tags, add structure
 # SEO audit and improvements for a Typeroll site
 
 > **The buffer model (draft writes).** Every content write in this recipe
-> (pages, blocks, partials, collection items) lands in an unsaved per-doc
+> (pages, blocks and partials) lands in an unsaved per-doc
 > DRAFT — deploys and plain previews only see SAVED content. For recipe-style
 > build work, pass `save: true` on write calls (the work is pre-approved by
 > the task itself), or run `commit_working_copy` per doc before any

package/dist/tools/collections.js

@@ -1,242 +0,0 @@
-// Collections + items (blog, team, events, products, custom).
-import { z } from 'zod';
-import { ok, withErrorBoundary, versionParam } from './helpers.js';
-function v(version) {
-    return version ? { version } : undefined;
-}
-function existingCollectionArg(args) {
-    const value = args.collection ?? args.name;
-    if (!value)
-        throw new Error('collection is required');
-    return value;
-}
-export const collectionTools = [
-    {
-        name: 'create_collection',
-        description: 'Create a new content collection with a field schema and (optionally) per-item URLs. Pass `route_template` (e.g. "/restaurants/{slug}") to give each published item its own URL — omit to default to "/{name}/{slug}", set to "" to disable per-item URLs entirely. Pass template_kind for a polished native item template, or item_template_blocks for a custom block tree.',
-        inputSchema: {
-            name: z.string().regex(/^[a-z][a-z0-9_-]{0,62}$/),
-            label_singular: z.string().min(1),
-            label_plural: z.string().min(1),
-            icon: z.string().optional(),
-            fields: z
-                .array(z.object({
-                name: z.string(),
-                label: z.string(),
-                type: z.string(),
-                required: z.boolean().optional(),
-                default: z.unknown().optional(),
-                options: z.array(z.string()).optional(),
-            }).passthrough())
-                .min(1),
-            slug_field: z.string().optional(),
-            sort_field: z.string().optional(),
-            sort_dir: z.enum(['asc', 'desc']).optional(),
-            route_template: z.string().optional(),
-            item_template_html: z.string().optional(),
-            template_kind: z
-                .enum(['blog', 'article', 'checklist', 'team', 'events', 'products', 'custom'])
-                .optional()
-                .describe('Native starter for item pages. article includes breadcrumbs + body outline; checklist includes optional PDF CTA + explicit previous/next fields.'),
-            item_template_blocks: z.array(z.any()).optional().describe('Explicit item-template block tree. Overrides template_kind.'),
-            version: versionParam,
-        },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const { version, ...body } = args;
-            const res = await client.post(siteId, 'collections', body, v(version));
-            return ok(res);
-        }),
-    },
-    {
-        name: 'update_collection_schema',
-        description: 'PATCH a collection\'s schema or routing. `collection` is required (`name` remains a deprecated compatibility alias). Pass only the fields you want to change. Renaming a field would orphan existing item data — adding new fields is safe, removing fields is silently allowed but item docs keep the dropped data.',
-        inputSchema: {
-            collection: z.string().optional().describe('Collection machine name. Preferred argument name.'),
-            name: z.string().optional().describe('Deprecated alias for collection.'),
-            patch: z
-                .object({
-                label_singular: z.string().optional(),
-                label_plural: z.string().optional(),
-                icon: z.string().optional(),
-                fields: z.array(z.record(z.unknown())).optional(),
-                slug_field: z.string().optional(),
-                sort_field: z.string().optional(),
-                sort_dir: z.enum(['asc', 'desc']).optional(),
-                route_template: z.string().optional(),
-                item_template_html: z.string().optional(),
-                schema_type: z
-                    .string()
-                    .optional()
-                    .describe('Free-form Schema.org type for auto JSON-LD on every item route ("BlogPosting", "PodcastEpisode", "Product", "Event", "Recipe", "Course", …). Pair with schema_field_map when item field names differ from the schema property names.'),
-                schema_field_map: z
-                    .record(z.string())
-                    .optional()
-                    .describe('Override the default field→schema-property mapping. Example: { "audio_url": "contentUrl", "show_notes": "description" }. Values use camelCase (Schema.org convention).'),
-            })
-                .passthrough(),
-            version: versionParam,
-        },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const collection = existingCollectionArg(args);
-            const res = await client.patch(siteId, `collections/${encodeURIComponent(collection)}`, { patch: args.patch }, v(args.version));
-            return ok(res);
-        }),
-    },
-    {
-        name: 'delete_collection',
-        description: 'Delete a collection AND every item in it. `collection` is required (`name` remains a deprecated compatibility alias). Destructive; requires `confirm: true`. Get-the-user-to-confirm workflow recommended.',
-        inputSchema: {
-            collection: z.string().optional().describe('Collection machine name. Preferred argument name.'),
-            name: z.string().optional().describe('Deprecated alias for collection.'),
-            confirm: z.literal(true).describe('Must be true to actually delete.'),
-            version: versionParam,
-        },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const collection = existingCollectionArg(args);
-            const res = await client.del(siteId, `collections/${encodeURIComponent(collection)}`, { confirm: 'true', ...v(args.version) });
-            return ok(res);
-        }),
-    },
-    {
-        name: 'list_collections',
-        description: 'List content collections on the site (name, label, icon, field schemas).',
-        inputSchema: { version: versionParam },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const res = await client.get(siteId, 'collections', v(args.version));
-            return ok(res);
-        }),
-    },
-    {
-        name: 'read_collection',
-        description: 'Fetch one collection\'s schema (label, fields, icon). `collection` is required; `name` remains a deprecated compatibility alias.',
-        inputSchema: {
-            collection: z.string().optional().describe('Collection machine name. Preferred argument name.'),
-            name: z.string().optional().describe('Deprecated alias for collection.'),
-            version: versionParam,
-        },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const collection = existingCollectionArg(args);
-            const res = await client.get(siteId, `collections/${encodeURIComponent(collection)}`, v(args.version));
-            return ok(res);
-        }),
-    },
-    {
-        name: 'collection_completeness',
-        description: "Which records in a collection need work, worst first. Returns per-field gap counts across the whole collection plus the N worst items (missing fields, never-verified fields, and fields whose last write is older than the staleness window). Use this INSTEAD of paging every item and diffing client-side — it's the intended entry point for an enrichment pass. Computed at read time, so it's never stale. By default only fields an API key may actually write are counted, since a gap you're forbidden to close is noise; pass all_fields: true for a human audit.",
-        inputSchema: {
-            collection: z.string(),
-            limit: z.number().int().min(1).max(500).optional().describe('Worst-N items to return. Default 50.'),
-            stale_after_days: z.number().int().min(1).optional().describe('A field untouched for longer than this is reported stale. Default 180.'),
-            all_fields: z.boolean().optional().describe('Include fields no API key may write. Default false.'),
-            version: versionParam,
-        },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const { collection, version, ...query } = args;
-            const res = await client.get(siteId, `collections/${encodeURIComponent(collection)}/completeness`, { ...query, ...v(version) });
-            return ok(res);
-        }),
-    },
-    {
-        name: 'list_collection_items',
-        description: 'List items in a collection with status filter + cursor pagination (cap 200 per page). Defaults to summary mode (richtext/textarea fields replaced with a byte-count hint) so a 200-item directory listing stays compact; pass include_richtext: true if you actually need full bodies.',
-        inputSchema: {
-            collection: z.string(),
-            status: z.enum(['draft', 'published', 'all']).optional(),
-            limit: z.number().int().min(1).max(200).optional(),
-            cursor: z.string().optional(),
-            include_richtext: z.boolean().optional().describe('Include full richtext/textarea field values inline. Default false.'),
-            version: versionParam,
-        },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const { collection, version, include_richtext, ...query } = args;
-            const res = await client.get(siteId, `collections/${encodeURIComponent(collection)}/items`, { ...query, ...(include_richtext ? {} : { summary: 'true' }), ...v(version) });
-            return ok(res);
-        }),
-    },
-    {
-        name: 'batch_read_collection_items',
-        description: 'Read up to 200 collection items in one call. Returns per-id found/not-found.',
-        inputSchema: {
-            collection: z.string(),
-            item_ids: z.array(z.string()).min(1).max(200),
-            version: versionParam,
-        },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const res = await client.post(siteId, `collections/${encodeURIComponent(args.collection)}/items/batch-read`, { item_ids: args.item_ids }, v(args.version));
-            return ok(res);
-        }),
-    },
-    {
-        name: 'read_collection_item',
-        description: 'Fetch a single item with all fields. item_id may be the internal id or the value of the collection\'s slug_field.',
-        inputSchema: { collection: z.string(), item_id: z.string(), version: versionParam },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const res = await client.get(siteId, `collections/${encodeURIComponent(args.collection)}/items/${encodeURIComponent(args.item_id)}`, v(args.version));
-            return ok(res);
-        }),
-    },
-    {
-        name: 'create_collection_item',
-        description: 'Create an item. Fields outside the collection schema are silently dropped — call list_collections first if you\'re unsure what fields exist.',
-        inputSchema: {
-            collection: z.string(),
-            fields: z.record(z.unknown()),
-            status: z.enum(['draft', 'published']).optional(),
-            version: versionParam,
-        },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const { collection, version, ...body } = args;
-            const res = await client.post(siteId, `collections/${encodeURIComponent(collection)}/items`, body, v(version));
-            return ok(res);
-        }),
-    },
-    {
-        name: 'update_collection_item',
-        description: 'Update a collection item by internal id or slug_field value. Fields outside the schema are dropped. BUFFER MODEL: field values land in the item\'s unsaved DRAFT (status applies immediately); pass save:true to commit in the same call, or commit_working_copy later. Scheduled publishing (0.29.0+): pass publish_at/unpublish_at INSIDE `fields` — ISO datetime at which the platform flips status (+ deploys the site); null clears; applies immediately like status.',
-        inputSchema: {
-            collection: z.string(),
-            item_id: z.string(),
-            fields: z.record(z.unknown()).optional(),
-            status: z.enum(['draft', 'published']).optional(),
-            save: z.boolean().optional().describe('Also SAVE (commit) the draft in the same call.'),
-            version: versionParam,
-        },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const { collection, item_id, version, ...body } = args;
-            const res = await client.patch(siteId, `collections/${encodeURIComponent(collection)}/items/${encodeURIComponent(item_id)}`, body, v(version));
-            return ok(res);
-        }),
-    },
-    {
-        name: 'regenerate_collection_listing',
-        description: 'Refresh a hand-managed listing of collection items on a page. The agent inserts a marker pair `<!-- typeroll:listing:{collection} -->` ... `<!-- /typeroll:listing:{collection} -->` into a page body once; from then on this tool fills the section between the markers with the current published items, sorted by the collection\'s sort_field. Pass `item_template` to customize per-item HTML — {{field}} substitutes HTML-escaped, {{{field}}} raw, {{url}} resolves through the collection\'s route_template. Defaults to a basic <ul> of links.',
-        inputSchema: {
-            collection: z.string(),
-            page_id: z.string(),
-            item_template: z.string().optional()
-                .describe('Per-item HTML template. Default: <li><a href="{{url}}">{{title}}</a></li>'),
-            wrap_open: z.string().optional().describe('Override the opening wrap element. Default: <ul class="tr-listing">'),
-            wrap_close: z.string().optional().describe('Override the closing wrap element. Default: </ul>'),
-            empty_html: z.string().optional().describe('Rendered when no items exist.'),
-            sort_field: z.string().optional().describe('Override the collection\'s default sort_field.'),
-            sort_dir: z.enum(['asc', 'desc']).optional(),
-            status_filter: z.enum(['published', 'all']).optional().describe('Default: published.'),
-            limit: z.number().int().min(1).max(500).optional(),
-            version: versionParam,
-        },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const { collection, version, ...body } = args;
-            const res = await client.post(siteId, `collections/${encodeURIComponent(collection)}/regenerate-listing`, body, v(version));
-            return ok(res);
-        }),
-    },
-    {
-        name: 'delete_collection_item',
-        description: 'Delete a collection item.',
-        inputSchema: { collection: z.string(), item_id: z.string(), version: versionParam },
-        handler: withErrorBoundary(async (args, { client, siteId }) => {
-            const res = await client.del(siteId, `collections/${encodeURIComponent(args.collection)}/items/${encodeURIComponent(args.item_id)}`, v(args.version));
-            return ok(res);
-        }),
-    },
-];