@solumflow-app/crm-mcp-server 0.4.0 → 0.6.0

package/dist/index.js

@@ -6,10 +6,10 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { createClient } from "@solumflow-app/crm-client";
 
 // package.json
-var version = "0.4.0";
+var version = "0.6.0";
 
-// src/catalog-tools.ts
-import { z as z3 } from "zod";
+// src/catalog-migration-tools.ts
+import { z as z4 } from "zod";
 
 // ../features/crm-invoicing/src/schema/catalog-api.schema.ts
 import * as z from "zod";
@@ -43,6 +43,12 @@ var CatalogPriceSchema = z.object({
   /** The price's own id at the source, so a renamed price stays itself. */
   externalRef: CatalogExternalRefSchema.optional(),
   label: z.string().trim().min(1).max(120),
+  /**
+   * ISO 4217. Left out, the price is in the product's own currency. A
+   * price in another currency is the fixed price for that currency: it
+   * wins over a converted one and is never the default.
+   */
+  currency: z.string().regex(/^[A-Z]{3}$/).optional(),
   amountCents: cents,
   compareAtCents: cents.nullable().optional(),
   kind: z.enum(["one_off", "recurring"]).optional(),
@@ -78,21 +84,64 @@ var pricesSchema = z.array(CatalogPriceSchema).min(1).max(50).superRefine((price
       message: "Two prices carry the same externalRef."
     });
   }
-  const labels = prices.map((price) => price.label.toLowerCase());
+  const labels = prices.map(
+    (price) => `${price.currency ?? ""} ${price.label.toLowerCase()}`
+  );
   if (new Set(labels).size !== labels.length) {
     ctx.addIssue({
       code: "custom",
       // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
-      message: "Two prices carry the same label."
+      message: "Two prices carry the same label in the same currency."
     });
   }
 });
+var HttpsUrlSchema = z.string().max(2048).url().refine((url) => url.startsWith("https://"), {
+  // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+  message: "A file is fetched over https only."
+});
+var UploadPathSchema = z.string().min(1).max(200);
+var CatalogFileRefSchema = z.union([
+  z.object({ url: HttpsUrlSchema }).strict(),
+  z.object({ upload: UploadPathSchema }).strict()
+]);
+var IMAGE_ROLE = /^[a-z][a-z0-9_-]{0,31}$/;
+var CatalogImageDetailsSchema = z.record(
+  z.string().min(1).max(64),
+  z.union([z.string().max(500), z.number().finite(), z.boolean()])
+).refine((details) => JSON.stringify(details).length <= 1800, {
+  // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+  message: "Details are at most about 2 KB."
+});
 var CatalogImageSchema = z.object({
-  url: z.string().max(2048).url().refine((url) => url.startsWith("https://"), {
+  url: HttpsUrlSchema.optional(),
+  upload: UploadPathSchema.optional(),
+  alt: text(300),
+  /**
+   * What the picture is of, in the account's own words: `work`, `detail`,
+   * `insitu`. Left out keeps the role a stored picture has; `null` clears it.
+   */
+  role: z.string().regex(IMAGE_ROLE, {
+    message: (
+      // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+      "A role starts with a letter and holds lower-case letters, digits, hyphens and underscores, at most 32."
+    )
+  }).nullable().optional(),
+  details: CatalogImageDetailsSchema.optional()
+}).strict().refine(
+  (image) => image.url === void 0 !== (image.upload === void 0),
+  {
     // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
-    message: "A picture is fetched over https only."
-  }),
-  alt: text(300)
+    message: "A picture names either a url or an upload, not both."
+  }
+);
+var CatalogStockSchema = z.object({
+  managed: z.boolean(),
+  /** Left out, the count stays as it is. */
+  quantity: z.number().int().min(0).max(1e9).optional(),
+  /** Below this a product counts as running low; `null` warns never. */
+  lowThreshold: z.number().int().min(0).max(1e9).nullable().optional(),
+  /** Whether it can still be ordered at zero: `deny`, `allow`, or `allow_notify`. */
+  backorders: z.enum(["deny", "allow", "allow_notify"]).optional()
 }).strict();
 var CatalogVariantAxisSchema = z.object({
   slug: CatalogFieldSlugSchema,
@@ -108,6 +157,8 @@ var CatalogVariantSchema = z.object({
   sku: text(100),
   gtin: z.string().regex(/^[0-9]{8,14}$/).nullable().optional(),
   prices: pricesSchema.optional(),
+  /** The variant's own shelf; a physical product counts per variant. */
+  stock: CatalogStockSchema.optional(),
   position: z.number().int().min(0).max(1e4).optional(),
   active: z.boolean().optional()
 }).strict();
@@ -139,6 +190,15 @@ var CatalogProductUpsertSchema = z.object({
   visibility: z.enum(["public", "unlisted"]).optional(),
   metaTitle: text(300),
   metaDescription: text(1e3),
+  /**
+   * What a shared link to the product shows (the og tags): its own title,
+   * description and picture. Left out, a link falls back to the name, the
+   * description and the first picture. `socialImage` is fetched after the
+   * answer like `images`; `null` takes it away.
+   */
+  socialTitle: text(300),
+  socialDescription: text(1e3),
+  socialImage: CatalogFileRefSchema.nullable().optional(),
   /** Replaces the product's categories, by slug. */
   categories: z.array(CatalogWebSlugSchema).max(50).optional(),
   /**
@@ -157,6 +217,11 @@ var CatalogProductUpsertSchema = z.object({
   addMissingOptions: z.boolean().optional(),
   /** Replaces the product's prices as a whole. */
   prices: pricesSchema.optional(),
+  /**
+   * The product's own shelf. Physical products only, and only one without
+   * variants: a product with variants counts per variant.
+   */
+  stock: CatalogStockSchema.optional(),
   /** Replaces the product's pictures, in this order. */
   images: z.array(CatalogImageSchema).max(20).optional(),
   variantAxes: z.array(CatalogVariantAxisSchema).min(1).max(3).optional(),
@@ -219,6 +284,14 @@ var CatalogProductUpsertSchema = z.object({
       });
     }
   }
+  if (body.stock !== void 0 && body.variantAxes !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["stock"],
+      // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+      message: "A product with variants counts its stock per variant."
+    });
+  }
   if (body.availability === "scheduled" && !body.publishedAt) {
     ctx.addIssue({
       code: "custom",
@@ -230,6 +303,15 @@ var CatalogProductUpsertSchema = z.object({
 });
 var CatalogProductArchiveSchema = z.object({ source: CatalogSourceSchema }).strict();
 var CatalogCategoryUpsertSchema = z.object({
+  /**
+   * The category's id in the system it came from -- a series in a site's
+   * own CMS -- with `source` naming whose id it is. With both, a category
+   * that carries this reference is changed, and renamed to the address in
+   * the path when somebody gave it another one in the app; without, the
+   * address alone finds it, as before.
+   */
+  source: CatalogSourceSchema.optional(),
+  externalRef: CatalogExternalRefSchema.optional(),
   name: z.string().trim().min(1).max(200).optional(),
   description: text(5e3),
   /** `null` puts the category at the top of the tree. */
@@ -238,7 +320,14 @@ var CatalogCategoryUpsertSchema = z.object({
   publishedAt: z.string().datetime({ offset: true }).nullable().optional(),
   metaTitle: text(300),
   metaDescription: text(1e3)
-}).strict();
+}).strict().refine(
+  (body) => body.source === void 0 === (body.externalRef === void 0),
+  {
+    path: ["externalRef"],
+    // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+    message: "A category reference names both source and externalRef."
+  }
+);
 var CatalogObjectSlugSchema = z.string().max(64).regex(FIELD_SLUG, {
   message: (
     // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
@@ -256,6 +345,7 @@ var CatalogFieldTypeSchema = z.enum([
   "number",
   "select",
   "checkbox",
+  "color",
   "url",
   "date",
   "content_text",
@@ -286,7 +376,24 @@ var CatalogAttributeUpsertSchema = z.object({
    * a configurator's whole structure. An item field keeps its type once it
    * exists.
    */
-  config: z.record(z.string(), z.unknown()).optional()
+  config: z.record(z.string(), z.unknown()).optional(),
+  /**
+   * Say what this body would change -- a new field, a new label, choices
+   * added, choices taken away and how many products hold each -- and
+   * write nothing.
+   */
+  dryRun: z.boolean().optional(),
+  /**
+   * Bring the field back from the trash under its own id, with every value
+   * the products kept. Nothing else may be sent with it.
+   */
+  restore: z.literal(true).optional(),
+  /**
+   * For a new content field (`content_text`, `repeater`, `cta`): put its
+   * block at the end of the product page. On by default; `false` makes the
+   * field only. Never moves or restores a block of an existing field.
+   */
+  placeOnPage: z.boolean().optional()
 }).strict();
 var CONFIGURATOR_FILE_KINDS = ["model", "texture"];
 var CONFIGURATOR_TEXTURE_CONTENT_TYPES = [
@@ -312,6 +419,38 @@ var ConfiguratorFileUploadSchema = z.discriminatedUnion("step", [
     uploadPath: z.string().max(200)
   }).strict()
 ]);
+var CATALOG_FILE_KINDS = ["image", "file"];
+var CATALOG_FILE_CONTENT_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "application/pdf",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "text/plain",
+  "text/csv",
+  "application/zip"
+];
+var CatalogFileUploadSchema = z.discriminatedUnion("step", [
+  z.object({
+    step: z.literal("start"),
+    /** A picture (2 MB, png/jpeg/webp) or a download for a list item (20 MB). */
+    kind: z.enum(CATALOG_FILE_KINDS),
+    /** The bytes about to be sent, so a too-large file is refused before it travels. */
+    size: z.number().int().min(1),
+    contentType: z.enum(CATALOG_FILE_CONTENT_TYPES)
+  }).strict(),
+  z.object({
+    step: z.literal("finish"),
+    kind: z.enum(CATALOG_FILE_KINDS),
+    /** The `uploadPath` `start` answered with. */
+    uploadPath: z.string().max(200)
+  }).strict()
+]);
+
+// src/catalog-tools.ts
+import { z as z3 } from "zod";
 
 // src/tool-answers.ts
 import { CrmApiError } from "@solumflow-app/crm-client";
@@ -342,7 +481,7 @@ function refusal(error, scope) {
 var NEXT_STEP = {
   unauthorized: "The key is not recognised or was revoked. Ask the account owner for a new secret key.",
   feature_unavailable: "The module this needs is switched off for the account. Ask somebody to switch it on in the app.",
-  rate_limited: "Too many requests. Wait a moment and try again.",
+  rate_limited: "Too many requests: 120 a minute per key, 600 per account, and 5 MB of bodies a day per key. Wait the seconds the answer names and try again.",
   internal_error: "Something went wrong in the app. Trying again is safe."
 };
 function codeBlock(snippet) {
@@ -357,8 +496,8 @@ var page = {
 function more(nextCursor) {
   return nextCursor ? `More on the next page: cursor ${nextCursor}` : "";
 }
-function money(cents2, currency) {
-  return `${(cents2 / 100).toFixed(2)} ${currency.toUpperCase()}`;
+function money(cents2, currency2) {
+  return `${(cents2 / 100).toFixed(2)} ${currency2.toUpperCase()}`;
 }
 
 // src/catalog-tools.ts
@@ -367,7 +506,15 @@ var objectInput = {
     "The slug of the catalogue (see list_catalogs). Leave out for the account\u2019s own catalogue."
   )
 };
-var CONTENT_BLOCKS = 'Besides plain values (text, number, choice), a product can carry content blocks, three field types: "content_text" is { html, links? } with already-sanitised html; "cta" is { heading, body, primary: {label,url}, secondary? }, a call to action; "repeater" is { items: [{ id, ...one value per item field }] } and covers lists, accordions (FAQ), downloads and testimonials. A repeater\u2019s field says how to draw it: "display" is "list" or "accordion", "preset" names where it started (list, faq, downloads, testimonials), "itemFields" is the structure of one item (key, label, type: text, richtext, url {label,url}, icon {set,name}, image or file {url,name,size,contentType}) and "titleKey" is the item field that names an item, such as the question of a FAQ. A "configurator" is a 3D product configurator: a listing carries only { configurator: true }, a product\u2019s own page the whole document (see read_configurator). A block that is public but empty is null; a block that is not public is not there at all.';
+var CONTENT_BLOCKS = 'Besides plain values (text, number, choice), a product can carry content blocks, three field types: "content_text" is { html, links? } with already-sanitised html; "cta" is { heading, body, primary: {label,url}, secondary? }, a call to action; "repeater" is { items: [{ id, ...one value per item field }] } and covers lists, accordions (FAQ), downloads and testimonials. A repeater\u2019s field says how to draw it: "display" is "list" or "accordion", "preset" names where it started (list, faq, downloads, testimonials), "itemFields" is the structure of one item (key, label, type: text, richtext, url {label,url}, icon {set,name}, image or file {url,name,size,contentType}) and "titleKey" is the item field that names an item, such as the question of a FAQ. A "configurator" is a 3D product configurator: a listing carries only { configurator: true }, a product\u2019s own page the whole document (see read_configurator). A block that is public but empty is null; a block that is not public is not there at all. A new block field stands at the end of the product page from the moment upsert_field makes it (`placeOnPage: false` skips that).';
+var currency = z3.string().regex(/^[A-Z]{3}$/).optional().describe(
+  "Every price in this currency (see list_currencies), each with its origin: base, fixed or converted. Left out, every price in its own currency."
+);
+var READ_STATUS_HINT = 'Left out, only published ones. "draft" is what is not on the website yet (concept, internal or scheduled), "archived" what was taken out, "all" everything; each answers with a `status` and `publishedAt` per item. Anything but published needs a key with catalog:write.';
+var productStatus = z3.enum(["published", "draft", "archived", "all"]).optional().describe(`Which products. ${READ_STATUS_HINT}`);
+var categoryStatus = z3.enum(["published", "draft", "all"]).optional().describe(
+  `Which categories. ${READ_STATUS_HINT.replace('"archived" what was taken out, ', "")} A category cannot be archived.`
+);
 var slugOrId = z3.string().min(1).max(200).describe("The address (slug) or the id of the product.");
 function registerCatalogTools(server, client) {
   server.registerTool(
@@ -412,17 +559,49 @@ function registerCatalogTools(server, client) {
       }
     }
   );
+  server.registerTool(
+    "list_currencies",
+    {
+      title: "List the currencies the shop sells in",
+      description: "The account\u2019s own currency first, then the ones it switched on, with a name and symbol: what a currency menu on a website is built from. Pass one as `currency` to get_product or list_products for prices in it. Which currencies are offered, and at what rate, is set in the app (Settings \u2192 Verkoop \u2192 Valuta), not through this tool.",
+      inputSchema: {
+        locale: z3.string().min(2).max(35).optional().describe('The language names are written in, such as "nl".')
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ locale }) => {
+      try {
+        const currencies = await client.getCurrencies(
+          locale ? { locale } : void 0
+        );
+        return answer(
+          currencies.map(
+            (option) => `${option.code} (${option.symbol}) ${option.name}${option.isDefault ? ", the account\u2019s own" : ""}`
+          ).join("\n"),
+          currencies
+        );
+      } catch (error) {
+        return refusal(error, "catalog:read");
+      }
+    }
+  );
   server.registerTool(
     "get_product",
     {
       title: "Read one product",
-      description: "One product as its page needs it: name, prices, pictures, categories, variants and `fields`, keyed by field slug. May be a minute old. Answers that it is not found for an unknown product. " + CONTENT_BLOCKS,
-      inputSchema: { slugOrId },
+      description: "One product as its page needs it: name, prices, pictures, categories, variants and `fields`, keyed by field slug. Published products only unless you pass `status` (needs catalog:write), and a published one may be a minute old: to read back exactly what you just wrote, use get_product_by_ref. Answers that it is not found for an unknown product, or one not in the status asked. " + CONTENT_BLOCKS,
+      inputSchema: { slugOrId, currency, status: productStatus },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async ({ slugOrId: wanted }) => {
+    async ({ slugOrId: wanted, currency: inCurrency, status }) => {
       try {
-        const product = await client.getProduct(wanted);
+        const product = await client.getProduct(
+          wanted,
+          inCurrency || status ? {
+            ...inCurrency ? { currency: inCurrency } : {},
+            ...status ? { status } : {}
+          } : void 0
+        );
         if (!product) {
           return answer(`No product "${wanted}" on this account.`, null);
         }
@@ -439,22 +618,41 @@ function registerCatalogTools(server, client) {
   server.registerTool(
     "list_products",
     {
-      title: "List the published products",
-      description: "One page of the catalogue: name, address (slug), lowest price, whether it is in stock, its first picture and the public fields a listing shows. Narrow it to one category\u2019s whole branch by its id (from list_categories), or to one catalogue by the slug of its object. Read get_product for everything a product page needs. May be a minute old.",
+      title: "List the products",
+      description: "One page of the catalogue: name, address (slug), lowest price, whether it is in stock, its first picture and the public fields a listing shows. Narrow it to one category\u2019s whole branch by its id or address, or by the reference upsert_category recorded (`categorySource` + `categoryRef`), to one catalogue by the slug of its object, or to the product carrying an article number (`sku`). Read get_product for everything a product page needs. Published products only, and may be a minute old; `status` lists concepts, scheduled and archived ones too (needs catalog:write).",
       inputSchema: {
         ...page,
-        category: z3.string().uuid().optional().describe("A category id; includes its subcategories."),
+        category: z3.string().regex(
+          /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[a-z0-9]+(-[a-z0-9]+)*)$/i
+        ).max(64).optional().describe(
+          "A category id or address (slug); includes its subcategories."
+        ),
+        categorySource: z3.string().max(64).optional().describe("With categoryRef: whose id the category reference is."),
+        categoryRef: z3.string().max(255).optional().describe("A category by the id it has in your own system."),
+        sku: z3.string().min(1).max(100).optional().describe(
+          "The product carrying this article number, or whose variant does."
+        ),
         object: z3.string().min(1).max(63).optional().describe(
           'One catalogue, by the slug of its object, such as "product".'
-        )
+        ),
+        currency,
+        status: productStatus
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async (input) => {
+    async ({ categorySource, categoryRef, ...input }) => {
       try {
-        const list = await client.getProducts(input);
+        const list = await client.getProducts({
+          ...input,
+          ...categorySource && categoryRef ? {
+            categoryRef: {
+              source: categorySource,
+              externalRef: categoryRef
+            }
+          } : {}
+        });
         return answer(
-          list.data.length === 0 ? "No published products match." : [...list.data.map(describeProduct), more(list.nextCursor)].filter(Boolean).join("\n"),
+          list.data.length === 0 ? `No ${input.status && input.status !== "published" ? input.status : "published"} products match.` : [...list.data.map(describeProduct), more(list.nextCursor)].filter(Boolean).join("\n"),
           list
         );
       } catch (error) {
@@ -465,11 +663,12 @@ function registerCatalogTools(server, client) {
   server.registerTool(
     "list_categories",
     {
-      title: "List the published categories",
-      description: 'The categories of the catalogue, each with its path from the top and how many products are in it. Left without `parent`, every category comes back, which is what building a menu in one go needs; "root" asks for the top level, a category id for its children.',
+      title: "List the categories",
+      description: 'The categories of the catalogue, each with its path from the top and how many products are in it. Left without `parent`, every category comes back, which is what building a menu in one go needs; "root" asks for the top level, a category id for its children. Published categories only unless you pass `status` (draft or all, needs catalog:write).',
       inputSchema: {
         ...page,
-        parent: z3.union([z3.literal("root"), z3.string().uuid()]).optional().describe('"root" or the id of a category.')
+        parent: z3.union([z3.literal("root"), z3.string().uuid()]).optional().describe('"root" or the id of a category.'),
+        status: categoryStatus
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -477,7 +676,7 @@ function registerCatalogTools(server, client) {
       try {
         const list = await client.getCategories(input);
         return answer(
-          list.data.length === 0 ? "No published categories." : [...list.data.map(describeCategory), more(list.nextCursor)].filter(Boolean).join("\n"),
+          list.data.length === 0 ? `No ${input.status && input.status !== "published" ? input.status : "published"} categories.` : [...list.data.map(describeCategory), more(list.nextCursor)].filter(Boolean).join("\n"),
           list
         );
       } catch (error) {
@@ -489,10 +688,11 @@ function registerCatalogTools(server, client) {
     "get_category",
     {
       title: "Read one category page",
-      description: "One category as its page needs it: name, description, the texts for search engines and social media, and the first page of its products. Pass the nextCursor back to page through the products.",
+      description: "One category as its page needs it: name, description, the texts for search engines and social media, and the first page of its products. Pass the nextCursor back to page through the products. A category that is not on the website yet needs `status` (draft or all, catalog:write); its products are the published ones.",
       inputSchema: {
         slugOrId: z3.string().min(1).max(200).describe("The address (slug) or the id of the category."),
-        ...page
+        ...page,
+        status: categoryStatus
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -541,35 +741,308 @@ function registerCatalogTools(server, client) {
   );
 }
 function describeProduct(product) {
-  const stock = product.inStock ? "" : ", out of stock";
-  return `- ${product.name} (${product.slug}): from ${money(product.priceFromCents, product.currency)}${stock}`;
+  const stock = `${product.inStock ? "" : ", out of stock"}${product.status ? `, ${product.status}` : ""}`;
+  const from = product.priceFromCents === null ? `no price in ${product.currency}` : `from ${money(product.priceFromCents, product.currency)}`;
+  return `- ${product.name} (${product.slug}): ${from}${stock}`;
 }
 function describeCategory(category) {
   const path = category.path.map((step) => step.name).join(" / ");
-  return `- ${path || category.name} (${category.slug}, id ${category.id}): ${category.productCount} products`;
+  const state = category.status ? `, ${category.status}` : "";
+  return `- ${path || category.name} (${category.slug || "no address yet"}, id ${category.id}${state}): ${category.productCount} products`;
 }
 function describeField(field) {
   if (field.type !== "repeater") {
-    return `- ${field.slug}: ${field.label}, ${field.type}`;
+    return `- ${field.slug}: ${field.label}, ${field.type}${settingsOf(field)}`;
   }
   const items = (field.itemFields ?? []).map(({ key, type }) => `${key}:${type}`).join(", ");
   const preset = field.preset ? `, ${field.preset}` : "";
   const title = field.titleKey ? `; titled by ${field.titleKey}` : "";
   return `- ${field.slug}: ${field.label}, repeater (${field.display ?? "list"}${preset}; items: ${items}${title})`;
 }
+var SETTING_KEYS = [
+  "prefix",
+  "suffix",
+  "currency",
+  "symbolPosition",
+  "thousandsSeparator",
+  "decimalSeparator",
+  "decimals",
+  "display",
+  "layout",
+  "mode",
+  "secondary"
+];
+function settingsOf(field) {
+  const given = SETTING_KEYS.flatMap(
+    (key) => field[key] === void 0 ? [] : [`${key} ${JSON.stringify(field[key])}`]
+  );
+  if (field.rows) {
+    given.push(`${field.rows.length} rows`);
+  }
+  if (field.columns) {
+    given.push(`${field.columns.length} columns`);
+  }
+  return given.length > 0 ? ` (${given.join(", ")})` : "";
+}
 
-// src/catalog-write-tools.ts
+// src/catalog-migration-tools.ts
+import { readFile, stat } from "fs/promises";
+import { extname } from "path";
+var BULK_LIMIT = 25;
+var LIMITS = "Limits: 120 requests a minute per key and 600 per account; 5 MB of request bodies a day per key and 20 MB per account (a long HTML description counts). A refusal for speed says how long to wait.";
+var FILE_RULES = {
+  image: {
+    maxBytes: 2 * 1024 * 1024,
+    types: {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".webp": "image/webp"
+    }
+  },
+  file: {
+    maxBytes: 20 * 1024 * 1024,
+    types: {
+      ".pdf": "application/pdf",
+      ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      ".txt": "text/plain",
+      ".csv": "text/csv",
+      ".zip": "application/zip"
+    }
+  }
+};
 function target(object2) {
   return object2 ? { object: object2 } : void 0;
 }
-var FIELD_KINDS = 'Kinds: text, number, select, checkbox, url, date, and three content blocks for a product page: "content_text" (formatted text, no config), "cta" (a call to action; config { secondary: true } offers a second button) and "repeater" (a list, an accordion such as a FAQ, downloads or testimonials; config { display: "list" | "accordion", preset?: "list" | "faq" | "downloads" | "testimonials", itemFields: [{ key, label, type: text | richtext | url | icon | image | file }], titleKey?: the item field that names an item }). A number may take config { prefix?, suffix? }. A configurator is made with upsert_configurator. The kind is fixed once the field exists, and so is the type of a repeater\u2019s item field.';
+function notDone(text2) {
+  return { isError: true, content: [{ type: "text", text: text2 }] };
+}
+function registerCatalogMigrationTools(server, client) {
+  server.registerTool(
+    "get_product_by_ref",
+    {
+      title: "Read back a product you wrote",
+      description: "One product by the reference it was written under (`source` + `externalRef`), a draft too. `fields` holds every field the product has a value for, public or not, as stored -- list item ids and file paths included, which a write accepts back; `publicFields` is what a visitor sees of them. `categories` lists every category it is filed under, a concept one too, each with its `status`. Also `status` and `publishedAt`, its sku and shelf per variant, the shared-link texts and picture, and `files` -- for every picture or file of the last write whether it is `pending`, `stored` or `refused`, with a reason code. Live, never cached: read this after upsert_product to see what arrived.",
+      inputSchema: {
+        externalRef: CatalogExternalRefSchema,
+        source: CatalogSourceSchema,
+        ...objectInput
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ externalRef, source, object: object2 }) => {
+      try {
+        const product = await client.getProductByRef(
+          externalRef,
+          source,
+          target(object2)
+        );
+        if (!product) {
+          return answer(
+            `No product with reference "${externalRef}" from "${source}".`,
+            null
+          );
+        }
+        const refused = product.files.filter(
+          (file) => file.status === "refused"
+        );
+        const pending = product.files.filter(
+          (file) => file.status === "pending"
+        );
+        return answer(
+          `${product.name} (${product.slug || "no address"}), ${product.status} (${product.availability}); ${Object.keys(product.fields).length} fields, ${product.categories.length} categories, ${product.images.length} pictures; files: ${pending.length} pending, ${refused.length} refused${refused.length ? ` (${refused.map((file) => `${file.ref}: ${file.reason}`).join("; ")})` : ""}.`,
+          product
+        );
+      } catch (error) {
+        return refusal(error, "catalog:write");
+      }
+    }
+  );
+  server.registerTool(
+    "upsert_products",
+    {
+      title: "Make or change many products",
+      description: `Up to ${BULK_LIMIT} products, one after another, each exactly as upsert_product takes it (\`externalRef\` beside its body). A refusal is that product\u2019s outcome and the others go on; a refusal for speed is waited out and the product sent again; a key that is refused stops the run and the rest is \`skipped\`. Answers per product \`created\`, \`changed\`, \`refused\` (with the fields) or \`skipped\`. ` + LIMITS,
+      inputSchema: {
+        products: z4.array(
+          z4.object({
+            externalRef: CatalogExternalRefSchema,
+            product: CatalogProductUpsertSchema
+          })
+        ).min(1).max(BULK_LIMIT),
+        ...objectInput
+      },
+      annotations: { destructiveHint: true, idempotentHint: true }
+    },
+    async ({ products, object: object2 }) => {
+      try {
+        const outcomes = await client.upsertProducts(
+          products.map((item) => ({
+            externalRef: item.externalRef,
+            input: item.product
+          })),
+          target(object2)
+        );
+        const count = (kind) => outcomes.filter((outcome) => outcome.outcome === kind).length;
+        const refusals = outcomes.filter((outcome) => outcome.outcome === "refused").map(
+          (outcome) => `- ${outcome.externalRef}: ${outcome.error?.message ?? "refused"}` + (outcome.error?.fields.length ? ` (${outcome.error.fields.map((field) => `${field.path}: ${field.message}`).join("; ")})` : "")
+        );
+        return answer(
+          [
+            `${count("created")} made, ${count("changed")} changed, ${count("refused")} refused, ${count("skipped")} skipped.`,
+            ...refusals
+          ].join("\n"),
+          outcomes
+        );
+      } catch (error) {
+        return refusal(error, "catalog:write");
+      }
+    }
+  );
+  server.registerTool(
+    "delete_field",
+    {
+      title: "Take a catalogue field away",
+      description: "Moves a field to the trash, as the app does: for thirty days it can come back with restore_field, and every product keeps its value meanwhile. Use `permanent` only when the user explicitly asks to delete for good, and first without `confirm`: that only counts the products that would lose their value. Show the user that count; send `confirm` (the slug again) only after they agree. A field of the app\u2019s own, or one a product varies along, is refused.",
+      inputSchema: {
+        slug: CatalogFieldSlugSchema,
+        permanent: z4.boolean().optional(),
+        confirm: z4.string().max(63).optional(),
+        ...objectInput
+      },
+      annotations: { destructiveHint: true, idempotentHint: true }
+    },
+    async ({ slug, permanent, confirm, object: object2 }) => {
+      try {
+        const result = await client.removeField(slug, {
+          ...target(object2),
+          ...permanent ? { permanent } : {},
+          ...confirm ? { confirm } : {}
+        });
+        const text2 = result.state === "trashed" ? `${slug} is in the trash until ${result.restorableUntil ?? "thirty days from now"}; ${result.productsWithValue} products keep their value.` : result.state === "would_delete" ? `Nothing changed. Deleting ${slug} for good would clear its value on ${result.productsWithValue} products. ${result.confirm}` : `${slug} is deleted; its value on ${result.productsWithValue} products is being cleared.`;
+        return answer(text2, result);
+      } catch (error) {
+        return refusal(error, "catalog:write");
+      }
+    }
+  );
+  server.registerTool(
+    "restore_field",
+    {
+      title: "Bring a catalogue field back from the trash",
+      description: "A field moved to the trash in the last thirty days comes back under its own id, with every value the products kept.",
+      inputSchema: { slug: CatalogFieldSlugSchema, ...objectInput },
+      annotations: { destructiveHint: false, idempotentHint: true }
+    },
+    async ({ slug, object: object2 }) => {
+      try {
+        const field = await client.restoreField(slug, target(object2));
+        return answer(`${field.label} (${field.slug}) is back.`, field);
+      } catch (error) {
+        return refusal(error, "catalog:write");
+      }
+    }
+  );
+  server.registerTool(
+    "get_category_by_ref",
+    {
+      title: "Find a category by its reference",
+      description: 'The category upsert_category recorded with this `source` and `externalRef` -- the id of a series in your own system -- also after its address was changed in the app. A published category unless you pass `status`: "draft" finds a concept or scheduled one, "all" any (needs catalog:write).',
+      inputSchema: {
+        source: CatalogSourceSchema,
+        externalRef: CatalogExternalRefSchema,
+        status: z4.enum(["published", "draft", "all"]).optional().describe(
+          "Which categories to look in; anything but published needs catalog:write."
+        )
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ source, externalRef, status }) => {
+      try {
+        const category = await client.getCategoryByRef(
+          source,
+          externalRef,
+          status ? { status } : void 0
+        );
+        return answer(
+          category ? `${category.name} (${category.slug || "no address yet"}), id ${category.id}${category.status ? `, ${category.status}` : ""}.` : `No ${status && status !== "published" ? status : "published"} category with reference "${externalRef}" from "${source}"${status ? "" : ' (a concept category needs status "all")'}.`,
+          category
+        );
+      } catch (error) {
+        return refusal(error, "catalog:read");
+      }
+    }
+  );
+  server.registerTool(
+    "upload_catalog_file",
+    {
+      title: "Upload a picture or a file from disk",
+      description: 'Reads one file from the user\u2019s disk and uploads it, for a product write to name as { "upload": "<uploadPath>" } instead of a url: a picture (png, jpeg, webp, at most 2 MB) for `images`, `socialImage` or a list item\u2019s image, or a "file" (pdf, Office, txt, csv, zip, at most 20 MB) for a list item\u2019s download. An upload is kept a day.',
+      inputSchema: {
+        kind: z4.enum(["image", "file"]),
+        filePath: z4.string().min(1).max(1e3).describe("The absolute path of the file on this machine.")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false }
+    },
+    async ({ kind, filePath }) => {
+      const rules = FILE_RULES[kind];
+      const extension = extname(filePath).toLowerCase();
+      const contentType = rules.types[extension];
+      if (!contentType) {
+        return notDone(
+          `A ${kind} is a ${Object.keys(rules.types).join(", ")} file; this is "${extension || "no extension"}".`
+        );
+      }
+      const info = await stat(filePath).catch(() => null);
+      if (!info?.isFile()) {
+        return notDone(`"${filePath}" is not a file on this machine.`);
+      }
+      if (info.size > rules.maxBytes) {
+        return notDone(
+          `The file is ${info.size} bytes; a ${kind} may be at most ${rules.maxBytes}.`
+        );
+      }
+      try {
+        const result = await client.uploadCatalogFile({
+          kind,
+          bytes: new Uint8Array(await readFile(filePath)),
+          contentType
+        });
+        return answer(
+          `Uploaded. Name it as { "upload": "${result.uploadPath}" }.`,
+          result
+        );
+      } catch (error) {
+        return refusal(error, "catalog:write");
+      }
+    }
+  );
+}
+
+// src/catalog-write-tools.ts
+import { CrmApiError as CrmApiError2 } from "@solumflow-app/crm-client";
+function usedIn(details) {
+  const blockers = details?.blockers;
+  if (!Array.isArray(blockers) || blockers.length === 0) {
+    return null;
+  }
+  return blockers.map(
+    (entry) => `${String(entry.kind).replaceAll("_", " ")} (${String(entry.count)})`
+  ).join(", ");
+}
+function target2(object2) {
+  return object2 ? { object: object2 } : void 0;
+}
+var FIELD_KINDS = 'Kinds: text, number, select, checkbox, color (a value "#rrggbb"; upper case is stored lower case), url, date, and three content blocks for a product page: "content_text" (formatted text, no config), "cta" (a call to action; config { secondary: true } offers a second button) and "repeater" (a list, an accordion such as a FAQ, downloads or testimonials; config { display: "list" | "accordion", preset?: "list" | "faq" | "downloads" | "testimonials", itemFields: [{ key, label, type: text | richtext | url | icon | image | file | number | select }], titleKey?: the item field that names an item }). A number item may name { min?, max?, suffix? }, a select item names { options: [{ value, label }] } (at most 100); its value is one of those values. An image or file item is filled with { url } or { upload } in upsert_product, fetched after the answer. A number may take config { prefix?, suffix? }. A configurator is made with upsert_configurator. The kind is fixed once the field exists, and so is the type of a repeater\u2019s item field.';
 var IDENTITY = 'A product is known by `externalRef`, its id in the system it comes from, together with `source`, the name of that system (for example "acme-webshop"). The same pair always means the same product: sending it again changes it instead of making a second one, so use references that stay the same, never a name that may change.';
 function registerCatalogWriteTools(server, client) {
   server.registerTool(
     "upsert_product",
     {
       title: "Make or change a product",
-      description: IDENTITY + ' Every field but `source` may be left out, and left out means "leave it as it is"; null empties a field. A new product needs a `name` and is a draft unless `availability` says otherwise: do not publish without the user asking. `prices`, `categories`, `images` and `variants` each replace what the product had as a whole, and a variant left out is archived. Categories are named by slug and a missing one is refused unless `createMissingCategories` is true; a choice a select field does not offer is refused unless `addMissingOptions` is true. Pictures are https URLs, fetched after the answer (`images: "pending"`). Amounts are in cents. Read list_catalog_fields first for the slugs `fields` takes.',
+      description: IDENTITY + ' Every field but `source` may be left out, and left out means "leave it as it is"; null empties a field. A new product needs a `name` and is a draft unless `availability` says otherwise: do not publish without the user asking. `prices`, `categories`, `images` and `variants` each replace what the product had as a whole, and a variant left out is archived. Categories are named by slug and a missing one is refused unless `createMissingCategories` is true; a choice a select field does not offer is refused unless `addMissingOptions` is true. Pictures are https URLs, fetched after the answer (`images: "pending"`). Amounts are in cents. A price without `currency` is in the product\'s own; one with another `currency` is the fixed price for that currency, may share its label with the euro price, and can never be the default. `stock` (physical only; per variant when there are variants) is a count, not a movement: a second run writes it again over a correction made in the app, so send it only when the source keeps the count. A picture is { url } or { upload } (upload_catalog_file), with `alt`, a `role` in your own words ("insitu") and flat `details` ({ widthCm: 120 }); `socialImage` is the shared-link picture beside `socialTitle` and `socialDescription`. Files arrive after the answer: get_product_by_ref says per file whether it came. `description` is plain text (5,000 characters); `longDescription` is HTML, cleaned to headings, paragraphs, lists, links, bold and italic. A repeater is sent whole: `items` replaces the list. An item may leave out its `id` -- SolumFlow makes one, and `fields` in the answer holds it; send the id back to change that item, or the items are replaced by new ones and their files fetched again. An image or file item key is { url: "https://..." } (fetched after the answer) or { upload }; a wrong one is refused with the path of the item. To write many products use upsert_products. Read list_catalog_fields first for the slugs `fields` takes.',
       inputSchema: {
         externalRef: CatalogExternalRefSchema.describe(
           "The id of the product in the system named by `source`."
@@ -584,7 +1057,7 @@ function registerCatalogWriteTools(server, client) {
         const product = await client.upsertProduct(
           externalRef,
           input,
-          target(object2)
+          target2(object2)
         );
         const verb = product.created ? "Made" : "Changed";
         return answer(
@@ -615,7 +1088,7 @@ function registerCatalogWriteTools(server, client) {
         const result = await client.archiveProduct(
           externalRef,
           source,
-          target(object2)
+          target2(object2)
         );
         return answer(
           result.alreadyArchived ? "That product was already archived." : "Archived.",
@@ -626,11 +1099,54 @@ function registerCatalogWriteTools(server, client) {
       }
     }
   );
+  server.registerTool(
+    "delete_product",
+    {
+      title: "Delete a product for good",
+      description: IDENTITY + " Deleting removes the product, its variants, prices and pictures for good; it cannot be undone. It only works for a product that nothing uses: one that is on an order, a payment page, a subscription, a booking or a hosting service is refused, and the answer says where. Then archive_product is the way out. Archive when in doubt, and ask the user before deleting anything they did not name.",
+      inputSchema: {
+        externalRef: CatalogExternalRefSchema.describe(
+          "The id of the product in the system named by `source`."
+        ),
+        ...CatalogProductArchiveSchema.shape,
+        ...objectInput
+      },
+      annotations: { destructiveHint: true, idempotentHint: true }
+    },
+    async ({ externalRef, source, object: object2 }) => {
+      try {
+        const result = await client.deleteProduct(
+          externalRef,
+          source,
+          target2(object2)
+        );
+        return answer("Deleted for good.", result);
+      } catch (error) {
+        if (error instanceof CrmApiError2 && error.code === "conflict") {
+          const places = usedIn(error.details);
+          if (places) {
+            return {
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: `conflict: ${error.message}
+Used in: ${places}.
+Archive it with archive_product instead.`
+                }
+              ]
+            };
+          }
+        }
+        return refusal(error, "catalog:write");
+      }
+    }
+  );
   server.registerTool(
     "upsert_category",
     {
       title: "Make or change a category",
-      description: "A category, known by its address (slug): sending the same slug again changes it. Left-out fields stay as they are; a new category needs a `name`. `parentSlug` places it under another category, null at the top. A new category is a draft unless `availability` says otherwise. Categories belong to one catalogue: a product names only categories of its own catalogue.",
+      description: "A category, known by its address (slug): sending the same slug again changes it. Left-out fields stay as they are; a new category needs a `name`. `parentSlug` places it under another category, null at the top. A new category is a draft unless `availability` says otherwise. Categories belong to one catalogue: a product names only categories of its own catalogue. Send `source` and `externalRef` -- the id of the series in your own system -- and the category keeps that identity: it is found by it even after its address was changed in the app (and gets the address of this call back), and list_products narrows by it. Content of a series (long texts, galleries) stays in your own CMS.",
       inputSchema: {
         slug: CatalogWebSlugSchema.describe(
           "The address of the category: lower case, digits and dashes."
@@ -645,7 +1161,7 @@ function registerCatalogWriteTools(server, client) {
         const category = await client.upsertCategory(
           slug,
           input,
-          target(object2)
+          target2(object2)
         );
         return answer(
           `${category.created ? "Made" : "Changed"} ${category.name} (${category.slug}).`,
@@ -660,7 +1176,7 @@ function registerCatalogWriteTools(server, client) {
     "upsert_field",
     {
       title: "Make or change a catalogue field",
-      description: "A custom field on products, known by its slug: sending the same slug again changes it. A new field needs a `label`. " + FIELD_KINDS + " `config` replaces the settings as a whole. `options` makes sure choices exist and never removes one; `removeOptions` takes choices off the list, which empties them on every product that had them. `public` decides whether the website may show the field at all.",
+      description: "A custom field on products, known by its slug: sending the same slug again changes it. A new field needs a `label`. " + FIELD_KINDS + " `config` replaces the settings as a whole. `options` makes sure choices exist and never removes one; `removeOptions` takes choices off the list, which empties them on every product that had them. `public` decides whether the website may show the field at all. A new content field (content_text, repeater, cta) gets its block at the end of the product page in the same save, and the answer says `placedOnPage`; `placeOnPage: false` makes the field only. An existing field is never placed again, so a block somebody took off the page stays off. `dryRun: true` answers what would change -- and how many products hold each choice that would go -- and writes nothing. A slug in the trash is taken until restore_field or a permanent delete_field.",
       inputSchema: {
         slug: CatalogFieldSlugSchema.describe(
           "The slug of the field: a lower-case letter, then lower case, digits and underscores."
@@ -672,9 +1188,14 @@ function registerCatalogWriteTools(server, client) {
     },
     async ({ slug, object: object2, ...input }) => {
       try {
-        const field = await client.upsertField(slug, input, target(object2));
+        if (input.dryRun) {
+          const { dryRun: _dryRun, ...rest } = input;
+          const preview = await client.previewField(slug, rest, target2(object2));
+          return answer(`Nothing written. ${JSON.stringify(preview)}`, preview);
+        }
+        const field = await client.upsertField(slug, input, target2(object2));
         return answer(
-          `${field.created ? "Made" : "Changed"} ${field.label} (${field.slug}), ${field.type}, ${field.public ? "public" : "not public"}.`,
+          `${field.created ? "Made" : "Changed"} ${field.label} (${field.slug}), ${field.type}, ${field.public ? "public" : "not public"}.` + (field.placedOnPage === void 0 ? "" : field.placedOnPage ? " Its block is at the end of the product page." : ` Its block is not on the product page (${field.notPlacedBecause ?? "not placed"}).`),
           field
         );
       } catch (error) {
@@ -710,7 +1231,7 @@ function registerCatalogWriteTools(server, client) {
 }
 
 // src/configurator-tools.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // ../features/product-configurator/src/shared/configurator-limits.ts
 var CONFIGURATOR_LIMITS = {
@@ -1076,16 +1597,16 @@ function evaluateFormulaSource(source, scope) {
 }
 
 // ../features/product-configurator/src/shared/geometry-document.schema.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var CONFIGURATOR_NAME_PATTERN = /^[a-z][a-z0-9_]{0,39}$/;
 var CONFIGURATOR_CODE_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/;
-var ConfiguratorNameSchema = z4.string().regex(CONFIGURATOR_NAME_PATTERN, "configurator.invalidName");
-var ConfiguratorCodeSchema = z4.string().regex(CONFIGURATOR_CODE_PATTERN, "configurator.invalidCode");
-var FormulaSchema = z4.union([
-  z4.number().finite(),
-  z4.string().trim().min(1).max(CONFIGURATOR_LIMITS.formulaChars, "configurator.formulaTooLong")
+var ConfiguratorNameSchema = z5.string().regex(CONFIGURATOR_NAME_PATTERN, "configurator.invalidName");
+var ConfiguratorCodeSchema = z5.string().regex(CONFIGURATOR_CODE_PATTERN, "configurator.invalidCode");
+var FormulaSchema = z5.union([
+  z5.number().finite(),
+  z5.string().trim().min(1).max(CONFIGURATOR_LIMITS.formulaChars, "configurator.formulaTooLong")
 ]);
-var Vector3Schema = z4.tuple([FormulaSchema, FormulaSchema, FormulaSchema]);
+var Vector3Schema = z5.tuple([FormulaSchema, FormulaSchema, FormulaSchema]);
 var PRIMITIVE_TYPES = [
   "box",
   "rounded_top_box",
@@ -1128,93 +1649,93 @@ var PrimitiveNodeFields = {
   size: Vector3Schema,
   at: Vector3Schema,
   visible: FormulaSchema.optional(),
-  params: z4.record(ConfiguratorNameSchema, FormulaSchema).optional()
+  params: z5.record(ConfiguratorNameSchema, FormulaSchema).optional()
 };
-var PrimitiveNodeSchema = z4.strictObject({
+var PrimitiveNodeSchema = z5.strictObject({
   ...PrimitiveNodeFields,
-  type: z4.enum(PRIMITIVE_TYPES).exclude(["model"])
+  type: z5.enum(PRIMITIVE_TYPES).exclude(["model"])
 });
-var ModelPathSchema = z4.string().regex(CONFIGURATOR_MODEL_PATH_PATTERN, "configurator.invalidModelPath");
-var ServedFileUrlSchema = z4.url({ protocol: /^https?$/ });
+var ModelPathSchema = z5.string().regex(CONFIGURATOR_MODEL_PATH_PATTERN, "configurator.invalidModelPath");
+var ServedFileUrlSchema = z5.url({ protocol: /^https?$/ });
 function geometryNodeSchema(modelFile) {
-  const ModelNodeSchema = z4.strictObject({
+  const ModelNodeSchema = z5.strictObject({
     ...PrimitiveNodeFields,
-    type: z4.literal("model"),
+    type: z5.literal("model"),
     model: modelFile
   });
-  const ModelPerChoiceNodeSchema = z4.strictObject({
+  const ModelPerChoiceNodeSchema = z5.strictObject({
     ...PrimitiveNodeFields,
-    type: z4.literal("model"),
+    type: z5.literal("model"),
     follows: ConfiguratorNameSchema,
-    models: z4.record(ConfiguratorCodeSchema, modelFile).refine(
+    models: z5.record(ConfiguratorCodeSchema, modelFile).refine(
       (models) => Object.keys(models).length <= CONFIGURATOR_LIMITS.presets,
       { message: "configurator.tooMany" }
     )
   });
-  const node = z4.lazy(
-    () => z4.union([
+  const node = z5.lazy(
+    () => z5.union([
       PrimitiveNodeSchema,
       ModelNodeSchema,
       ModelPerChoiceNodeSchema,
-      z4.strictObject({
+      z5.strictObject({
         id: ConfiguratorNameSchema,
-        type: z4.literal("repeat"),
+        type: z5.literal("repeat"),
         count: FormulaSchema,
-        index: z4.enum(["i", "j"]).optional(),
+        index: z5.enum(["i", "j"]).optional(),
         visible: FormulaSchema.optional(),
-        children: z4.array(node).min(1)
+        children: z5.array(node).min(1)
       })
     ])
   );
   return node;
 }
 var GeometryNodeSchema = geometryNodeSchema(ModelPathSchema);
-var GeometryBindingSchema = z4.strictObject({
+var GeometryBindingSchema = z5.strictObject({
   param: ConfiguratorNameSchema,
-  map: z4.record(ConfiguratorCodeSchema, z4.number().finite()).optional()
+  map: z5.record(ConfiguratorCodeSchema, z5.number().finite()).optional()
 });
-var GeometryInputSchema = z4.strictObject({
+var GeometryInputSchema = z5.strictObject({
   name: ConfiguratorNameSchema,
   binding: GeometryBindingSchema
 });
-var GeometrySlotSchema = z4.strictObject({
+var GeometrySlotSchema = z5.strictObject({
   name: ConfiguratorNameSchema,
   param: ConfiguratorNameSchema.optional(),
   material: ConfiguratorCodeSchema.optional(),
-  color: z4.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor").optional(),
+  color: z5.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor").optional(),
   /**
    * Which way the grain of a picture runs on this part: `horizontal` (the
    * default) as the picture is drawn, `vertical` turned a quarter. It belongs
    * to the part, not the material: the same oak lies on a cabinet and stands
    * on a tall wall panel.
    */
-  grain: z4.enum(["horizontal", "vertical"]).optional()
+  grain: z5.enum(["horizontal", "vertical"]).optional()
 });
-var GeometryAnnotationSchema = z4.strictObject({
+var GeometryAnnotationSchema = z5.strictObject({
   id: ConfiguratorNameSchema,
-  axis: z4.enum(["x", "y"]),
+  axis: z5.enum(["x", "y"]),
   from: FormulaSchema,
   to: FormulaSchema,
   at: FormulaSchema,
-  label: z4.string().trim().min(1).max(80).optional()
+  label: z5.string().trim().min(1).max(80).optional()
 });
 function geometryDocumentSchema(modelFile) {
-  return z4.strictObject({
+  return z5.strictObject({
     /** Rises with every new upload, so a product page can say which one it shows. */
-    version: z4.number().int().min(1),
+    version: z5.number().int().min(1),
     /** The starter document this one was copied from, for information only. */
-    startedFrom: z4.string().trim().max(80).optional(),
-    inputs: z4.array(GeometryInputSchema).max(CONFIGURATOR_LIMITS.geometryInputs),
-    constants: z4.record(ConfiguratorNameSchema, z4.number().finite()),
-    slots: z4.array(GeometrySlotSchema).min(1).max(CONFIGURATOR_LIMITS.geometrySlots),
-    root: z4.array(geometryNodeSchema(modelFile)).min(1),
-    camera: z4.strictObject({
+    startedFrom: z5.string().trim().max(80).optional(),
+    inputs: z5.array(GeometryInputSchema).max(CONFIGURATOR_LIMITS.geometryInputs),
+    constants: z5.record(ConfiguratorNameSchema, z5.number().finite()),
+    slots: z5.array(GeometrySlotSchema).min(1).max(CONFIGURATOR_LIMITS.geometrySlots),
+    root: z5.array(geometryNodeSchema(modelFile)).min(1),
+    camera: z5.strictObject({
       /** Degrees around the vertical axis, 0 is straight on. */
-      azimuth: z4.number().min(-90).max(90),
+      azimuth: z5.number().min(-90).max(90),
       /** Degrees above the horizon. */
-      elevation: z4.number().min(-10).max(80)
+      elevation: z5.number().min(-10).max(80)
     }).optional(),
-    annotations: z4.array(GeometryAnnotationSchema).max(CONFIGURATOR_LIMITS.annotations)
+    annotations: z5.array(GeometryAnnotationSchema).max(CONFIGURATOR_LIMITS.annotations)
   });
 }
 var GeometryDocumentSchema = geometryDocumentSchema(ModelPathSchema);
@@ -1504,98 +2025,98 @@ function followProblems(follows, path, context) {
 }
 
 // ../features/product-configurator/src/shared/configurator-structure.schema.ts
-import { z as z5 } from "zod";
-var LabelSchema = z5.string().trim().min(1).max(80);
+import { z as z6 } from "zod";
+var LabelSchema = z6.string().trim().min(1).max(80);
 var CONFIGURATOR_TEXTURE_PATH_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.(webp|jpg|jpeg)$/;
-var TexturePathSchema = z5.string().regex(CONFIGURATOR_TEXTURE_PATH_PATTERN, "configurator.invalidTexturePath");
+var TexturePathSchema = z6.string().regex(CONFIGURATOR_TEXTURE_PATH_PATTERN, "configurator.invalidTexturePath");
 var ParameterBase = {
   key: ConfiguratorNameSchema,
   label: LabelSchema,
   tab: ConfiguratorNameSchema
 };
-var ConfiguratorParameterSchema = z5.discriminatedUnion("kind", [
-  z5.strictObject({
+var ConfiguratorParameterSchema = z6.discriminatedUnion("kind", [
+  z6.strictObject({
     ...ParameterBase,
-    kind: z5.literal("number"),
+    kind: z6.literal("number"),
     /** `mm` is a measure, `count` a number of things (compartments). */
-    unit: z5.enum(["mm", "count"]),
-    step: z5.number().positive().finite(),
+    unit: z6.enum(["mm", "count"]),
+    step: z6.number().positive().finite(),
     /** The widest range any model may offer; a model narrows it in its value. */
-    min: z5.number().finite(),
-    max: z5.number().finite()
+    min: z6.number().finite(),
+    max: z6.number().finite()
   }),
-  z5.strictObject({
+  z6.strictObject({
     ...ParameterBase,
-    kind: z5.literal("choice"),
+    kind: z6.literal("choice"),
     list: ConfiguratorNameSchema
   }),
-  z5.strictObject({ ...ParameterBase, kind: z5.literal("material") }),
-  z5.strictObject({ ...ParameterBase, kind: z5.literal("toggle") })
+  z6.strictObject({ ...ParameterBase, kind: z6.literal("material") }),
+  z6.strictObject({ ...ParameterBase, kind: z6.literal("toggle") })
 ]);
-var choiceListSchema = (picture) => z5.strictObject({
+var choiceListSchema = (picture) => z6.strictObject({
   key: ConfiguratorNameSchema,
   label: LabelSchema,
-  options: z5.array(
-    z5.strictObject({
+  options: z6.array(
+    z6.strictObject({
       code: ConfiguratorCodeSchema,
       label: LabelSchema,
       image: picture.optional()
     })
   ).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
 });
-var materialSchema = (picture) => z5.strictObject({
+var materialSchema = (picture) => z6.strictObject({
   code: ConfiguratorCodeSchema,
   label: LabelSchema,
-  color: z5.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor"),
+  color: z6.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor"),
   texture: picture.optional(),
   /** Millimetres one repeat of the texture covers; the two maps below share it. */
-  textureSize: z5.number().positive().max(1e4).optional(),
+  textureSize: z6.number().positive().max(1e4).optional(),
   /** Relief that moves with the light: a tangent-space normal map. */
   normalMap: picture.optional(),
   /** How deep the relief reads; 1 is the map as drawn. */
-  normalScale: z5.number().min(0).max(3).optional(),
+  normalScale: z6.number().min(0).max(3).optional(),
   /** Where the surface is matte and where it shines (the green channel), times `roughness`. */
   roughnessMap: picture.optional(),
-  roughness: z5.number().min(0).max(1).optional(),
-  metalness: z5.number().min(0).max(1).optional(),
+  roughness: z6.number().min(0).max(1).optional(),
+  metalness: z6.number().min(0).max(1).optional(),
   /** How much of what is behind it shows through: glass in front of a flame. Absent is solid. */
-  opacity: z5.number().min(0.05).max(1).optional(),
+  opacity: z6.number().min(0.05).max(1).optional(),
   /** Gives light rather than reflecting it: a flame, a LED. */
-  emissive: z5.boolean().optional(),
+  emissive: z6.boolean().optional(),
   priceGroup: ConfiguratorCodeSchema.optional()
 });
 var ConfiguratorChoiceListSchema = choiceListSchema(TexturePathSchema);
 var ConfiguratorMaterialSchema = materialSchema(TexturePathSchema);
-var ConditionValueSchema = z5.union([
-  z5.number().finite(),
-  z5.boolean(),
+var ConditionValueSchema = z6.union([
+  z6.number().finite(),
+  z6.boolean(),
   ConfiguratorCodeSchema,
-  z5.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
+  z6.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
 ]);
-var ConfiguratorConditionSchema = z5.strictObject({
+var ConfiguratorConditionSchema = z6.strictObject({
   param: ConfiguratorNameSchema,
-  op: z5.enum(["eq", "neq", "in", "gte", "lte"]),
+  op: z6.enum(["eq", "neq", "in", "gte", "lte"]),
   value: ConditionValueSchema
 });
-var ConfiguratorRuleSchema = z5.discriminatedUnion("kind", [
+var ConfiguratorRuleSchema = z6.discriminatedUnion("kind", [
   /** Show `param` only while `when` holds. */
-  z5.strictObject({
-    kind: z5.literal("visible"),
+  z6.strictObject({
+    kind: z6.literal("visible"),
     param: ConfiguratorNameSchema,
     when: ConfiguratorConditionSchema
   }),
   /** Narrow a number parameter: `max cabinet_height = total_height - 300`. */
-  z5.strictObject({
-    kind: z5.literal("limit"),
+  z6.strictObject({
+    kind: z6.literal("limit"),
     param: ConfiguratorNameSchema,
-    bound: z5.enum(["min", "max"]),
+    bound: z6.enum(["min", "max"]),
     formula: FormulaSchema
   }),
   /** While `when` holds, these codes of a choice or material are not offered. */
-  z5.strictObject({
-    kind: z5.literal("exclude"),
+  z6.strictObject({
+    kind: z6.literal("exclude"),
     param: ConfiguratorNameSchema,
-    codes: z5.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList),
+    codes: z6.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList),
     when: ConfiguratorConditionSchema
   })
 ]);
@@ -1605,23 +2126,23 @@ var PriceRuleBase = {
   /** How many times the amount counts, e.g. `compartments`. Absent is once. */
   multiplier: FormulaSchema.optional()
 };
-var ConfiguratorPriceRuleSchema = z5.discriminatedUnion("kind", [
+var ConfiguratorPriceRuleSchema = z6.discriminatedUnion("kind", [
   /** The surcharge the model gives the chosen option. */
-  z5.strictObject({
+  z6.strictObject({
     ...PriceRuleBase,
-    kind: z5.literal("choice"),
+    kind: z6.literal("choice"),
     param: ConfiguratorNameSchema
   }),
   /** The surcharge of the chosen material's price group. */
-  z5.strictObject({
+  z6.strictObject({
     ...PriceRuleBase,
-    kind: z5.literal("material"),
+    kind: z6.literal("material"),
     param: ConfiguratorNameSchema
   }),
   /** An amount, counted while a switch is on. */
-  z5.strictObject({
+  z6.strictObject({
     ...PriceRuleBase,
-    kind: z5.literal("toggle"),
+    kind: z6.literal("toggle"),
     param: ConfiguratorNameSchema,
     amount: ConfiguratorNameSchema
   }),
@@ -1629,10 +2150,10 @@ var ConfiguratorPriceRuleSchema = z5.discriminatedUnion("kind", [
    * A price on measure: `max(0, total_width - 1800) / 1000 * meter_price`.
    * Reads number parameters (in their unit) and amounts (in cents).
    */
-  z5.strictObject({
+  z6.strictObject({
     key: ConfiguratorNameSchema,
     label: LabelSchema,
-    kind: z5.literal("formula"),
+    kind: z6.literal("formula"),
     formula: FormulaSchema
   })
 ]);
@@ -1642,43 +2163,43 @@ var CONFIGURATOR_SCENE_LIGHTINGS = [
   "daylight"
 ];
 var CONFIGURATOR_SCENE_EDGES = ["soft", "sharp"];
-var ConfiguratorSceneSchema = z5.strictObject({
-  lighting: z5.enum(CONFIGURATOR_SCENE_LIGHTINGS).optional(),
-  edges: z5.enum(CONFIGURATOR_SCENE_EDGES).optional()
+var ConfiguratorSceneSchema = z6.strictObject({
+  lighting: z6.enum(CONFIGURATOR_SCENE_LIGHTINGS).optional(),
+  edges: z6.enum(CONFIGURATOR_SCENE_EDGES).optional()
 });
-var structureObjectSchema = (files) => z5.strictObject({
-  schemaVersion: z5.literal(1),
+var structureObjectSchema = (files) => z6.strictObject({
+  schemaVersion: z6.literal(1),
   geometry: geometryDocumentSchema(files.model),
   /**
    * How the scene is presented. Part of the structure and not of the shape
    * document, so the owner sets it under `crm.manage` like a material.
    */
   scene: ConfiguratorSceneSchema.optional(),
-  tabs: z5.array(
-    z5.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })
+  tabs: z6.array(
+    z6.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })
   ).min(1).max(CONFIGURATOR_LIMITS.tabs),
-  parameters: z5.array(ConfiguratorParameterSchema).max(CONFIGURATOR_LIMITS.parameters),
-  choiceLists: z5.array(choiceListSchema(files.picture)).max(CONFIGURATOR_LIMITS.choiceLists),
-  materials: z5.array(materialSchema(files.picture)).max(CONFIGURATOR_LIMITS.materials),
-  priceGroups: z5.array(
-    z5.strictObject({ code: ConfiguratorCodeSchema, label: LabelSchema })
+  parameters: z6.array(ConfiguratorParameterSchema).max(CONFIGURATOR_LIMITS.parameters),
+  choiceLists: z6.array(choiceListSchema(files.picture)).max(CONFIGURATOR_LIMITS.choiceLists),
+  materials: z6.array(materialSchema(files.picture)).max(CONFIGURATOR_LIMITS.materials),
+  priceGroups: z6.array(
+    z6.strictObject({ code: ConfiguratorCodeSchema, label: LabelSchema })
   ).max(CONFIGURATOR_LIMITS.priceGroups),
   /** Named amounts a model fills in and price rules read (`meter_price`). */
-  amounts: z5.array(
-    z5.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })
+  amounts: z6.array(
+    z6.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })
   ).max(CONFIGURATOR_LIMITS.amounts),
   /**
    * A list of fixed combinations a model offers, each setting some number
    * parameters at once: a fireplace and the niche it needs.
    */
-  presets: z5.strictObject({
+  presets: z6.strictObject({
     label: LabelSchema,
     tab: ConfiguratorNameSchema,
-    sets: z5.array(ConfiguratorNameSchema).min(1).max(CONFIGURATOR_LIMITS.parameters),
-    required: z5.boolean()
+    sets: z6.array(ConfiguratorNameSchema).min(1).max(CONFIGURATOR_LIMITS.parameters),
+    required: z6.boolean()
   }).optional(),
-  rules: z5.array(ConfiguratorRuleSchema).max(CONFIGURATOR_LIMITS.rules),
-  priceRules: z5.array(ConfiguratorPriceRuleSchema).max(CONFIGURATOR_LIMITS.priceRules)
+  rules: z6.array(ConfiguratorRuleSchema).max(CONFIGURATOR_LIMITS.rules),
+  priceRules: z6.array(ConfiguratorPriceRuleSchema).max(CONFIGURATOR_LIMITS.priceRules)
 });
 var ConfiguratorStructureObjectSchema = structureObjectSchema({
   picture: TexturePathSchema,
@@ -1837,8 +2358,8 @@ function configuratorStructureProblems(structure) {
   };
   structure.rules.forEach((rule, index) => {
     const path = ["rules", index];
-    const target2 = parameters.get(rule.param);
-    if (!target2) {
+    const target3 = parameters.get(rule.param);
+    if (!target3) {
       problems.push(
         issue([...path, "param"], "configurator.unknownParam", {
           key: rule.param
@@ -1847,7 +2368,7 @@ function configuratorStructureProblems(structure) {
       return;
     }
     if (rule.kind === "limit") {
-      if (target2.kind !== "number") {
+      if (target3.kind !== "number") {
         problems.push(
           issue([...path, "param"], "configurator.notANumberParam", {
             key: rule.param
@@ -1865,7 +2386,7 @@ function configuratorStructureProblems(structure) {
       return;
     }
     if (rule.kind === "exclude") {
-      const codes = codesOf(target2, lists, materials);
+      const codes = codesOf(target3, lists, materials);
       if (!codes) {
         problems.push(
           issue([...path, "param"], "configurator.notAChoiceParam", {
@@ -1944,8 +2465,8 @@ function configuratorStructureProblems(structure) {
         problems
       );
     }
-    const target2 = parameters.get(rule.param);
-    if (!target2 || target2.kind !== rule.kind) {
+    const target3 = parameters.get(rule.param);
+    if (!target3 || target3.kind !== rule.kind) {
       problems.push(
         issue([...path, "param"], "configurator.priceRuleParamKind", {
           key: rule.param,
@@ -2094,55 +2615,55 @@ function parameterResolutionOrder(structure) {
 }
 
 // ../features/product-configurator/src/shared/configurator-value.schema.ts
-import { z as z6 } from "zod";
-var CentsSchema = z6.number().int().min(0).max(1e8);
+import { z as z7 } from "zod";
+var CentsSchema = z7.number().int().min(0).max(1e8);
 var PriceSchema = CentsSchema.nullable();
-var ConfiguratorValueObjectSchema = z6.strictObject({
+var ConfiguratorValueObjectSchema = z7.strictObject({
   /** Null: the model has no price of its own, every quote is "open". */
   basePriceCents: PriceSchema,
-  numbers: z6.record(
+  numbers: z7.record(
     ConfiguratorNameSchema,
-    z6.strictObject({
-      min: z6.number().finite(),
-      max: z6.number().finite(),
-      default: z6.number().finite()
+    z7.strictObject({
+      min: z7.number().finite(),
+      max: z7.number().finite(),
+      default: z7.number().finite()
     })
   ).default({}),
   /** Per choice list: the options this model offers, with their surcharge. */
-  choices: z6.record(
+  choices: z7.record(
     ConfiguratorNameSchema,
-    z6.strictObject({
-      options: z6.record(
+    z7.strictObject({
+      options: z7.record(
         ConfiguratorCodeSchema,
-        z6.strictObject({ priceCents: PriceSchema })
+        z7.strictObject({ priceCents: PriceSchema })
       ),
       default: ConfiguratorCodeSchema.optional()
     })
   ).default({}),
   /** Per material parameter: the materials this model offers. */
-  materials: z6.record(
+  materials: z7.record(
     ConfiguratorNameSchema,
-    z6.strictObject({
-      offered: z6.array(ConfiguratorCodeSchema).max(CONFIGURATOR_LIMITS.materials),
+    z7.strictObject({
+      offered: z7.array(ConfiguratorCodeSchema).max(CONFIGURATOR_LIMITS.materials),
       default: ConfiguratorCodeSchema.optional()
     })
   ).default({}),
   /** Per switch: whether this model offers it, and how it starts. Absent is offered, off. */
-  toggles: z6.record(
+  toggles: z7.record(
     ConfiguratorNameSchema,
-    z6.strictObject({ offered: z6.boolean(), default: z6.boolean() })
+    z7.strictObject({ offered: z7.boolean(), default: z7.boolean() })
   ).default({}),
   /** The surcharge of each material price group. */
-  priceGroups: z6.record(ConfiguratorCodeSchema, PriceSchema).default({}),
+  priceGroups: z7.record(ConfiguratorCodeSchema, PriceSchema).default({}),
   /** The amounts the structure names, such as a price per metre. */
-  amounts: z6.record(ConfiguratorNameSchema, PriceSchema).default({}),
-  presets: z6.array(
-    z6.strictObject({
+  amounts: z7.record(ConfiguratorNameSchema, PriceSchema).default({}),
+  presets: z7.array(
+    z7.strictObject({
       code: ConfiguratorCodeSchema,
-      label: z6.string().trim().min(1).max(80),
+      label: z7.string().trim().min(1).max(80),
       /** A product of the same account this preset stands for, e.g. the fireplace. */
-      productId: z6.string().uuid().nullable(),
-      values: z6.record(ConfiguratorNameSchema, z6.number().finite())
+      productId: z7.string().uuid().nullable(),
+      values: z7.record(ConfiguratorNameSchema, z7.number().finite())
     })
   ).max(CONFIGURATOR_LIMITS.presets).default([])
 });
@@ -2601,9 +3122,9 @@ function modelOf(node, chosen) {
 }
 
 // src/configurator-tools.ts
-import { readFile, stat } from "fs/promises";
-import { extname } from "path";
-var FILE_RULES = {
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { extname as extname2 } from "path";
+var FILE_RULES2 = {
   model: { extensions: [".glb"], maxBytes: 10 * 1024 * 1024 },
   texture: {
     extensions: [".webp", ".jpg", ".jpeg"],
@@ -2611,7 +3132,7 @@ var FILE_RULES = {
   }
 };
 var CONFIGURATOR = 'A "configurator" field holds a 3D product configurator. Its structure has "geometry" (the shape document: "inputs" bound to parameters, "constants", material "slots", a "root" tree of building blocks and "annotations" for dimension lines), "parameters", "choiceLists", "materials", "priceGroups", "amounts", optional "presets", optional "scene" ({ "lighting": "studio" | "warm" | "daylight" }), "rules" and "priceRules". Building blocks: box, rounded_top_box (params.radius), stadium_prism, arc_panel (params.thickness, params.mirror), led_strip, niche_panel (params.niche_x, niche_y, niche_width, niche_height), model (a "model" path to a .glb uploaded with upload_configurator_file, params.fit 0 contain or 1 stretch, params.paint 1 to use the slot material) and repeat (count, children, index i or j). Every measure is millimetres; "at" is the minimum corner, x left to right, y bottom to top, z from the wall into the room; "size" is width, height, depth. A measure is a number or a formula with + - * / ( ) and min, max, floor, ceil, round, abs over the shape\u2019s inputs, constants and the repeat index. Texture paths in materials come from upload_configurator_file too. Making a configurator, or changing its "geometry", needs a key with the configurator:shape scope; everything around the shape needs only catalog:write.';
-var documentInput = z7.string().min(2).max(2e5).describe(
+var documentInput = z8.string().min(2).max(2e5).describe(
   'The JSON text of a whole configurator structure (it has "schemaVersion"), or of a shape document alone (it has "root").'
 );
 function registerConfiguratorTools(server, client) {
@@ -2643,11 +3164,11 @@ function registerConfiguratorTools(server, client) {
         slug: CatalogFieldSlugSchema.describe(
           "The slug of the configurator field."
         ),
-        label: z7.string().trim().min(1).max(120).optional(),
-        structure: z7.string().min(2).max(2e5).describe(
+        label: z8.string().trim().min(1).max(120).optional(),
+        structure: z8.string().min(2).max(2e5).describe(
           'The JSON text of the whole configurator structure (it has "schemaVersion").'
         ),
-        public: z7.boolean().optional().describe("Whether product pages may show the configurator."),
+        public: z8.boolean().optional().describe("Whether product pages may show the configurator."),
         ...objectInput
       },
       annotations: { destructiveHint: true, idempotentHint: true }
@@ -2697,21 +3218,21 @@ function registerConfiguratorTools(server, client) {
         fieldSlug: CatalogFieldSlugSchema.describe(
           "The slug of the configurator field."
         ),
-        kind: z7.enum(CONFIGURATOR_FILE_KINDS),
-        filePath: z7.string().min(1).max(1e3).describe("The absolute path of the file on this machine."),
+        kind: z8.enum(CONFIGURATOR_FILE_KINDS),
+        filePath: z8.string().min(1).max(1e3).describe("The absolute path of the file on this machine."),
         ...objectInput
       },
       annotations: { destructiveHint: false, idempotentHint: false }
     },
     async ({ fieldSlug, kind, filePath, object: object2 }) => {
-      const rules = FILE_RULES[kind];
-      const extension = extname(filePath).toLowerCase();
+      const rules = FILE_RULES2[kind];
+      const extension = extname2(filePath).toLowerCase();
       if (!rules.extensions.includes(extension)) {
         return notUploaded(
           `A ${kind} is a ${rules.extensions.join(" or ")} file; this is "${extension || "no extension"}".`
         );
       }
-      const info = await stat(filePath).catch(() => null);
+      const info = await stat2(filePath).catch(() => null);
       if (!info?.isFile()) {
         return notUploaded(`"${filePath}" is not a file on this machine.`);
       }
@@ -2721,7 +3242,7 @@ function registerConfiguratorTools(server, client) {
         );
       }
       try {
-        const bytes = new Uint8Array(await readFile(filePath));
+        const bytes = new Uint8Array(await readFile2(filePath));
         const result = await client.uploadConfiguratorFile(
           fieldSlug,
           {
@@ -2751,8 +3272,8 @@ function registerConfiguratorTools(server, client) {
       title: "Read the configurator of a product",
       description: "The configurator field of one product as its page receives it: the structure (texture paths already URLs), the model\u2019s value (ranges, offered options, amounts, presets), the tax a quote uses and the two hashes a request must send back. Useful to draft a new shape from an existing one. " + CONFIGURATOR,
       inputSchema: {
-        slugOrId: z7.string().min(1).max(200).describe("The address (slug) or the id of the product."),
-        field: z7.string().min(1).max(64).describe("The slug of the configurator field.")
+        slugOrId: z8.string().min(1).max(200).describe("The address (slug) or the id of the product."),
+        field: z8.string().min(1).max(64).describe("The slug of the configurator field.")
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -2834,8 +3355,8 @@ function isRecord(value) {
 }
 
 // src/event-tools.ts
-import { z as z8 } from "zod";
-var moment = z8.string().datetime({ offset: true }).optional().describe("An ISO timestamp with its offset, such as 2026-11-01T00:00:00Z.");
+import { z as z9 } from "zod";
+var moment = z9.string().datetime({ offset: true }).optional().describe("An ISO timestamp with its offset, such as 2026-11-01T00:00:00Z.");
 function registerEventTools(server, client) {
   server.registerTool(
     "list_events",
@@ -2863,7 +3384,7 @@ function registerEventTools(server, client) {
       title: "Read one event",
       description: "One event as its page needs it: description, doors and sales times, address, ticket types with their prices, and the texts for search engines. May be a minute old; ask get_event_availability for seats that must be current.",
       inputSchema: {
-        idOrSlug: z8.string().min(1).max(200).describe("The id or the address (slug) of the event.")
+        idOrSlug: z9.string().min(1).max(200).describe("The id or the address (slug) of the event.")
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -2888,7 +3409,7 @@ function registerEventTools(server, client) {
       title: "Seats left for an event",
       description: "Live, not cached: how many seats are left for the event and for each ticket type, and whether it is sold out. A remaining of null means there is no ceiling.",
       inputSchema: {
-        eventId: z8.string().uuid().describe("The id of the event.")
+        eventId: z9.string().uuid().describe("The id of the event.")
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -2916,9 +3437,9 @@ function describeEvent(event) {
 }
 
 // src/placement-tools.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var REACT_HINT = "On a React or Next.js site, prefer the components in `@solumflow-app/crm-client/react` (CrmForm, CrmBooking, CrmChatWidget, CrmSiteTracking) over pasting HTML.";
-var origin = z9.string().regex(/^https?:\/\/[a-zA-Z0-9.-]+(:[0-9]{1,5})?$/).describe("Scheme, host and optional port; no path: https://www.example.com");
+var origin = z10.string().regex(/^https?:\/\/[a-zA-Z0-9.-]+(:[0-9]{1,5})?$/).describe("Scheme, host and optional port; no path: https://www.example.com");
 function registerPlacementTools(server, client) {
   server.registerTool(
     "list_forms",
@@ -2991,13 +3512,13 @@ function registerPlacementTools(server, client) {
       title: "Make or change a chat widget",
       description: "Makes the chat widget at this address when there is none, or changes it. Sets its name, whether it is live, and which sites it may run on. How it looks and what it says is done in the app\u2019s builder. Sites are added and removed, never replaced. Careful: an empty list means ANY site, so adding the first origin narrows the widget to that site only, and removing an origin takes the chat off a site that may be live.",
       inputSchema: {
-        slug: z9.string().regex(/^[a-z][a-z0-9-]*$/).max(100).describe(
+        slug: z10.string().regex(/^[a-z][a-z0-9-]*$/).max(100).describe(
           'The widget\u2019s address on this account, such as "website-chat".'
         ),
-        name: z9.string().min(1).max(200).optional().describe("Required when the widget does not exist yet."),
-        status: z9.enum(["draft", "published"]).optional().describe("Only a published widget answers on a site."),
-        addAllowedOrigins: z9.array(origin).max(20).optional(),
-        removeAllowedOrigins: z9.array(origin).max(20).optional()
+        name: z10.string().min(1).max(200).optional().describe("Required when the widget does not exist yet."),
+        status: z10.enum(["draft", "published"]).optional().describe("Only a published widget answers on a site."),
+        addAllowedOrigins: z10.array(origin).max(20).optional(),
+        removeAllowedOrigins: z10.array(origin).max(20).optional()
       },
       annotations: {
         readOnlyHint: false,
@@ -3045,9 +3566,9 @@ ${describeChatWidget(widget)}`,
       title: "Set up or change the tracking script",
       description: "Sets website tracking up when it is not there, adds or removes the hosts it counts visits from, and changes the consent it waits for. An empty list of hosts counts nothing, so add the host of every site the script is placed on. Hosts are added and removed, never replaced.",
       inputSchema: {
-        addAllowedHosts: z9.array(z9.string()).max(20).optional().describe('Hosts such as "www.example.com" or "*.example.com".'),
-        removeAllowedHosts: z9.array(z9.string()).max(20).optional(),
-        consentSignal: z9.enum([
+        addAllowedHosts: z10.array(z10.string()).max(20).optional().describe('Hosts such as "www.example.com" or "*.example.com".'),
+        removeAllowedHosts: z10.array(z10.string()).max(20).optional(),
+        consentSignal: z10.enum([
           "ad_storage",
           "analytics_storage",
           "personalization_storage",
@@ -3132,7 +3653,119 @@ function readServerConfig(env) {
   return { ok: true, apiKey, baseUrl };
 }
 
+// src/server-info-tool.ts
+function registerServerInfoTool(server, info) {
+  server.registerTool(
+    "server_info",
+    {
+      title: "Which version of this server is running",
+      description: "The version of this MCP server and of the API client it uses, the address of the API it talks to, and `definitionsVersion`, a fingerprint of every tool definition it serves. A write tool names the same fingerprint in its description; when the two differ, your session was started before an update of this server and works from older tool definitions -- restart the session (in Claude Code `/mcp` and reconnect, or a new session). The server cannot do that for you.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async () => {
+      const result = {
+        version: info.version,
+        clientVersion: info.clientVersion,
+        baseUrl: info.baseUrl,
+        definitionsVersion: info.definitionsVersion()
+      };
+      return answer(
+        `crm-mcp-server ${result.version} (client ${result.clientVersion}), API ${result.baseUrl}, tool definitions ${result.definitionsVersion}.`,
+        result
+      );
+    }
+  );
+}
+
+// src/tool-definitions-version.ts
+import { z as z11 } from "zod";
+import { createHash } from "crypto";
+function toolDefinitionsHash(tools) {
+  const definitions = [...tools].sort((left, right) => left.name.localeCompare(right.name)).map(({ name, config }) => ({
+    name,
+    title: config.title ?? null,
+    description: config.description ?? null,
+    inputSchema: config.inputSchema ? z11.toJSONSchema(z11.object(config.inputSchema), {
+      io: "input",
+      unrepresentable: "any"
+    }) : null,
+    annotations: config.annotations ?? null
+  }));
+  return createHash("sha256").update(JSON.stringify(definitions)).digest("hex").slice(0, 12);
+}
+function writesSomething(config) {
+  return config.annotations?.readOnlyHint !== true;
+}
+function holdToolRegistrations(real) {
+  const pending = [];
+  let hash;
+  const server = new Proxy(real, {
+    get(target3, property) {
+      if (property === "registerTool") {
+        return (name, config, handler) => {
+          pending.push({ name, config, handler });
+          return void 0;
+        };
+      }
+      const value = Reflect.get(target3, property, target3);
+      return typeof value === "function" ? value.bind(target3) : value;
+    }
+  });
+  function currentHash() {
+    hash ??= toolDefinitionsHash(pending);
+    return hash;
+  }
+  function publish() {
+    const version2 = currentHash();
+    for (const { name, config, handler } of pending) {
+      if (!writesSomething(config)) {
+        real.registerTool(
+          name,
+          config,
+          handler
+        );
+        continue;
+      }
+      real.registerTool(
+        name,
+        {
+          ...config,
+          description: `${config.description ?? ""} Definitions version ${version2}: send it as schemaHash and the answer tells you when these tool definitions are older than the server.`,
+          inputSchema: {
+            ...config.inputSchema,
+            schemaHash: z11.string().max(64).optional().describe(
+              `The definitions version named in this tool's description (${version2}).`
+            )
+          }
+        },
+        (async ({ schemaHash, ...input }, extra) => {
+          const result = await handler(input, extra);
+          return schemaHash !== void 0 && schemaHash !== version2 ? {
+            ...result,
+            content: [
+              ...result.content ?? [],
+              { type: "text", text: staleDefinitions(version2) }
+            ]
+          } : result;
+        })
+      );
+    }
+    return version2;
+  }
+  return { server, publish, currentHash };
+}
+function staleDefinitions(version2) {
+  return `Note: your tool definitions are older than this server (its version is ${version2}). The call was carried out as given. Restart the session, or reconnect the server with /mcp in Claude Code, to load the current definitions; server_info says which version is running.`;
+}
+
 // src/index.ts
+import { createRequire } from "module";
+function installedClientVersion() {
+  return createRequire(import.meta.url)(
+    "@solumflow-app/crm-client/package.json"
+  ).version;
+}
 async function main() {
   const config = readServerConfig(process.env);
   if (!config.ok) {
@@ -3149,12 +3782,26 @@ async function main() {
     apiKey: config.apiKey,
     baseUrl: config.baseUrl
   });
-  registerPlacementTools(server, client);
-  registerCatalogTools(server, client);
-  registerCatalogWriteTools(server, client);
-  registerEventTools(server, client);
-  registerConfiguratorTools(server, client);
+  const held = holdToolRegistrations(server);
+  registerServerInfoTool(held.server, {
+    version,
+    clientVersion: installedClientVersion(),
+    baseUrl: config.baseUrl,
+    definitionsVersion: held.currentHash
+  });
+  registerPlacementTools(held.server, client);
+  registerCatalogTools(held.server, client);
+  registerCatalogWriteTools(held.server, client);
+  registerCatalogMigrationTools(held.server, client);
+  registerEventTools(held.server, client);
+  registerConfiguratorTools(held.server, client);
+  held.publish();
   await server.connect(new StdioServerTransport());
+  try {
+    server.sendToolListChanged();
+  } catch (error) {
+    console.error("crm-mcp-server: could not announce the tool list:", error);
+  }
 }
 main().catch((error) => {
   console.error("crm-mcp-server:", error);