@botlr/cli 0.1.2 → 0.3.0

package/dist/cli.js

@@ -3,6 +3,7 @@
 // src/cli.ts
 import { Command, InvalidArgumentError } from "commander";
 import { createRequire } from "module";
+import path7 from "path";
 
 // src/config.ts
 import { access, readFile } from "fs/promises";
@@ -10,6 +11,7 @@ import path from "path";
 var CONFIG_FILE = "botlr.config.json";
 var DEFAULT_FRAMEWORK = "react-next";
 var DEFAULT_SECTIONS_DIR = "components/sections";
+var DEFAULT_REGISTRY_FILE = "publisher-section-registry.ts";
 var ConfigError = class extends Error {
   constructor(message) {
     super(message);
@@ -67,6 +69,8 @@ async function loadConfig(cwd, overrides2 = {}, env = process.env) {
     appId,
     framework: overrides2.framework ?? env.BOTLR_FRAMEWORK ?? file.framework ?? DEFAULT_FRAMEWORK,
     sectionsDir,
+    registryFile: path.resolve(sectionsDir, file.registryFile ?? DEFAULT_REGISTRY_FILE),
+    types: file.types !== false,
     apiKey: env.BOTLR_API_KEY || void 0,
     personalToken: env.BOTLR_PAT || void 0
   };
@@ -104,6 +108,12 @@ import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
 import path2 from "path";
 var LOCK_DIR = ".botlr";
 var LOCK_FILE = "sections.lock.json";
+function nextLockEntry(previous, fresh) {
+  if (previous && previous.scope === fresh.scope && previous.framework === fresh.framework && previous.version === fresh.version && previous.contentHash === fresh.contentHash) {
+    return { ...fresh, pulledAt: previous.pulledAt };
+  }
+  return fresh;
+}
 function lockPath(root) {
   return path2.join(root, LOCK_DIR, LOCK_FILE);
 }
@@ -127,7 +137,7 @@ async function writeLock(root, lock) {
 }
 async function updateLock(root, name, entry) {
   const lock = await readLock(root);
-  lock[name] = entry;
+  lock[name] = nextLockEntry(lock[name], entry);
   await writeLock(root, lock);
   return lock;
 }
@@ -198,13 +208,80 @@ function validateManifest(value, where = "manifest") {
   }
   return m;
 }
+var MANIFEST_KEY_ORDER = [
+  "section",
+  "framework",
+  "entry",
+  "exportName",
+  "files",
+  "title",
+  "description",
+  "category",
+  "icon",
+  "dependencies",
+  "schema"
+];
+var DEPENDENCIES_KEY_ORDER = ["npm", "internal"];
+function orderKeys(value, first) {
+  const out = {};
+  for (const key of first) {
+    if (key in value && value[key] !== void 0) out[key] = value[key];
+  }
+  for (const key of Object.keys(value).sort()) {
+    if (first.includes(key) || value[key] === void 0) continue;
+    out[key] = value[key];
+  }
+  return out;
+}
+function normalizeNested(value) {
+  if (Array.isArray(value)) return value.map(normalizeNested);
+  if (value && typeof value === "object") {
+    const record = value;
+    const ordered = orderKeys(record, []);
+    for (const key of Object.keys(ordered)) ordered[key] = normalizeNested(ordered[key]);
+    return ordered;
+  }
+  return value;
+}
+function normalizeManifest(manifest) {
+  const stripped = stripManifestState(manifest);
+  const ordered = orderKeys(stripped, MANIFEST_KEY_ORDER);
+  for (const key of Object.keys(ordered)) {
+    if (key === "dependencies" && ordered[key] && typeof ordered[key] === "object" && !Array.isArray(ordered[key])) {
+      const deps = orderKeys(ordered[key], DEPENDENCIES_KEY_ORDER);
+      for (const depKey of Object.keys(deps)) deps[depKey] = normalizeNested(deps[depKey]);
+      ordered[key] = deps;
+    } else {
+      ordered[key] = normalizeNested(ordered[key]);
+    }
+  }
+  return ordered;
+}
+function formatManifest(manifest) {
+  return `${JSON.stringify(normalizeManifest(manifest), null, 2)}
+`;
+}
+function manifestsEqual(a, b) {
+  return formatManifest(a) === formatManifest(b);
+}
 async function writeManifest(sectionsDir, name, manifest) {
   const file = manifestPath(sectionsDir, name);
   await mkdir2(sectionsDir, { recursive: true });
-  await writeFile2(file, `${JSON.stringify(stripManifestState(manifest), null, 2)}
-`, "utf8");
+  await writeFile2(file, formatManifest(manifest), "utf8");
   return file;
 }
+async function writeManifestIfChanged(sectionsDir, name, manifest) {
+  const file = manifestPath(sectionsDir, name);
+  try {
+    const existing = JSON.parse(await readFile3(file, "utf8"));
+    if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+      if (manifestsEqual(existing, manifest)) return { file, changed: false };
+    }
+  } catch {
+  }
+  await writeManifest(sectionsDir, name, manifest);
+  return { file, changed: true };
+}
 async function readSectionFiles(sectionsDir, manifest) {
   return Promise.all(
     manifest.files.map(async (relative) => {
@@ -240,6 +317,512 @@ function safeJoin(dir, relative) {
   return target;
 }
 
+// src/registry.ts
+import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import path5 from "path";
+
+// src/init.ts
+import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
+import path4 from "path";
+function parseRegistry(source) {
+  const importedFrom = /* @__PURE__ */ new Map();
+  const importRe = /import\s*(?:type\s*)?\{([^}]*)\}\s*from\s*["']([^"']+)["']/g;
+  for (const match of source.matchAll(importRe)) {
+    const names = match[1];
+    const spec = match[2];
+    for (const raw of names.split(",")) {
+      const name = raw.trim().split(/\s+as\s+/).pop()?.trim();
+      if (name) importedFrom.set(name, spec);
+    }
+  }
+  const bodyMatch = source.match(/=\s*\{([\s\S]*?)\n\}\s*;?/);
+  if (!bodyMatch) return [];
+  const entries = [];
+  const entryRe = /^\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_$-]+))\s*:\s*([A-Za-z0-9_$]+)\s*,?\s*(?:\/\/.*)?$/gm;
+  for (const match of bodyMatch[1].matchAll(entryRe)) {
+    const slug = match[1] ?? match[2] ?? match[3];
+    const exportName = match[4];
+    const importPath = importedFrom.get(exportName);
+    if (!importPath || !importPath.startsWith(".")) continue;
+    entries.push({ slug, exportName, importPath });
+  }
+  return entries;
+}
+function parseDefinition(source) {
+  const match = source.match(/export\s+const\s+\w+Definition\s*=\s*\{([\s\S]*?)\n\}/);
+  if (!match) return null;
+  const body = match[1];
+  const field = (key) => {
+    const m = body.match(new RegExp(`(?:^|\\n)\\s*${key}\\s*:\\s*(?:"([^"]*)"|'([^']*)'|\`([^\`]*)\`)`));
+    return m ? m[1] ?? m[2] ?? m[3] : void 0;
+  };
+  const schemaName = body.match(/(?:^|\n)\s*schema\s*:\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*,?/)?.[1];
+  return {
+    name: field("name"),
+    heading: field("heading"),
+    category: field("category"),
+    description: field("description"),
+    icon: field("icon"),
+    ...schemaName ? { schemaName } : {}
+  };
+}
+function splitTopLevel(body) {
+  const parts = [];
+  let depth = 0;
+  let quote = null;
+  let current = "";
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (quote) {
+      current += ch;
+      if (ch === "\\") current += body[++i] ?? "";
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "/" && body[i + 1] === "/") {
+      while (i < body.length && body[i] !== "\n") i++;
+      current += "\n";
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") quote = ch;
+    else if ("([{".includes(ch)) depth++;
+    else if (")]}".includes(ch)) depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  parts.push(current);
+  return parts.map((p) => p.trim()).filter(Boolean);
+}
+function enumValues(expr) {
+  const m = expr.match(/^z\.enum\(\s*\[([\s\S]*?)\]/);
+  if (!m) return null;
+  const values = [];
+  for (const raw of splitTopLevel(m[1])) {
+    const lit = raw.match(/^(?:"([^"]*)"|'([^']*)'|`([^`]*)`)$/);
+    if (!lit) return null;
+    values.push(lit[1] ?? lit[2] ?? lit[3]);
+  }
+  return values;
+}
+function zodFieldToSchemaField(expr) {
+  const source = expr.trim();
+  const optional = /\.(optional|nullable|nullish|default)\(/.test(source);
+  let field = null;
+  if (/^z\.string\(/.test(source)) field = { type: /\.(email)\(/.test(source) ? "email" : /\.(url)\(/.test(source) ? "url" : "text" };
+  else if (/^z\.number\(/.test(source)) field = { type: /\.int\(/.test(source) ? "integer" : "number" };
+  else if (/^z\.boolean\(/.test(source)) field = { type: "boolean" };
+  else if (/^z\.enum\(/.test(source)) {
+    const options = enumValues(source);
+    field = options ? { type: "select", options } : { type: "select" };
+  } else if (/^z\.array\(/.test(source)) field = { type: "array" };
+  else if (/^z\.(object|record)\(/.test(source)) field = { type: "json" };
+  else if (/^z\.union\(\s*\[\s*z\.string\(\)\s*,\s*z\.(any|object|record)\(/.test(source)) field = { type: "asset" };
+  if (!field) return null;
+  if (!optional) field.required = true;
+  const describe = source.match(/\.describe\(\s*(?:"([^"]*)"|'([^']*)'|`([^`]*)`)\s*\)/);
+  const label = describe ? describe[1] ?? describe[2] ?? describe[3] : void 0;
+  if (label) field.label = label;
+  return field;
+}
+function parseZodSchema(source, schemaName) {
+  const start = source.match(new RegExp(`(?:export\\s+)?const\\s+${schemaName}\\s*=\\s*z\\.object\\(\\s*\\{`));
+  if (!start || start.index === void 0) return null;
+  const open = start.index + start[0].length;
+  let depth = 1;
+  let end = -1;
+  for (let i = open; i < source.length; i++) {
+    const ch = source[i];
+    if (ch === "{" || ch === "(" || ch === "[") depth++;
+    else if (ch === "}" || ch === ")" || ch === "]") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end < 0) return null;
+  const schema2 = {};
+  for (const entry of splitTopLevel(source.slice(open, end))) {
+    const m = entry.match(/^(?:"([^"]+)"|'([^']+)'|([A-Za-z_$][A-Za-z0-9_$]*))\s*:\s*([\s\S]+)$/);
+    if (!m) continue;
+    const field = zodFieldToSchemaField(m[4]);
+    if (field) schema2[m[1] ?? m[2] ?? m[3]] = field;
+  }
+  return Object.keys(schema2).length ? schema2 : null;
+}
+function parseImports(source) {
+  const internal = /* @__PURE__ */ new Set();
+  const npm = /* @__PURE__ */ new Set();
+  const re = /(?:import|export)\s+(?:[^"';]*?\s+from\s+)?["']([^"']+)["']|import\s*\(\s*["']([^"']+)["']\s*\)/g;
+  for (const match of source.matchAll(re)) {
+    const spec = match[1] ?? match[2];
+    if (!spec) continue;
+    if (spec.startsWith(".") || spec.startsWith("@/") || spec.startsWith("~/")) internal.add(spec);
+    else npm.add(spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0]);
+  }
+  return { internal: [...internal].sort(), npm: [...npm].sort() };
+}
+var SOURCE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+async function resolveImport(sectionsDir, spec) {
+  const base = path4.resolve(sectionsDir, spec);
+  for (const ext of SOURCE_EXTENSIONS) {
+    try {
+      await readFile4(base + ext);
+      return base + ext;
+    } catch {
+    }
+  }
+  return null;
+}
+async function deriveManifests(sectionsDir, options) {
+  const registrySource = await readFile4(options.registryFile ?? path4.join(sectionsDir, DEFAULT_REGISTRY_FILE), "utf8");
+  const entries = parseRegistry(registrySource);
+  const out = [];
+  for (const entry of entries) {
+    const entryFile = await resolveImport(sectionsDir, entry.importPath);
+    if (!entryFile) continue;
+    const source = await readFile4(entryFile, "utf8");
+    const meta = parseDefinition(source);
+    const schema2 = meta?.schemaName ? parseZodSchema(source, meta.schemaName) : null;
+    const imports = parseImports(source);
+    const relative = path4.relative(sectionsDir, entryFile).split(path4.sep).join("/");
+    const npm = {};
+    for (const pkg of imports.npm) {
+      if (pkg === "react" || pkg === "next") continue;
+      npm[pkg] = options.npmVersions?.[pkg] ?? "*";
+    }
+    const manifest = {
+      section: entry.slug,
+      framework: options.framework,
+      entry: relative,
+      exportName: entry.exportName,
+      files: [relative],
+      ...meta?.heading ? { title: meta.heading } : {},
+      ...meta?.description ? { description: meta.description } : {},
+      ...meta?.category ? { category: meta.category } : {},
+      ...meta?.icon ? { icon: meta.icon } : {},
+      dependencies: {
+        ...Object.keys(npm).length ? { npm } : {},
+        ...imports.internal.length ? { internal: imports.internal } : {}
+      },
+      ...schema2 ? { schema: schema2 } : {}
+    };
+    out.push({ name: entry.slug, manifest, entryFile });
+  }
+  return out;
+}
+async function readNpmVersions(dir) {
+  let current = path4.resolve(dir);
+  for (; ; ) {
+    try {
+      const raw = await readFile4(path4.join(current, "package.json"), "utf8");
+      const pkg = JSON.parse(raw);
+      return { ...pkg.devDependencies, ...pkg.dependencies };
+    } catch {
+      const parent = path4.dirname(current);
+      if (parent === current) return {};
+      current = parent;
+    }
+  }
+}
+async function hasRegistry(sectionsDir, registryFile) {
+  const file = registryFile ?? path4.join(sectionsDir, DEFAULT_REGISTRY_FILE);
+  try {
+    return (await readdir2(path4.dirname(file))).includes(path4.basename(file));
+  } catch {
+    return false;
+  }
+}
+
+// src/registry.ts
+var SOURCE_EXTENSIONS2 = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
+function importPathFor(registryFile, entryFile) {
+  const relative = path5.relative(path5.dirname(registryFile), entryFile).split(path5.sep).join("/");
+  const ext = path5.extname(relative);
+  const bare = SOURCE_EXTENSIONS2.includes(ext) ? relative.slice(0, -ext.length) : relative;
+  return bare.startsWith(".") ? bare : `./${bare}`;
+}
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function addRegistryEntry(source, addition) {
+  const { slug, exportName, importPath } = addition;
+  if (!IDENTIFIER.test(exportName)) throw new Error(`'${exportName}' is not a valid export name`);
+  const eol = source.includes("\r\n") ? "\r\n" : "\n";
+  let out = source;
+  let addedImport = false;
+  let addedEntry = false;
+  const importRe = /^[ \t]*import\s*(?:type\s*)?\{([^}]*)\}\s*from\s*(["'])([^"']+)\2[ \t]*;?[ \t]*$/gm;
+  const imports = [...out.matchAll(importRe)];
+  const alreadyImported = imports.some(
+    (m) => m[1].split(",").some((raw) => raw.trim().split(/\s+as\s+/).pop()?.trim() === exportName)
+  );
+  if (!alreadyImported) {
+    const last = imports.at(-1);
+    const quote = last?.[2] ?? '"';
+    const semicolon = last ? last[0].trimEnd().endsWith(";") : true;
+    const line = `import { ${exportName} } from ${quote}${importPath}${quote}${semicolon ? ";" : ""}`;
+    if (last) {
+      const end = last.index + last[0].length;
+      out = `${out.slice(0, end)}${eol}${line}${out.slice(end)}`;
+    } else {
+      out = `${line}${eol}${eol}${out}`;
+    }
+    addedImport = true;
+  }
+  const alreadyMapped = parseRegistry(out).some((e) => e.slug === slug) || hasEntry(out, slug);
+  if (!alreadyMapped) {
+    const object = findRegistryObject(out);
+    if (!object) throw new Error("could not find the registry object (`export const ... = { ... }`)");
+    const body = out.slice(object.bodyStart, object.bodyEnd);
+    const entryLines = body.split(/\r?\n/).filter((l) => /^\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_$-]+)\s*:/.test(l));
+    const lastEntry = entryLines.at(-1);
+    const indent = lastEntry?.match(/^\s*/)?.[0] ?? "  ";
+    const key = IDENTIFIER.test(slug) ? slug : `"${slug}"`;
+    const entryLine = `${indent}${key}: ${exportName},`;
+    let newBody = body;
+    if (lastEntry !== void 0) {
+      const stripped = lastEntry.replace(/\/\/.*$/, "").trimEnd();
+      if (!stripped.endsWith(",")) {
+        const at = newBody.lastIndexOf(lastEntry);
+        const fixed = lastEntry.replace(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_$-]+)\s*:\s*[A-Za-z0-9_$]+)/, "$1,");
+        newBody = `${newBody.slice(0, at)}${fixed}${newBody.slice(at + lastEntry.length)}`;
+      }
+    }
+    newBody = `${newBody.replace(/\s*$/, "")}${eol}${entryLine}`;
+    out = `${out.slice(0, object.bodyStart)}${newBody}${out.slice(object.bodyEnd)}`;
+    addedEntry = true;
+  }
+  return { source: out, changed: addedImport || addedEntry, addedImport, addedEntry };
+}
+function hasEntry(source, slug) {
+  const object = findRegistryObject(source);
+  if (!object) return false;
+  const body = source.slice(object.bodyStart, object.bodyEnd);
+  const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^\\s*(?:"${escaped}"|'${escaped}'|${escaped})\\s*:`, "m").test(body);
+}
+function findRegistryObject(source) {
+  const open = source.match(/export\s+const\s+\w+\s*(?::[^=]*)?=\s*\{/) ?? source.match(/=\s*\{/);
+  if (!open || open.index === void 0) return null;
+  const bodyStart = open.index + open[0].length;
+  const close = /\r?\n\}/g;
+  close.lastIndex = bodyStart;
+  const closeMatch = close.exec(source);
+  if (!closeMatch) return null;
+  return { bodyStart, bodyEnd: closeMatch.index };
+}
+async function registerSection(sectionsDir, registryFile, manifest) {
+  const name = path5.basename(registryFile);
+  let source;
+  try {
+    source = await readFile5(registryFile, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { file: registryFile, changed: false, notice: `no ${name} in ${path5.dirname(registryFile)}, register the section yourself` };
+    }
+    throw error;
+  }
+  if (!manifest.exportName) {
+    return { file: registryFile, changed: false, notice: `manifest has no exportName, ${name} not updated` };
+  }
+  const importPath = importPathFor(registryFile, path5.resolve(sectionsDir, manifest.entry));
+  let edit;
+  try {
+    edit = addRegistryEntry(source, { slug: manifest.section, exportName: manifest.exportName, importPath });
+  } catch (error) {
+    return { file: registryFile, changed: false, notice: `${name} not updated: ${error.message}` };
+  }
+  if (edit.changed) await writeFile3(registryFile, edit.source, "utf8");
+  return { file: registryFile, changed: edit.changed, addedImport: edit.addedImport, addedEntry: edit.addedEntry };
+}
+
+// src/typegen.ts
+import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import path6 from "path";
+import {
+  isFieldSchema,
+  isFormBuilderSchema
+} from "@botlr/sdk";
+var PROPS_SUFFIX = ".props.ts";
+var STRING_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "textarea",
+  "markdown",
+  "richtext",
+  "string",
+  "email",
+  "tel",
+  "url",
+  "icon",
+  "color",
+  "date",
+  "datetime",
+  "timestamp",
+  "timestamptz",
+  "uuid"
+]);
+var NUMBER_TYPES = /* @__PURE__ */ new Set(["number", "integer", "currency"]);
+var BOOLEAN_TYPES = /* @__PURE__ */ new Set(["boolean"]);
+var STRING_LIST_TYPES = /* @__PURE__ */ new Set(["multiselect", "tags"]);
+var LIST_TYPES = /* @__PURE__ */ new Set(["array", "list", "repeater"]);
+var OBJECT_TYPES = /* @__PURE__ */ new Set(["json", "jsonb", "object"]);
+var REFERENCE_TYPES = /* @__PURE__ */ new Set([
+  "asset",
+  "asset-picker-image",
+  "asset-picker-file",
+  "asset-picker-video",
+  "media",
+  "document",
+  "page",
+  "post",
+  "reference",
+  "relation",
+  "entity_reference",
+  "app_instance",
+  "forum_thread"
+]);
+var REFERENCE_TYPE = "string | Record<string, unknown>";
+var OBJECT_TYPE = "Record<string, unknown>";
+var GROUP_NODE_TYPES = /* @__PURE__ */ new Set(["section", "fieldset", "composite", "group"]);
+function literal(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return null;
+}
+function optionUnion(options) {
+  if (!Array.isArray(options) || options.length === 0) return null;
+  const literals = [];
+  for (const option of options) {
+    const raw = option && typeof option === "object" ? option.value : option;
+    const lit = literal(raw);
+    if (lit === null) return null;
+    if (!literals.includes(lit)) literals.push(lit);
+  }
+  return literals.join(" | ");
+}
+function wrapArray(type) {
+  return /^[A-Za-z0-9_<>, ]+$/.test(type) ? `${type}[]` : `Array<${type}>`;
+}
+function tsTypeForField(field) {
+  const kind = typeof field.type === "string" ? field.type : "";
+  const multiple = field.multiple === true;
+  if (kind === "select") {
+    const union = optionUnion(field.options) ?? "string";
+    return multiple ? wrapArray(union) : union;
+  }
+  if (STRING_TYPES.has(kind)) return "string";
+  if (NUMBER_TYPES.has(kind)) return "number";
+  if (BOOLEAN_TYPES.has(kind)) return "boolean";
+  if (STRING_LIST_TYPES.has(kind)) return "string[]";
+  if (kind === "repeater" && Array.isArray(field.fields)) {
+    const items = collectFormBuilderFields(field.fields);
+    return items.length ? `Array<${inlineObject(items)}>` : "unknown[]";
+  }
+  if (LIST_TYPES.has(kind)) return "unknown[]";
+  if (OBJECT_TYPES.has(kind)) return OBJECT_TYPE;
+  if (REFERENCE_TYPES.has(kind)) return multiple ? `Array<${REFERENCE_TYPE}>` : REFERENCE_TYPE;
+  return "unknown";
+}
+function docFor(field) {
+  const doc = [];
+  for (const value of [field.label, field.helpText ?? field.description]) {
+    if (typeof value === "string" && value.trim()) doc.push(value.trim());
+  }
+  return doc;
+}
+function collectDslFields(schema2) {
+  const out = [];
+  for (const [name, value] of Object.entries(schema2)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const field = value;
+    out.push({ name, type: tsTypeForField(field), required: field.required === true, doc: docFor(field) });
+  }
+  return out;
+}
+function collectFormBuilderFields(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    if (!node || typeof node !== "object") continue;
+    if (GROUP_NODE_TYPES.has(node.type) && Array.isArray(node.children)) {
+      out.push(...collectFormBuilderFields(node.children));
+      continue;
+    }
+    const name = typeof node.name === "string" && node.name ? node.name : typeof node.key === "string" ? node.key : "";
+    if (!name) continue;
+    const kind = node.type === "field" ? node.fieldType ?? "" : node.fieldType ?? node.type;
+    const type = tsTypeForField({ type: kind, options: node.options, multiple: node.multiple, fields: node.fields });
+    out.push({ name, type, required: node.required === true, doc: docFor(node) });
+  }
+  return out;
+}
+function collectFields(schema2) {
+  if (isFormBuilderSchema(schema2)) return collectFormBuilderFields(schema2.nodes);
+  if (isFieldSchema(schema2)) return collectDslFields(schema2);
+  return [];
+}
+function schemaFieldNames(schema2) {
+  return collectFields(schema2).map((f) => f.name);
+}
+var IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function propertyKey(name) {
+  return IDENTIFIER_RE.test(name) ? name : JSON.stringify(name);
+}
+function inlineObject(fields) {
+  return `{ ${fields.map((f) => `${propertyKey(f.name)}${f.required ? "" : "?"}: ${f.type}`).join("; ")} }`;
+}
+function pascalCase(slug) {
+  const words = slug.split(/[^A-Za-z0-9]+/).filter(Boolean);
+  const name = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+  return /^[0-9]/.test(name) ? `Section${name}` : name || "Section";
+}
+function propsInterfaceName(manifest) {
+  const base = manifest.exportName && IDENTIFIER_RE.test(manifest.exportName) ? manifest.exportName : pascalCase(manifest.section);
+  return `${base}Props`;
+}
+function generatePropsSource(schema2, options) {
+  const fields = collectFields(schema2);
+  const lines = [
+    `// Generated by @botlr/cli from the Botlr section definition "${options.section}".`,
+    "// Do not edit: the props schema lives in the dashboard, and `botlr pull` rewrites this file.",
+    ""
+  ];
+  if (fields.length === 0) {
+    lines.push("/** The definition has no props yet; define them in the dashboard and pull again. */");
+    lines.push(`export type ${options.interfaceName} = Record<string, unknown>;`);
+    return `${lines.join("\n")}
+`;
+  }
+  lines.push(`export interface ${options.interfaceName} {`);
+  fields.forEach((field, index) => {
+    if (index > 0 && field.doc.length) lines.push("");
+    if (field.doc.length === 1) lines.push(`  /** ${field.doc[0]} */`);
+    else if (field.doc.length > 1) lines.push("  /**", ...field.doc.map((d) => `   * ${d}`), "   */");
+    lines.push(`  ${propertyKey(field.name)}${field.required ? "" : "?"}: ${field.type};`);
+  });
+  lines.push("}");
+  return `${lines.join("\n")}
+`;
+}
+function propsPath(sectionsDir, name) {
+  return path6.join(sectionsDir, `${name}${PROPS_SUFFIX}`);
+}
+async function writePropsTypes(sectionsDir, manifest, schema2) {
+  const interfaceName = propsInterfaceName(manifest);
+  const file = propsPath(sectionsDir, manifest.section);
+  const text = generatePropsSource(schema2, { section: manifest.section, interfaceName });
+  try {
+    if (await readFile6(file, "utf8") === text) return { file, interfaceName, changed: false };
+  } catch {
+  }
+  await mkdir3(sectionsDir, { recursive: true });
+  await writeFile4(file, text, "utf8");
+  return { file, interfaceName, changed: true };
+}
+
 // src/commands/pull.ts
 async function localHash(sectionsDir, name) {
   try {
@@ -276,16 +859,35 @@ async function pullSections(config, options) {
     });
     const { source } = response;
     const files = await writeSectionFiles(config.sectionsDir, source.files);
-    await writeManifest(config.sectionsDir, name, source.manifest);
-    const newEntry = {
+    const manifest = await writeManifestIfChanged(config.sectionsDir, name, source.manifest);
+    const registry = options.noRegistry ? void 0 : await registerSection(config.sectionsDir, config.registryFile, source.manifest);
+    let types;
+    let typesNotice;
+    if (config.types && !options.noTypes) {
+      if (response.definition) {
+        types = await writePropsTypes(config.sectionsDir, source.manifest, response.definition.schema);
+      } else {
+        typesNotice = "no section definition resolves for this section, no prop types written";
+      }
+    }
+    const fresh = {
       scope: source.scope,
       framework: source.framework,
       version: source.version,
       contentHash: source.contentHash,
       pulledAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    lock[name] = newEntry;
-    results.push({ name, scope: source.scope, version: source.version, files });
+    lock[name] = nextLockEntry(entry, fresh);
+    results.push({
+      name,
+      scope: source.scope,
+      version: source.version,
+      files,
+      manifestChanged: manifest.changed,
+      registry,
+      types,
+      typesNotice
+    });
   }
   await writeLock(config.root, lock);
   return results;
@@ -296,6 +898,38 @@ import {
   BotlrConflictError,
   contentHash as contentHash2
 } from "@botlr/sdk";
+
+// src/drift.ts
+import { schemaFormat } from "@botlr/sdk";
+function manifestSchema(manifest) {
+  const schema2 = manifest.schema;
+  return schemaFormat(schema2) ? schema2 : null;
+}
+function compareSchemas(manifest, definitionSchema) {
+  const code = manifestSchema(manifest);
+  if (!code) return null;
+  const codeKeys = new Set(schemaFieldNames(code));
+  const dashboardKeys = new Set(schemaFieldNames(definitionSchema));
+  const missingInDashboard = [...codeKeys].filter((k) => !dashboardKeys.has(k)).sort();
+  const missingInCode = [...dashboardKeys].filter((k) => !codeKeys.has(k)).sort();
+  if (missingInDashboard.length === 0 && missingInCode.length === 0) return null;
+  return { missingInDashboard, missingInCode };
+}
+function formatDriftWarning(name, drift) {
+  const lines = [`warning: props schema of '${name}' differs between the code and the dashboard`];
+  if (drift.missingInDashboard.length) {
+    lines.push(`  the code expects props the dashboard does not define: ${drift.missingInDashboard.join(", ")}`);
+  }
+  if (drift.missingInCode.length) {
+    lines.push(`  the dashboard defines props the code does not list: ${drift.missingInCode.join(", ")}`);
+  }
+  lines.push(`  the dashboard owns the schema; a code push never changes it. To resolve:`);
+  lines.push(`    botlr schema pull ${name}   takes the dashboard's schema into ${name}.botlr.json`);
+  lines.push(`    botlr schema push ${name}   sends the code's schema to the dashboard`);
+  return lines.join("\n");
+}
+
+// src/commands/push.ts
 var PushConflict = class extends Error {
   constructor(message, latest) {
     super(message);
@@ -358,12 +992,14 @@ async function pushSection(config, options) {
     contentHash: response.contentHash,
     pulledAt: (/* @__PURE__ */ new Date()).toISOString()
   });
+  const drift = compareSchemas(manifest, response.definition?.schema) ?? void 0;
   return {
     name,
     created: response.created,
     scope: response.scope,
     version: response.version,
-    contentHash: response.contentHash
+    contentHash: response.contentHash,
+    drift
   };
 }
 
@@ -391,10 +1027,20 @@ async function sectionStatuses(config, options = {}) {
   const names = options.names?.length ? options.names : await listManifests(config.sectionsDir);
   const lock = await readLock(config.root);
   let summaries = /* @__PURE__ */ new Map();
-  if (!options.offline) {
-    const listing = await clientFor(config).sections.list({ framework: config.framework });
+  const client = options.offline ? null : clientFor(config);
+  if (client) {
+    const listing = await client.sections.list({ framework: config.framework });
     summaries = new Map(listing.sections.map((s) => [s.name, s]));
   }
+  const driftFor = async (manifest) => {
+    if (!client || !manifestSchema(manifest) || !summaries.has(manifest.section)) return void 0;
+    try {
+      const pulled = await client.sections.pull(manifest.section, { framework: config.framework });
+      return compareSchemas(manifest, pulled.definition?.schema) ?? void 0;
+    } catch {
+      return void 0;
+    }
+  };
   const rows = [];
   for (const name of names) {
     const entry = lock[name];
@@ -408,7 +1054,8 @@ async function sectionStatuses(config, options = {}) {
         status: computeStatus({ localHash: localHash2, lock: entry, remote }),
         local: entry?.version ?? null,
         remote: remote?.version ?? null,
-        scope: entry?.scope ?? summary?.effective ?? "-"
+        scope: entry?.scope ?? summary?.effective ?? "-",
+        drift: await driftFor(manifest)
       });
     } catch (error) {
       rows.push({
@@ -424,149 +1071,171 @@ async function sectionStatuses(config, options = {}) {
   return rows;
 }
 
-// src/init.ts
-import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
-import path4 from "path";
-var REGISTRY_FILE = "publisher-section-registry.ts";
-function parseRegistry(source) {
-  const importedFrom = /* @__PURE__ */ new Map();
-  const importRe = /import\s*(?:type\s*)?\{([^}]*)\}\s*from\s*["']([^"']+)["']/g;
-  for (const match of source.matchAll(importRe)) {
-    const names = match[1];
-    const spec = match[2];
-    for (const raw of names.split(",")) {
-      const name = raw.trim().split(/\s+as\s+/).pop()?.trim();
-      if (name) importedFrom.set(name, spec);
-    }
+// src/commands/init.ts
+async function initSections(config, options = {}) {
+  if (!await hasRegistry(config.sectionsDir, config.registryFile)) {
+    throw new Error(`No ${config.registryFile}; sections init reads the registry map to find components`);
   }
-  const bodyMatch = source.match(/=\s*\{([\s\S]*?)\n\}\s*;?/);
-  if (!bodyMatch) return [];
-  const entries = [];
-  const entryRe = /^\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_$-]+))\s*:\s*([A-Za-z0-9_$]+)\s*,?\s*(?:\/\/.*)?$/gm;
-  for (const match of bodyMatch[1].matchAll(entryRe)) {
-    const slug = match[1] ?? match[2] ?? match[3];
-    const exportName = match[4];
-    const importPath = importedFrom.get(exportName);
-    if (!importPath || !importPath.startsWith(".")) continue;
-    entries.push({ slug, exportName, importPath });
+  const existing = new Set(await listManifests(config.sectionsDir));
+  const npmVersions = await readNpmVersions(config.sectionsDir);
+  const derived = await deriveManifests(config.sectionsDir, {
+    framework: config.framework,
+    npmVersions,
+    registryFile: config.registryFile
+  });
+  const results = [];
+  for (const { name, manifest, entryFile } of derived) {
+    const skip = existing.has(name) && !options.force;
+    let file = `${name}.botlr.json`;
+    if (!skip && !options.dryRun) {
+      file = await writeManifest(config.sectionsDir, name, manifest);
+    }
+    results.push({ name, file, entry: entryFile, written: !skip && !options.dryRun });
   }
-  return entries;
+  return results;
 }
-function parseDefinition(source) {
-  const match = source.match(/export\s+const\s+\w+Definition\s*=\s*\{([\s\S]*?)\n\}/);
-  if (!match) return null;
-  const body = match[1];
-  const field = (key) => {
-    const m = body.match(new RegExp(`(?:^|\\n)\\s*${key}\\s*:\\s*(?:"([^"]*)"|'([^']*)'|\`([^\`]*)\`)`));
-    return m ? m[1] ?? m[2] ?? m[3] : void 0;
+
+// src/commands/schema.ts
+import { BotlrError, BotlrSchemaFormatConflictError, botlrErrorMessage } from "@botlr/sdk";
+
+// src/schema-diff.ts
+import { schemaFormat as schemaFormat2 } from "@botlr/sdk";
+function schemaKeys(schema2) {
+  return [...new Set(schemaFieldNames(schema2))];
+}
+function diffSchemaKeys(current, next) {
+  const currentKeys = new Set(schemaKeys(current));
+  const nextKeys = new Set(schemaKeys(next));
+  return {
+    added: [...nextKeys].filter((k) => !currentKeys.has(k)).sort(),
+    removed: [...currentKeys].filter((k) => !nextKeys.has(k)).sort(),
+    kept: [...nextKeys].filter((k) => currentKeys.has(k)).sort()
   };
+}
+function previewSchemaPush(name, current, next, formats = {}) {
   return {
-    name: field("name"),
-    heading: field("heading"),
-    category: field("category"),
-    description: field("description"),
-    icon: field("icon")
+    name,
+    current,
+    currentFormat: formats.currentFormat ?? schemaFormat2(current),
+    next,
+    nextFormat: formats.nextFormat ?? schemaFormat2(next),
+    diff: diffSchemaKeys(current, next)
   };
 }
-function parseImports(source) {
-  const internal = /* @__PURE__ */ new Set();
-  const npm = /* @__PURE__ */ new Set();
-  const re = /(?:import|export)\s+(?:[^"';]*?\s+from\s+)?["']([^"']+)["']|import\s*\(\s*["']([^"']+)["']\s*\)/g;
-  for (const match of source.matchAll(re)) {
-    const spec = match[1] ?? match[2];
-    if (!spec) continue;
-    if (spec.startsWith(".") || spec.startsWith("@/") || spec.startsWith("~/")) internal.add(spec);
-    else npm.add(spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0]);
-  }
-  return { internal: [...internal].sort(), npm: [...npm].sort() };
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
 }
-var SOURCE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
-async function resolveImport(sectionsDir, spec) {
-  const base = path4.resolve(sectionsDir, spec);
-  for (const ext of SOURCE_EXTENSIONS) {
-    try {
-      await readFile4(base + ext);
-      return base + ext;
-    } catch {
-    }
-  }
-  return null;
+function formatName(format) {
+  return format ?? "unknown";
 }
-async function deriveManifests(sectionsDir, options) {
-  const registrySource = await readFile4(path4.join(sectionsDir, REGISTRY_FILE), "utf8");
-  const entries = parseRegistry(registrySource);
-  const out = [];
-  for (const entry of entries) {
-    const entryFile = await resolveImport(sectionsDir, entry.importPath);
-    if (!entryFile) continue;
-    const source = await readFile4(entryFile, "utf8");
-    const meta = parseDefinition(source);
-    const imports = parseImports(source);
-    const relative = path4.relative(sectionsDir, entryFile).split(path4.sep).join("/");
-    const npm = {};
-    for (const pkg of imports.npm) {
-      if (pkg === "react" || pkg === "next") continue;
-      npm[pkg] = options.npmVersions?.[pkg] ?? "*";
-    }
-    const manifest = {
-      section: entry.slug,
-      framework: options.framework,
-      entry: relative,
-      exportName: entry.exportName,
-      files: [relative],
-      ...meta?.heading ? { title: meta.heading } : {},
-      ...meta?.description ? { description: meta.description } : {},
-      ...meta?.category ? { category: meta.category } : {},
-      ...meta?.icon ? { icon: meta.icon } : {},
-      dependencies: {
-        ...Object.keys(npm).length ? { npm } : {},
-        ...imports.internal.length ? { internal: imports.internal } : {}
-      }
-    };
-    out.push({ name: entry.slug, manifest, entryFile });
+function formatSchemaDiff(preview) {
+  const { diff } = preview;
+  const header = `schema of '${preview.name}': dashboard has ${formatName(preview.currentFormat)} (${plural(schemaKeys(preview.current).length, "field")}), code has ${formatName(preview.nextFormat)} (${plural(schemaKeys(preview.next).length, "field")})`;
+  const lines = [header];
+  if (diff.added.length) lines.push(`  + added    ${diff.added.join(", ")}`);
+  if (diff.removed.length) lines.push(`  - removed  ${diff.removed.join(", ")}`);
+  lines.push(`  = kept     ${diff.kept.length ? diff.kept.join(", ") : "none"}`);
+  if (preview.currentFormat && preview.nextFormat && preview.currentFormat !== preview.nextFormat) {
+    lines.push(`  the formats differ: the push needs --force to replace ${preview.currentFormat} with ${preview.nextFormat}`);
   }
-  return out;
+  if (!diff.added.length && !diff.removed.length) lines.push("  the field keys match; only field settings may change");
+  return lines.join("\n");
 }
-async function readNpmVersions(dir) {
-  let current = path4.resolve(dir);
-  for (; ; ) {
+
+// src/commands/schema.ts
+function isNotFound(error) {
+  return error instanceof BotlrError && error.status === 404;
+}
+async function pullSchemas(config, options) {
+  const client = clientFor(config);
+  const names = options.all ? await listManifests(config.sectionsDir) : options.names;
+  const results = [];
+  for (const name of names) {
+    let manifest;
     try {
-      const raw = await readFile4(path4.join(current, "package.json"), "utf8");
-      const pkg = JSON.parse(raw);
-      return { ...pkg.devDependencies, ...pkg.dependencies };
-    } catch {
-      const parent = path4.dirname(current);
-      if (parent === current) return {};
-      current = parent;
+      manifest = await readManifest(config.sectionsDir, name);
+    } catch (error) {
+      results.push({ name, changed: false, file: "", error: error.message });
+      continue;
     }
+    let definition;
+    try {
+      definition = (await client.sections.getSchema(name)).definition;
+    } catch (error) {
+      if (!isNotFound(error)) throw error;
+      results.push({ name, changed: false, file: "", error: `the app has no section type '${name}' (botlr push ${name} --create adds one)` });
+      continue;
+    }
+    const updated = { ...manifest, schema: definition.schema };
+    const written = await writeManifestIfChanged(config.sectionsDir, name, updated);
+    const types = config.types && !options.noTypes ? await writePropsTypes(config.sectionsDir, manifest, definition.schema) : void 0;
+    results.push({ name, changed: written.changed, file: written.file, format: definition.format, types });
   }
+  return results;
 }
-async function hasRegistry(sectionsDir) {
+var SchemaFormatConflict = class extends Error {
+  constructor(sectionName, currentFormat, newFormat, message) {
+    super(message ?? `the schema of '${sectionName}' is stored as ${currentFormat}, the manifest's is ${newFormat}`);
+    this.sectionName = sectionName;
+    this.currentFormat = currentFormat;
+    this.newFormat = newFormat;
+    this.name = "SchemaFormatConflict";
+  }
+  sectionName;
+  currentFormat;
+  newFormat;
+};
+var SchemaRejected = class extends Error {
+  constructor(sectionName, message) {
+    super(message);
+    this.sectionName = sectionName;
+    this.name = "SchemaRejected";
+  }
+  sectionName;
+};
+async function pushSchema(config, options) {
+  const client = clientFor(config, { needPersonalToken: true });
+  const { name } = options;
+  const manifest = await readManifest(config.sectionsDir, name);
+  const next = manifest.schema;
+  if (!next || typeof next !== "object" || Array.isArray(next)) {
+    throw new ManifestError(
+      `${name}.botlr.json has no 'schema' object to push; add one, or run 'botlr schema pull ${name}' to take the dashboard's`
+    );
+  }
+  let current;
   try {
-    return (await readdir2(sectionsDir)).includes(REGISTRY_FILE);
-  } catch {
-    return false;
+    current = (await client.sections.getSchema(name)).definition;
+  } catch (error) {
+    if (!isNotFound(error)) throw error;
+    throw new ManifestError(`the app has no section type '${name}'; push the code first with 'botlr push ${name} --create'`);
   }
-}
-
-// src/commands/init.ts
-async function initSections(config, options = {}) {
-  if (!await hasRegistry(config.sectionsDir)) {
-    throw new Error(`No ${REGISTRY_FILE} in ${config.sectionsDir}; sections init reads the registry map to find components`);
+  const preview = previewSchemaPush(name, current.schema, next, { currentFormat: current.format });
+  if (options.confirm && !await options.confirm(preview)) {
+    return { name, preview, pushed: false };
   }
-  const existing = new Set(await listManifests(config.sectionsDir));
-  const npmVersions = await readNpmVersions(config.sectionsDir);
-  const derived = await deriveManifests(config.sectionsDir, { framework: config.framework, npmVersions });
-  const results = [];
-  for (const { name, manifest, entryFile } of derived) {
-    const skip = existing.has(name) && !options.force;
-    let file = `${name}.botlr.json`;
-    if (!skip && !options.dryRun) {
-      file = await writeManifest(config.sectionsDir, name, manifest);
+  let response;
+  try {
+    response = await client.sections.putSchema(name, { schema: next, force: options.force ?? false });
+  } catch (error) {
+    if (error instanceof BotlrSchemaFormatConflictError) {
+      throw new SchemaFormatConflict(name, error.currentFormat, error.newFormat, botlrErrorMessage(error));
     }
-    results.push({ name, file, entry: entryFile, written: !skip && !options.dryRun });
+    if (error instanceof BotlrError && error.status === 422) {
+      throw new SchemaRejected(name, botlrErrorMessage(error) ?? "the server rejected the schema (422)");
+    }
+    throw error;
   }
-  return results;
+  const types = config.types && !options.noTypes ? await writePropsTypes(config.sectionsDir, manifest, response.definition.schema) : void 0;
+  return {
+    name,
+    preview,
+    pushed: true,
+    changed: response.changed,
+    previousFormat: response.previousFormat,
+    format: response.definition.format,
+    types
+  };
 }
 
 // src/output.ts
@@ -586,6 +1255,7 @@ function fail(message) {
 }
 
 // src/cli.ts
+import { createInterface } from "readline/promises";
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 function parseVersion(value) {
@@ -609,12 +1279,23 @@ async function run(action) {
   latest on server: ${latest}
   pull first, or push --force to overwrite`);
     }
+    if (error instanceof SchemaFormatConflict) {
+      fail(
+        `${error.message}
+  dashboard: ${error.currentFormat}
+  code:      ${error.newFormat}
+  rerun with --force to replace the ${error.currentFormat} schema: botlr schema push ${error.sectionName} --force`
+      );
+    }
+    if (error instanceof SchemaRejected) {
+      fail(`the server rejected the schema of '${error.sectionName}': ${error.message}`);
+    }
     fail(error.message);
   }
 }
 var program = new Command("botlr").description("Pull and push section source between a Botlr site and this app").version(version).configureHelp({ sortSubcommands: true });
 withCommon(
-  program.command("pull [names...]").description("pull sections into the sections directory; writes <name>.botlr.json and the lock file").option("--all", "every section the server lists for the framework").option("--version <n>", "a specific version instead of the latest", parseVersion).option("--shared", "the shared row (per section definition) even when the app has its own").option("--force", "overwrite files that changed locally since the last pull")
+  program.command("pull [names...]").description("pull sections into the sections directory; writes <name>.botlr.json and the lock file").option("--all", "every section the server lists for the framework").option("--version <n>", "a specific version instead of the latest", parseVersion).option("--shared", "the shared row (per section definition) even when the app has its own").option("--force", "overwrite files that changed locally since the last pull").option("--no-registry", "do not add the section to the registry file").option("--no-types", "do not write <name>.props.ts from the definition's props schema")
 ).action(
   (names, opts) => run(async () => {
     if (names.length === 0 && !opts.all) fail("name a section or pass --all");
@@ -625,15 +1306,30 @@ withCommon(
       all: opts.all,
       version: opts.version,
       shared: opts.shared,
-      force: opts.force
+      force: opts.force,
+      noRegistry: opts.registry === false,
+      noTypes: opts.types === false
     });
     if (results.length === 0) {
       console.log("nothing to pull");
       return;
     }
     for (const r of results) {
-      if (r.skipped) console.log(`skip  ${r.name}: ${r.skipped}`);
-      else console.log(`pull  ${r.name} ${r.scope} v${r.version} (${r.files.length} file${r.files.length === 1 ? "" : "s"})`);
+      if (r.skipped) {
+        console.log(`skip  ${r.name}: ${r.skipped}`);
+        continue;
+      }
+      console.log(`pull  ${r.name} ${r.scope} v${r.version} (${r.files.length} file${r.files.length === 1 ? "" : "s"})`);
+      if (r.types?.changed) console.log(`      types: wrote ${r.types.interfaceName} to ${path7.relative(process.cwd(), r.types.file)}`);
+      if (r.typesNotice) console.log(`      types: ${r.typesNotice}`);
+      const registry = r.registry;
+      if (!registry) continue;
+      const file = path7.relative(process.cwd(), registry.file);
+      if (registry.notice) console.log(`      registry: ${registry.notice}`);
+      else if (registry.changed) {
+        const what = [registry.addedImport ? "import" : "", registry.addedEntry ? `"${r.name}" entry` : ""].filter(Boolean).join(" and ");
+        console.log(`      registry: added ${what} to ${file}`);
+      }
     }
   })
 );
@@ -651,6 +1347,8 @@ withCommon(
     });
     if (result.created) console.log(`pushed ${result.name} ${result.scope} v${result.version}`);
     else console.log(`${result.name} ${result.scope} v${result.version} already matches, nothing pushed`);
+    if (result.drift) process.stderr.write(`${formatDriftWarning(result.name, result.drift)}
+`);
   })
 );
 var sections = program.command("sections").description("list, inspect and bootstrap sections");
@@ -694,6 +1392,10 @@ withCommon(
         ["name", "status", "local", "remote", "scope", ""]
       )
     );
+    for (const r of rows) {
+      if (r.drift) process.stderr.write(`${formatDriftWarning(r.name, r.drift)}
+`);
+    }
     if (rows.some((r) => r.status === "diverged" || r.status === "error")) process.exitCode = 1;
   })
 );
@@ -711,5 +1413,67 @@ withCommon(
 review the manifests, then push each section: botlr push <name> --create`);
   })
 );
+var schema = program.command("schema").description("copy a section's props schema between the dashboard and <name>.botlr.json");
+withCommon(
+  schema.command("pull [names...]").description("write the dashboard's props schema into <name>.botlr.json as 'schema', then regenerate <name>.props.ts").option("--all", "every section with a manifest in the sections directory").option("--no-types", "do not write <name>.props.ts afterwards")
+).action(
+  (names, opts) => run(async () => {
+    if (names.length === 0 && !opts.all) fail("name a section or pass --all");
+    const config = await loadConfig(process.cwd(), overrides(opts));
+    const results = await pullSchemas(config, { names, all: opts.all, noTypes: opts.types === false });
+    if (results.length === 0) {
+      console.log(`no *.botlr.json manifests in ${config.sectionsDir}`);
+      return;
+    }
+    for (const r of results) {
+      if (r.error) {
+        console.log(`skip  ${r.name}: ${r.error}`);
+        process.exitCode = 1;
+        continue;
+      }
+      const format = r.format ? ` (${r.format})` : "";
+      if (r.changed) console.log(`pull  ${r.name}: wrote schema${format} to ${path7.relative(process.cwd(), r.file)}`);
+      else console.log(`pull  ${r.name}: schema unchanged${format}`);
+      if (r.types?.changed) console.log(`      types: wrote ${r.types.interfaceName} to ${path7.relative(process.cwd(), r.types.file)}`);
+    }
+  })
+);
+async function confirmOnTerminal(preview) {
+  console.log(formatSchemaDiff(preview));
+  if (!process.stdin.isTTY) {
+    fail(`not a terminal: rerun with --yes to push the schema of '${preview.name}' without asking`);
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await rl.question(`replace the dashboard's schema of '${preview.name}' with the code's? [y/N] `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+withCommon(
+  schema.command("push <name>").description("send the manifest's 'schema' to the dashboard as the definition's props schema (needs BOTLR_PAT)").option("--force", "replace the schema even when the dashboard's is in the other format").option("-y, --yes", "push without asking").option("--no-types", "do not write <name>.props.ts afterwards")
+).action(
+  (name, opts) => run(async () => {
+    const config = await loadConfig(process.cwd(), overrides(opts));
+    const result = await pushSchema(config, {
+      name,
+      force: opts.force,
+      noTypes: opts.types === false,
+      confirm: opts.yes ? (preview) => {
+        console.log(formatSchemaDiff(preview));
+        return true;
+      } : confirmOnTerminal
+    });
+    if (!result.pushed) {
+      console.log(`nothing pushed`);
+      return;
+    }
+    const formats = result.previousFormat && result.format && result.previousFormat !== result.format ? ` (${result.previousFormat} -> ${result.format})` : result.format ? ` (${result.format})` : "";
+    if (result.changed) console.log(`pushed schema of ${result.name}${formats}`);
+    else console.log(`schema of ${result.name} already matches, nothing changed${formats}`);
+    if (result.types?.changed) console.log(`      types: wrote ${result.types.interfaceName} to ${path7.relative(process.cwd(), result.types.file)}`);
+  })
+);
 program.parseAsync(process.argv).catch((error) => fail(error.message));
 //# sourceMappingURL=cli.js.map