@solumflow-app/crm-mcp-server 0.3.1 → 0.5.0

package/dist/index.js

@@ -5,23 +5,462 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createClient } from "@solumflow-app/crm-client";
 
+// package.json
+var version = "0.5.0";
+
+// 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";
+
+// ../features/crm-invoicing/src/schema/amount-ceiling.ts
+var MAX_AMOUNT_CENTS = 99999999;
+
+// ../features/crm-invoicing/src/schema/catalog-api.schema.ts
+var WEB_SLUG = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var FIELD_SLUG = /^[a-z][a-z0-9_]*$/;
+var CatalogSourceSchema = z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/, {
+  message: (
+    // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+    'A source is lower-case letters, digits and hyphens, at most 64 characters (for example "coolflames-payload").'
+  )
+});
+var CatalogExternalRefSchema = z.string().trim().min(1).max(255);
+var CatalogWebSlugSchema = z.string().min(2).max(64).regex(WEB_SLUG, {
+  // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+  message: "An address is lower-case letters and digits joined by hyphens."
+});
+var CatalogFieldSlugSchema = z.string().max(63).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
+    "A field slug starts with a letter and holds lower-case letters, digits and underscores."
+  )
+});
+var cents = z.number().int().min(0).max(MAX_AMOUNT_CENTS);
+var text = (max) => z.string().trim().max(max).nullable().optional();
+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(),
+  recurringInterval: z.enum(["day", "week", "month", "year"]).optional(),
+  recurringIntervalCount: z.number().int().min(1).max(365).optional(),
+  isDefault: z.boolean().optional(),
+  active: z.boolean().optional()
+}).strict().superRefine((price, ctx) => {
+  if ((price.kind ?? "one_off") === "recurring" && !price.recurringInterval) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["recurringInterval"],
+      // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+      message: "A recurring price needs an interval."
+    });
+  }
+});
+var pricesSchema = z.array(CatalogPriceSchema).min(1).max(50).superRefine((prices, ctx) => {
+  if (prices.filter((price) => price.isDefault).length > 1) {
+    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: "At most one price can be the default."
+    });
+  }
+  const refs = prices.flatMap(
+    (price) => price.externalRef ? [price.externalRef] : []
+  );
+  if (new Set(refs).size !== refs.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 externalRef."
+    });
+  }
+  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 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: 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 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,
+  label: z.string().trim().min(1).max(120).optional()
+}).strict();
+var CatalogVariantSchema = z.object({
+  externalRef: CatalogExternalRefSchema,
+  /** The value per axis, keyed by the axis slug. */
+  options: z.record(
+    CatalogFieldSlugSchema,
+    z.string().trim().min(1).max(120)
+  ),
+  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();
+var CATALOG_AVAILABILITIES = [
+  "draft",
+  "internal",
+  "scheduled",
+  "public"
+];
+var CatalogProductUpsertSchema = z.object({
+  source: CatalogSourceSchema,
+  /** Required to create a product; optional to update one. */
+  name: z.string().trim().min(1).max(500).optional(),
+  slug: CatalogWebSlugSchema.nullable().optional(),
+  description: text(5e3),
+  /** HTML; cleaned against the same allow-list the app uses. */
+  longDescription: text(1e5),
+  sku: text(100),
+  gtin: z.string().regex(/^[0-9]{8,14}$/).nullable().optional(),
+  productType: z.enum(["digital", "physical"]).optional(),
+  /**
+   * Where the product stands. A new product is a `draft` unless this says
+   * otherwise -- an import should not put a hundred products on somebody's
+   * website because a run finished.
+   */
+  availability: z.enum(CATALOG_AVAILABILITIES).optional(),
+  /** The moment for `scheduled`; ignored for the other three. */
+  publishedAt: z.string().datetime({ offset: true }).nullable().optional(),
+  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(),
+  /**
+   * Make a category that does not exist yet instead of refusing. Off unless
+   * asked for, so a typo cannot become a category on a customer's website.
+   */
+  createMissingCategories: z.boolean().optional(),
+  /** Field values by field slug; `null` empties one field. */
+  fields: z.record(CatalogFieldSlugSchema, z.unknown()).optional(),
+  /** Which fields the product's own page shows, in that order. */
+  publicFields: z.array(CatalogFieldSlugSchema).max(100).optional(),
+  /**
+   * Add a choice a select field does not offer yet instead of refusing.
+   * Off unless asked for, for the same reason as categories.
+   */
+  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(),
+  /** Replaces the product's variants; one missing here is archived. */
+  variants: z.array(CatalogVariantSchema).max(100).optional(),
+  /** `false` brings back a product the API archived earlier. */
+  archived: z.literal(false).optional()
+}).strict().superRefine((body, ctx) => {
+  if (body.variants !== void 0 && body.variantAxes === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["variantAxes"],
+      // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+      message: "Variants need the axes they differ along."
+    });
+  }
+  if (body.variants && body.variantAxes) {
+    const axes = body.variantAxes.map((axis) => axis.slug);
+    const seen = /* @__PURE__ */ new Set();
+    const refs = /* @__PURE__ */ new Set();
+    body.variants.forEach((variant, index) => {
+      const named = Object.keys(variant.options);
+      if (named.length !== axes.length || !axes.every((axis) => named.includes(axis))) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["variants", index, "options"],
+          // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+          message: `A variant names a value for exactly these axes: ${axes.join(", ")}.`
+        });
+      }
+      const combination = axes.map((axis) => variant.options[axis] ?? "").join("\0");
+      if (seen.has(combination)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["variants", index, "options"],
+          // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+          message: "Two variants stand for the same combination."
+        });
+      }
+      if (refs.has(variant.externalRef)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["variants", index, "externalRef"],
+          // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+          message: "Two variants carry the same externalRef."
+        });
+      }
+      seen.add(combination);
+      refs.add(variant.externalRef);
+    });
+  }
+  if (body.variantAxes) {
+    const slugs = body.variantAxes.map((axis) => axis.slug);
+    if (new Set(slugs).size !== slugs.length) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["variantAxes"],
+        // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+        message: "An axis is named twice."
+      });
+    }
+  }
+  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",
+      path: ["publishedAt"],
+      // i18n-exempt: a public API's field error, returned verbatim to an integration's own code and never shown in this app
+      message: "A scheduled product needs the moment it appears."
+    });
+  }
+});
+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. */
+  parentSlug: CatalogWebSlugSchema.nullable().optional(),
+  availability: z.enum(CATALOG_AVAILABILITIES).optional(),
+  publishedAt: z.string().datetime({ offset: true }).nullable().optional(),
+  metaTitle: text(300),
+  metaDescription: text(1e3)
+}).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
+    "A catalogue slug starts with a letter and holds lower-case letters, digits and underscores."
+  )
+});
+var CatalogCatalogueUpsertSchema = z.object({
+  nameSingular: z.string().trim().min(1).max(120).optional(),
+  namePlural: z.string().trim().min(1).max(120).optional(),
+  /** A lucide icon name, as the object settings offer them. */
+  icon: z.string().trim().max(64).nullable().optional()
+}).strict();
+var CatalogFieldTypeSchema = z.enum([
+  "text",
+  "number",
+  "select",
+  "checkbox",
+  "color",
+  "url",
+  "date",
+  "content_text",
+  "repeater",
+  "cta",
+  "configurator"
+]);
+var CATALOG_FIELD_TYPES = CatalogFieldTypeSchema.options;
+var CatalogFieldOptionSchema = z.object({
+  value: z.string().trim().min(1).max(120),
+  label: z.string().trim().min(1).max(120).optional()
+}).strict();
+var CatalogAttributeUpsertSchema = z.object({
+  label: z.string().trim().min(1).max(120).optional(),
+  type: CatalogFieldTypeSchema.optional(),
+  /** For a select: whether a product may carry more than one choice. */
+  multiple: z.boolean().optional(),
+  /** Choices to make sure exist; never removes one that is not listed. */
+  options: z.array(CatalogFieldOptionSchema).max(500).optional(),
+  /** Choices to take off the list, by value. */
+  removeOptions: z.array(z.string().trim().min(1).max(120)).max(500).optional(),
+  /** Whether the public API may show this field at all. */
+  public: z.boolean().optional(),
+  /**
+   * The field's settings, replaced as a whole. Checked against the same
+   * schema the object builder saves with, per type: a repeater's `display`,
+   * `preset`, `itemFields` and `titleKey`; a call to action's `secondary`;
+   * a configurator's whole structure. An item field keeps its type once it
+   * exists.
+   */
+  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()
+}).strict();
+var CONFIGURATOR_FILE_KINDS = ["model", "texture"];
+var CONFIGURATOR_TEXTURE_CONTENT_TYPES = [
+  "image/webp",
+  "image/jpeg"
+];
+var ConfiguratorFileUploadSchema = z.discriminatedUnion("step", [
+  z.object({
+    step: z.literal("start"),
+    /** The slug of the configurator field the file is for. */
+    field: CatalogFieldSlugSchema,
+    kind: z.enum(CONFIGURATOR_FILE_KINDS),
+    /** The bytes the caller is about to send, so a too-large file is refused before it travels. */
+    size: z.number().int().min(1),
+    /** For a texture: what kind of picture it is. A model is always glTF binary. */
+    contentType: z.enum(CONFIGURATOR_TEXTURE_CONTENT_TYPES).optional()
+  }).strict(),
+  z.object({
+    step: z.literal("finish"),
+    field: CatalogFieldSlugSchema,
+    kind: z.enum(CONFIGURATOR_FILE_KINDS),
+    /** The `uploadPath` `start` answered with. */
+    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 } from "zod";
+import { z as z3 } from "zod";
 
 // src/tool-answers.ts
 import { CrmApiError } from "@solumflow-app/crm-client";
-function answer(text, data) {
+import { z as z2 } from "zod";
+function answer(text2, data) {
   return {
-    content: [{ type: "text", text }],
+    content: [{ type: "text", text: text2 }],
     structuredContent: { result: data }
   };
 }
-function refusal(error) {
+function refusal(error, scope) {
   if (!(error instanceof CrmApiError)) {
     throw error;
   }
   const lines = [`${error.code}: ${error.message}`];
-  const next = NEXT_STEP[error.code];
+  const next = error.code === "forbidden" ? `The key may not do this. It needs to be a secret key with the scope "${scope}".` : NEXT_STEP[error.code];
   if (next) {
     lines.push(next);
   }
@@ -35,9 +474,8 @@ function refusal(error) {
 }
 var NEXT_STEP = {
   unauthorized: "The key is not recognised or was revoked. Ask the account owner for a new secret key.",
-  forbidden: 'The key may not do this. It needs to be a secret key with the scope "website:manage".',
   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) {
@@ -45,28 +483,94 @@ function codeBlock(snippet) {
 ${snippet}
 \`\`\``;
 }
+var page = {
+  cursor: z2.string().optional().describe("The nextCursor of the previous page; leave out for the first."),
+  limit: z2.number().int().min(1).max(100).optional()
+};
+function more(nextCursor) {
+  return nextCursor ? `More on the next page: cursor ${nextCursor}` : "";
+}
+function money(cents2, currency2) {
+  return `${(cents2 / 100).toFixed(2)} ${currency2.toUpperCase()}`;
+}
 
 // src/catalog-tools.ts
+var objectInput = {
+  object: CatalogObjectSlugSchema.optional().describe(
+    "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 slugOrId = z.string().min(1).max(200).describe("The address (slug) or the id of the product.");
+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 slugOrId = z3.string().min(1).max(200).describe("The address (slug) or the id of the product.");
 function registerCatalogTools(server, client) {
   server.registerTool(
     "list_catalog_fields",
     {
       title: "List the public fields of the catalogue",
       description: "The custom fields the catalogue publishes on its products, with their type, choices and, for a content block, how it is built. Read this once before building a product page: it says which blocks exist and what each one looks like. " + CONTENT_BLOCKS,
-      inputSchema: {},
+      inputSchema: { ...objectInput },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async () => {
+    async ({ object: object2 }) => {
       try {
-        const fields = await client.getFields();
+        const fields = await client.getFields(object2 ? { object: object2 } : void 0);
         return answer(
           fields.length === 0 ? "The catalogue publishes no custom fields." : fields.map(describeField).join("\n"),
           fields
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "catalog:read");
+      }
+    }
+  );
+  server.registerTool(
+    "list_catalogs",
+    {
+      title: "List the product catalogues",
+      description: "The product catalogues this key can write to, the account\u2019s own first. A catalogue other than the account\u2019s own is named by its slug in `object` on every catalogue tool; upsert_catalog makes one.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async () => {
+      try {
+        const catalogs = await client.getCatalogs();
+        return answer(
+          catalogs.map(
+            (catalog) => `${catalog.name} (${catalog.slug})${catalog.isDefault ? ", the account\u2019s own" : ""}`
+          ).join("\n") || "This account has no product catalogue.",
+          catalogs
+        );
+      } catch (error) {
+        return refusal(error, "catalog:read");
+      }
+    }
+  );
+  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");
       }
     }
   );
@@ -74,13 +578,16 @@ function registerCatalogTools(server, client) {
     "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, and may be a minute old: to read back what you just wrote, use get_product_by_ref. Answers that it is not found for an unknown product. " + CONTENT_BLOCKS,
+      inputSchema: { slugOrId, currency },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async ({ slugOrId: wanted }) => {
+    async ({ slugOrId: wanted, currency: inCurrency }) => {
       try {
-        const product = await client.getProduct(wanted);
+        const product = await client.getProduct(
+          wanted,
+          inCurrency ? { currency: inCurrency } : void 0
+        );
         if (!product) {
           return answer(`No product "${wanted}" on this account.`, null);
         }
@@ -90,11 +597,141 @@ function registerCatalogTools(server, client) {
           product
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "catalog:read");
+      }
+    }
+  );
+  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 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. May be a minute old.",
+      inputSchema: {
+        ...page,
+        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
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ categorySource, categoryRef, ...input }) => {
+      try {
+        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
+        );
+      } catch (error) {
+        return refusal(error, "catalog:read");
+      }
+    }
+  );
+  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.',
+      inputSchema: {
+        ...page,
+        parent: z3.union([z3.literal("root"), z3.string().uuid()]).optional().describe('"root" or the id of a category.')
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async (input) => {
+      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
+        );
+      } catch (error) {
+        return refusal(error, "catalog:read");
+      }
+    }
+  );
+  server.registerTool(
+    "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.",
+      inputSchema: {
+        slugOrId: z3.string().min(1).max(200).describe("The address (slug) or the id of the category."),
+        ...page
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ slugOrId: wanted, ...listOptions }) => {
+      try {
+        const category = await client.getCategory(wanted, listOptions);
+        if (!category) {
+          return answer(`No category "${wanted}" on this account.`, null);
+        }
+        const { data, nextCursor } = category;
+        return answer(
+          [
+            `${data.name} (${data.slug}), ${data.productCount} products.`,
+            ...data.products.map(describeProduct),
+            more(nextCursor)
+          ].filter(Boolean).join("\n"),
+          category
+        );
+      } catch (error) {
+        return refusal(error, "catalog:read");
+      }
+    }
+  );
+  server.registerTool(
+    "get_product_availability",
+    {
+      title: "Whether a product can be bought now",
+      description: "Live, not cached: whether a visitor can buy the product right now. Never how many are left. For a stock badge that must be current; the inStock of a listing may be a minute old.",
+      inputSchema: { slugOrId },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ slugOrId: wanted }) => {
+      try {
+        const status = await client.getAvailability(wanted);
+        if (!status) {
+          return answer(`No product "${wanted}" on this account.`, null);
+        }
+        return answer(
+          `${status.slug}: ${status.inStock ? "in stock" : "out of stock"}.`,
+          status
+        );
+      } catch (error) {
+        return refusal(error, "catalog:read");
       }
     }
   );
 }
+function describeProduct(product) {
+  const stock = product.inStock ? "" : ", out of stock";
+  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`;
+}
 function describeField(field) {
   if (field.type !== "repeater") {
     return `- ${field.slug}: ${field.label}, ${field.type}`;
@@ -105,8 +742,393 @@ function describeField(field) {
   return `- ${field.slug}: ${field.label}, repeater (${field.display ?? "list"}${preset}; items: ${items}${title})`;
 }
 
+// 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;
+}
+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: its page, 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.availability}; ${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. Only a published category.",
+      inputSchema: {
+        source: CatalogSourceSchema,
+        externalRef: CatalogExternalRefSchema
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ source, externalRef }) => {
+      try {
+        const category = await client.getCategoryByRef(source, externalRef);
+        return answer(
+          category ? `${category.name} (${category.slug}), id ${category.id}.` : `No published category with reference "${externalRef}" from "${source}".`,
+          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
+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. 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. 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`."
+        ),
+        ...CatalogProductUpsertSchema.shape,
+        ...objectInput
+      },
+      annotations: { destructiveHint: true, idempotentHint: true }
+    },
+    async ({ externalRef, object: object2, ...input }) => {
+      try {
+        const product = await client.upsertProduct(
+          externalRef,
+          input,
+          target2(object2)
+        );
+        const verb = product.created ? "Made" : "Changed";
+        return answer(
+          `${verb} ${product.name} (${product.slug ?? "no address"}), ${product.availability}; ${product.variants.length} variants; pictures ${product.images}.`,
+          product
+        );
+      } catch (error) {
+        return refusal(error, "catalog:write");
+      }
+    }
+  );
+  server.registerTool(
+    "archive_product",
+    {
+      title: "Take a product out of the catalogue",
+      description: IDENTITY + " Archiving takes the product and its variants off the website and out of the shop at once. It stays in the database for every invoice that names it, and upsert_product with `archived: false` brings it back. Ask the user before archiving 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.archiveProduct(
+          externalRef,
+          source,
+          target2(object2)
+        );
+        return answer(
+          result.alreadyArchived ? "That product was already archived." : "Archived.",
+          result
+        );
+      } catch (error) {
+        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. 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."
+        ),
+        ...CatalogCategoryUpsertSchema.shape,
+        ...objectInput
+      },
+      annotations: { destructiveHint: false, idempotentHint: true }
+    },
+    async ({ slug, object: object2, ...input }) => {
+      try {
+        const category = await client.upsertCategory(
+          slug,
+          input,
+          target2(object2)
+        );
+        return answer(
+          `${category.created ? "Made" : "Changed"} ${category.name} (${category.slug}).`,
+          category
+        );
+      } catch (error) {
+        return refusal(error, "catalog:write");
+      }
+    }
+  );
+  server.registerTool(
+    "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. `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."
+        ),
+        ...CatalogAttributeUpsertSchema.shape,
+        ...objectInput
+      },
+      annotations: { destructiveHint: true, idempotentHint: true }
+    },
+    async ({ slug, object: object2, ...input }) => {
+      try {
+        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
+        );
+      } catch (error) {
+        return refusal(error, "catalog:write");
+      }
+    }
+  );
+  server.registerTool(
+    "upsert_catalog",
+    {
+      title: "Make or rename a product catalogue",
+      description: 'A product catalogue of its own beside the account\u2019s products, such as "Fireplaces", known by its slug: sending the same slug again renames it. A new one needs both names, one product and many. Its fields, categories and products are then written with `object` set to this slug. Make one only when the user asks for a separate catalogue; most products belong in the account\u2019s own.',
+      inputSchema: {
+        slug: CatalogObjectSlugSchema.describe(
+          "The slug of the catalogue: a lower-case letter, then lower case, digits and underscores."
+        ),
+        ...CatalogCatalogueUpsertSchema.shape
+      },
+      annotations: { destructiveHint: false, idempotentHint: true }
+    },
+    async ({ slug, ...input }) => {
+      try {
+        const catalog = await client.upsertCatalog(slug, input);
+        return answer(
+          `${catalog.created ? "Made" : "Changed"} ${catalog.namePlural} (${catalog.slug}).`,
+          catalog
+        );
+      } catch (error) {
+        return refusal(error, "catalog:write");
+      }
+    }
+  );
+}
+
 // src/configurator-tools.ts
-import { z as z5 } from "zod";
+import { z as z8 } from "zod";
 
 // ../features/product-configurator/src/shared/configurator-limits.ts
 var CONFIGURATOR_LIMITS = {
@@ -155,11 +1177,11 @@ function issue(path, code, params) {
   return params ? { path, code, params } : { path, code };
 }
 function formatIssuePath(path) {
-  return path.reduce((text, part) => {
+  return path.reduce((text2, part) => {
     if (typeof part === "number") {
-      return `${text}[${part}]`;
+      return `${text2}[${part}]`;
     }
-    return text ? `${text}.${part}` : part;
+    return text2 ? `${text2}.${part}` : part;
   }, "");
 }
 
@@ -181,11 +1203,11 @@ function tokenize(source) {
       while (end < source.length && /[0-9.]/.test(source.charAt(end))) {
         end += 1;
       }
-      const text = source.slice(index, end);
-      if (!/^(\d+(\.\d+)?|\.\d+)$/.test(text)) {
+      const text2 = source.slice(index, end);
+      if (!/^(\d+(\.\d+)?|\.\d+)$/.test(text2)) {
         return null;
       }
-      tokens.push({ type: "number", value: Number(text) });
+      tokens.push({ type: "number", value: Number(text2) });
       index = end;
       continue;
     }
@@ -472,16 +1494,16 @@ function evaluateFormulaSource(source, scope) {
 }
 
 // ../features/product-configurator/src/shared/geometry-document.schema.ts
-import { z as z2 } 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 = z2.string().regex(CONFIGURATOR_NAME_PATTERN, "configurator.invalidName");
-var ConfiguratorCodeSchema = z2.string().regex(CONFIGURATOR_CODE_PATTERN, "configurator.invalidCode");
-var FormulaSchema = z2.union([
-  z2.number().finite(),
-  z2.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 = z2.tuple([FormulaSchema, FormulaSchema, FormulaSchema]);
+var Vector3Schema = z5.tuple([FormulaSchema, FormulaSchema, FormulaSchema]);
 var PRIMITIVE_TYPES = [
   "box",
   "rounded_top_box",
@@ -524,86 +1546,93 @@ var PrimitiveNodeFields = {
   size: Vector3Schema,
   at: Vector3Schema,
   visible: FormulaSchema.optional(),
-  params: z2.record(ConfiguratorNameSchema, FormulaSchema).optional()
+  params: z5.record(ConfiguratorNameSchema, FormulaSchema).optional()
 };
-var PrimitiveNodeSchema = z2.strictObject({
+var PrimitiveNodeSchema = z5.strictObject({
   ...PrimitiveNodeFields,
-  type: z2.enum(PRIMITIVE_TYPES).exclude(["model"])
+  type: z5.enum(PRIMITIVE_TYPES).exclude(["model"])
 });
-var ModelPathSchema = z2.string().regex(CONFIGURATOR_MODEL_PATH_PATTERN, "configurator.invalidModelPath");
-var ServedFileUrlSchema = z2.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 = z2.strictObject({
+  const ModelNodeSchema = z5.strictObject({
     ...PrimitiveNodeFields,
-    type: z2.literal("model"),
+    type: z5.literal("model"),
     model: modelFile
   });
-  const ModelPerChoiceNodeSchema = z2.strictObject({
+  const ModelPerChoiceNodeSchema = z5.strictObject({
     ...PrimitiveNodeFields,
-    type: z2.literal("model"),
+    type: z5.literal("model"),
     follows: ConfiguratorNameSchema,
-    models: z2.record(ConfiguratorCodeSchema, modelFile).refine(
+    models: z5.record(ConfiguratorCodeSchema, modelFile).refine(
       (models) => Object.keys(models).length <= CONFIGURATOR_LIMITS.presets,
       { message: "configurator.tooMany" }
     )
   });
-  const node = z2.lazy(
-    () => z2.union([
+  const node = z5.lazy(
+    () => z5.union([
       PrimitiveNodeSchema,
       ModelNodeSchema,
       ModelPerChoiceNodeSchema,
-      z2.strictObject({
+      z5.strictObject({
         id: ConfiguratorNameSchema,
-        type: z2.literal("repeat"),
+        type: z5.literal("repeat"),
         count: FormulaSchema,
-        index: z2.enum(["i", "j"]).optional(),
+        index: z5.enum(["i", "j"]).optional(),
         visible: FormulaSchema.optional(),
-        children: z2.array(node).min(1)
+        children: z5.array(node).min(1)
       })
     ])
   );
   return node;
 }
 var GeometryNodeSchema = geometryNodeSchema(ModelPathSchema);
-var GeometryBindingSchema = z2.strictObject({
+var GeometryBindingSchema = z5.strictObject({
   param: ConfiguratorNameSchema,
-  map: z2.record(ConfiguratorCodeSchema, z2.number().finite()).optional()
+  map: z5.record(ConfiguratorCodeSchema, z5.number().finite()).optional()
 });
-var GeometryInputSchema = z2.strictObject({
+var GeometryInputSchema = z5.strictObject({
   name: ConfiguratorNameSchema,
   binding: GeometryBindingSchema
 });
-var GeometrySlotSchema = z2.strictObject({
+var GeometrySlotSchema = z5.strictObject({
   name: ConfiguratorNameSchema,
   param: ConfiguratorNameSchema.optional(),
   material: ConfiguratorCodeSchema.optional(),
-  color: z2.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: z5.enum(["horizontal", "vertical"]).optional()
 });
-var GeometryAnnotationSchema = z2.strictObject({
+var GeometryAnnotationSchema = z5.strictObject({
   id: ConfiguratorNameSchema,
-  axis: z2.enum(["x", "y"]),
+  axis: z5.enum(["x", "y"]),
   from: FormulaSchema,
   to: FormulaSchema,
   at: FormulaSchema,
-  label: z2.string().trim().min(1).max(80).optional()
+  label: z5.string().trim().min(1).max(80).optional()
 });
 function geometryDocumentSchema(modelFile) {
-  return z2.strictObject({
+  return z5.strictObject({
     /** Rises with every new upload, so a product page can say which one it shows. */
-    version: z2.number().int().min(1),
+    version: z5.number().int().min(1),
     /** The starter document this one was copied from, for information only. */
-    startedFrom: z2.string().trim().max(80).optional(),
-    inputs: z2.array(GeometryInputSchema).max(CONFIGURATOR_LIMITS.geometryInputs),
-    constants: z2.record(ConfiguratorNameSchema, z2.number().finite()),
-    slots: z2.array(GeometrySlotSchema).min(1).max(CONFIGURATOR_LIMITS.geometrySlots),
-    root: z2.array(geometryNodeSchema(modelFile)).min(1),
-    camera: z2.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: z2.number().min(-90).max(90),
+      azimuth: z5.number().min(-90).max(90),
       /** Degrees above the horizon. */
-      elevation: z2.number().min(-10).max(80)
+      elevation: z5.number().min(-10).max(80)
     }).optional(),
-    annotations: z2.array(GeometryAnnotationSchema).max(CONFIGURATOR_LIMITS.annotations)
+    annotations: z5.array(GeometryAnnotationSchema).max(CONFIGURATOR_LIMITS.annotations)
   });
 }
 var GeometryDocumentSchema = geometryDocumentSchema(ModelPathSchema);
@@ -893,98 +1922,98 @@ function followProblems(follows, path, context) {
 }
 
 // ../features/product-configurator/src/shared/configurator-structure.schema.ts
-import { z as z3 } from "zod";
-var LabelSchema = z3.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 = z3.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 = z3.discriminatedUnion("kind", [
-  z3.strictObject({
+var ConfiguratorParameterSchema = z6.discriminatedUnion("kind", [
+  z6.strictObject({
     ...ParameterBase,
-    kind: z3.literal("number"),
+    kind: z6.literal("number"),
     /** `mm` is a measure, `count` a number of things (compartments). */
-    unit: z3.enum(["mm", "count"]),
-    step: z3.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: z3.number().finite(),
-    max: z3.number().finite()
+    min: z6.number().finite(),
+    max: z6.number().finite()
   }),
-  z3.strictObject({
+  z6.strictObject({
     ...ParameterBase,
-    kind: z3.literal("choice"),
+    kind: z6.literal("choice"),
     list: ConfiguratorNameSchema
   }),
-  z3.strictObject({ ...ParameterBase, kind: z3.literal("material") }),
-  z3.strictObject({ ...ParameterBase, kind: z3.literal("toggle") })
+  z6.strictObject({ ...ParameterBase, kind: z6.literal("material") }),
+  z6.strictObject({ ...ParameterBase, kind: z6.literal("toggle") })
 ]);
-var choiceListSchema = (picture) => z3.strictObject({
+var choiceListSchema = (picture) => z6.strictObject({
   key: ConfiguratorNameSchema,
   label: LabelSchema,
-  options: z3.array(
-    z3.strictObject({
+  options: z6.array(
+    z6.strictObject({
       code: ConfiguratorCodeSchema,
       label: LabelSchema,
       image: picture.optional()
     })
   ).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
 });
-var materialSchema = (picture) => z3.strictObject({
+var materialSchema = (picture) => z6.strictObject({
   code: ConfiguratorCodeSchema,
   label: LabelSchema,
-  color: z3.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: z3.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: z3.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: z3.number().min(0).max(1).optional(),
-  metalness: z3.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: z3.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: z3.boolean().optional(),
+  emissive: z6.boolean().optional(),
   priceGroup: ConfiguratorCodeSchema.optional()
 });
 var ConfiguratorChoiceListSchema = choiceListSchema(TexturePathSchema);
 var ConfiguratorMaterialSchema = materialSchema(TexturePathSchema);
-var ConditionValueSchema = z3.union([
-  z3.number().finite(),
-  z3.boolean(),
+var ConditionValueSchema = z6.union([
+  z6.number().finite(),
+  z6.boolean(),
   ConfiguratorCodeSchema,
-  z3.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
+  z6.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
 ]);
-var ConfiguratorConditionSchema = z3.strictObject({
+var ConfiguratorConditionSchema = z6.strictObject({
   param: ConfiguratorNameSchema,
-  op: z3.enum(["eq", "neq", "in", "gte", "lte"]),
+  op: z6.enum(["eq", "neq", "in", "gte", "lte"]),
   value: ConditionValueSchema
 });
-var ConfiguratorRuleSchema = z3.discriminatedUnion("kind", [
+var ConfiguratorRuleSchema = z6.discriminatedUnion("kind", [
   /** Show `param` only while `when` holds. */
-  z3.strictObject({
-    kind: z3.literal("visible"),
+  z6.strictObject({
+    kind: z6.literal("visible"),
     param: ConfiguratorNameSchema,
     when: ConfiguratorConditionSchema
   }),
   /** Narrow a number parameter: `max cabinet_height = total_height - 300`. */
-  z3.strictObject({
-    kind: z3.literal("limit"),
+  z6.strictObject({
+    kind: z6.literal("limit"),
     param: ConfiguratorNameSchema,
-    bound: z3.enum(["min", "max"]),
+    bound: z6.enum(["min", "max"]),
     formula: FormulaSchema
   }),
   /** While `when` holds, these codes of a choice or material are not offered. */
-  z3.strictObject({
-    kind: z3.literal("exclude"),
+  z6.strictObject({
+    kind: z6.literal("exclude"),
     param: ConfiguratorNameSchema,
-    codes: z3.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList),
+    codes: z6.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList),
     when: ConfiguratorConditionSchema
   })
 ]);
@@ -994,23 +2023,23 @@ var PriceRuleBase = {
   /** How many times the amount counts, e.g. `compartments`. Absent is once. */
   multiplier: FormulaSchema.optional()
 };
-var ConfiguratorPriceRuleSchema = z3.discriminatedUnion("kind", [
+var ConfiguratorPriceRuleSchema = z6.discriminatedUnion("kind", [
   /** The surcharge the model gives the chosen option. */
-  z3.strictObject({
+  z6.strictObject({
     ...PriceRuleBase,
-    kind: z3.literal("choice"),
+    kind: z6.literal("choice"),
     param: ConfiguratorNameSchema
   }),
   /** The surcharge of the chosen material's price group. */
-  z3.strictObject({
+  z6.strictObject({
     ...PriceRuleBase,
-    kind: z3.literal("material"),
+    kind: z6.literal("material"),
     param: ConfiguratorNameSchema
   }),
   /** An amount, counted while a switch is on. */
-  z3.strictObject({
+  z6.strictObject({
     ...PriceRuleBase,
-    kind: z3.literal("toggle"),
+    kind: z6.literal("toggle"),
     param: ConfiguratorNameSchema,
     amount: ConfiguratorNameSchema
   }),
@@ -1018,10 +2047,10 @@ var ConfiguratorPriceRuleSchema = z3.discriminatedUnion("kind", [
    * A price on measure: `max(0, total_width - 1800) / 1000 * meter_price`.
    * Reads number parameters (in their unit) and amounts (in cents).
    */
-  z3.strictObject({
+  z6.strictObject({
     key: ConfiguratorNameSchema,
     label: LabelSchema,
-    kind: z3.literal("formula"),
+    kind: z6.literal("formula"),
     formula: FormulaSchema
   })
 ]);
@@ -1031,43 +2060,43 @@ var CONFIGURATOR_SCENE_LIGHTINGS = [
   "daylight"
 ];
 var CONFIGURATOR_SCENE_EDGES = ["soft", "sharp"];
-var ConfiguratorSceneSchema = z3.strictObject({
-  lighting: z3.enum(CONFIGURATOR_SCENE_LIGHTINGS).optional(),
-  edges: z3.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) => z3.strictObject({
-  schemaVersion: z3.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: z3.array(
-    z3.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })
+  tabs: z6.array(
+    z6.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })
   ).min(1).max(CONFIGURATOR_LIMITS.tabs),
-  parameters: z3.array(ConfiguratorParameterSchema).max(CONFIGURATOR_LIMITS.parameters),
-  choiceLists: z3.array(choiceListSchema(files.picture)).max(CONFIGURATOR_LIMITS.choiceLists),
-  materials: z3.array(materialSchema(files.picture)).max(CONFIGURATOR_LIMITS.materials),
-  priceGroups: z3.array(
-    z3.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: z3.array(
-    z3.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: z3.strictObject({
+  presets: z6.strictObject({
     label: LabelSchema,
     tab: ConfiguratorNameSchema,
-    sets: z3.array(ConfiguratorNameSchema).min(1).max(CONFIGURATOR_LIMITS.parameters),
-    required: z3.boolean()
+    sets: z6.array(ConfiguratorNameSchema).min(1).max(CONFIGURATOR_LIMITS.parameters),
+    required: z6.boolean()
   }).optional(),
-  rules: z3.array(ConfiguratorRuleSchema).max(CONFIGURATOR_LIMITS.rules),
-  priceRules: z3.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,
@@ -1226,8 +2255,8 @@ function configuratorStructureProblems(structure) {
   };
   structure.rules.forEach((rule, index) => {
     const path = ["rules", index];
-    const target = parameters.get(rule.param);
-    if (!target) {
+    const target3 = parameters.get(rule.param);
+    if (!target3) {
       problems.push(
         issue([...path, "param"], "configurator.unknownParam", {
           key: rule.param
@@ -1236,7 +2265,7 @@ function configuratorStructureProblems(structure) {
       return;
     }
     if (rule.kind === "limit") {
-      if (target.kind !== "number") {
+      if (target3.kind !== "number") {
         problems.push(
           issue([...path, "param"], "configurator.notANumberParam", {
             key: rule.param
@@ -1254,7 +2283,7 @@ function configuratorStructureProblems(structure) {
       return;
     }
     if (rule.kind === "exclude") {
-      const codes = codesOf(target, lists, materials);
+      const codes = codesOf(target3, lists, materials);
       if (!codes) {
         problems.push(
           issue([...path, "param"], "configurator.notAChoiceParam", {
@@ -1333,8 +2362,8 @@ function configuratorStructureProblems(structure) {
         problems
       );
     }
-    const target = parameters.get(rule.param);
-    if (!target || target.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,
@@ -1483,55 +2512,55 @@ function parameterResolutionOrder(structure) {
 }
 
 // ../features/product-configurator/src/shared/configurator-value.schema.ts
-import { z as z4 } from "zod";
-var CentsSchema = z4.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 = z4.strictObject({
+var ConfiguratorValueObjectSchema = z7.strictObject({
   /** Null: the model has no price of its own, every quote is "open". */
   basePriceCents: PriceSchema,
-  numbers: z4.record(
+  numbers: z7.record(
     ConfiguratorNameSchema,
-    z4.strictObject({
-      min: z4.number().finite(),
-      max: z4.number().finite(),
-      default: z4.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: z4.record(
+  choices: z7.record(
     ConfiguratorNameSchema,
-    z4.strictObject({
-      options: z4.record(
+    z7.strictObject({
+      options: z7.record(
         ConfiguratorCodeSchema,
-        z4.strictObject({ priceCents: PriceSchema })
+        z7.strictObject({ priceCents: PriceSchema })
       ),
       default: ConfiguratorCodeSchema.optional()
     })
   ).default({}),
   /** Per material parameter: the materials this model offers. */
-  materials: z4.record(
+  materials: z7.record(
     ConfiguratorNameSchema,
-    z4.strictObject({
-      offered: z4.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: z4.record(
+  toggles: z7.record(
     ConfiguratorNameSchema,
-    z4.strictObject({ offered: z4.boolean(), default: z4.boolean() })
+    z7.strictObject({ offered: z7.boolean(), default: z7.boolean() })
   ).default({}),
   /** The surcharge of each material price group. */
-  priceGroups: z4.record(ConfiguratorCodeSchema, PriceSchema).default({}),
+  priceGroups: z7.record(ConfiguratorCodeSchema, PriceSchema).default({}),
   /** The amounts the structure names, such as a price per metre. */
-  amounts: z4.record(ConfiguratorNameSchema, PriceSchema).default({}),
-  presets: z4.array(
-    z4.strictObject({
+  amounts: z7.record(ConfiguratorNameSchema, PriceSchema).default({}),
+  presets: z7.array(
+    z7.strictObject({
       code: ConfiguratorCodeSchema,
-      label: z4.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: z4.string().uuid().nullable(),
-      values: z4.record(ConfiguratorNameSchema, z4.number().finite())
+      productId: z7.string().uuid().nullable(),
+      values: z7.record(ConfiguratorNameSchema, z7.number().finite())
     })
   ).max(CONFIGURATOR_LIMITS.presets).default([])
 });
@@ -1671,7 +2700,8 @@ function resolveConfiguration(params) {
         max,
         step: parameter.step,
         unit: parameter.unit,
-        fixed: fixedValue !== void 0
+        fixed: fixedValue !== void 0,
+        settled: fixedValue === void 0 && min === max
       });
       continue;
     }
@@ -1739,7 +2769,8 @@ function resolveConfiguration(params) {
       ...base,
       visible,
       value: visible ? current : null,
-      options
+      options,
+      settled: options.length === 1
     });
   }
   const parameters = structure.parameters.map((parameter) => resolved.get(parameter.key)).filter(
@@ -1770,7 +2801,8 @@ function resolveConfiguration(params) {
     }
     slots[slot.name] = {
       color: material?.color ?? slot.color ?? NEUTRAL_SLOT_COLOR,
-      material
+      material,
+      grain: slot.grain === "vertical" ? "vertical" : "horizontal"
     };
   }
   const normalised = { values: {} };
@@ -1809,8 +2841,8 @@ function expandGeometry(document, inputs, chosen = { choices: {} }) {
   const parts = [];
   const baseScope = { ...document.constants };
   for (const input of document.inputs) {
-    const number = inputs[input.name];
-    if (number === void 0 || !Number.isFinite(number)) {
+    const number2 = inputs[input.name];
+    if (number2 === void 0 || !Number.isFinite(number2)) {
       issues.push(
         issue(["inputs", input.name], "configurator.inputMissing", {
           name: input.name
@@ -1818,7 +2850,7 @@ function expandGeometry(document, inputs, chosen = { choices: {} }) {
       );
       continue;
     }
-    baseScope[input.name] = number;
+    baseScope[input.name] = number2;
   }
   if (issues.length > 0) {
     return { ok: false, issues };
@@ -1910,11 +2942,11 @@ function expandGeometry(document, inputs, chosen = { choices: {} }) {
       }
       const params = {};
       for (const [key, formula] of Object.entries(node.params ?? {})) {
-        const number = evaluate(formula, scope, [...nodePath, "params", key]);
-        if (number === null) {
+        const number2 = evaluate(formula, scope, [...nodePath, "params", key]);
+        if (number2 === null) {
           return;
         }
-        params[key] = number;
+        params[key] = number2;
       }
       parts.push({
         key: `${node.id}${keySuffix}`,
@@ -1987,8 +3019,17 @@ function modelOf(node, chosen) {
 }
 
 // src/configurator-tools.ts
-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 an uploaded .glb, params.fit 0 contain or 1 stretch, params.paint 1 to use the slot material; a model is uploaded in the object builder, never through this server) 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. This server can check such a document but never save it: a reseller uploads it in the object builder.';
-var documentInput = z5.string().min(2).max(2e5).describe(
+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"],
+    maxBytes: 2 * 1024 * 1024
+  }
+};
+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 = 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) {
@@ -1996,14 +3037,14 @@ function registerConfiguratorTools(server, client) {
     "check_configurator_shape",
     {
       title: "Check a configurator structure or shape document",
-      description: "Checks a configurator structure or a shape document exactly as the object builder will when a reseller uploads it: the outline, every name a formula reads, bindings, cycles in the rules and the limits. A whole structure is also expanded at its smallest measures, so a part that would come out negative is named. Answers with every problem and where it is, or that the document is sound. " + CONFIGURATOR,
+      description: "Checks a configurator structure or a shape document exactly as the API will when it is saved: the outline, every name a formula reads, bindings, cycles in the rules and the limits. A whole structure is also expanded at its smallest measures, so a part that would come out negative is named. Answers with every problem and where it is, or that the document is sound. " + CONFIGURATOR,
       inputSchema: { document: documentInput },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
     ({ document }) => {
       const problems = checkDocument(document);
       return answer(
-        problems.length === 0 ? "The document is sound. A reseller can upload it in the object builder." : [
+        problems.length === 0 ? "The document is sound. upsert_configurator saves it." : [
           `${problems.length} problem(s):`,
           ...problems.map(describeIssue)
         ].join("\n"),
@@ -2011,14 +3052,125 @@ function registerConfiguratorTools(server, client) {
       );
     }
   );
+  server.registerTool(
+    "upsert_configurator",
+    {
+      title: "Save a configurator",
+      description: 'Makes a configurator field, or changes one, with its whole structure. The structure is checked here first, exactly as check_configurator_shape does, and nothing is sent while it has a problem. Making the field, or changing its "geometry", needs a key with configurator:shape; changing parameters, lists, materials, prices or rules of an existing one needs only catalog:write. A new field needs a `label`. Upload models and textures first with upload_configurator_file and put the paths it answers in the structure. ' + CONFIGURATOR,
+      inputSchema: {
+        slug: CatalogFieldSlugSchema.describe(
+          "The slug of the configurator field."
+        ),
+        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: z8.boolean().optional().describe("Whether product pages may show the configurator."),
+        ...objectInput
+      },
+      annotations: { destructiveHint: true, idempotentHint: true }
+    },
+    async ({ slug, label, structure, public: isPublic, object: object2 }) => {
+      const problems = checkDocument(structure);
+      if (problems.length > 0 || !structure.includes('"schemaVersion"')) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: [
+                problems.length > 0 ? `Not saved. ${problems.length} problem(s):` : 'Not saved: this is a shape document alone; save a whole structure (it has "schemaVersion").',
+                ...problems.map(describeIssue)
+              ].join("\n")
+            }
+          ]
+        };
+      }
+      try {
+        const field = await client.upsertField(
+          slug,
+          {
+            ...label ? { label } : {},
+            type: "configurator",
+            config: JSON.parse(structure),
+            ...isPublic === void 0 ? {} : { public: isPublic }
+          },
+          object2 ? { object: object2 } : void 0
+        );
+        return answer(
+          `${field.created ? "Made" : "Changed"} the configurator ${field.label} (${field.slug}).`,
+          field
+        );
+      } catch (error) {
+        return refusal(error, "configurator:shape");
+      }
+    }
+  );
+  server.registerTool(
+    "upload_configurator_file",
+    {
+      title: "Upload a model or a texture for a configurator",
+      description: 'Reads one file from the user\u2019s disk and uploads it for a configurator field: a "model" is a binary glTF (.glb, at most 10 MB, everything inside the file, no Draco, no lights of its own, at most 200,000 triangles) and part of the shape, so it needs configurator:shape; a "texture" is a .webp or .jpg picture of at most 2 MB. Answers with the path to put in the structure. The field must exist first (upsert_configurator).',
+      inputSchema: {
+        fieldSlug: CatalogFieldSlugSchema.describe(
+          "The slug of the configurator field."
+        ),
+        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_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 stat2(filePath).catch(() => null);
+      if (!info?.isFile()) {
+        return notUploaded(`"${filePath}" is not a file on this machine.`);
+      }
+      if (info.size > rules.maxBytes) {
+        return notUploaded(
+          `The file is ${info.size} bytes; a ${kind} may be at most ${rules.maxBytes}.`
+        );
+      }
+      try {
+        const bytes = new Uint8Array(await readFile2(filePath));
+        const result = await client.uploadConfiguratorFile(
+          fieldSlug,
+          {
+            kind,
+            bytes,
+            ...kind === "texture" ? {
+              contentType: extension === ".webp" ? "image/webp" : "image/jpeg"
+            } : {}
+          },
+          object2 ? { object: object2 } : void 0
+        );
+        return answer(
+          `Uploaded. Put this path in the structure: ${result.path}`,
+          result
+        );
+      } catch (error) {
+        return refusal(
+          error,
+          kind === "model" ? "configurator:shape" : "catalog:write"
+        );
+      }
+    }
+  );
   server.registerTool(
     "read_configurator",
     {
       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: z5.string().min(1).max(200).describe("The address (slug) or the id of the product."),
-        field: z5.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 }
     },
@@ -2037,15 +3189,15 @@ function registerConfiguratorTools(server, client) {
         }
         return answer(`The configurator "${field}" of ${product.name}.`, value);
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "catalog:read");
       }
     }
   );
 }
-function checkDocument(text) {
+function checkDocument(text2) {
   let parsed;
   try {
-    parsed = JSON.parse(text);
+    parsed = JSON.parse(text2);
   } catch {
     return [{ path: [], code: "configurator.notJson" }];
   }
@@ -2089,18 +3241,102 @@ function describeIssue(problem) {
   const params = problem.params ? ` (${Object.entries(problem.params).map(([key, value]) => `${key}: ${value}`).join(", ")})` : "";
   return `- ${where}: ${problem.code}${params}`;
 }
+function notUploaded(text2) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: `Not uploaded. ${text2}` }]
+  };
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/event-tools.ts
+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",
+    {
+      title: "List upcoming events",
+      description: "The published events of the account, soonest first: title, when and where, the lowest ticket price, whether it is sold out and the link to its ticket page. Both ends of the window are optional and inclusive. Events are made in the app; this cannot create one. May be a minute old.",
+      inputSchema: { ...page, from: moment, to: moment },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async (input) => {
+      try {
+        const list = await client.getEvents(input);
+        return answer(
+          list.events.length === 0 ? "No published events in this window." : [...list.events.map(describeEvent), more(list.nextCursor)].filter(Boolean).join("\n"),
+          list
+        );
+      } catch (error) {
+        return refusal(error, "events:read");
+      }
+    }
+  );
+  server.registerTool(
+    "get_event",
+    {
+      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: z9.string().min(1).max(200).describe("The id or the address (slug) of the event.")
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ idOrSlug }) => {
+      try {
+        const event = await client.getEvent(idOrSlug);
+        if (!event) {
+          return answer(`No event "${idOrSlug}" on this account.`, null);
+        }
+        return answer(
+          `${event.title} (${event.slug}), ${event.status}, ${event.ticketTypes.length} ticket types.`,
+          event
+        );
+      } catch (error) {
+        return refusal(error, "events:read");
+      }
+    }
+  );
+  server.registerTool(
+    "get_event_availability",
+    {
+      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: z9.string().uuid().describe("The id of the event.")
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ eventId }) => {
+      try {
+        const seats = await client.getEventAvailability(eventId);
+        if (!seats) {
+          return answer(`No event "${eventId}" on this account.`, null);
+        }
+        return answer(
+          seats.soldOut ? "Sold out." : `${seats.remaining ?? "No limit on"} seats left.`,
+          seats
+        );
+      } catch (error) {
+        return refusal(error, "events:read");
+      }
+    }
+  );
+}
+function describeEvent(event) {
+  const where = event.locationName ? `, ${event.locationName}` : "";
+  const price = event.priceFromCents !== null && event.currency ? `, from ${money(event.priceFromCents, event.currency)}` : "";
+  const sold = event.soldOut ? ", sold out" : "";
+  return `- ${event.title} (id ${event.id}): ${event.startsAt}${where}${price}${sold} \u2014 ${event.url}`;
+}
+
 // src/placement-tools.ts
-import { z as z6 } 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 page = {
-  cursor: z6.string().optional().describe("The nextCursor of the previous page; leave out for the first."),
-  limit: z6.number().int().min(1).max(100).optional()
-};
-var origin = z6.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",
@@ -2120,7 +3356,7 @@ function registerPlacementTools(server, client) {
           list
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2140,7 +3376,7 @@ function registerPlacementTools(server, client) {
           pages
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2163,7 +3399,7 @@ function registerPlacementTools(server, client) {
           list
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2173,13 +3409,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: z6.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: z6.string().min(1).max(200).optional().describe("Required when the widget does not exist yet."),
-        status: z6.enum(["draft", "published"]).optional().describe("Only a published widget answers on a site."),
-        addAllowedOrigins: z6.array(origin).max(20).optional(),
-        removeAllowedOrigins: z6.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,
@@ -2197,7 +3433,7 @@ ${describeChatWidget(widget)}`,
           widget
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2217,7 +3453,7 @@ ${describeChatWidget(widget)}`,
           site
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2227,9 +3463,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: z6.array(z6.string()).max(20).optional().describe('Hosts such as "www.example.com" or "*.example.com".'),
-        removeAllowedHosts: z6.array(z6.string()).max(20).optional(),
-        consentSignal: z6.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",
@@ -2254,7 +3490,7 @@ ${describeSiteTracking(site)}`,
           site
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2288,9 +3524,6 @@ function describeSiteTracking(site) {
     codeBlock(site.embed)
   ].join("\n");
 }
-function more(nextCursor) {
-  return nextCursor ? `More on the next page: cursor ${nextCursor}` : "";
-}
 
 // src/server-config.ts
 function readServerConfig(env) {
@@ -2299,13 +3532,13 @@ function readServerConfig(env) {
   if (!apiKey) {
     return {
       ok: false,
-      error: 'SOLUMFLOW_API_KEY is not set. Make a secret key with the scope "website:manage" in the app (Settings \u2192 API keys) and pass it in the environment.'
+      error: 'SOLUMFLOW_API_KEY is not set. Make a secret key in the app (Settings \u2192 API keys) with the scopes the agent needs: "website:manage" to place things on a site, "catalog:read" and "events:read" to read, "catalog:write" to fill the catalogue, and "configurator:shape" -- which only a reseller can give -- to make a 3D configurator and upload its models. Settings \u2192 Integrations \u2192 MCP server makes such a key and the command to add this server in one go. Pass it in the environment.'
     };
   }
   if (!apiKey.startsWith("crms_")) {
     return {
       ok: false,
-      error: 'SOLUMFLOW_API_KEY is not a secret key. Placing things on a website needs a `crms_` key with the scope "website:manage"; a `crmp_` key can only read the catalogue.'
+      error: "SOLUMFLOW_API_KEY is not a secret key. This server needs a `crms_` key: a `crmp_` key is meant for a browser and can never place things on a website or write the catalogue."
     };
   }
   if (!/^https?:\/\/[^/]+$/.test(baseUrl)) {
@@ -2326,7 +3559,9 @@ async function main() {
   }
   const server = new McpServer({
     name: "crm-mcp-server",
-    version: "0.3.1"
+    // Read from the package, so the version an agent is told is the one
+    // that was published.
+    version
   });
   const client = createClient({
     apiKey: config.apiKey,
@@ -2334,6 +3569,9 @@ async function main() {
   });
   registerPlacementTools(server, client);
   registerCatalogTools(server, client);
+  registerCatalogWriteTools(server, client);
+  registerCatalogMigrationTools(server, client);
+  registerEventTools(server, client);
   registerConfiguratorTools(server, client);
   await server.connect(new StdioServerTransport());
 }