@anyday/sanity-workspace-manager 0.4.0 → 0.6.0

package/dist/cli.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync as existsSync3, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync } from "node:fs";
+import { join as join4, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 
@@ -174,6 +174,10 @@ var workspace_manager_schema_default = {
     $schema: {
       type: "string"
     },
+    $generated: {
+      description: "Set by the CLI's generate: a note and a hash that check uses to spot hand edits.",
+      type: "string"
+    },
     id: {
       description: "Stable id stored on jobs and used as the Vercel project prefix.",
       type: "string",
@@ -452,7 +456,7 @@ function humanize(name) {
   return words.charAt(0).toUpperCase() + words.slice(1);
 }
 
-// src/init/extract.ts
+// src/generate/extract.ts
 var PLUGIN_TYPES = /^(sanity\.|system\.|assist\.|media\.tag$|translation\.metadata$|fieldTranslation\.metadata$)/;
 var Extract = class {
   byName;
@@ -519,7 +523,8 @@ var Extract = class {
   }
 };
 
-// src/init/draft.ts
+// src/generate/draft.ts
+var SETTINGS_ROLES = ["siteName", "domain", "logo", "favicon"];
 var SYSTEM_FIELDS = /* @__PURE__ */ new Set(["_rev", "_createdAt", "_updatedAt", "_system"]);
 var ENV_DEFAULTS = {
   projectId: "NEXT_PUBLIC_SANITY_PROJECT_ID",
@@ -540,21 +545,33 @@ function suggestNames(repo) {
   const id = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
   return { id: id || "site", title: humanize(name.replace(/[-_]+/g, " ").trim()) || "Site" };
 }
-function draftManifest(repo, answers, live = {}) {
+var guessSingletons = (schema) => schema.contentDocuments.map((type) => type.name).filter((name) => /settings$/i.test(name));
+function sectionCandidates(schema, singletons) {
+  const setupTypes = draftLanguages(schema, () => {
+  })?.setupTypes ?? [];
+  return schema.contentDocuments.map((type) => type.name).filter((name) => !singletons.includes(name) && !setupTypes.includes(name));
+}
+function draftManifest(repo, answers, live = {}, choices) {
   const notes = [];
   const note = (message) => void notes.push(message);
   const schema = new Extract(repo.types);
-  const singletons = schema.contentDocuments.map((type) => type.name).filter((name) => /settings$/i.test(name));
-  if (singletons.length)
-    note(`Singletons guessed from names ending in "Settings": ${singletons.join(", ")}`);
-  else note("No singletons found: list your settings documents in content.singletons");
-  const homePage = findHomePage(schema, singletons);
-  if (homePage) note(`Home page: ${homePage.documentId}.${homePage.field}`);
-  else note("No home page reference found: set content.homePage by hand");
+  const singletons = choices?.singletons ?? guessSingletons(schema);
+  const homePage = choices?.homePage ?? findHomePage(schema, singletons);
+  if (!choices) {
+    if (singletons.length)
+      note(`Singletons guessed from names ending in "Settings": ${singletons.join(", ")}`);
+    else note("No singletons found: list your settings documents in content.singletons");
+    if (homePage) note(`Home page: ${homePage.documentId}.${homePage.field}`);
+    else note("No home page reference found: set content.homePage by hand");
+  }
   const home = homePage ?? { documentId: singletons[0] ?? "siteSettings", field: "homePage" };
   const languages = draftLanguages(schema, note);
-  const sections = schema.contentDocuments.map((type) => type.name).filter((name) => !singletons.includes(name) && !languages?.setupTypes.includes(name)).map((name) => [name, humanize(name)]);
-  note(`Copy sections list every content type (${sections.length}): remove the ones not to offer`);
+  const sections = sectionCandidates(schema, singletons).map((name) => [
+    name,
+    humanize(name)
+  ]);
+  if (!choices)
+    note(`Copy sections list every content type (${sections.length}): remove the ones not to offer`);
   const siteEnv = Object.fromEntries(
     Object.entries(ENV_PATTERNS).map(([key, pattern]) => {
       const matches = repo.envNames.filter((name) => pattern.test(name));
@@ -593,13 +610,40 @@ function draftManifest(repo, answers, live = {}) {
         sections,
         singletons,
         homePage: home,
-        starter: draftStarter(schema, home, live, note)
+        starter: draftStarter(schema, home, live, note, Boolean(choices))
       },
-      brand: draftBrand(schema, home, live, note)
+      brand: draftBrand(
+        schema,
+        home,
+        live,
+        note,
+        choices?.settingsFields ?? guessSettingsFields(schema, home.documentId),
+        Boolean(choices)
+      )
     },
     notes
   };
 }
+function fitsRole(schema, documentId, role, field) {
+  const value = schema.fields(documentId)[field]?.value;
+  if (!value) return false;
+  if (role === "logo" || role === "favicon") return schema.isImage(value);
+  if (role === "siteName")
+    return value.type === "string" || schema.inlineName(value) === "internationalizedArrayString";
+  return true;
+}
+var SITE_NAME_FIELDS = ["siteName", "siteTitle", "title", "name"];
+function guessSettingsFields(schema, documentId) {
+  return Object.fromEntries(
+    SETTINGS_ROLES.map((role) => {
+      const names = role === "siteName" ? SITE_NAME_FIELDS : [role];
+      return [role, names.find((name) => fitsRole(schema, documentId, role, name)) ?? null];
+    })
+  );
+}
+var themeTypeOf = (schema) => schema.contentDocuments.find((type) => /theme/i.test(type.name))?.name ?? null;
+var colorRolesOf = (schema, themeId) => Object.entries(schema.fields(themeId)).filter(([, { value }]) => schema.colorShape(value)).map(([role]) => role);
+var fontFieldsOf = (schema, themeId) => Object.entries(schema.fields(themeId)).filter(([, { value }]) => schema.fontShape(value)).map(([field]) => field);
 function findHomePage(schema, singletons) {
   for (const documentId of singletons) {
     const fields = schema.fields(documentId);
@@ -638,17 +682,17 @@ function draftLanguages(schema, note) {
   note(`Language documents: ${type.name}, ids like ${document._id}; check the id pattern`);
   return { document, setupTypes };
 }
-function draftStarter(schema, home, live, note) {
+function draftStarter(schema, home, live, note, quiet = false) {
   if (live.starter?.length) {
     const siteName = siteNameOf(live.settings);
     const language = live.starter.find((doc) => typeof doc.language === "string")?.language;
     const ids = new Set(live.starter.map((doc) => doc._id));
-    const documents = live.starter.map((doc) => placeholders(stripSystem(doc), siteName, language));
-    const outside = live.starter.flatMap((doc) => references(doc).filter((ref) => !ids.has(ref)));
-    if (outside.length)
-      note(
-        `Starter pages link to documents not in the starter: ${[...new Set(outside)].join(", ")}`
-      );
+    const dropped = [];
+    const documents = live.starter.map(
+      (doc) => placeholders(dropOutsideLinks(stripSystem(doc), ids, dropped), siteName, language)
+    );
+    if (dropped.length)
+      note(`Starter: removed what links outside the picked pages: ${dropped.join(", ")}`);
     const liveHome = live.settings?.[home.field]?._ref;
     const homeId = liveHome && ids.has(liveHome) ? liveHome : live.starter[0]._id;
     note(`Starter: ${documents.length} documents from the live project, home ${homeId}`);
@@ -660,15 +704,15 @@ function draftStarter(schema, home, live, note) {
   const page = { _id: "starter-home", _type: type };
   if ("title" in fields) page.title = "{{siteName}}";
   if ("language" in fields) page.language = "{{language}}";
-  note("Starter is one empty home page: run with --live to pick real pages instead");
+  if (!quiet) note("Starter is one empty home page: run with --live to pick real pages instead");
   return { homeId: "starter-home", documents: [page] };
 }
-function draftBrand(schema, home, live, note) {
+function draftBrand(schema, home, live, note, roles, quiet = false) {
   const settingsFields = schema.fields(home.documentId);
   const fields = {};
-  const siteName = settingsFields.siteName;
+  const siteName = roles.siteName ? settingsFields[roles.siteName] : void 0;
   if (siteName) {
-    fields.siteName = schema.inlineName(siteName.value) === "internationalizedArrayString" ? [
+    fields[roles.siteName] = schema.inlineName(siteName.value) === "internationalizedArrayString" ? [
       {
         _key: "{{language}}",
         _type: "internationalizedArrayStringValue",
@@ -678,21 +722,22 @@ function draftBrand(schema, home, live, note) {
     ] : "{{siteName}}";
   }
   fields[home.field] = { _type: "reference", _ref: "{{homePageId}}" };
-  if (settingsFields.domain) fields.domain = "{{domain}}";
-  for (const [field, id] of [
+  if (roles.domain && settingsFields[roles.domain]) fields[roles.domain] = "{{domain}}";
+  for (const [role, id] of [
     ["logo", "logoAssetId"],
     ["favicon", "faviconAssetId"]
   ]) {
-    const value = settingsFields[field]?.value;
-    if (!value || !schema.isImage(value)) continue;
+    const field = roles[role];
+    const value = field ? settingsFields[field]?.value : void 0;
+    if (!field || !value || !schema.isImage(value)) continue;
     fields[field] = {
       _type: "image",
       asset: { _type: "reference", _ref: `{{${id}}}` },
-      ...field === "logo" && "alt" in (value.attributes ?? {}) ? { alt: "{{siteName}}" } : {}
+      ...role === "logo" && "alt" in (value.attributes ?? {}) ? { alt: "{{siteName}}" } : {}
     };
   }
-  const themeType = schema.contentDocuments.find((type) => /theme/i.test(type.name));
-  const themeId = themeType?.name ?? "themeSettings";
+  const themeType = themeTypeOf(schema);
+  const themeId = themeType ?? "themeSettings";
   if (!themeType) note("No theme document found: brand colours and fonts left empty");
   const themeFields = schema.fields(themeId);
   let color = { $color: "{{hex}}" };
@@ -716,7 +761,7 @@ function draftBrand(schema, home, live, note) {
       label: typeof current?.label === "string" ? current.label : humanize(role)
     });
   }
-  if (colorRoles.length && !live.theme)
+  if (colorRoles.length && !live.theme && !quiet)
     note("Colour defaults are #000000: run with --live to read them");
   const fontShape = Object.values(themeFields).map(({ value }) => schema.fontShape(value)).find(Boolean);
   const fonts = fontShape ? {
@@ -734,7 +779,8 @@ function draftBrand(schema, home, live, note) {
   const defaults = live.theme ? compactColors(stripSystem(live.theme)) : {};
   delete defaults._id;
   delete defaults._type;
-  if (!live.theme) note("Theme defaults are empty: run with --live to copy the current theme");
+  if (!live.theme && !quiet)
+    note("Theme defaults are empty: run with --live to copy the current theme");
   const linked = Object.keys(defaults).filter((field) => hasReference(defaults[field]));
   for (const field of linked) delete defaults[field];
   if (linked.length) {
@@ -773,6 +819,40 @@ function placeholders(value, siteName, language, key, parent) {
   return value;
 }
 var hasReference = (value) => JSON.stringify(value ?? null).includes('"_ref":');
+var linksOutside = (value, ids) => references(value).some((ref) => !ids.has(ref));
+function dropOutsideLinks(doc, ids, dropped) {
+  const walk = (value, path) => {
+    if (Array.isArray(value)) {
+      return value.flatMap((item, index) => {
+        const at = `${path}[${item?._key ?? index}]`;
+        if (!linksOutside(item, ids) || hasArray(item)) return [walk(item, at)];
+        dropped.push(`${doc._id} ${at}`);
+        return [];
+      });
+    }
+    if (!value || typeof value !== "object") return value;
+    const result = {};
+    for (const [key, inner] of Object.entries(value)) {
+      if (!Array.isArray(inner) && linksOutside(inner, ids) && !hasArray(inner)) {
+        dropped.push(`${doc._id} ${path ? `${path}.` : ""}${key}`);
+        continue;
+      }
+      result[key] = walk(inner, path ? `${path}.${key}` : key);
+    }
+    return dropDanglingMarks(result);
+  };
+  return walk(doc, "");
+}
+var hasArray = (value) => Boolean(value && typeof value === "object") && Object.values(value).some((inner) => Array.isArray(inner) || hasArray(inner));
+function dropDanglingMarks(block) {
+  if (!Array.isArray(block.markDefs) || !Array.isArray(block.children)) return block;
+  const defs = new Set(block.markDefs.map((def) => def._key));
+  const decorator = (mark) => /^[a-z][a-z-]*$/i.test(mark) && mark.length < 12;
+  block.children = block.children.map(
+    (child) => Array.isArray(child.marks) ? { ...child, marks: child.marks.filter((mark) => defs.has(mark) || decorator(mark)) } : child
+  );
+  return block;
+}
 function references(value) {
   if (Array.isArray(value)) return value.flatMap(references);
   if (value && typeof value === "object") {
@@ -792,16 +872,603 @@ function compactColors(value) {
   return value;
 }
 
-// src/init/live.ts
+// src/generate/build.ts
+var BUILT_IN_FIELDS = /* @__PURE__ */ new Set(["_id", "_type", "_key"]);
+function buildManifest(input) {
+  const { repo, config, live, previous } = input;
+  const schema = new Extract(repo.types);
+  const draft = draftManifest(
+    repo,
+    {
+      id: config.id,
+      title: config.title,
+      organizationId: config.organizationId,
+      ...config.vercelTeamId ? { vercelTeamId: config.vercelTeamId } : {},
+      schemaSourceProjectId: config.schemaSourceProjectId,
+      ...config.studioOrigins ? { studioOrigins: config.studioOrigins } : {}
+    },
+    live ?? {},
+    {
+      singletons: config.singletons,
+      homePage: config.homePage,
+      settingsFields: config.settingsFields
+    }
+  );
+  const kept = new Set(config.themeFiles ?? []);
+  const notes = draft.notes.filter((text) => !/studioOrigins|^Studio: |No GitHub remote/.test(text)).flatMap((text) => {
+    const [lead, list] = text.split(/: (?=[^:]+$)/);
+    if (!lead.startsWith("Left out of theme defaults") || !list) return [text];
+    const left = list.split(", ").filter((field) => !kept.has(field));
+    return left.length ? [`${lead}: ${left.join(", ")}`] : [];
+  });
+  const note = (message) => void notes.push(message);
+  const { manifest } = draft;
+  manifest.site = { ...manifest.site, ...config.site };
+  manifest.content.sections = Object.entries(config.sections).filter(
+    (entry) => entry[1] !== false
+  );
+  const theme = manifest.brand.theme;
+  const previousRoles = new Map(previous?.brand.colorRoles.map((role) => [role.role, role]));
+  for (const role of manifest.brand.colorRoles) {
+    role.description = config.colorRoles[role.role] ?? "";
+    const before = previousRoles.get(role.role);
+    if (!live?.theme && before) Object.assign(role, { default: before.default, label: before.label });
+  }
+  const themeFields = schema.fields(themeTypeOf(schema) ?? theme.documentId);
+  if (live?.theme) {
+    for (const role of manifest.brand.colorRoles) delete theme.defaults[role.role];
+    for (const field of config.themeFiles ?? [])
+      if (live.theme[field] !== void 0) theme.defaults[field] = live.theme[field];
+  } else if (previous) {
+    theme.defaults = { ...previous.brand.theme.defaults };
+  }
+  for (const field of Object.keys(theme.defaults).filter((field2) => !(field2 in themeFields))) {
+    delete theme.defaults[field];
+    note(`Theme default ${field} is gone from the schema: dropped`);
+  }
+  if (config.starter?.length !== 0 && !live) {
+    if (previous) manifest.content.starter = previous.content.starter;
+    else note("Starter is one empty home page until generate can read the live pages");
+  }
+  manifest.content.starter = fitStarter(schema, manifest.content.starter, note);
+  if (!live) {
+    if (!previousRoles.size && manifest.brand.colorRoles.length)
+      note("Colour defaults are #000000: sign in to Sanity and run generate again");
+    if (!previous) note("Theme defaults are empty: sign in to Sanity and run generate again");
+  }
+  return { manifest, notes };
+}
+function fitStarter(schema, starter, note) {
+  const documents = starter.documents.flatMap((value) => {
+    const doc = value;
+    if (!schema.has(doc._type)) {
+      if (doc._id === starter.homeId)
+        throw new Error(
+          `The starter home page's type ${doc._type} is gone: pick starter pages again`
+        );
+      note(`Starter ${doc._id} dropped: type ${doc._type} is gone from the schema`);
+      return [];
+    }
+    const fields = schema.fields(doc._type);
+    const gone = Object.keys(doc).filter((key) => !BUILT_IN_FIELDS.has(key) && !(key in fields));
+    if (gone.length) note(`Starter ${doc._id}: dropped ${gone.join(", ")}, gone from ${doc._type}`);
+    return [Object.fromEntries(Object.entries(doc).filter(([key]) => !gone.includes(key)))];
+  });
+  return { ...starter, documents };
+}
+
+// src/generate/config.ts
 import { existsSync, readFileSync } from "node:fs";
+import { Ajv as Ajv2 } from "ajv";
+
+// config.schema.json
+var config_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://github.com/anydayagency/anyday-workspace-manager-sanity/workspace-manager.config.schema.json",
+  title: "Workspace manager config",
+  description: "The decisions behind a site's workspace-manager.json. Edit this file, then run `sanity-workspace-manager generate`.",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "id",
+    "title",
+    "organizationId",
+    "schemaSourceProjectId",
+    "site",
+    "singletons",
+    "homePage",
+    "settingsFields",
+    "sections",
+    "colorRoles"
+  ],
+  definitions: {
+    nullableField: {
+      type: ["string", "null"]
+    }
+  },
+  properties: {
+    $schema: {
+      type: "string"
+    },
+    id: {
+      description: "Permanent: jobs store it and it prefixes each site's Vercel project.",
+      type: "string",
+      pattern: "^[a-z0-9][a-z0-9-]{0,31}$"
+    },
+    title: {
+      description: "The name shown in the Workspaces app.",
+      type: "string"
+    },
+    organizationId: {
+      description: "The Sanity organisation new workspaces are created in.",
+      type: "string"
+    },
+    vercelTeamId: {
+      description: "The client's own Vercel team; leave out for Anyday's.",
+      type: "string"
+    },
+    schemaSourceProjectId: {
+      description: "The Sanity project new workspaces copy their schema from.",
+      type: "string"
+    },
+    dataset: {
+      description: "The dataset live values are read from. Default: production.",
+      type: "string"
+    },
+    site: {
+      type: "object",
+      additionalProperties: false,
+      required: ["repo", "branch"],
+      properties: {
+        repo: {
+          description: "owner/name on GitHub.",
+          type: "string",
+          pattern: "^[\\w.-]+/[\\w.-]+$"
+        },
+        branch: {
+          type: "string"
+        },
+        revalidatePath: {
+          type: "string"
+        }
+      }
+    },
+    studioOrigins: {
+      description: "The Studios that open new workspaces, e.g. https://acme.sanity.studio.",
+      type: "array",
+      items: {
+        type: "string",
+        pattern: "^https://"
+      }
+    },
+    singletons: {
+      description: "Settings documents: one each, never offered for copy.",
+      type: "array",
+      items: {
+        type: "string"
+      }
+    },
+    homePage: {
+      description: "The settings field that references the home page.",
+      type: "object",
+      additionalProperties: false,
+      required: ["documentId", "field"],
+      properties: {
+        documentId: {
+          type: "string"
+        },
+        field: {
+          type: "string"
+        }
+      }
+    },
+    settingsFields: {
+      description: "The field on the home page's settings document that holds each brand value; null for none.",
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        siteName: {
+          $ref: "#/definitions/nullableField"
+        },
+        domain: {
+          $ref: "#/definitions/nullableField"
+        },
+        logo: {
+          $ref: "#/definitions/nullableField"
+        },
+        favicon: {
+          $ref: "#/definitions/nullableField"
+        }
+      }
+    },
+    sections: {
+      description: "Each content type, with its label in the Copy picker, or false to leave it out.",
+      type: "object",
+      additionalProperties: {
+        anyOf: [
+          {
+            type: "string",
+            minLength: 1
+          },
+          {
+            const: false
+          }
+        ]
+      }
+    },
+    colorRoles: {
+      description: "Each colour role on the theme, with where it is used, shown to whoever sets up a brand.",
+      type: "object",
+      additionalProperties: {
+        type: "string"
+      }
+    },
+    themeFiles: {
+      description: "Theme fields with uploaded files, e.g. fonts, to copy into new sites. Fonts are often licensed per brand.",
+      type: "array",
+      items: {
+        type: "string"
+      }
+    },
+    starter: {
+      description: "What Start fresh writes: live pages (`home`, slugs or ids), or [] for one empty home page.",
+      type: "array",
+      items: {
+        type: "string"
+      }
+    }
+  }
+};
+
+// src/generate/config.ts
+var CONFIG_FILE = "workspace-manager.config.json";
+var MANIFEST_FILE = "workspace-manager.json";
+var SCHEMA_REF = "./node_modules/@anyday/sanity-workspace-manager/config.schema.json";
+var validate2 = new Ajv2({ allErrors: true }).compile(config_schema_default);
+function parseConfig(json) {
+  if (validate2(json)) return json;
+  const problems = validate2.errors.map((error) => `${error.instancePath || "/"} ${error.message}`);
+  throw new Error(`Invalid ${CONFIG_FILE}:
+${problems.join("\n")}`);
+}
+function readJsonFile(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    throw new Error(`${path} isn't valid JSON`);
+  }
+}
+function formatConfig(config) {
+  const { $schema, ...rest2 } = config;
+  const ordered = {
+    $schema: $schema ?? SCHEMA_REF,
+    id: rest2.id,
+    title: rest2.title,
+    organizationId: rest2.organizationId,
+    ...rest2.vercelTeamId ? { vercelTeamId: rest2.vercelTeamId } : {},
+    schemaSourceProjectId: rest2.schemaSourceProjectId,
+    ...rest2.dataset && rest2.dataset !== "production" ? { dataset: rest2.dataset } : {},
+    site: rest2.site,
+    ...rest2.studioOrigins?.length ? { studioOrigins: rest2.studioOrigins } : {},
+    singletons: rest2.singletons,
+    homePage: rest2.homePage,
+    settingsFields: rest2.settingsFields,
+    sections: rest2.sections,
+    colorRoles: rest2.colorRoles,
+    ...rest2.themeFiles?.length ? { themeFiles: rest2.themeFiles } : {},
+    ...rest2.starter !== void 0 ? { starter: rest2.starter } : {}
+  };
+  return `${JSON.stringify(ordered, null, 2)}
+`;
+}
+var holds = (template, placeholder) => JSON.stringify(template ?? null).includes(`{{${placeholder}}}`);
+function configFromManifest(manifest, schema) {
+  const { content, brand } = manifest;
+  const fields = Object.entries(brand.settings.fields);
+  const fieldFor = (placeholder, except) => fields.find(
+    ([field, template]) => field !== except && field !== content.homePage.field && holds(template, placeholder)
+  )?.[0] ?? null;
+  const logo = fieldFor("logoAssetId");
+  const offered = Object.fromEntries(content.sections);
+  const defaults = brand.theme.defaults;
+  return {
+    id: manifest.id,
+    title: manifest.title,
+    organizationId: manifest.organizationId,
+    ...manifest.vercelTeamId ? { vercelTeamId: manifest.vercelTeamId } : {},
+    schemaSourceProjectId: manifest.schemaSourceProjectId,
+    site: manifest.site,
+    ...manifest.studioOrigins ? { studioOrigins: manifest.studioOrigins } : {},
+    singletons: content.singletons,
+    homePage: content.homePage,
+    settingsFields: {
+      siteName: fieldFor("siteName", logo ?? void 0),
+      domain: fieldFor("domain"),
+      logo,
+      favicon: fieldFor("faviconAssetId")
+    },
+    sections: {
+      ...offered,
+      ...Object.fromEntries(
+        sectionCandidates(schema, content.singletons).filter((type) => !(type in offered)).map((type) => [type, false])
+      )
+    },
+    colorRoles: Object.fromEntries(brand.colorRoles.map((role) => [role.role, role.description])),
+    themeFiles: Object.keys(defaults).filter(
+      (field) => JSON.stringify(defaults[field]).includes('"_ref":')
+    )
+  };
+}
+
+// src/generate/resolve.ts
+var yes = (answer) => /^y(es)?$/i.test(answer.trim());
+var ROLE_NAMES = { siteName: "site name", domain: "domain", logo: "logo", favicon: "favicon" };
+async function resolveIdentity(options) {
+  const { saved, flags, repo, ask, lookups, note } = options;
+  const known = { ...saved, ...flags };
+  const fresh = options.askAgain || !saved.id;
+  const pick = async (key, text, suggestion) => flags[key] !== void 0 ? flags[key] : !fresh && saved[key] !== void 0 ? saved[key] : ask({ text, suggestion: saved[key] ?? suggestion });
+  const names = suggestNames(repo.repo);
+  const id = await pick("id", "Project type id, short and lowercase", names.id);
+  const title = await pick("title", "Name shown in the app", names.title);
+  const project = await pick(
+    "schemaSourceProjectId",
+    "Sanity project to copy schemas from",
+    repo.projectId ?? ""
+  );
+  if (!project) throw new Error("Pass --project <id>: the Sanity project to copy schemas from");
+  const org = flags.organizationId ?? (!fresh ? saved.organizationId : void 0) ?? await ask({
+    text: "Sanity organisation to create workspaces in",
+    suggestion: saved.organizationId ?? await lookups.organizationOf?.(project).catch(() => "") ?? ""
+  });
+  if (!org) throw new Error("Pass --org <id>: the Sanity organisation for new workspaces");
+  const vercelTeamId = flags.vercelTeamId ?? (fresh ? await ask({
+    text: "Vercel team for the sites, only if it's the client's own (Enter for Anyday's)",
+    suggestion: saved.vercelTeamId ?? ""
+  }) : saved.vercelTeamId);
+  const site = known.site ?? {
+    repo: repo.repo ?? await ask({ text: "GitHub repo of the site (owner/name)", suggestion: "" }),
+    branch: repo.branch ?? "main"
+  };
+  if (!site.repo) throw new Error("No GitHub remote found: add one, or set site.repo in the config");
+  let studioOrigins = known.studioOrigins;
+  if (!studioOrigins?.length || options.askAgain) {
+    const found = await lookups.studioOriginsOf?.(project).catch(() => void 0);
+    studioOrigins = found?.length ? found : studioOrigins;
+  }
+  if (!studioOrigins?.length)
+    note(`No Studio found: add studioOrigins to the config, e.g. ["https://acme.sanity.studio"]`);
+  return {
+    ...saved.$schema ? { $schema: saved.$schema } : {},
+    id,
+    title,
+    organizationId: org,
+    ...vercelTeamId ? { vercelTeamId } : {},
+    schemaSourceProjectId: project,
+    ...known.dataset ? { dataset: known.dataset } : {},
+    site,
+    ...studioOrigins?.length ? { studioOrigins } : {},
+    ...known.themeFiles ? { themeFiles: known.themeFiles } : {},
+    ...known.starter !== void 0 ? { starter: known.starter } : {}
+  };
+}
+async function resolveChoices(options) {
+  const { saved, schema, ask, note } = options;
+  const contentTypes = schema.contentDocuments.map((type) => type.name);
+  let singletons = guessSingletons(schema);
+  if (saved.singletons) {
+    for (const type of saved.singletons.filter((type2) => !contentTypes.includes(type2)))
+      note(`Singleton ${type} is gone from the schema: dropped`);
+    const known = /* @__PURE__ */ new Set([...saved.singletons, ...Object.keys(saved.sections ?? {})]);
+    const added = [];
+    for (const type of singletons.filter((type2) => !known.has(type2))) {
+      const answer = await ask({
+        text: `New type ${type} looks like settings. Treat it as a singleton, never offered for copy?`,
+        suggestion: "y",
+        choices: ["y", "n"]
+      });
+      if (yes(answer)) added.push(type);
+    }
+    singletons = [...saved.singletons.filter((type) => contentTypes.includes(type)), ...added];
+  } else if (singletons.length) {
+    note(`Singletons guessed from names ending in "Settings": ${singletons.join(", ")}`);
+  }
+  const homePage = await resolveHomePage(saved, schema, singletons, ask, note);
+  const settingsFields = await resolveSettingsFields(saved, schema, homePage.documentId, ask, note);
+  const sections = await resolveNamed({
+    saved: saved.sections,
+    current: sectionCandidates(schema, singletons),
+    fresh: (type) => humanize(type),
+    what: "Copy section",
+    ask,
+    note,
+    asked: async (type) => yes(
+      await ask({
+        text: `New content type ${type}: offer it as a copy section?`,
+        suggestion: "y",
+        choices: ["y", "n"]
+      })
+    ) ? humanize(type) : false
+  });
+  if (options.askAgain) {
+    for (const [type, label] of Object.entries(sections)) {
+      const answer = await ask({
+        text: `Offer ${type} as a copy section?`,
+        suggestion: label === false ? "n" : "y",
+        choices: ["y", "n"]
+      });
+      sections[type] = yes(answer) ? label || humanize(type) : false;
+    }
+  } else if (!saved.sections)
+    note("Copy sections list every content type: set the ones not to offer to false");
+  const themeId = themeTypeOf(schema);
+  const roles = themeId ? colorRolesOf(schema, themeId) : [];
+  const colorRoles = await resolveNamed({
+    saved: saved.colorRoles,
+    current: roles,
+    fresh: () => "",
+    what: "Colour role",
+    ask,
+    note,
+    asked: (role) => ask({
+      text: `New colour role ${role}: where is it used? (a short description)`,
+      suggestion: ""
+    })
+  });
+  const undescribed = Object.keys(colorRoles).filter((role) => !colorRoles[role]);
+  if (undescribed.length)
+    note(`Colour roles without a description in the config: ${undescribed.join(", ")}`);
+  const fontFields = themeId ? fontFieldsOf(schema, themeId) : [];
+  let themeFiles = saved.themeFiles;
+  if (themeFiles) {
+    for (const field of themeFiles.filter((field2) => !fontFields.includes(field2)))
+      note(`Theme file field ${field} is gone from the schema: dropped from themeFiles`);
+    themeFiles = themeFiles.filter((field) => fontFields.includes(field));
+  } else if (fontFields.length && !saved.id) {
+    const answer = await ask({
+      text: `Copy the live fonts (${fontFields.join(", ")}) into new sites? Fonts are often licensed per brand`,
+      suggestion: "n",
+      choices: ["y", "n"]
+    });
+    themeFiles = yes(answer) ? fontFields : [];
+  }
+  return {
+    singletons,
+    homePage,
+    settingsFields,
+    sections,
+    colorRoles,
+    ...themeFiles ? { themeFiles } : {}
+  };
+}
+async function resolveHomePage(saved, schema, singletons, ask, note) {
+  const isReference = (documentId, field) => {
+    const value = schema.fields(documentId)[field]?.value;
+    return singletons.includes(documentId) && Boolean(value && schema.referenceTarget(value));
+  };
+  if (saved.homePage && isReference(saved.homePage.documentId, saved.homePage.field))
+    return saved.homePage;
+  const candidates = singletons.flatMap(
+    (documentId) => Object.keys(schema.fields(documentId)).filter((field) => isReference(documentId, field)).map((field) => `${documentId}.${field}`)
+  );
+  if (!candidates.length)
+    throw new Error("No singleton has a reference field to use as the home page");
+  const guess = findHomePage(schema, singletons);
+  const suggestion = guess ? `${guess.documentId}.${guess.field}` : candidates[0];
+  let answer = suggestion;
+  if (saved.homePage) {
+    answer = await ask({
+      text: `${saved.homePage.documentId}.${saved.homePage.field} is gone. Which field is the home page?`,
+      suggestion,
+      choices: candidates
+    });
+  } else note(`Home page: ${suggestion}`);
+  if (!candidates.includes(answer))
+    throw new Error(`Pick the home page from ${candidates.join(", ")}`);
+  const dot = answer.lastIndexOf(".");
+  return { documentId: answer.slice(0, dot), field: answer.slice(dot + 1) };
+}
+async function resolveSettingsFields(saved, schema, documentId, ask, note) {
+  const guessed = guessSettingsFields(schema, documentId);
+  if (!saved.settingsFields) return guessed;
+  const result = {};
+  const fields = Object.keys(schema.fields(documentId));
+  for (const role of SETTINGS_ROLES) {
+    const field = saved.settingsFields[role];
+    if (field && fitsRole(schema, documentId, role, field)) {
+      result[role] = field;
+      continue;
+    }
+    const taken = /* @__PURE__ */ new Set([...Object.values(saved.settingsFields), ...Object.values(result)]);
+    const candidates = fields.filter(
+      (candidate) => !taken.has(candidate) && fitsRole(schema, documentId, role, candidate)
+    );
+    if (field) {
+      const answer = await ask({
+        text: `${documentId}.${field} is gone. Which field is the ${ROLE_NAMES[role]}?`,
+        suggestion: guessed[role] && candidates.includes(guessed[role]) ? guessed[role] : "none",
+        choices: [...candidates, "none"]
+      });
+      result[role] = candidates.includes(answer) ? answer : null;
+      if (!result[role]) note(`No ${ROLE_NAMES[role]} field: new sites won't set one`);
+    } else if (field === void 0 && guessed[role]) {
+      const answer = await ask({
+        text: `New field ${documentId}.${guessed[role]}: use it for the ${ROLE_NAMES[role]}?`,
+        suggestion: "y",
+        choices: ["y", "n"]
+      });
+      result[role] = yes(answer) ? guessed[role] : null;
+    } else result[role] = null;
+  }
+  return result;
+}
+async function resolveNamed(options) {
+  const { saved, current, ask, note } = options;
+  if (!saved) return Object.fromEntries(current.map((name) => [name, options.fresh(name)]));
+  let added = current.filter((name) => !(name in saved));
+  const entries = [];
+  for (const [name, value] of Object.entries(saved)) {
+    if (current.includes(name)) {
+      entries.push([name, value]);
+      continue;
+    }
+    const renamed = added.length ? await ask({
+      text: `${options.what} ${name} is gone from the schema. Was it renamed?`,
+      suggestion: "no",
+      choices: [...added, "no"]
+    }) : "no";
+    if (added.includes(renamed)) {
+      entries.push([renamed, value]);
+      added = added.filter((name2) => name2 !== renamed);
+    } else note(`${options.what} ${name} is gone from the schema: dropped`);
+  }
+  for (const name of added) entries.push([name, await options.asked(name)]);
+  return Object.fromEntries(entries);
+}
+
+// src/generate/stamp.ts
+import { createHash } from "node:crypto";
+var NOTE = "GENERATED FILE, DO NOT EDIT. Change workspace-manager.config.json, then run: npx @anyday/sanity-workspace-manager generate";
+var hashOf = (manifest) => createHash("sha256").update(JSON.stringify(manifest)).digest("hex").slice(0, 16);
+var unstamped = ({ $generated: _, ...manifest }) => manifest;
+function stamp(manifest) {
+  const body = unstamped(manifest);
+  return `${JSON.stringify({ $generated: `${NOTE}. sha256:${hashOf(body)}`, ...body }, null, 2)}
+`;
+}
+function stampState(manifest) {
+  const hash = manifest.$generated?.match(/sha256:([0-9a-f]+)$/)?.[1];
+  if (!hash) return "none";
+  return hash === hashOf(unstamped(manifest)) ? "generated" : "edited";
+}
+var show = (value) => {
+  const text = JSON.stringify(value);
+  return text.length > 60 ? `${text.slice(0, 57)}...` : text;
+};
+function diffJson(before, after, path = "") {
+  if (JSON.stringify(before) === JSON.stringify(after)) return [];
+  const bothObjects = [before, after].every((value) => value && typeof value === "object");
+  if (!bothObjects || Array.isArray(before) !== Array.isArray(after))
+    return [`~ ${path || "."}: ${show(before)} \u2192 ${show(after)}`];
+  const a = before;
+  const b = after;
+  const at = (key) => Array.isArray(before) ? `${path}[${key}]` : path ? `${path}.${key}` : key;
+  return [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])].flatMap(
+    (key) => !(key in a) ? [`+ ${at(key)}: ${show(b[key])}`] : !(key in b) ? [`- ${at(key)}`] : diffJson(a[key], b[key], at(key))
+  );
+}
+
+// src/generate/live.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createClient } from "@sanity/client";
 function sanityToken() {
   if (process.env.SANITY_AUTH_TOKEN) return process.env.SANITY_AUTH_TOKEN;
   const config = join(homedir(), ".config", "sanity", "config.json");
-  if (!existsSync(config)) return null;
-  return JSON.parse(readFileSync(config, "utf8")).authToken ?? null;
+  if (!existsSync2(config)) return null;
+  return JSON.parse(readFileSync2(config, "utf8")).authToken ?? null;
 }
 async function projectInfo(projectId, token) {
   const response = await fetch(`https://api.sanity.io/v2021-06-07/projects/${projectId}`, {
@@ -861,9 +1528,9 @@ async function readLive(options) {
   };
 }
 
-// src/init/repo.ts
+// src/generate/repo.ts
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "node:fs";
 import { join as join2 } from "node:path";
 var APP_DIRS = [".", "frontend", "web", "site", "studio", "apps"];
 var git = (dir, ...args) => {
@@ -878,24 +1545,24 @@ function repoFromRemote(remote) {
 }
 function appDirs(root) {
   const apps = join2(root, "apps");
-  const nested = existsSync2(apps) ? readdirSync(apps, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join2(apps, entry.name)) : [];
-  return [...APP_DIRS.map((dir) => join2(root, dir)), ...nested].filter((dir) => existsSync2(dir));
+  const nested = existsSync3(apps) ? readdirSync(apps, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join2(apps, entry.name)) : [];
+  return [...APP_DIRS.map((dir) => join2(root, dir)), ...nested].filter((dir) => existsSync3(dir));
 }
 function readRepo(root) {
   const dirs = appDirs(root);
-  const schemaPath = dirs.map((dir) => join2(dir, "sanity.schema.json")).find(existsSync2);
+  const schemaPath = dirs.map((dir) => join2(dir, "sanity.schema.json")).find(existsSync3);
   if (!schemaPath) {
     throw new Error("No sanity.schema.json: run `npx sanity schema extract` in the Studio first");
   }
   const envNames = dirs.flatMap((dir) => {
     const file = join2(dir, ".env.example");
-    if (!existsSync2(file)) return [];
-    return [...readFileSync2(file, "utf8").matchAll(/^\s*([A-Z][A-Z0-9_]*)\s*=/gm)].map((m) => m[1]);
+    if (!existsSync3(file)) return [];
+    return [...readFileSync3(file, "utf8").matchAll(/^\s*([A-Z][A-Z0-9_]*)\s*=/gm)].map((m) => m[1]);
   });
-  const projectId = dirs.flatMap((dir) => ["sanity.cli.ts", "sanity.config.ts"].map((file) => join2(dir, file))).filter(existsSync2).map((file) => readFileSync2(file, "utf8").match(/projectId:\s*['"]([a-z0-9]+)['"]/)?.[1]).find(Boolean) ?? null;
+  const projectId = dirs.flatMap((dir) => ["sanity.cli.ts", "sanity.config.ts"].map((file) => join2(dir, file))).filter(existsSync3).map((file) => readFileSync3(file, "utf8").match(/projectId:\s*['"]([a-z0-9]+)['"]/)?.[1]).find(Boolean) ?? null;
   const hasRevalidateRoute = dirs.some(
     (dir) => ["app", "src/app", "pages", "src/pages"].some(
-      (base) => existsSync2(join2(dir, base, "api/revalidate")) || ["ts", "js"].some((ext) => existsSync2(join2(dir, base, `api/revalidate.${ext}`)))
+      (base) => existsSync3(join2(dir, base, "api/revalidate")) || ["ts", "js"].some((ext) => existsSync3(join2(dir, base, `api/revalidate.${ext}`)))
     )
   );
   return {
@@ -904,16 +1571,19 @@ function readRepo(root) {
     envNames: [...new Set(envNames)],
     projectId,
     hasRevalidateRoute,
-    types: JSON.parse(readFileSync2(schemaPath, "utf8"))
+    types: JSON.parse(readFileSync3(schemaPath, "utf8"))
   };
 }
 
-// src/init/starter.ts
+// src/generate/starter.ts
+var StarterError = class extends Error {
+};
 function resolveStarter(entries, pages, homeId) {
   const home = pages.find((page) => page._id === homeId);
   return entries.map((entry) => {
     if (entry === "home") {
-      if (!homeId) throw new Error("The live settings name no home page: pass its slug instead");
+      if (!homeId)
+        throw new StarterError("The live settings name no home page: pass its slug instead");
       return homeId;
     }
     if (pages.some((page) => page._id === entry)) return entry;
@@ -921,8 +1591,8 @@ function resolveStarter(entries, pages, homeId) {
     if (matches.length > 1 && home?.language)
       matches = matches.filter((page) => page.language === home.language);
     if (matches.length === 1) return matches[0]._id;
-    if (!matches.length) throw new Error(`No page with the slug or id "${entry}"`);
-    throw new Error(
+    if (!matches.length) throw new StarterError(`No page with the slug or id "${entry}"`);
+    throw new StarterError(
       `Several pages have the slug "${entry}": pass one of ${matches.map((page) => page._id).join(", ")}`
     );
   });
@@ -942,18 +1612,18 @@ function parsePick(answer, count) {
 }
 
 // src/register.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 import { join as join3 } from "node:path";
 async function register(options) {
   const file = join3(options.dir, "workspace-manager.json");
-  const manifest = parseManifest(JSON.parse(readFileSync3(file, "utf8")));
+  const manifest = parseManifest(JSON.parse(readFileSync4(file, "utf8")));
   configFrom(manifest);
   const response = await (options.fetch ?? fetch)(
     `${options.api.replace(/\/+$/, "")}/api/project-types`,
     {
       method: "POST",
       headers: { "Authorization": `Bearer ${options.token}`, "Content-Type": "application/json" },
-      body: JSON.stringify(manifest)
+      body: JSON.stringify(unstamped(manifest))
     }
   );
   const body = await response.json().catch(() => ({}));
@@ -963,158 +1633,342 @@ async function register(options) {
 }
 
 // src/cli.ts
-var USAGE = `Usage: sanity-workspace-manager <init|register> [dir] [options]
+var USAGE = `Usage: sanity-workspace-manager <generate|check|register> [dir] [options]
 
-init [dir]
-
-Drafts workspace-manager.json for a site repo from its git remote, .env.example
-and sanity.schema.json (run \`npx sanity schema extract\` first).
+generate [dir]
+Writes workspace-manager.json from the repo's sanity.schema.json (run \`npx sanity schema extract\`
+first), the live Sanity project and workspace-manager.config.json. Saves your answers in the
+config and, next time, asks only about what changed in the schema.
 
 Options:
-  --yes              Accept the suggested id, title and project without asking
+  --yes              Take the suggested answers without asking
+  --offline          Don't read the live project; keep the live values already in the manifest
+  --diff             Show what would change, and write nothing
+  --ask-again        Ask the saved questions again, e.g. to change copy sections or starter pages
   --project <id>     The Sanity project new workspaces copy their schema from
-  --org <id>         The Sanity organisation new workspaces are created in (found with --live)
+  --org <id>         The Sanity organisation new workspaces are created in
   --vercel-team <id> The client's own Vercel team for the sites (default: Anyday's team)
   --studio <origin>  The Studio that opens new workspaces, e.g. https://acme.sanity.studio
-                     (found with --live from the project's deployed Studio)
-  --live             Read the current theme, settings and starter pages from that project
-  --dataset <name>   Dataset to read with --live (default: production)
-  --starter <pages>  Comma-separated pages to copy as starter content: \`home\`, slugs or
-                     document ids (needs --live; without it, --live offers a list to pick from)
-  --force            Overwrite an existing workspace-manager.json
-  --print            Print the draft instead of writing it
+  --dataset <name>   The dataset live values are read from (default: production)
+  --starter <pages>  Starter pages from the live site: \`home\`, slugs or ids, comma-separated
+
+check [dir]
+Fails when workspace-manager.json is out of date with the schema or was edited by hand.
+Reads only the repo, so it runs in CI without signing in.
 
 register [dir]
 Checks the repo's workspace-manager.json and saves it through the workspace manager API,
 signed in as you (SANITY_AUTH_TOKEN or \`npx sanity login\`).
 
 Options:
-  --api <url>        The workspace manager API (or set WORKSPACE_MANAGER_API_URL)`;
+  --api <url>        The workspace manager API (or set WORKSPACE_MANAGER_API_URL)
+  --dry-run          Check the manifest without saving it
+  --yes              Register without asking, even with placeholder colours or fonts`;
 var dirOf = (positional) => resolve(process.env.INIT_CWD ?? ".", positional ?? ".");
-async function registerCommand(argv) {
-  const { values, positionals } = parseArgs({
-    args: argv,
-    allowPositionals: true,
-    options: { api: { type: "string" } }
-  });
-  const api = values.api ?? process.env.WORKSPACE_MANAGER_API_URL;
-  if (!api) throw new Error("Pass --api <url> or set WORKSPACE_MANAGER_API_URL");
-  const token = sanityToken();
-  if (!token) throw new Error("register needs SANITY_AUTH_TOKEN or `npx sanity login`");
-  const saved = await register({ dir: dirOf(positionals[0]), api, token });
-  console.log(`Registered ${saved.title} (${saved.id})`);
-  for (const warning of saved.warnings ?? []) console.error(`Warning: ${warning}`);
+var readText = (path) => existsSync4(path) ? readFileSync5(path, "utf8") : "";
+function readManifest(root) {
+  const json = readJsonFile(join4(root, MANIFEST_FILE));
+  return json ? parseManifest(json) : null;
+}
+function createPrompt() {
+  const prompt = createInterface({ input: process.stdin, output: process.stderr });
+  const ask = async ({ text, suggestion, choices }) => {
+    const hint = choices ? ` [${choices.join("/")}]` : "";
+    for (; ; ) {
+      const typed = (await prompt.question(`${text}${hint}${suggestion ? ` (${suggestion})` : ""}: `)).trim();
+      const answer = choices?.find((choice) => choice.toLowerCase() === typed.toLowerCase());
+      if (!typed) return suggestion;
+      if (!choices) return typed;
+      if (answer) return answer;
+      if (/^(yes|no)$/i.test(typed) && choices.includes(typed[0].toLowerCase()))
+        return typed[0].toLowerCase();
+      console.error(`Answer one of: ${choices.join(", ")}`);
+    }
+  };
+  return { ask, close: () => prompt.close() };
 }
-async function init(argv) {
+async function generate(argv) {
   const { values, positionals } = parseArgs({
     args: argv,
     allowPositionals: true,
     options: {
       "yes": { type: "boolean", default: false },
+      "offline": { type: "boolean", default: false },
+      "diff": { type: "boolean", default: false },
+      "ask-again": { type: "boolean", default: false },
       "project": { type: "string" },
       "org": { type: "string" },
       "studio": { type: "string" },
       "vercel-team": { type: "string" },
-      "live": { type: "boolean", default: false },
-      "dataset": { type: "string", default: "production" },
-      "starter": { type: "string" },
-      "force": { type: "boolean", default: false },
-      "print": { type: "boolean", default: false }
+      "dataset": { type: "string" },
+      "starter": { type: "string" }
     }
   });
   const root = dirOf(positionals[0]);
-  const out = resolve(root, "workspace-manager.json");
-  if (existsSync3(out) && !values.force && !values.print)
-    throw new Error(`${out} exists: pass --force to replace it`);
-  if (values.starter && !values.live) throw new Error("--starter needs --live");
-  const token = values.live ? sanityToken() : null;
-  if (values.live && !token) throw new Error("--live needs SANITY_AUTH_TOKEN or `npx sanity login`");
-  const orgFor = async (projectId) => values.org ?? (token && projectId ? await organizationOf(projectId, token) : "");
+  const notes = [];
+  const note = (message) => void notes.push(message);
   const repo = readRepo(root);
-  const suggested = { ...suggestNames(repo.repo), project: values.project ?? repo.projectId ?? "" };
-  const answers = values.yes ? {
-    ...suggested,
-    org: await orgFor(suggested.project),
-    vercelTeam: values["vercel-team"] ?? ""
-  } : await ask({ ...suggested, vercelTeam: values["vercel-team"] ?? "" }, orgFor);
-  if (!answers.project)
-    throw new Error("Pass --project <id>: the Sanity project to copy schemas from");
-  if (!answers.org) throw new Error("Pass --org <id>, or --live to read it from the project");
-  const base = {
-    id: answers.id,
-    title: answers.title,
-    organizationId: answers.org,
-    ...answers.vercelTeam ? { vercelTeamId: answers.vercelTeam } : {},
-    schemaSourceProjectId: answers.project,
-    studioOrigins: values.studio ? [values.studio.replace(/\/+$/, "")] : token ? await studioOriginsOf(answers.project, token) : []
+  const schema = new Extract(repo.types);
+  const previous = readManifest(root);
+  let saved = {};
+  const configJson = readJsonFile(join4(root, CONFIG_FILE));
+  if (configJson) saved = parseConfig(configJson);
+  else if (previous) {
+    saved = configFromManifest(previous, schema);
+    note(`Moved the choices in ${MANIFEST_FILE} into ${CONFIG_FILE}`);
+  }
+  const starterFlag = values.starter?.trim();
+  const flags = {
+    ...values.project ? { schemaSourceProjectId: values.project } : {},
+    ...values.org ? { organizationId: values.org } : {},
+    ...values["vercel-team"] ? { vercelTeamId: values["vercel-team"] } : {},
+    ...values.studio ? { studioOrigins: [values.studio.replace(/\/+$/, "")] } : {},
+    ...values.dataset ? { dataset: values.dataset } : {},
+    ...starterFlag !== void 0 ? {
+      starter: starterFlag.split(",").map((entry) => entry.trim()).filter(Boolean)
+    } : {}
   };
-  let draft = draftManifest(repo, base);
-  if (token) {
-    const project = { projectId: answers.project, dataset: values.dataset, token };
-    const { pages, homeId } = await listPages({
-      ...project,
-      pageType: draft.manifest.content.starter.documents[0]._type,
-      home: draft.manifest.content.homePage
-    });
-    const starterIds = values.starter ? resolveStarter(
-      values.starter.split(",").map((entry) => entry.trim()).filter(Boolean),
-      pages,
-      homeId
-    ) : values.yes ? [] : await pickStarter(pickable(pages, homeId), homeId);
-    const live = await readLive({
-      ...project,
-      settingsId: draft.manifest.brand.settings.documentId,
-      themeId: draft.manifest.brand.theme.documentId,
-      starterIds
+  const prompt = values.yes ? null : createPrompt();
+  const ask = prompt?.ask ?? (async ({ text, suggestion }) => {
+    note(`Took "${suggestion}" for: ${text}`);
+    return suggestion;
+  });
+  const askAgain = values["ask-again"];
+  try {
+    let token = values.offline ? null : sanityToken();
+    const fallback = previous ? `keeping the colours, fonts and starter pages already in ${MANIFEST_FILE}` : "with black colours, system fonts and one empty home page";
+    const goOffline = async (reason) => {
+      console.error(`${reason}.`);
+      const answer = await ask({
+        text: `Continue from the schema only, ${fallback}?`,
+        suggestion: "y",
+        choices: ["y", "n"]
+      });
+      if (answer !== "y") throw new Error("Stopped: sign in with `npx sanity login` and run again");
+      return null;
+    };
+    if (!values.offline && !token)
+      token = await goOffline("Not signed in to Sanity: run `npx sanity login` to read live values");
+    const identity = await resolveIdentity({
+      saved,
+      flags,
+      repo,
+      ask,
+      askAgain,
+      note,
+      lookups: token ? {
+        organizationOf: (projectId) => organizationOf(projectId, token),
+        studioOriginsOf: (projectId) => studioOriginsOf(projectId, token)
+      } : {}
     });
-    draft = draftManifest(repo, base, live);
+    const choices = await resolveChoices({ saved, schema, ask, askAgain, note });
+    const config = { ...identity, ...choices };
+    let live = null;
+    if (token) {
+      try {
+        live = await readLiveFacts({ config, schema, token, prompt, askAgain });
+      } catch (error) {
+        if (error instanceof StarterError) throw error;
+        token = await goOffline(accessProblem(error, config.schemaSourceProjectId));
+      }
+    }
+    const built = buildManifest({ repo, config, live, previous });
+    configFrom(parseManifest(built.manifest));
+    const configText = formatConfig(config);
+    if (values.diff) {
+      const changes = [
+        ...diffJson(saved, JSON.parse(configText)).map((line) => `${CONFIG_FILE} ${line}`),
+        ...diffJson(previous && unstamped(previous), built.manifest).map(
+          (line) => `${MANIFEST_FILE} ${line}`
+        )
+      ];
+      console.log(changes.length ? changes.join("\n") : "No changes");
+      if (!live) console.error(`
+Schema only: live values not read, ${fallback}`);
+      return;
+    }
+    writeFileSync(join4(root, CONFIG_FILE), configText);
+    writeFileSync(join4(root, MANIFEST_FILE), stamp(built.manifest));
+    console.error(
+      live ? `Wrote ${MANIFEST_FILE}` : `Wrote ${MANIFEST_FILE} from the schema only, ${fallback}. Sign in and run generate again to read live values`
+    );
+    const attributes = readText(join4(root, ".gitattributes"));
+    if (!attributes.includes(`${MANIFEST_FILE} linguist-generated`))
+      note(
+        `Add \`${MANIFEST_FILE} linguist-generated=true\` to .gitattributes, so GitHub collapses it in PRs`
+      );
+    const all = [...notes, ...built.notes];
+    if (all.length) console.error(`
+Check:
+${all.map((line) => `  - ${line}`).join("\n")}`);
+  } finally {
+    prompt?.close();
   }
-  configFrom(parseManifest(draft.manifest));
-  const json = `${JSON.stringify(draft.manifest, null, 2)}
-`;
-  if (values.print) process.stdout.write(json);
-  else writeFileSync(out, json);
-  console.error(`${values.print ? "Drafted" : `Wrote ${out}`}
-
-Check before registering:`);
-  for (const note of draft.notes) console.error(`  - ${note}`);
 }
-async function ask(suggested, orgFor) {
-  const prompt = createInterface({ input: process.stdin, output: process.stderr });
-  const question = async (label, fallback) => (await prompt.question(`${label}${fallback ? ` (${fallback})` : ""}: `)).trim() || fallback;
-  try {
-    const id = await question("Project type id, short and lowercase", suggested.id);
-    const title = await question("Name shown in the app", suggested.title);
-    const project = await question("Sanity project to copy schemas from", suggested.project);
-    const org = await question("Sanity organisation to create workspaces in", await orgFor(project));
-    const vercelTeam = await question(
-      "Vercel team for the sites, only if it's the client's own (Enter for Anyday's)",
-      suggested.vercelTeam
+function accessProblem(error, projectId) {
+  const message = error.message ?? String(error);
+  const status = error.statusCode ?? Number(message.match(/\b(401|403)\b/)?.[1]);
+  if (status === 401)
+    return "Your Sanity session is missing or expired: run `npx sanity login` to read live values";
+  if (status === 403)
+    return `Your Sanity account can't read project ${projectId}: ask one of its Administrators to add you`;
+  return `Couldn't read the live project ${projectId}: ${message}`;
+}
+async function readLiveFacts(options) {
+  const { config, schema, token, prompt } = options;
+  const project = {
+    projectId: config.schemaSourceProjectId,
+    dataset: config.dataset ?? "production",
+    token
+  };
+  const homeField = schema.fields(config.homePage.documentId)[config.homePage.field];
+  const pageType = (homeField && schema.referenceTarget(homeField.value)) ?? "page";
+  const { pages, homeId } = await listPages({ ...project, pageType, home: config.homePage });
+  if (config.starter === void 0 || options.askAgain) {
+    const picked = prompt ? await pickStarter(prompt, pickable(pages, homeId), homeId) : [];
+    config.starter = picked.map(
+      (id) => id === homeId ? "home" : pages.find((page) => page._id === id)?.slug ?? id
     );
-    return { id, title, project, org, vercelTeam };
-  } finally {
-    prompt.close();
   }
+  const starterIds = resolveStarter(config.starter, pages, homeId);
+  return readLive({
+    ...project,
+    settingsId: config.homePage.documentId,
+    themeId: themeTypeOf(schema) ?? "themeSettings",
+    starterIds
+  });
 }
-async function pickStarter(pages, homeId) {
+async function pickStarter(prompt, pages, homeId) {
   if (!pages.length) return [];
   console.error("\nPages of the live site:");
   pages.forEach((page, index) => {
     const label = `${page.title ?? page._id} (/${page.slug})`;
     console.error(`  ${index + 1}. ${label}${page._id === homeId ? "  \u2190 home" : ""}`);
   });
-  const prompt = createInterface({ input: process.stdin, output: process.stderr });
-  try {
-    const answer = await prompt.question(
-      "Starter pages, by number (e.g. 1,3; Enter for one empty home page): "
-    );
-    return parsePick(answer, pages.length).map((index) => pages[index]._id);
-  } finally {
-    prompt.close();
+  for (; ; ) {
+    const answer = await prompt.ask({
+      text: "Starter pages, by number (e.g. 1,3; Enter for one empty home page)",
+      suggestion: ""
+    });
+    try {
+      return parsePick(answer, pages.length).map((index) => pages[index]._id);
+    } catch (error) {
+      console.error(error.message);
+    }
   }
 }
+async function check(argv) {
+  const { positionals } = parseArgs({ args: argv, allowPositionals: true, options: {} });
+  const root = dirOf(positionals[0]);
+  const configJson = readJsonFile(join4(root, CONFIG_FILE));
+  if (!configJson) throw new Error(`No ${CONFIG_FILE}: run \`sanity-workspace-manager generate\``);
+  const config = parseConfig(configJson);
+  const manifest = readManifest(root);
+  if (!manifest) throw new Error(`No ${MANIFEST_FILE}: run \`sanity-workspace-manager generate\``);
+  const failures = [];
+  const state = stampState(manifest);
+  if (state === "edited")
+    failures.push(`${MANIFEST_FILE} was edited by hand: put the change in ${CONFIG_FILE} instead`);
+  if (state === "none") failures.push(`${MANIFEST_FILE} wasn't made by generate`);
+  const repo = readRepo(root);
+  const schema = new Extract(repo.types);
+  const notes = [];
+  const note = (message) => void notes.push(message);
+  const ask = async ({ text, suggestion }) => {
+    failures.push(text);
+    return suggestion;
+  };
+  const identity = await resolveIdentity({
+    saved: config,
+    flags: {},
+    repo,
+    ask,
+    askAgain: false,
+    lookups: {},
+    note
+  });
+  const next = {
+    ...identity,
+    ...await resolveChoices({ saved: config, schema, ask, askAgain: false, note })
+  };
+  const built = buildManifest({ repo, config: next, live: null, previous: manifest });
+  failures.push(
+    ...diffJson(JSON.parse(formatConfig(config)), JSON.parse(formatConfig(next))).map(
+      (line) => `${CONFIG_FILE} ${line}`
+    ),
+    ...diffJson(unstamped(manifest), built.manifest).map((line) => `${MANIFEST_FILE} ${line}`)
+  );
+  if (!failures.length) {
+    console.log(`${MANIFEST_FILE} is up to date`);
+    return;
+  }
+  console.error(
+    `${MANIFEST_FILE} is out of date:
+${failures.map((line) => `  ${line}`).join("\n")}`
+  );
+  console.error("\nRun `npx @anyday/sanity-workspace-manager generate` and commit the result.");
+  process.exit(1);
+}
+function placeholderValues(manifest) {
+  const { colorRoles, theme } = manifest.brand;
+  const found = [];
+  if (colorRoles.length && colorRoles.every((role) => /^#0{6}$/.test(role.default)))
+    found.push("black colours");
+  const hasFonts = Object.values(theme.defaults).some(
+    (value) => JSON.stringify(value).includes('"_ref":')
+  );
+  if (theme.font && !hasFonts) found.push("system fonts");
+  return found;
+}
+async function registerCommand(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      "api": { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      "yes": { type: "boolean", default: false }
+    }
+  });
+  const dir = dirOf(positionals[0]);
+  const manifest = readManifest(dir);
+  if (!manifest) throw new Error(`No ${MANIFEST_FILE} in ${dir}`);
+  configFrom(manifest);
+  if (stampState(manifest) === "edited")
+    console.error(`Warning: ${MANIFEST_FILE} was edited by hand since generate wrote it`);
+  const placeholders2 = placeholderValues(manifest);
+  if (placeholders2.length) {
+    console.error(`New sites will use ${placeholders2.join(" and ")}.`);
+    if (!values["dry-run"] && !values.yes) {
+      const prompt = createPrompt();
+      try {
+        const answer = await prompt.ask({
+          text: "Register anyway?",
+          suggestion: "n",
+          choices: ["y", "n"]
+        });
+        if (answer !== "y")
+          throw new Error("Not registered: run generate signed in to Sanity first");
+      } finally {
+        prompt.close();
+      }
+    }
+  }
+  if (values["dry-run"]) {
+    console.log(`Valid: ${manifest.title} (${manifest.id}) is ready to register`);
+    return;
+  }
+  const api = values.api ?? process.env.WORKSPACE_MANAGER_API_URL;
+  if (!api) throw new Error("Pass --api <url> or set WORKSPACE_MANAGER_API_URL");
+  const token = sanityToken();
+  if (!token) throw new Error("register needs SANITY_AUTH_TOKEN or `npx sanity login`");
+  const saved = await register({ dir, api, token });
+  console.log(`Registered ${saved.title} (${saved.id})`);
+  for (const warning of saved.warnings ?? []) console.error(`Warning: ${warning}`);
+}
 var commands = {
-  init,
+  generate,
+  check,
   register: registerCommand
 };
 var [command, ...rest] = process.argv.slice(2);