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

package/dist/index.js

@@ -5,23 +5,329 @@ 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.4.0";
+
 // src/catalog-tools.ts
-import { z } from "zod";
+import { z as z3 } 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),
+  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.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."
+    });
+  }
+});
+var CatalogImageSchema = z.object({
+  url: 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 picture is fetched over https only."
+  }),
+  alt: text(300)
+}).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(),
+  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),
+  /** 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(),
+  /** 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.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({
+  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();
+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",
+  "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()
+}).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()
+]);
 
 // 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,7 +341,6 @@ 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.",
   internal_error: "Something went wrong in the app. Trying again is safe."
@@ -45,28 +350,65 @@ 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, currency) {
+  return `${(cents2 / 100).toFixed(2)} ${currency.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 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");
       }
     }
   );
@@ -90,11 +432,122 @@ 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 (from list_categories), or to one catalogue by the slug of its object. Read get_product for everything a product page needs. May be a minute old.",
+      inputSchema: {
+        ...page,
+        category: z3.string().uuid().optional().describe("A category id; includes its subcategories."),
+        object: z3.string().min(1).max(63).optional().describe(
+          'One catalogue, by the slug of its object, such as "product".'
+        )
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async (input) => {
+      try {
+        const list = await client.getProducts(input);
+        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";
+  return `- ${product.name} (${product.slug}): from ${money(product.priceFromCents, product.currency)}${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 +558,159 @@ function describeField(field) {
   return `- ${field.slug}: ${field.label}, repeater (${field.display ?? "list"}${preset}; items: ${items}${title})`;
 }
 
+// src/catalog-write-tools.ts
+function target(object2) {
+  return object2 ? { object: object2 } : void 0;
+}
+var FIELD_KINDS = 'Kinds: text, number, select, checkbox, url, date, and three content blocks for a product page: "content_text" (formatted text, no config), "cta" (a call to action; config { secondary: true } offers a second button) and "repeater" (a list, an accordion such as a FAQ, downloads or testimonials; config { display: "list" | "accordion", preset?: "list" | "faq" | "downloads" | "testimonials", itemFields: [{ key, label, type: text | richtext | url | icon | image | file }], titleKey?: the item field that names an item }). A number may take config { prefix?, suffix? }. A configurator is made with upsert_configurator. The kind is fixed once the field exists, and so is the type of a repeater\u2019s item field.';
+var IDENTITY = 'A product is known by `externalRef`, its id in the system it comes from, together with `source`, the name of that system (for example "acme-webshop"). The same pair always means the same product: sending it again changes it instead of making a second one, so use references that stay the same, never a name that may change.';
+function registerCatalogWriteTools(server, client) {
+  server.registerTool(
+    "upsert_product",
+    {
+      title: "Make or change a product",
+      description: IDENTITY + ' Every field but `source` may be left out, and left out means "leave it as it is"; null empties a field. A new product needs a `name` and is a draft unless `availability` says otherwise: do not publish without the user asking. `prices`, `categories`, `images` and `variants` each replace what the product had as a whole, and a variant left out is archived. Categories are named by slug and a missing one is refused unless `createMissingCategories` is true; a choice a select field does not offer is refused unless `addMissingOptions` is true. Pictures are https URLs, fetched after the answer (`images: "pending"`). Amounts are in cents. Read list_catalog_fields first for the slugs `fields` takes.',
+      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,
+          target(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,
+          target(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.",
+      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,
+          target(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.",
+      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 {
+        const field = await client.upsertField(slug, input, target(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 z7 } from "zod";
 
 // ../features/product-configurator/src/shared/configurator-limits.ts
 var CONFIGURATOR_LIMITS = {
@@ -155,11 +759,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 +785,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,23 +1076,24 @@ function evaluateFormulaSource(source, scope) {
 }
 
 // ../features/product-configurator/src/shared/geometry-document.schema.ts
-import { z as z2 } from "zod";
+import { z as z4 } 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 = z4.string().regex(CONFIGURATOR_NAME_PATTERN, "configurator.invalidName");
+var ConfiguratorCodeSchema = z4.string().regex(CONFIGURATOR_CODE_PATTERN, "configurator.invalidCode");
+var FormulaSchema = z4.union([
+  z4.number().finite(),
+  z4.string().trim().min(1).max(CONFIGURATOR_LIMITS.formulaChars, "configurator.formulaTooLong")
 ]);
-var Vector3Schema = z2.tuple([FormulaSchema, FormulaSchema, FormulaSchema]);
+var Vector3Schema = z4.tuple([FormulaSchema, FormulaSchema, FormulaSchema]);
 var PRIMITIVE_TYPES = [
   "box",
   "rounded_top_box",
   "stadium_prism",
   "arc_panel",
   "led_strip",
-  "niche_panel"
+  "niche_panel",
+  "model"
 ];
 var PRIMITIVE_PARAMS = {
   box: { required: [], optional: [] },
@@ -506,69 +1111,127 @@ var PRIMITIVE_PARAMS = {
   niche_panel: {
     required: ["niche_x", "niche_y", "niche_width", "niche_height"],
     optional: []
-  }
+  },
+  // An uploaded `.glb` placed in the block's frame. `fit` 0 scales it evenly
+  // and centres it (the default), 1 stretches it to the frame: a handle that
+  // grows with the door; 2 keeps the model's own size, standing on the
+  // frame's floor in the middle and against its front: a fire insert, which
+  // is as large as it is. `paint` 1 gives every mesh the slot's material, so
+  // it follows the visitor's colour; 0 (the default) keeps the model's own.
+  model: { required: [], optional: ["fit", "paint"] }
 };
-var PrimitiveNodeSchema = z2.strictObject({
+var CONFIGURATOR_MODEL_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}\.glb$/;
+var CONFIGURATOR_FOLLOWS_PRESET = "preset";
+var PrimitiveNodeFields = {
   id: ConfiguratorNameSchema,
-  type: z2.enum(PRIMITIVE_TYPES),
   slot: ConfiguratorNameSchema,
   size: Vector3Schema,
   at: Vector3Schema,
   visible: FormulaSchema.optional(),
-  params: z2.record(ConfiguratorNameSchema, FormulaSchema).optional()
+  params: z4.record(ConfiguratorNameSchema, FormulaSchema).optional()
+};
+var PrimitiveNodeSchema = z4.strictObject({
+  ...PrimitiveNodeFields,
+  type: z4.enum(PRIMITIVE_TYPES).exclude(["model"])
 });
-var GeometryNodeSchema = z2.lazy(
-  () => z2.union([
-    PrimitiveNodeSchema,
-    z2.strictObject({
-      id: ConfiguratorNameSchema,
-      type: z2.literal("repeat"),
-      count: FormulaSchema,
-      index: z2.enum(["i", "j"]).optional(),
-      visible: FormulaSchema.optional(),
-      children: z2.array(GeometryNodeSchema).min(1)
-    })
-  ])
-);
-var GeometryBindingSchema = z2.strictObject({
+var ModelPathSchema = z4.string().regex(CONFIGURATOR_MODEL_PATH_PATTERN, "configurator.invalidModelPath");
+var ServedFileUrlSchema = z4.url({ protocol: /^https?$/ });
+function geometryNodeSchema(modelFile) {
+  const ModelNodeSchema = z4.strictObject({
+    ...PrimitiveNodeFields,
+    type: z4.literal("model"),
+    model: modelFile
+  });
+  const ModelPerChoiceNodeSchema = z4.strictObject({
+    ...PrimitiveNodeFields,
+    type: z4.literal("model"),
+    follows: ConfiguratorNameSchema,
+    models: z4.record(ConfiguratorCodeSchema, modelFile).refine(
+      (models) => Object.keys(models).length <= CONFIGURATOR_LIMITS.presets,
+      { message: "configurator.tooMany" }
+    )
+  });
+  const node = z4.lazy(
+    () => z4.union([
+      PrimitiveNodeSchema,
+      ModelNodeSchema,
+      ModelPerChoiceNodeSchema,
+      z4.strictObject({
+        id: ConfiguratorNameSchema,
+        type: z4.literal("repeat"),
+        count: FormulaSchema,
+        index: z4.enum(["i", "j"]).optional(),
+        visible: FormulaSchema.optional(),
+        children: z4.array(node).min(1)
+      })
+    ])
+  );
+  return node;
+}
+var GeometryNodeSchema = geometryNodeSchema(ModelPathSchema);
+var GeometryBindingSchema = z4.strictObject({
   param: ConfiguratorNameSchema,
-  map: z2.record(ConfiguratorCodeSchema, z2.number().finite()).optional()
+  map: z4.record(ConfiguratorCodeSchema, z4.number().finite()).optional()
 });
-var GeometryInputSchema = z2.strictObject({
+var GeometryInputSchema = z4.strictObject({
   name: ConfiguratorNameSchema,
   binding: GeometryBindingSchema
 });
-var GeometrySlotSchema = z2.strictObject({
+var GeometrySlotSchema = z4.strictObject({
   name: ConfiguratorNameSchema,
   param: ConfiguratorNameSchema.optional(),
   material: ConfiguratorCodeSchema.optional(),
-  color: z2.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor").optional()
+  color: z4.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor").optional(),
+  /**
+   * Which way the grain of a picture runs on this part: `horizontal` (the
+   * default) as the picture is drawn, `vertical` turned a quarter. It belongs
+   * to the part, not the material: the same oak lies on a cabinet and stands
+   * on a tall wall panel.
+   */
+  grain: z4.enum(["horizontal", "vertical"]).optional()
 });
-var GeometryAnnotationSchema = z2.strictObject({
+var GeometryAnnotationSchema = z4.strictObject({
   id: ConfiguratorNameSchema,
-  axis: z2.enum(["x", "y"]),
+  axis: z4.enum(["x", "y"]),
   from: FormulaSchema,
   to: FormulaSchema,
   at: FormulaSchema,
-  label: z2.string().trim().min(1).max(80).optional()
-});
-var GeometryDocumentSchema = z2.strictObject({
-  /** Rises with every new upload, so a product page can say which one it shows. */
-  version: z2.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).min(1),
-  camera: z2.strictObject({
-    /** Degrees around the vertical axis, 0 is straight on. */
-    azimuth: z2.number().min(-90).max(90),
-    /** Degrees above the horizon. */
-    elevation: z2.number().min(-10).max(80)
-  }).optional(),
-  annotations: z2.array(GeometryAnnotationSchema).max(CONFIGURATOR_LIMITS.annotations)
+  label: z4.string().trim().min(1).max(80).optional()
 });
+function geometryDocumentSchema(modelFile) {
+  return z4.strictObject({
+    /** Rises with every new upload, so a product page can say which one it shows. */
+    version: z4.number().int().min(1),
+    /** The starter document this one was copied from, for information only. */
+    startedFrom: z4.string().trim().max(80).optional(),
+    inputs: z4.array(GeometryInputSchema).max(CONFIGURATOR_LIMITS.geometryInputs),
+    constants: z4.record(ConfiguratorNameSchema, z4.number().finite()),
+    slots: z4.array(GeometrySlotSchema).min(1).max(CONFIGURATOR_LIMITS.geometrySlots),
+    root: z4.array(geometryNodeSchema(modelFile)).min(1),
+    camera: z4.strictObject({
+      /** Degrees around the vertical axis, 0 is straight on. */
+      azimuth: z4.number().min(-90).max(90),
+      /** Degrees above the horizon. */
+      elevation: z4.number().min(-10).max(80)
+    }).optional(),
+    annotations: z4.array(GeometryAnnotationSchema).max(CONFIGURATOR_LIMITS.annotations)
+  });
+}
+var GeometryDocumentSchema = geometryDocumentSchema(ModelPathSchema);
+function choiceModelBlocks(nodes) {
+  const found = [];
+  const walk = (list) => {
+    for (const node of list) {
+      if (node.type === "repeat") {
+        walk(node.children);
+      } else if (node.type === "model" && node.follows !== void 0) {
+        found.push({ name: `${node.id}_shown`, node });
+      }
+    }
+  };
+  walk(nodes);
+  return found;
+}
 
 // ../features/product-configurator/src/shared/geometry-document-problems.ts
 function geometryDocumentProblems(document, context = {}) {
@@ -685,7 +1348,17 @@ function geometryDocumentProblems(document, context = {}) {
       );
     }
   });
-  const shapeNames = /* @__PURE__ */ new Set([...inputNames, ...constantNames]);
+  const shownNames = choiceModelBlocks(document.root).map(
+    (block) => block.name
+  );
+  for (const name of shownNames) {
+    if (inputNames.has(name) || constantNames.includes(name)) {
+      problems.push(
+        issue([...base, "root"], "configurator.duplicateName", { name })
+      );
+    }
+  }
+  const shapeNames = /* @__PURE__ */ new Set([...inputNames, ...constantNames, ...shownNames]);
   const ids = /* @__PURE__ */ new Set();
   let declared = 0;
   const checkFormula2 = (formula, path, scope) => {
@@ -784,6 +1457,14 @@ function geometryDocumentProblems(document, context = {}) {
         }
         checkFormula2(formula, [...nodePath, "params", key], scope);
       }
+      if (node.follows !== void 0 && context.parameters) {
+        problems.push(
+          ...followProblems(node.follows, nodePath, {
+            parameters: context.parameters,
+            hasPresets: context.hasPresets ?? false
+          })
+        );
+      }
     }
   };
   walk(document.root, [...base, "root"], shapeNames, 0);
@@ -811,92 +1492,110 @@ function geometryDocumentProblems(document, context = {}) {
   });
   return problems;
 }
+function followProblems(follows, path, context) {
+  if (follows === CONFIGURATOR_FOLLOWS_PRESET) {
+    return context.hasPresets ? [] : [issue([...path, "follows"], "configurator.followsNoPresets")];
+  }
+  return context.parameters.get(follows)?.kind === "choice" ? [] : [
+    issue([...path, "follows"], "configurator.followsNotAChoice", {
+      param: follows
+    })
+  ];
+}
 
 // ../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 z5 } from "zod";
+var LabelSchema = z5.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 = z5.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 = z5.discriminatedUnion("kind", [
+  z5.strictObject({
     ...ParameterBase,
-    kind: z3.literal("number"),
+    kind: z5.literal("number"),
     /** `mm` is a measure, `count` a number of things (compartments). */
-    unit: z3.enum(["mm", "count"]),
-    step: z3.number().positive().finite(),
+    unit: z5.enum(["mm", "count"]),
+    step: z5.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: z5.number().finite(),
+    max: z5.number().finite()
   }),
-  z3.strictObject({
+  z5.strictObject({
     ...ParameterBase,
-    kind: z3.literal("choice"),
+    kind: z5.literal("choice"),
     list: ConfiguratorNameSchema
   }),
-  z3.strictObject({ ...ParameterBase, kind: z3.literal("material") }),
-  z3.strictObject({ ...ParameterBase, kind: z3.literal("toggle") })
+  z5.strictObject({ ...ParameterBase, kind: z5.literal("material") }),
+  z5.strictObject({ ...ParameterBase, kind: z5.literal("toggle") })
 ]);
-var ConfiguratorChoiceListSchema = z3.strictObject({
+var choiceListSchema = (picture) => z5.strictObject({
   key: ConfiguratorNameSchema,
   label: LabelSchema,
-  options: z3.array(
-    z3.strictObject({
+  options: z5.array(
+    z5.strictObject({
       code: ConfiguratorCodeSchema,
       label: LabelSchema,
-      image: TexturePathSchema.optional()
+      image: picture.optional()
     })
   ).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
 });
-var ConfiguratorMaterialSchema = z3.strictObject({
+var materialSchema = (picture) => z5.strictObject({
   code: ConfiguratorCodeSchema,
   label: LabelSchema,
-  color: z3.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor"),
-  texture: TexturePathSchema.optional(),
-  /** Millimetres one repeat of the texture covers. */
-  textureSize: z3.number().positive().max(1e4).optional(),
-  roughness: z3.number().min(0).max(1).optional(),
-  metalness: z3.number().min(0).max(1).optional(),
+  color: z5.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor"),
+  texture: picture.optional(),
+  /** Millimetres one repeat of the texture covers; the two maps below share it. */
+  textureSize: z5.number().positive().max(1e4).optional(),
+  /** Relief that moves with the light: a tangent-space normal map. */
+  normalMap: picture.optional(),
+  /** How deep the relief reads; 1 is the map as drawn. */
+  normalScale: z5.number().min(0).max(3).optional(),
+  /** Where the surface is matte and where it shines (the green channel), times `roughness`. */
+  roughnessMap: picture.optional(),
+  roughness: z5.number().min(0).max(1).optional(),
+  metalness: z5.number().min(0).max(1).optional(),
   /** 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: z5.number().min(0.05).max(1).optional(),
   /** Gives light rather than reflecting it: a flame, a LED. */
-  emissive: z3.boolean().optional(),
+  emissive: z5.boolean().optional(),
   priceGroup: ConfiguratorCodeSchema.optional()
 });
-var ConditionValueSchema = z3.union([
-  z3.number().finite(),
-  z3.boolean(),
+var ConfiguratorChoiceListSchema = choiceListSchema(TexturePathSchema);
+var ConfiguratorMaterialSchema = materialSchema(TexturePathSchema);
+var ConditionValueSchema = z5.union([
+  z5.number().finite(),
+  z5.boolean(),
   ConfiguratorCodeSchema,
-  z3.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
+  z5.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList)
 ]);
-var ConfiguratorConditionSchema = z3.strictObject({
+var ConfiguratorConditionSchema = z5.strictObject({
   param: ConfiguratorNameSchema,
-  op: z3.enum(["eq", "neq", "in", "gte", "lte"]),
+  op: z5.enum(["eq", "neq", "in", "gte", "lte"]),
   value: ConditionValueSchema
 });
-var ConfiguratorRuleSchema = z3.discriminatedUnion("kind", [
+var ConfiguratorRuleSchema = z5.discriminatedUnion("kind", [
   /** Show `param` only while `when` holds. */
-  z3.strictObject({
-    kind: z3.literal("visible"),
+  z5.strictObject({
+    kind: z5.literal("visible"),
     param: ConfiguratorNameSchema,
     when: ConfiguratorConditionSchema
   }),
   /** Narrow a number parameter: `max cabinet_height = total_height - 300`. */
-  z3.strictObject({
-    kind: z3.literal("limit"),
+  z5.strictObject({
+    kind: z5.literal("limit"),
     param: ConfiguratorNameSchema,
-    bound: z3.enum(["min", "max"]),
+    bound: z5.enum(["min", "max"]),
     formula: FormulaSchema
   }),
   /** While `when` holds, these codes of a choice or material are not offered. */
-  z3.strictObject({
-    kind: z3.literal("exclude"),
+  z5.strictObject({
+    kind: z5.literal("exclude"),
     param: ConfiguratorNameSchema,
-    codes: z3.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList),
+    codes: z5.array(ConfiguratorCodeSchema).min(1).max(CONFIGURATOR_LIMITS.optionsPerList),
     when: ConfiguratorConditionSchema
   })
 ]);
@@ -906,23 +1605,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 = z5.discriminatedUnion("kind", [
   /** The surcharge the model gives the chosen option. */
-  z3.strictObject({
+  z5.strictObject({
     ...PriceRuleBase,
-    kind: z3.literal("choice"),
+    kind: z5.literal("choice"),
     param: ConfiguratorNameSchema
   }),
   /** The surcharge of the chosen material's price group. */
-  z3.strictObject({
+  z5.strictObject({
     ...PriceRuleBase,
-    kind: z3.literal("material"),
+    kind: z5.literal("material"),
     param: ConfiguratorNameSchema
   }),
   /** An amount, counted while a switch is on. */
-  z3.strictObject({
+  z5.strictObject({
     ...PriceRuleBase,
-    kind: z3.literal("toggle"),
+    kind: z5.literal("toggle"),
     param: ConfiguratorNameSchema,
     amount: ConfiguratorNameSchema
   }),
@@ -930,35 +1629,64 @@ 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({
+  z5.strictObject({
     key: ConfiguratorNameSchema,
     label: LabelSchema,
-    kind: z3.literal("formula"),
+    kind: z5.literal("formula"),
     formula: FormulaSchema
   })
 ]);
-var ConfiguratorStructureObjectSchema = z3.strictObject({
-  schemaVersion: z3.literal(1),
-  geometry: GeometryDocumentSchema,
-  tabs: z3.array(z3.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })).min(1).max(CONFIGURATOR_LIMITS.tabs),
-  parameters: z3.array(ConfiguratorParameterSchema).max(CONFIGURATOR_LIMITS.parameters),
-  choiceLists: z3.array(ConfiguratorChoiceListSchema).max(CONFIGURATOR_LIMITS.choiceLists),
-  materials: z3.array(ConfiguratorMaterialSchema).max(CONFIGURATOR_LIMITS.materials),
-  priceGroups: z3.array(z3.strictObject({ code: ConfiguratorCodeSchema, label: LabelSchema })).max(CONFIGURATOR_LIMITS.priceGroups),
+var CONFIGURATOR_SCENE_LIGHTINGS = [
+  "studio",
+  "warm",
+  "daylight"
+];
+var CONFIGURATOR_SCENE_EDGES = ["soft", "sharp"];
+var ConfiguratorSceneSchema = z5.strictObject({
+  lighting: z5.enum(CONFIGURATOR_SCENE_LIGHTINGS).optional(),
+  edges: z5.enum(CONFIGURATOR_SCENE_EDGES).optional()
+});
+var structureObjectSchema = (files) => z5.strictObject({
+  schemaVersion: z5.literal(1),
+  geometry: geometryDocumentSchema(files.model),
+  /**
+   * How the scene is presented. Part of the structure and not of the shape
+   * document, so the owner sets it under `crm.manage` like a material.
+   */
+  scene: ConfiguratorSceneSchema.optional(),
+  tabs: z5.array(
+    z5.strictObject({ key: ConfiguratorNameSchema, label: LabelSchema })
+  ).min(1).max(CONFIGURATOR_LIMITS.tabs),
+  parameters: z5.array(ConfiguratorParameterSchema).max(CONFIGURATOR_LIMITS.parameters),
+  choiceLists: z5.array(choiceListSchema(files.picture)).max(CONFIGURATOR_LIMITS.choiceLists),
+  materials: z5.array(materialSchema(files.picture)).max(CONFIGURATOR_LIMITS.materials),
+  priceGroups: z5.array(
+    z5.strictObject({ code: ConfiguratorCodeSchema, label: LabelSchema })
+  ).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 })).max(CONFIGURATOR_LIMITS.amounts),
+  amounts: z5.array(
+    z5.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: z5.strictObject({
     label: LabelSchema,
     tab: ConfiguratorNameSchema,
-    sets: z3.array(ConfiguratorNameSchema).min(1).max(CONFIGURATOR_LIMITS.parameters),
-    required: z3.boolean()
+    sets: z5.array(ConfiguratorNameSchema).min(1).max(CONFIGURATOR_LIMITS.parameters),
+    required: z5.boolean()
   }).optional(),
-  rules: z3.array(ConfiguratorRuleSchema).max(CONFIGURATOR_LIMITS.rules),
-  priceRules: z3.array(ConfiguratorPriceRuleSchema).max(CONFIGURATOR_LIMITS.priceRules)
+  rules: z5.array(ConfiguratorRuleSchema).max(CONFIGURATOR_LIMITS.rules),
+  priceRules: z5.array(ConfiguratorPriceRuleSchema).max(CONFIGURATOR_LIMITS.priceRules)
+});
+var ConfiguratorStructureObjectSchema = structureObjectSchema({
+  picture: TexturePathSchema,
+  model: ModelPathSchema
+});
+var ServedConfiguratorStructureObjectSchema = structureObjectSchema({
+  picture: ServedFileUrlSchema,
+  model: ServedFileUrlSchema
 });
 var ConfiguratorStructureSchema = ConfiguratorStructureObjectSchema.superRefine((structure, ctx) => {
   for (const problem of configuratorStructureProblems(structure)) {
@@ -1109,8 +1837,8 @@ function configuratorStructureProblems(structure) {
   };
   structure.rules.forEach((rule, index) => {
     const path = ["rules", index];
-    const target = parameters.get(rule.param);
-    if (!target) {
+    const target2 = parameters.get(rule.param);
+    if (!target2) {
       problems.push(
         issue([...path, "param"], "configurator.unknownParam", {
           key: rule.param
@@ -1119,7 +1847,7 @@ function configuratorStructureProblems(structure) {
       return;
     }
     if (rule.kind === "limit") {
-      if (target.kind !== "number") {
+      if (target2.kind !== "number") {
         problems.push(
           issue([...path, "param"], "configurator.notANumberParam", {
             key: rule.param
@@ -1137,7 +1865,7 @@ function configuratorStructureProblems(structure) {
       return;
     }
     if (rule.kind === "exclude") {
-      const codes = codesOf(target, lists, materials);
+      const codes = codesOf(target2, lists, materials);
       if (!codes) {
         problems.push(
           issue([...path, "param"], "configurator.notAChoiceParam", {
@@ -1216,8 +1944,8 @@ function configuratorStructureProblems(structure) {
         problems
       );
     }
-    const target = parameters.get(rule.param);
-    if (!target || target.kind !== rule.kind) {
+    const target2 = parameters.get(rule.param);
+    if (!target2 || target2.kind !== rule.kind) {
       problems.push(
         issue([...path, "param"], "configurator.priceRuleParamKind", {
           key: rule.param,
@@ -1243,6 +1971,7 @@ function configuratorStructureProblems(structure) {
     ...geometryDocumentProblems(structure.geometry, {
       parameters: geometryParameters,
       materialCodes: materials,
+      hasPresets: structure.presets !== void 0,
       path: ["geometry"]
     })
   );
@@ -1365,55 +2094,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 z6 } from "zod";
+var CentsSchema = z6.number().int().min(0).max(1e8);
 var PriceSchema = CentsSchema.nullable();
-var ConfiguratorValueObjectSchema = z4.strictObject({
+var ConfiguratorValueObjectSchema = z6.strictObject({
   /** Null: the model has no price of its own, every quote is "open". */
   basePriceCents: PriceSchema,
-  numbers: z4.record(
+  numbers: z6.record(
     ConfiguratorNameSchema,
-    z4.strictObject({
-      min: z4.number().finite(),
-      max: z4.number().finite(),
-      default: z4.number().finite()
+    z6.strictObject({
+      min: z6.number().finite(),
+      max: z6.number().finite(),
+      default: z6.number().finite()
     })
   ).default({}),
   /** Per choice list: the options this model offers, with their surcharge. */
-  choices: z4.record(
+  choices: z6.record(
     ConfiguratorNameSchema,
-    z4.strictObject({
-      options: z4.record(
+    z6.strictObject({
+      options: z6.record(
         ConfiguratorCodeSchema,
-        z4.strictObject({ priceCents: PriceSchema })
+        z6.strictObject({ priceCents: PriceSchema })
       ),
       default: ConfiguratorCodeSchema.optional()
     })
   ).default({}),
   /** Per material parameter: the materials this model offers. */
-  materials: z4.record(
+  materials: z6.record(
     ConfiguratorNameSchema,
-    z4.strictObject({
-      offered: z4.array(ConfiguratorCodeSchema).max(CONFIGURATOR_LIMITS.materials),
+    z6.strictObject({
+      offered: z6.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: z6.record(
     ConfiguratorNameSchema,
-    z4.strictObject({ offered: z4.boolean(), default: z4.boolean() })
+    z6.strictObject({ offered: z6.boolean(), default: z6.boolean() })
   ).default({}),
   /** The surcharge of each material price group. */
-  priceGroups: z4.record(ConfiguratorCodeSchema, PriceSchema).default({}),
+  priceGroups: z6.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: z6.record(ConfiguratorNameSchema, PriceSchema).default({}),
+  presets: z6.array(
+    z6.strictObject({
       code: ConfiguratorCodeSchema,
-      label: z4.string().trim().min(1).max(80),
+      label: z6.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: z6.string().uuid().nullable(),
+      values: z6.record(ConfiguratorNameSchema, z6.number().finite())
     })
   ).max(CONFIGURATOR_LIMITS.presets).default([])
 });
@@ -1553,7 +2282,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;
     }
@@ -1621,7 +2351,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(
@@ -1652,7 +2383,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: {} };
@@ -1686,13 +2418,13 @@ function onStep(value, step) {
 }
 
 // ../features/product-configurator/src/shared/expand-geometry.ts
-function expandGeometry(document, inputs) {
+function expandGeometry(document, inputs, chosen = { choices: {} }) {
   const issues = [];
   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
@@ -1700,11 +2432,14 @@ function expandGeometry(document, inputs) {
       );
       continue;
     }
-    baseScope[input.name] = number;
+    baseScope[input.name] = number2;
   }
   if (issues.length > 0) {
     return { ok: false, issues };
   }
+  for (const block of choiceModelBlocks(document.root)) {
+    baseScope[block.name] = modelOf(block.node, chosen) === void 0 ? 0 : 1;
+  }
   const evaluate = (formula, scope, path) => {
     const result = evaluateFormulaSource(formula, scope);
     if (!result.ok) {
@@ -1783,13 +2518,17 @@ function expandGeometry(document, inputs) {
         );
         return;
       }
+      const model = modelOf(node, chosen);
+      if (node.type === "model" && model === void 0) {
+        continue;
+      }
       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}`,
@@ -1798,7 +2537,8 @@ function expandGeometry(document, inputs) {
         slot: node.slot,
         size,
         at,
-        params
+        params,
+        ...model === void 0 ? {} : { model }
       });
       if (parts.length > CONFIGURATOR_LIMITS.expandedParts) {
         issues.push(
@@ -1852,10 +2592,26 @@ function boundsOf(parts) {
   }
   return { min, max };
 }
+function modelOf(node, chosen) {
+  if (node.follows === void 0) {
+    return node.model;
+  }
+  const code = node.follows === CONFIGURATOR_FOLLOWS_PRESET ? chosen.preset : chosen.choices[node.follows];
+  return code === void 0 ? void 0 : node.models?.[code];
+}
 
 // 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", "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) 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, stat } from "fs/promises";
+import { extname } from "path";
+var FILE_RULES = {
+  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 = z7.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) {
@@ -1863,14 +2619,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"),
@@ -1878,14 +2634,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: z7.string().trim().min(1).max(120).optional(),
+        structure: z7.string().min(2).max(2e5).describe(
+          'The JSON text of the whole configurator structure (it has "schemaVersion").'
+        ),
+        public: z7.boolean().optional().describe("Whether product pages may show the configurator."),
+        ...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: z7.enum(CONFIGURATOR_FILE_KINDS),
+        filePath: z7.string().min(1).max(1e3).describe("The absolute path of the file on this machine."),
+        ...objectInput
+      },
+      annotations: { destructiveHint: false, idempotentHint: false }
+    },
+    async ({ fieldSlug, kind, filePath, object: object2 }) => {
+      const rules = FILE_RULES[kind];
+      const extension = extname(filePath).toLowerCase();
+      if (!rules.extensions.includes(extension)) {
+        return notUploaded(
+          `A ${kind} is a ${rules.extensions.join(" or ")} file; this is "${extension || "no extension"}".`
+        );
+      }
+      const info = await stat(filePath).catch(() => null);
+      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 readFile(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: z7.string().min(1).max(200).describe("The address (slug) or the id of the product."),
+        field: z7.string().min(1).max(64).describe("The slug of the configurator field.")
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
@@ -1904,15 +2771,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" }];
   }
@@ -1956,18 +2823,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 z8 } from "zod";
+var moment = z8.string().datetime({ offset: true }).optional().describe("An ISO timestamp with its offset, such as 2026-11-01T00:00:00Z.");
+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: z8.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: z8.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 z9 } 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 = z9.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",
@@ -1987,7 +2938,7 @@ function registerPlacementTools(server, client) {
           list
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2007,7 +2958,7 @@ function registerPlacementTools(server, client) {
           pages
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2030,7 +2981,7 @@ function registerPlacementTools(server, client) {
           list
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2040,13 +2991,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: z9.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: z9.string().min(1).max(200).optional().describe("Required when the widget does not exist yet."),
+        status: z9.enum(["draft", "published"]).optional().describe("Only a published widget answers on a site."),
+        addAllowedOrigins: z9.array(origin).max(20).optional(),
+        removeAllowedOrigins: z9.array(origin).max(20).optional()
       },
       annotations: {
         readOnlyHint: false,
@@ -2064,7 +3015,7 @@ ${describeChatWidget(widget)}`,
           widget
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2084,7 +3035,7 @@ ${describeChatWidget(widget)}`,
           site
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2094,9 +3045,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: z9.array(z9.string()).max(20).optional().describe('Hosts such as "www.example.com" or "*.example.com".'),
+        removeAllowedHosts: z9.array(z9.string()).max(20).optional(),
+        consentSignal: z9.enum([
           "ad_storage",
           "analytics_storage",
           "personalization_storage",
@@ -2121,7 +3072,7 @@ ${describeSiteTracking(site)}`,
           site
         );
       } catch (error) {
-        return refusal(error);
+        return refusal(error, "website:manage");
       }
     }
   );
@@ -2155,9 +3106,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) {
@@ -2166,13 +3114,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)) {
@@ -2193,7 +3141,9 @@ async function main() {
   }
   const server = new McpServer({
     name: "crm-mcp-server",
-    version: "0.3.0"
+    // Read from the package, so the version an agent is told is the one
+    // that was published.
+    version
   });
   const client = createClient({
     apiKey: config.apiKey,
@@ -2201,6 +3151,8 @@ async function main() {
   });
   registerPlacementTools(server, client);
   registerCatalogTools(server, client);
+  registerCatalogWriteTools(server, client);
+  registerEventTools(server, client);
   registerConfiguratorTools(server, client);
   await server.connect(new StdioServerTransport());
 }