@407dev/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,4289 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import fs10 from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { parseArgs } from "util";
+
+// src/extract/check.ts
+import fs4 from "fs";
+import path4 from "path";
+
+// src/extract/collect.ts
+import ts5 from "typescript";
+
+// src/extract/collection-schema.ts
+import ts4 from "typescript";
+
+// src/extract/resolve.ts
+import fs2 from "fs";
+import path2 from "path";
+import ts2 from "typescript";
+
+// src/extract/field-registry.ts
+import { listFieldTypes, resolveTypeAlias } from "@407dev/field-types";
+function knownFieldMethodNames() {
+  const types = listFieldTypes();
+  const names = /* @__PURE__ */ new Set();
+  for (const def of types) {
+    names.add(def.id);
+    if (def.aliases) {
+      for (const alias of def.aliases) {
+        names.add(alias);
+      }
+    }
+  }
+  return names;
+}
+function normalizeFieldType(methodName) {
+  return resolveTypeAlias(methodName);
+}
+
+// src/extract/parse.ts
+import fs from "fs";
+import path from "path";
+import { convertToTSX } from "@astrojs/compiler";
+import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
+import ts from "typescript";
+async function parseFile(filePath, rootPath = process.cwd()) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const relativePath = path.relative(rootPath, filePath).replace(/\\/g, "/");
+  const isAstro = filePath.endsWith(".astro");
+  if (isAstro) {
+    const { code, map } = await convertToTSX(content, {
+      sourcemap: "both"
+    });
+    const traceMap = map ? new TraceMap(map) : void 0;
+    const sourceFile2 = ts.createSourceFile(
+      filePath,
+      code,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TSX
+    );
+    const getLocation2 = (node) => {
+      const pos = node.getStart(sourceFile2);
+      const { line, character } = sourceFile2.getLineAndCharacterOfPosition(pos);
+      if (traceMap) {
+        const orig = originalPositionFor(traceMap, {
+          line: line + 1,
+          column: character
+        });
+        if (orig && orig.line !== null && orig.column !== null) {
+          return {
+            file: relativePath,
+            line: orig.line,
+            column: orig.column + 1
+          };
+        }
+      }
+      return {
+        file: relativePath,
+        line: line + 1,
+        column: character + 1
+      };
+    };
+    return {
+      filePath,
+      relativePath,
+      isAstro: true,
+      sourceFile: sourceFile2,
+      traceMap,
+      getLocation: getLocation2
+    };
+  }
+  const isTsx = filePath.endsWith(".tsx") || filePath.endsWith(".jsx");
+  const scriptKind = isTsx ? ts.ScriptKind.TSX : filePath.endsWith(".ts") ? ts.ScriptKind.TS : ts.ScriptKind.JS;
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.Latest,
+    true,
+    scriptKind
+  );
+  const getLocation = (node) => {
+    const pos = node.getStart(sourceFile);
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
+    return {
+      file: relativePath,
+      line: line + 1,
+      column: character + 1
+    };
+  };
+  return {
+    filePath,
+    relativePath,
+    isAstro: false,
+    sourceFile,
+    getLocation
+  };
+}
+function globSourceFiles(dir) {
+  const files = [];
+  function walk(currentDir) {
+    if (!fs.existsSync(currentDir)) return;
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") {
+        continue;
+      }
+      const full = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (/\.(astro|ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith(".d.ts") && !entry.name.includes(".test.") && !entry.name.includes(".spec.")) {
+        files.push(full);
+      }
+    }
+  }
+  walk(dir);
+  return files.sort();
+}
+
+// src/extract/resolve.ts
+function parseBareSpecifier(specifier) {
+  if (specifier.startsWith("@")) {
+    const parts2 = specifier.split("/");
+    const packageName2 = parts2.slice(0, 2).join("/");
+    const subpathParts2 = parts2.slice(2);
+    const subpath2 = subpathParts2.length > 0 ? `./${subpathParts2.join("/")}` : ".";
+    return { packageName: packageName2, subpath: subpath2 };
+  }
+  const parts = specifier.split("/");
+  const packageName = parts[0];
+  const subpathParts = parts.slice(1);
+  const subpath = subpathParts.length > 0 ? `./${subpathParts.join("/")}` : ".";
+  return { packageName, subpath };
+}
+function findPackageRoot(fromFile, packageName) {
+  let currentDir = path2.dirname(path2.resolve(fromFile));
+  const root = path2.parse(currentDir).root;
+  while (true) {
+    const candidate = path2.join(currentDir, "node_modules", ...packageName.split("/"));
+    if (fs2.existsSync(candidate) && fs2.existsSync(path2.join(candidate, "package.json"))) {
+      return candidate;
+    }
+    if (currentDir === root) {
+      break;
+    }
+    currentDir = path2.dirname(currentDir);
+  }
+  return null;
+}
+function resolvePackageExport(pkgRoot, subpath) {
+  try {
+    const pkgJsonPath = path2.join(pkgRoot, "package.json");
+    if (!fs2.existsSync(pkgJsonPath)) {
+      return { resolvedPath: null, hasSource: false, exportFound: false };
+    }
+    const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+    if (pkgJson.exports) {
+      const exportsObj = pkgJson.exports;
+      let target = exportsObj[subpath];
+      let matchedSub = null;
+      if (!target && typeof exportsObj === "object" && exportsObj !== null) {
+        let bestPrefix = "";
+        let bestKey = null;
+        for (const key of Object.keys(exportsObj)) {
+          if (key.includes("*")) {
+            const starIdx = key.indexOf("*");
+            const prefix = key.slice(0, starIdx);
+            const suffix = key.slice(starIdx + 1);
+            if (subpath.startsWith(prefix) && subpath.endsWith(suffix) && subpath.length >= prefix.length + suffix.length) {
+              if (prefix.length >= bestPrefix.length) {
+                bestPrefix = prefix;
+                bestKey = key;
+              }
+            }
+          }
+        }
+        if (bestKey !== null) {
+          const starIdx = bestKey.indexOf("*");
+          const prefix = bestKey.slice(0, starIdx);
+          const suffix = bestKey.slice(starIdx + 1);
+          matchedSub = subpath.slice(prefix.length, subpath.length - suffix.length);
+          target = exportsObj[bestKey];
+        }
+      }
+      if (!target && subpath === ".") {
+        if (typeof exportsObj === "string" || exportsObj.source || exportsObj.import || exportsObj.default) {
+          target = exportsObj;
+        }
+      }
+      if (!target) {
+        return { resolvedPath: null, hasSource: false, exportFound: false };
+      }
+      const substitute = (val) => matchedSub !== null ? val.replaceAll("*", matchedSub) : val;
+      if (typeof target === "string") {
+        return {
+          resolvedPath: path2.resolve(pkgRoot, substitute(target)),
+          hasSource: true,
+          exportFound: true
+        };
+      }
+      if (typeof target === "object" && target !== null) {
+        if (typeof target.source === "string") {
+          return {
+            resolvedPath: path2.resolve(pkgRoot, substitute(target.source)),
+            hasSource: true,
+            exportFound: true
+          };
+        }
+        return { resolvedPath: null, hasSource: false, exportFound: true };
+      }
+    }
+    if (subpath === "." && typeof pkgJson.source === "string") {
+      return {
+        resolvedPath: path2.resolve(pkgRoot, pkgJson.source),
+        hasSource: true,
+        exportFound: true
+      };
+    }
+  } catch {
+  }
+  return { resolvedPath: null, hasSource: false, exportFound: false };
+}
+function resolveModulePath(fromFile, importSpecifier) {
+  if (importSpecifier.startsWith(".")) {
+    const dir = path2.dirname(fromFile);
+    const resolvedBase = path2.resolve(dir, importSpecifier);
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".astro", "/index.ts", "/index.js"];
+    for (const ext of extensions) {
+      const candidate = resolvedBase + ext;
+      if (fs2.existsSync(candidate) && fs2.statSync(candidate).isFile()) {
+        return candidate;
+      }
+    }
+    if (fs2.existsSync(resolvedBase) && fs2.statSync(resolvedBase).isFile()) {
+      return resolvedBase;
+    }
+    return null;
+  }
+  const { packageName, subpath } = parseBareSpecifier(importSpecifier);
+  const pkgRoot = findPackageRoot(fromFile, packageName);
+  if (!pkgRoot) {
+    return null;
+  }
+  const result = resolvePackageExport(pkgRoot, subpath);
+  if (result.hasSource && result.resolvedPath && fs2.existsSync(result.resolvedPath)) {
+    return result.resolvedPath;
+  }
+  return null;
+}
+function getStringLiteralValue(node) {
+  if (ts2.isStringLiteral(node) || ts2.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text;
+  }
+  return null;
+}
+function shapeValueMethodName(node) {
+  const target = ts2.isCallExpression(node) ? node.expression : node;
+  if (ts2.isPropertyAccessExpression(target)) {
+    return target.name.text;
+  }
+  return null;
+}
+function extractGroupFromCall(callExpr, fallbackName, sf, diagnostics = [], getLocation) {
+  const args = callExpr.arguments;
+  let groupName = fallbackName;
+  let shapeNode = null;
+  if (args.length === 1) {
+    shapeNode = args[0];
+  } else if (args.length >= 2) {
+    const literalName = getStringLiteralValue(args[0]);
+    if (literalName) {
+      groupName = literalName;
+    }
+    shapeNode = args[1];
+  }
+  if (shapeNode && ts2.isObjectLiteralExpression(shapeNode)) {
+    const known = knownFieldMethodNames();
+    const shape = {};
+    for (const prop of shapeNode.properties) {
+      if (ts2.isPropertyAssignment(prop)) {
+        const propName = prop.name.getText(sf);
+        const methodName = shapeValueMethodName(prop.initializer);
+        if (methodName && known.has(methodName)) {
+          shape[propName] = normalizeFieldType(methodName);
+        } else {
+          shape[propName] = "text";
+          if (getLocation) {
+            diagnostics.push({
+              type: "warning",
+              message: `Group '${fallbackName}' field '${propName}' does not reference a known field helper (got '${prop.initializer.getText(sf)}'); defaulting to 'text'`,
+              file: getLocation(prop).file,
+              line: getLocation(prop).line,
+              column: getLocation(prop).column
+            });
+          }
+        }
+      } else if (ts2.isShorthandPropertyAssignment(prop)) {
+        const propName = prop.name.getText(sf);
+        shape[propName] = "text";
+      }
+    }
+    return { groupName, shape };
+  }
+  return null;
+}
+async function checkIsGroupOrCollection(filePath, symbolName, rootPath, cachedParsedFiles, visited = /* @__PURE__ */ new Set()) {
+  const visitKey = `${filePath}::${symbolName}`;
+  if (visited.has(visitKey)) return false;
+  visited.add(visitKey);
+  let parsed = cachedParsedFiles.get(filePath);
+  if (!parsed) {
+    parsed = await parseFile(filePath, rootPath);
+    cachedParsedFiles.set(filePath, parsed);
+  }
+  for (const stmt of parsed.sourceFile.statements) {
+    if (ts2.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (decl.name.getText(parsed.sourceFile) === symbolName && decl.initializer) {
+          if (ts2.isCallExpression(decl.initializer)) {
+            const callText = decl.initializer.expression.getText(parsed.sourceFile);
+            if (callText === "f.group" || callText === "defineGroup" || callText.endsWith(".group") || callText === "defineCollection" || callText === "f.defineCollection") {
+              return true;
+            }
+          } else if (ts2.isArrowFunction(decl.initializer) || ts2.isFunctionExpression(decl.initializer)) {
+            let found = false;
+            ts2.forEachChild(decl.initializer.body, (child) => {
+              if (ts2.isCallExpression(child)) {
+                const t = child.expression.getText(parsed.sourceFile);
+                if (t === "defineCollection" || t === "f.defineCollection") found = true;
+              }
+            });
+            if (found) return true;
+          }
+        }
+      }
+    }
+    if (ts2.isFunctionDeclaration(stmt) && stmt.name?.text === symbolName) {
+      if (stmt.body) {
+        let found = false;
+        ts2.forEachChild(stmt.body, (child) => {
+          if (ts2.isCallExpression(child)) {
+            const t = child.expression.getText(parsed.sourceFile);
+            if (t === "defineCollection" || t === "f.defineCollection") found = true;
+          }
+        });
+        if (found) return true;
+      }
+    }
+    if (ts2.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
+      const specifier = getStringLiteralValue(stmt.moduleSpecifier);
+      if (specifier && stmt.exportClause && ts2.isNamedExports(stmt.exportClause)) {
+        for (const el of stmt.exportClause.elements) {
+          if (el.name.text === symbolName) {
+            const targetSymbol = el.propertyName ? el.propertyName.text : el.name.text;
+            const targetModulePath = resolveModulePath(parsed.filePath, specifier);
+            if (targetModulePath) {
+              const res = await checkIsGroupOrCollection(
+                targetModulePath,
+                targetSymbol,
+                rootPath,
+                cachedParsedFiles,
+                visited
+              );
+              if (res) return true;
+            }
+          }
+        }
+      }
+    }
+    if (ts2.isImportDeclaration(stmt) && stmt.moduleSpecifier) {
+      const specifier = getStringLiteralValue(stmt.moduleSpecifier);
+      if (specifier && stmt.importClause?.namedBindings) {
+        if (ts2.isNamedImports(stmt.importClause.namedBindings)) {
+          for (const el of stmt.importClause.namedBindings.elements) {
+            if (el.name.text === symbolName) {
+              const targetSymbol = el.propertyName ? el.propertyName.text : el.name.text;
+              const targetModulePath = resolveModulePath(parsed.filePath, specifier);
+              if (targetModulePath) {
+                const res = await checkIsGroupOrCollection(
+                  targetModulePath,
+                  targetSymbol,
+                  rootPath,
+                  cachedParsedFiles,
+                  visited
+                );
+                if (res) return true;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+async function resolveFileContext(parsed, rootPath = process.cwd(), cachedParsedFiles = /* @__PURE__ */ new Map()) {
+  const scopes = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  const groupInstances = /* @__PURE__ */ new Map();
+  const collections = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  const { sourceFile, getLocation } = parsed;
+  const importedSymbols = /* @__PURE__ */ new Map();
+  for (const statement of sourceFile.statements) {
+    if (ts2.isImportDeclaration(statement)) {
+      const moduleSpecifier = getStringLiteralValue(statement.moduleSpecifier);
+      if (moduleSpecifier && statement.importClause?.namedBindings) {
+        if (ts2.isNamedImports(statement.importClause.namedBindings)) {
+          for (const element of statement.importClause.namedBindings.elements) {
+            const importName = element.propertyName ? element.propertyName.text : element.name.text;
+            const localName = element.name.text;
+            importedSymbols.set(localName, {
+              importName,
+              moduleSpecifier,
+              node: statement
+            });
+          }
+        }
+      }
+    }
+  }
+  for (const statement of sourceFile.statements) {
+    if (ts2.isVariableStatement(statement)) {
+      const isExported = statement.modifiers?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
+      if (isExported) {
+        for (const decl of statement.declarationList.declarations) {
+          if (decl.initializer && ts2.isCallExpression(decl.initializer)) {
+            const calleeText = decl.initializer.expression.getText(sourceFile);
+            const importInfo = importedSymbols.get(calleeText);
+            if (importInfo && !importInfo.moduleSpecifier.startsWith(".")) {
+              const { packageName, subpath } = parseBareSpecifier(importInfo.moduleSpecifier);
+              const pkgRoot = findPackageRoot(parsed.filePath, packageName);
+              if (pkgRoot) {
+                const res = resolvePackageExport(pkgRoot, subpath);
+                if (res.exportFound && !res.hasSource) {
+                  diagnostics.push({
+                    type: "error",
+                    message: `Package '${packageName}' export '${subpath}' lacks a 'source' condition required for static extraction`,
+                    file: parsed.relativePath,
+                    line: getLocation(decl).line,
+                    column: getLocation(decl).column
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  function walk(node) {
+    if (ts2.isVariableDeclaration(node) && node.initializer) {
+      const varName = node.name.getText(sourceFile);
+      if (ts2.isCallExpression(node.initializer)) {
+        const callText = node.initializer.expression.getText(sourceFile);
+        if (callText === "f.scope" || callText.endsWith(".scope")) {
+          const firstArg = node.initializer.arguments[0];
+          if (!firstArg) {
+            diagnostics.push({
+              type: "error",
+              message: `Scope '${varName}' declared without a prefix`,
+              file: parsed.relativePath,
+              line: getLocation(node).line,
+              column: getLocation(node).column
+            });
+          } else {
+            const prefix = getStringLiteralValue(firstArg);
+            if (prefix === null) {
+              diagnostics.push({
+                type: "error",
+                message: `Scope prefix for '${varName}' must be a static string literal, got non-literal expression`,
+                file: parsed.relativePath,
+                line: getLocation(firstArg).line,
+                column: getLocation(firstArg).column
+              });
+            } else {
+              if (callText.endsWith(".scope") && callText !== "f.scope") {
+                const parentVar = callText.replace(/\.scope$/, "");
+                const parentScope = scopes.get(parentVar);
+                const fullPrefix = parentScope ? `${parentScope.prefix}.${prefix}` : prefix;
+                scopes.set(varName, {
+                  prefix: fullPrefix,
+                  location: getLocation(node)
+                });
+              } else {
+                scopes.set(varName, {
+                  prefix,
+                  location: getLocation(node)
+                });
+              }
+            }
+          }
+        }
+        if (callText === "f.group" || callText === "defineGroup" || callText.endsWith(".group")) {
+          const groupInfo = extractGroupFromCall(
+            node.initializer,
+            varName,
+            sourceFile,
+            diagnostics,
+            getLocation
+          );
+          if (groupInfo) {
+            groups.set(varName, {
+              groupName: groupInfo.groupName,
+              shape: groupInfo.shape,
+              definedLocation: getLocation(node),
+              hopCount: 0
+            });
+          }
+        }
+      }
+    }
+    ts2.forEachChild(node, walk);
+  }
+  walk(sourceFile);
+  for (const [localName, importInfo] of importedSymbols) {
+    const resolvedPath = resolveModulePath(parsed.filePath, importInfo.moduleSpecifier);
+    if (!resolvedPath) {
+      continue;
+    }
+    let targetParsed = cachedParsedFiles.get(resolvedPath);
+    if (!targetParsed) {
+      targetParsed = await parseFile(resolvedPath, rootPath);
+      cachedParsedFiles.set(resolvedPath, targetParsed);
+    }
+    for (const stmt of targetParsed.sourceFile.statements) {
+      if (ts2.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
+        const specifier = getStringLiteralValue(stmt.moduleSpecifier);
+        if (specifier && stmt.exportClause && ts2.isNamedExports(stmt.exportClause)) {
+          for (const el of stmt.exportClause.elements) {
+            if (el.name.text === importInfo.importName) {
+              const targetSymbol = el.propertyName ? el.propertyName.text : el.name.text;
+              const nextPath = resolveModulePath(targetParsed.filePath, specifier);
+              const isGroupOrColl = nextPath ? await checkIsGroupOrCollection(
+                nextPath,
+                targetSymbol,
+                rootPath,
+                cachedParsedFiles
+              ) : false;
+              if (isGroupOrColl) {
+                diagnostics.push({
+                  type: "error",
+                  message: `Group or collection '${importInfo.importName}' is imported across multiple hops (> 1 hop) via '${importInfo.moduleSpecifier}'. It must be defined in the directly imported module.`,
+                  file: parsed.relativePath,
+                  line: getLocation(importInfo.node).line,
+                  column: getLocation(importInfo.node).column
+                });
+              }
+            }
+          }
+        }
+      }
+      if (ts2.isImportDeclaration(stmt) && stmt.moduleSpecifier) {
+        const specifier = getStringLiteralValue(stmt.moduleSpecifier);
+        if (specifier && stmt.importClause?.namedBindings) {
+          if (ts2.isNamedImports(stmt.importClause.namedBindings)) {
+            for (const el of stmt.importClause.namedBindings.elements) {
+              if (el.name.text === importInfo.importName) {
+                const targetSymbol = el.propertyName ? el.propertyName.text : el.name.text;
+                const nextPath = resolveModulePath(targetParsed.filePath, specifier);
+                const isGroupOrColl = nextPath ? await checkIsGroupOrCollection(
+                  nextPath,
+                  targetSymbol,
+                  rootPath,
+                  cachedParsedFiles
+                ) : false;
+                if (isGroupOrColl) {
+                  diagnostics.push({
+                    type: "error",
+                    message: `Group or collection '${importInfo.importName}' is imported across multiple hops (> 1 hop) via '${importInfo.moduleSpecifier}'. It must be defined in the directly imported module.`,
+                    file: parsed.relativePath,
+                    line: getLocation(importInfo.node).line,
+                    column: getLocation(importInfo.node).column
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+      if (ts2.isVariableStatement(stmt)) {
+        for (const decl of stmt.declarationList.declarations) {
+          if (decl.name.getText(targetParsed.sourceFile) === importInfo.importName && decl.initializer) {
+            if (ts2.isCallExpression(decl.initializer)) {
+              const callText = decl.initializer.expression.getText(targetParsed.sourceFile);
+              if (callText === "f.group" || callText === "defineGroup" || callText.endsWith(".group")) {
+                const groupInfo = extractGroupFromCall(
+                  decl.initializer,
+                  importInfo.importName,
+                  targetParsed.sourceFile,
+                  diagnostics,
+                  targetParsed.getLocation
+                );
+                if (groupInfo) {
+                  groups.set(localName, {
+                    groupName: groupInfo.groupName,
+                    shape: groupInfo.shape,
+                    definedLocation: targetParsed.getLocation(decl),
+                    hopCount: 1
+                  });
+                }
+              } else if (callText === "defineCollection" || callText === "f.defineCollection") {
+                const coll = extractCollectionFromCall(
+                  decl.initializer,
+                  targetParsed.sourceFile,
+                  targetParsed.getLocation,
+                  diagnostics,
+                  targetParsed.relativePath
+                );
+                if (coll) {
+                  collections.set(localName, coll);
+                }
+              }
+            } else if (ts2.isArrowFunction(decl.initializer) || ts2.isFunctionExpression(decl.initializer)) {
+              const findCall = (n) => {
+                if (ts2.isCallExpression(n)) {
+                  const t = n.expression.getText(targetParsed.sourceFile);
+                  if (t === "defineCollection" || t === "f.defineCollection") return n;
+                }
+                let res = null;
+                ts2.forEachChild(n, (child) => {
+                  if (!res) res = findCall(child);
+                });
+                return res;
+              };
+              const call = findCall(decl.initializer.body);
+              if (call) {
+                const coll = extractCollectionFromCall(
+                  call,
+                  targetParsed.sourceFile,
+                  targetParsed.getLocation,
+                  diagnostics,
+                  targetParsed.relativePath
+                );
+                if (coll) {
+                  collections.set(localName, coll);
+                }
+              }
+            }
+          }
+        }
+      }
+      if (ts2.isFunctionDeclaration(stmt) && stmt.name?.text === importInfo.importName) {
+        const findCall = (n) => {
+          if (ts2.isCallExpression(n)) {
+            const t = n.expression.getText(targetParsed.sourceFile);
+            if (t === "defineCollection" || t === "f.defineCollection") return n;
+          }
+          let res = null;
+          ts2.forEachChild(n, (child) => {
+            if (!res) res = findCall(child);
+          });
+          return res;
+        };
+        if (stmt.body) {
+          const call = findCall(stmt.body);
+          if (call) {
+            const coll = extractCollectionFromCall(
+              call,
+              targetParsed.sourceFile,
+              targetParsed.getLocation,
+              diagnostics,
+              targetParsed.relativePath
+            );
+            if (coll) {
+              collections.set(localName, coll);
+            }
+          }
+        }
+      }
+    }
+  }
+  function walkInstances(node) {
+    if (ts2.isVariableDeclaration(node) && node.initializer) {
+      const varName = node.name.getText(sourceFile);
+      if (ts2.isCallExpression(node.initializer)) {
+        const calleeName = node.initializer.expression.getText(sourceFile);
+        const resolvedGroup = groups.get(calleeName);
+        if (resolvedGroup) {
+          const firstArg = node.initializer.arguments[0];
+          if (!firstArg) {
+            diagnostics.push({
+              type: "error",
+              message: `Group '${calleeName}' instantiated without a scope prefix`,
+              file: parsed.relativePath,
+              line: getLocation(node).line,
+              column: getLocation(node).column
+            });
+          } else {
+            const prefix = getStringLiteralValue(firstArg);
+            if (prefix === null) {
+              diagnostics.push({
+                type: "error",
+                message: `Group '${calleeName}' instantiated with dynamic non-literal scope`,
+                file: parsed.relativePath,
+                line: getLocation(firstArg).line,
+                column: getLocation(firstArg).column
+              });
+            } else {
+              groupInstances.set(varName, {
+                groupName: resolvedGroup.groupName,
+                prefix,
+                shape: resolvedGroup.shape,
+                location: getLocation(node)
+              });
+            }
+          }
+        }
+      }
+    }
+    ts2.forEachChild(node, walkInstances);
+  }
+  walkInstances(sourceFile);
+  return {
+    scopes,
+    groups,
+    groupInstances,
+    collections,
+    diagnostics
+  };
+}
+
+// src/extract/seed-eval.ts
+import ts3 from "typescript";
+function unwrapTypeAssertions(node) {
+  let current = node;
+  while (ts3.isAsExpression(current) || ts3.isTypeAssertionExpression(current) || (ts3.isSatisfiesExpression?.(current) ?? false) || ts3.isParenthesizedExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+}
+function evalStaticJson(rawNode) {
+  const node = unwrapTypeAssertions(rawNode);
+  if (ts3.isStringLiteral(node) || ts3.isNoSubstitutionTemplateLiteral(node)) {
+    return { ok: true, value: node.text };
+  }
+  if (ts3.isNumericLiteral(node)) {
+    return { ok: true, value: Number(node.text) };
+  }
+  if (node.kind === ts3.SyntaxKind.TrueKeyword) {
+    return { ok: true, value: true };
+  }
+  if (node.kind === ts3.SyntaxKind.FalseKeyword) {
+    return { ok: true, value: false };
+  }
+  if (node.kind === ts3.SyntaxKind.NullKeyword) {
+    return { ok: true, value: null };
+  }
+  if (ts3.isPrefixUnaryExpression(node)) {
+    const operand = unwrapTypeAssertions(node.operand);
+    if (node.operator === ts3.SyntaxKind.MinusToken && ts3.isNumericLiteral(operand)) {
+      return { ok: true, value: -Number(operand.text) };
+    }
+    if (node.operator === ts3.SyntaxKind.PlusToken && ts3.isNumericLiteral(operand)) {
+      return { ok: true, value: Number(operand.text) };
+    }
+    return { ok: false, errorNode: node };
+  }
+  if (ts3.isArrayLiteralExpression(node)) {
+    const arr = [];
+    for (const el of node.elements) {
+      if (ts3.isSpreadElement(el)) {
+        return { ok: false, errorNode: el };
+      }
+      const res = evalStaticJson(el);
+      if (!res.ok) return res;
+      arr.push(res.value);
+    }
+    return { ok: true, value: arr };
+  }
+  if (ts3.isObjectLiteralExpression(node)) {
+    const obj = {};
+    for (const prop of node.properties) {
+      if (!ts3.isPropertyAssignment(prop)) {
+        return { ok: false, errorNode: prop };
+      }
+      let propName;
+      if (ts3.isIdentifier(prop.name) || ts3.isStringLiteral(prop.name) || ts3.isNoSubstitutionTemplateLiteral(prop.name)) {
+        propName = prop.name.text;
+      } else if (ts3.isNumericLiteral(prop.name)) {
+        propName = prop.name.text;
+      } else {
+        return { ok: false, errorNode: prop.name };
+      }
+      const valRes = evalStaticJson(prop.initializer);
+      if (!valRes.ok) return valRes;
+      obj[propName] = valRes.value;
+    }
+    return { ok: true, value: obj };
+  }
+  return { ok: false, errorNode: node };
+}
+function extractCollectionSeed(rawSeedNode, sourceFile, getLocation, relativePath, diagnostics) {
+  const seedNode = unwrapTypeAssertions(rawSeedNode);
+  let targetArrayNode;
+  if (ts3.isIdentifier(seedNode)) {
+    let walk2 = function(node) {
+      if (found) return;
+      if (ts3.isVariableStatement(node)) {
+        const hasConst = Boolean(node.declarationList.flags & ts3.NodeFlags.Const);
+        for (const decl of node.declarationList.declarations) {
+          if (ts3.isIdentifier(decl.name) && decl.name.text === idName) {
+            found = true;
+            isConst = hasConst;
+            declInit = decl.initializer;
+            return;
+          }
+        }
+      }
+      ts3.forEachChild(node, walk2);
+    };
+    var walk = walk2;
+    const idName = seedNode.text;
+    let found = false;
+    let isConst = false;
+    let declInit;
+    walk2(sourceFile);
+    const unwrappedDeclInit = declInit ? unwrapTypeAssertions(declInit) : void 0;
+    if (!found || !isConst || !unwrappedDeclInit || !ts3.isArrayLiteralExpression(unwrappedDeclInit)) {
+      diagnostics.push({
+        type: "error",
+        message: "seed must be a literal",
+        file: relativePath,
+        line: getLocation(
+          declInit && !ts3.isArrayLiteralExpression(unwrappedDeclInit ?? declInit) ? declInit : seedNode
+        ).line,
+        column: getLocation(
+          declInit && !ts3.isArrayLiteralExpression(unwrappedDeclInit ?? declInit) ? declInit : seedNode
+        ).column
+      });
+      return void 0;
+    }
+    targetArrayNode = unwrappedDeclInit;
+  } else if (ts3.isArrayLiteralExpression(seedNode)) {
+    targetArrayNode = seedNode;
+  } else {
+    diagnostics.push({
+      type: "error",
+      message: "seed must be a literal",
+      file: relativePath,
+      line: getLocation(seedNode).line,
+      column: getLocation(seedNode).column
+    });
+    return void 0;
+  }
+  const evalResult = evalStaticJson(targetArrayNode);
+  if (!evalResult.ok || !Array.isArray(evalResult.value)) {
+    const errNode = evalResult.errorNode || targetArrayNode;
+    diagnostics.push({
+      type: "error",
+      message: "seed must be a literal",
+      file: relativePath,
+      line: getLocation(errNode).line,
+      column: getLocation(errNode).column
+    });
+    return void 0;
+  }
+  return evalResult.value;
+}
+
+// src/extract/collection-schema.ts
+function parseZodObjectSchema(schemaNode, sourceFile, bodyField) {
+  const properties = {};
+  const required = [];
+  function processPropAssignment(name, initNode) {
+    const initText = initNode.getText(sourceFile);
+    let propSchema = { type: "string" };
+    if (name === bodyField) {
+      propSchema = { type: "object", "x-cms-type": "richtext" };
+    } else if (initText.includes("number()")) {
+      propSchema = { type: "number" };
+    } else if (initText.includes("boolean()")) {
+      propSchema = { type: "boolean" };
+    } else if (initText.includes("array(")) {
+      propSchema = { type: "array", items: { type: "string" } };
+    } else if (initText.includes("richtext") || initText.includes("richText")) {
+      propSchema = { type: "object", "x-cms-type": "richtext" };
+    } else if (initText.includes("streamVideo(")) {
+      propSchema = { type: "object", "x-cms-type": "media.streamVideo" };
+    } else if (initText.includes("image(") || initText.includes("video(") || initText.includes("asset(")) {
+      propSchema = { type: "string", format: "cms-asset-ref" };
+    }
+    properties[name] = propSchema;
+    if (!initText.includes(".optional()")) {
+      required.push(name);
+    }
+  }
+  if (ts4.isCallExpression(schemaNode)) {
+    const callText = schemaNode.expression.getText(sourceFile);
+    if (callText === "z.object" && schemaNode.arguments[0]) {
+      const objArg = schemaNode.arguments[0];
+      if (ts4.isObjectLiteralExpression(objArg)) {
+        for (const prop of objArg.properties) {
+          if (ts4.isPropertyAssignment(prop)) {
+            processPropAssignment(prop.name.getText(sourceFile), prop.initializer);
+          }
+        }
+      }
+    }
+  }
+  return {
+    jsonSchema: {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      properties,
+      required,
+      additionalProperties: false
+    },
+    properties
+  };
+}
+function extractCollectionFromCall(callExpr, sf, getLocation, diagnostics = [], file = "") {
+  const arg0 = callExpr.arguments[0];
+  if (!arg0 || !ts4.isObjectLiteralExpression(arg0)) return null;
+  let collKey = "";
+  let route;
+  let presentation;
+  let titleField;
+  let bodyField;
+  let listColumns;
+  let orderable;
+  let group;
+  let schemaNode;
+  let seed;
+  for (const prop of arg0.properties) {
+    if (ts4.isPropertyAssignment(prop)) {
+      const pName = prop.name.getText(sf);
+      if (pName === "key") {
+        collKey = getStringLiteralValue(prop.initializer) || "";
+      } else if (pName === "route") {
+        route = getStringLiteralValue(prop.initializer) || void 0;
+      } else if (pName === "presentation") {
+        const val = getStringLiteralValue(prop.initializer);
+        if (val === "visual" || val === "form") presentation = val;
+      } else if (pName === "titleField") {
+        titleField = getStringLiteralValue(prop.initializer) || void 0;
+      } else if (pName === "bodyField") {
+        bodyField = getStringLiteralValue(prop.initializer) || void 0;
+      } else if (pName === "group") {
+        group = getStringLiteralValue(prop.initializer) || void 0;
+      } else if (pName === "orderable") {
+        orderable = prop.initializer.kind === ts4.SyntaxKind.TrueKeyword;
+      } else if (pName === "schema") {
+        schemaNode = prop.initializer;
+      } else if (pName === "seed") {
+        seed = extractCollectionSeed(prop.initializer, sf, getLocation, file, diagnostics);
+      } else if (pName === "listColumns") {
+        if (ts4.isArrayLiteralExpression(prop.initializer)) {
+          listColumns = prop.initializer.elements.map((el) => getStringLiteralValue(el)).filter((s) => s !== null);
+        }
+      }
+    }
+  }
+  if (!collKey) {
+    diagnostics.push({
+      type: "error",
+      message: "Collection defined without a static string key",
+      file,
+      line: getLocation(callExpr).line,
+      column: getLocation(callExpr).column
+    });
+    return null;
+  }
+  const { jsonSchema } = schemaNode ? parseZodObjectSchema(schemaNode, sf, bodyField) : { jsonSchema: { type: "object", properties: {} } };
+  return {
+    key: collKey,
+    jsonSchema,
+    schemaVersion: 1,
+    orderable,
+    routePattern: route,
+    presentation,
+    titleField,
+    listColumns,
+    bodyField,
+    group,
+    seed,
+    location: getLocation(callExpr)
+  };
+}
+
+// src/extract/collect.ts
+function collectFromFile(parsed, context) {
+  const knownFieldTypes = knownFieldMethodNames();
+  const { sourceFile, getLocation, relativePath } = parsed;
+  const fields = [];
+  const collectionsMap = /* @__PURE__ */ new Map();
+  for (const coll of context.collections.values()) {
+    collectionsMap.set(coll.key, coll);
+  }
+  const diagnostics = [...context.diagnostics];
+  function extractOptions(node) {
+    if (!node || !ts5.isObjectLiteralExpression(node)) return {};
+    const result = {};
+    for (const prop of node.properties) {
+      if (ts5.isPropertyAssignment(prop)) {
+        const propName = prop.name.getText(sourceFile);
+        if (propName === "defaultValue") {
+          const strVal = getStringLiteralValue(prop.initializer);
+          if (strVal !== null) {
+            result.defaultValue = strVal;
+          } else if (ts5.isNumericLiteral(prop.initializer)) {
+            result.defaultValue = Number(prop.initializer.text);
+          } else if (prop.initializer.kind === ts5.SyntaxKind.TrueKeyword || prop.initializer.kind === ts5.SyntaxKind.FalseKeyword) {
+            result.defaultValue = prop.initializer.kind === ts5.SyntaxKind.TrueKeyword;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  for (const [varName, instance] of context.groupInstances) {
+    for (const [shapeKey, shapeType] of Object.entries(instance.shape)) {
+      const fullKey = `${instance.prefix}.${shapeKey}`;
+      fields.push({
+        key: fullKey,
+        type: normalizeFieldType(shapeType),
+        group: instance.groupName,
+        location: instance.location
+      });
+    }
+  }
+  function checkKeyArgument(keyNode, calleeText) {
+    if (!keyNode) {
+      diagnostics.push({
+        type: "error",
+        message: `Field helper '${calleeText}' called without a key`,
+        file: relativePath,
+        line: getLocation(keyNode || sourceFile).line,
+        column: getLocation(keyNode || sourceFile).column
+      });
+      return null;
+    }
+    const literalVal = getStringLiteralValue(keyNode);
+    if (literalVal === null) {
+      diagnostics.push({
+        type: "error",
+        message: `Field key in '${calleeText}' must be a static string literal, got non-literal expression`,
+        file: relativePath,
+        line: getLocation(keyNode).line,
+        column: getLocation(keyNode).column
+      });
+      return null;
+    }
+    return literalVal;
+  }
+  function walk(node) {
+    if (ts5.isCallExpression(node)) {
+      const expr = node.expression;
+      const exprText = expr.getText(sourceFile);
+      if (exprText === "defineCollection" || exprText === "f.defineCollection") {
+        const arg0 = node.arguments[0];
+        if (arg0 && ts5.isObjectLiteralExpression(arg0)) {
+          let collKey = "";
+          let route;
+          let presentation;
+          let titleField;
+          let bodyField;
+          let listColumns;
+          let orderable;
+          let group;
+          let schemaNode;
+          let seed;
+          for (const prop of arg0.properties) {
+            if (ts5.isPropertyAssignment(prop)) {
+              const pName = prop.name.getText(sourceFile);
+              if (pName === "key") {
+                collKey = getStringLiteralValue(prop.initializer) || "";
+              } else if (pName === "route") {
+                route = getStringLiteralValue(prop.initializer) || void 0;
+              } else if (pName === "presentation") {
+                const val = getStringLiteralValue(prop.initializer);
+                if (val === "visual" || val === "form") presentation = val;
+              } else if (pName === "titleField") {
+                titleField = getStringLiteralValue(prop.initializer) || void 0;
+              } else if (pName === "bodyField") {
+                bodyField = getStringLiteralValue(prop.initializer) || void 0;
+              } else if (pName === "group") {
+                group = getStringLiteralValue(prop.initializer) || void 0;
+              } else if (pName === "orderable") {
+                orderable = prop.initializer.kind === ts5.SyntaxKind.TrueKeyword;
+              } else if (pName === "schema") {
+                schemaNode = prop.initializer;
+              } else if (pName === "seed") {
+                seed = extractCollectionSeed(
+                  prop.initializer,
+                  sourceFile,
+                  getLocation,
+                  relativePath,
+                  diagnostics
+                );
+              } else if (pName === "listColumns") {
+                if (ts5.isArrayLiteralExpression(prop.initializer)) {
+                  listColumns = prop.initializer.elements.map((el) => getStringLiteralValue(el)).filter((s) => s !== null);
+                }
+              }
+            }
+          }
+          if (!collKey) {
+            diagnostics.push({
+              type: "error",
+              message: "Collection defined without a static string key",
+              file: relativePath,
+              line: getLocation(node).line,
+              column: getLocation(node).column
+            });
+          } else {
+            const { jsonSchema } = schemaNode ? parseZodObjectSchema(schemaNode, sourceFile, bodyField) : { jsonSchema: { type: "object", properties: {} } };
+            collectionsMap.set(collKey, {
+              key: collKey,
+              jsonSchema,
+              schemaVersion: 1,
+              orderable,
+              routePattern: route,
+              presentation,
+              titleField,
+              listColumns,
+              bodyField,
+              group,
+              seed,
+              location: getLocation(node)
+            });
+          }
+        }
+      }
+      if (ts5.isPropertyAccessExpression(expr)) {
+        const objText = expr.expression.getText(sourceFile);
+        const methodName = expr.name.getText(sourceFile);
+        let fieldType;
+        let prefix = "";
+        let groupName;
+        if (objText === "f") {
+          if (knownFieldTypes.has(methodName)) {
+            fieldType = methodName;
+          }
+        } else if (context.scopes.has(objText)) {
+          if (knownFieldTypes.has(methodName)) {
+            fieldType = methodName;
+            prefix = context.scopes.get(objText)?.prefix || "";
+          }
+        } else if (context.groupInstances.has(objText)) {
+          const inst = context.groupInstances.get(objText);
+          if (inst?.shape[methodName]) {
+            fieldType = inst.shape[methodName];
+            prefix = inst.prefix;
+            groupName = inst.groupName;
+          }
+        }
+        if (fieldType) {
+          const keyArg = node.arguments[0];
+          let key = null;
+          if (groupName && !keyArg) {
+            key = methodName;
+          } else {
+            key = checkKeyArgument(keyArg, exprText);
+          }
+          if (key !== null) {
+            const fullKey = prefix ? `${prefix}.${key}` : key;
+            const normType = normalizeFieldType(fieldType);
+            const opts = extractOptions(node.arguments[1]);
+            fields.push({
+              key: fullKey,
+              type: normType,
+              defaultValue: opts.defaultValue,
+              constraints: opts.constraints,
+              group: groupName,
+              location: getLocation(node)
+            });
+          }
+        }
+      }
+    }
+    if (ts5.isJsxSelfClosingElement(node) || ts5.isJsxOpeningElement(node)) {
+      const tagText = node.tagName.getText(sourceFile);
+      const parts = tagText.split(".");
+      if (parts.length === 2) {
+        const [objName, memberName] = parts;
+        let fieldType;
+        let prefix = "";
+        let groupName;
+        if (objName === "f") {
+          if (knownFieldTypes.has(memberName)) {
+            fieldType = memberName;
+          }
+        } else if (context.scopes.has(objName)) {
+          if (knownFieldTypes.has(memberName)) {
+            fieldType = memberName;
+            prefix = context.scopes.get(objName)?.prefix || "";
+          }
+        } else if (context.groupInstances.has(objName)) {
+          const inst = context.groupInstances.get(objName);
+          if (inst?.shape[memberName]) {
+            fieldType = inst.shape[memberName];
+            prefix = inst.prefix;
+            groupName = inst.groupName;
+          }
+        }
+        if (fieldType) {
+          let keyAttrVal = null;
+          let defaultValue;
+          for (const attr of node.attributes.properties) {
+            if (ts5.isJsxAttribute(attr)) {
+              const aName = attr.name.getText(sourceFile);
+              if (aName === "k" || aName === "key") {
+                if (attr.initializer) {
+                  if (ts5.isStringLiteral(attr.initializer)) {
+                    keyAttrVal = attr.initializer.text;
+                  } else if (ts5.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+                    keyAttrVal = getStringLiteralValue(attr.initializer.expression);
+                    if (keyAttrVal === null) {
+                      diagnostics.push({
+                        type: "error",
+                        message: `JSX attribute '${aName}' on '<${tagText}>' must be a static string literal`,
+                        file: relativePath,
+                        line: getLocation(attr.initializer).line,
+                        column: getLocation(attr.initializer).column
+                      });
+                    }
+                  }
+                }
+              } else if (aName === "defaultValue" && attr.initializer) {
+                if (ts5.isStringLiteral(attr.initializer)) {
+                  defaultValue = attr.initializer.text;
+                }
+              }
+            }
+          }
+          if (groupName && !keyAttrVal) {
+            keyAttrVal = memberName;
+          }
+          if (keyAttrVal !== null) {
+            const fullKey = prefix ? `${prefix}.${keyAttrVal}` : keyAttrVal;
+            const normType = normalizeFieldType(fieldType);
+            fields.push({
+              key: fullKey,
+              type: normType,
+              defaultValue,
+              group: groupName,
+              location: getLocation(node)
+            });
+          }
+        }
+      }
+    }
+    ts5.forEachChild(node, walk);
+  }
+  walk(sourceFile);
+  return {
+    file: relativePath,
+    fields,
+    collections: Array.from(collectionsMap.values()),
+    groups: Array.from(context.groups.values()).map((g) => ({
+      groupName: g.groupName,
+      shape: g.shape,
+      location: g.definedLocation
+    })),
+    scopes: Array.from(context.scopes.entries()).map(([varName, s]) => ({
+      varName,
+      prefix: s.prefix,
+      location: s.location
+    })),
+    diagnostics
+  };
+}
+
+// src/extract/manifest.ts
+import { validateContent } from "@407dev/blocks";
+function buildSiteManifest(merged, extraRoutes = []) {
+  const diagnostics = [...merged.diagnostics];
+  const fields = {};
+  const collections = {};
+  for (const [key, field] of Object.entries(merged.fields)) {
+    const uniqueFiles = Array.from(new Set(field.sources.map((s) => s.file))).sort();
+    const sourcePath = uniqueFiles.join(",");
+    const manifestField = {
+      type: field.type,
+      defaultValue: field.defaultValue,
+      constraints: field.constraints,
+      group: field.group,
+      sourcePath: sourcePath || void 0
+    };
+    fields[key] = manifestField;
+  }
+  for (const [key, coll] of Object.entries(merged.collections)) {
+    const schemaProps = coll.jsonSchema.properties || {};
+    if (coll.titleField && !(coll.titleField in schemaProps)) {
+      diagnostics.push({
+        type: "error",
+        message: `Collection '${key}' specifies titleField '${coll.titleField}' which does not exist in its schema properties`,
+        file: coll.location.file,
+        line: coll.location.line,
+        column: coll.location.column
+      });
+    }
+    if (coll.bodyField && !(coll.bodyField in schemaProps)) {
+      diagnostics.push({
+        type: "error",
+        message: `Collection '${key}' specifies bodyField '${coll.bodyField}' which does not exist in its schema properties`,
+        file: coll.location.file,
+        line: coll.location.line,
+        column: coll.location.column
+      });
+    }
+    if (coll.listColumns) {
+      for (const col of coll.listColumns) {
+        if (!(col in schemaProps)) {
+          diagnostics.push({
+            type: "error",
+            message: `Collection '${key}' specifies listColumn '${col}' which does not exist in its schema properties`,
+            file: coll.location.file,
+            line: coll.location.line,
+            column: coll.location.column
+          });
+        }
+      }
+    }
+    if (coll.seed) {
+      const seenSlugs = /* @__PURE__ */ new Set();
+      for (const item of coll.seed) {
+        if (!item || typeof item !== "object" || !item.slug || typeof item.slug !== "string") {
+          diagnostics.push({
+            type: "error",
+            message: `Collection '${key}' seed item must be an object with a 'slug' string`,
+            file: coll.location.file,
+            line: coll.location.line,
+            column: coll.location.column
+          });
+          continue;
+        }
+        if (seenSlugs.has(item.slug)) {
+          diagnostics.push({
+            type: "error",
+            message: `Collection '${key}' seed has duplicate slug '${item.slug}'`,
+            file: coll.location.file,
+            line: coll.location.line,
+            column: coll.location.column
+          });
+        }
+        seenSlugs.add(item.slug);
+        const valResult = validateContent(coll.jsonSchema, item.content || {});
+        if (!valResult.valid) {
+          for (const err of valResult.errors ?? []) {
+            diagnostics.push({
+              type: "error",
+              message: `Collection '${key}' seed item '${item.slug}' validation failed: ${err.message}`,
+              file: coll.location.file,
+              line: coll.location.line,
+              column: coll.location.column
+            });
+          }
+        }
+      }
+    }
+    collections[key] = {
+      jsonSchema: coll.jsonSchema,
+      schemaVersion: coll.schemaVersion || 1,
+      orderable: coll.orderable,
+      routePattern: coll.routePattern,
+      presentation: coll.presentation,
+      titleField: coll.titleField,
+      listColumns: coll.listColumns,
+      bodyField: coll.bodyField,
+      group: coll.group,
+      seed: coll.seed
+    };
+  }
+  const routes = [...extraRoutes];
+  for (const [key, coll] of Object.entries(merged.collections)) {
+    if (coll.routePattern) {
+      routes.push({
+        pathOrPattern: coll.routePattern,
+        kind: "collection",
+        collectionKey: key,
+        sourcePath: coll.location.file
+      });
+    }
+  }
+  const manifest = {
+    manifestVersion: 1,
+    fields,
+    collections: Object.keys(collections).length > 0 ? collections : void 0,
+    routes: routes.length > 0 ? routes : void 0
+  };
+  return { manifest, diagnostics };
+}
+
+// src/extract/merge.ts
+function areObjectsEqual(a, b) {
+  if (!a && !b) return true;
+  if (!a || !b) return false;
+  const keysA = Object.keys(a).sort();
+  const keysB = Object.keys(b).sort();
+  if (keysA.length !== keysB.length) return false;
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function mergeExtractionResults(fileResults) {
+  const mergedFields = {};
+  const collections = {};
+  const diagnostics = [];
+  for (const res of fileResults) {
+    diagnostics.push(...res.diagnostics);
+    for (const coll of res.collections) {
+      if (!collections[coll.key]) {
+        collections[coll.key] = coll;
+      }
+    }
+    for (const field of res.fields) {
+      const existing = mergedFields[field.key];
+      if (!existing) {
+        mergedFields[field.key] = {
+          type: field.type,
+          constraints: field.constraints,
+          defaultValue: field.defaultValue,
+          group: field.group,
+          sources: [field.location]
+        };
+      } else {
+        const typeConflict = existing.type !== field.type;
+        const defaultConflict = existing.defaultValue !== void 0 && field.defaultValue !== void 0 && existing.defaultValue !== field.defaultValue;
+        const constraintsConflict = !areObjectsEqual(existing.constraints, field.constraints);
+        if (typeConflict || defaultConflict || constraintsConflict) {
+          const allSources = [...existing.sources, field.location];
+          const locStr = allSources.map((s) => `${s.file}:${s.line}:${s.column}`).join(" vs ");
+          diagnostics.push({
+            type: "error",
+            message: `Conflicting field definition for key '${field.key}' (${locStr})`,
+            file: field.location.file,
+            line: field.location.line,
+            column: field.location.column
+          });
+        }
+        existing.sources.push(field.location);
+        if (!existing.group && field.group) {
+          existing.group = field.group;
+        }
+      }
+    }
+  }
+  return {
+    fields: mergedFields,
+    collections,
+    routes: [],
+    diagnostics
+  };
+}
+
+// src/extract/routes.ts
+import { execSync } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+function shouldSyncRoutes(siteDir, cmsRoutesFile) {
+  if (!fs3.existsSync(cmsRoutesFile)) {
+    return true;
+  }
+  const routesStat = fs3.statSync(cmsRoutesFile);
+  const srcDir = path3.join(siteDir, "src");
+  if (!fs3.existsSync(srcDir)) {
+    return false;
+  }
+  let newestMtime = 0;
+  function checkMtime(dir) {
+    const entries = fs3.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path3.join(dir, entry.name);
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        checkMtime(full);
+      } else if (entry.isFile()) {
+        const stat = fs3.statSync(full);
+        if (stat.mtimeMs > newestMtime) {
+          newestMtime = stat.mtimeMs;
+        }
+      }
+    }
+  }
+  checkMtime(srcDir);
+  return newestMtime > routesStat.mtimeMs;
+}
+function syncAstroRoutes(siteDir) {
+  try {
+    execSync("npx astro sync", {
+      cwd: siteDir,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deriveRouteFromComponent(componentPath) {
+  let route = componentPath.replace(/\\/g, "/").replace(/^.*src\/pages\/?/, "/").replace(/\.(astro|mdx|md|ts|js|jsx|tsx)$/, "").replace(/\/index$/, "");
+  if (!route.startsWith("/")) {
+    route = `/${route}`;
+  }
+  return route === "" ? "/" : route;
+}
+function scanPagesDirectory(siteDir) {
+  const pagesDir = path3.join(siteDir, "src", "pages");
+  if (!fs3.existsSync(pagesDir)) return [];
+  const found = [];
+  function walk(dir) {
+    const entries = fs3.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+          walk(fullPath);
+        }
+      } else if (entry.isFile()) {
+        const ext = path3.extname(entry.name).toLowerCase();
+        if ([".astro", ".md", ".mdx", ".html", ".ts", ".js", ".jsx", ".tsx"].includes(ext)) {
+          if (entry.name.startsWith("_")) continue;
+          const route = deriveRouteFromComponent(fullPath);
+          const params = [];
+          const matches = route.matchAll(/\[([^\]]+)\]/g);
+          for (const m of matches) {
+            params.push(m[1]);
+          }
+          found.push({
+            route,
+            component: fullPath,
+            type: "page",
+            params
+          });
+        }
+      }
+    }
+  }
+  walk(pagesDir);
+  return found;
+}
+function loadDerivedRoutes(siteDir, collections = {}, options = {}) {
+  const diagnostics = [];
+  const cmsRoutesFile = path3.join(siteDir, ".cms", "routes.json");
+  if (!options.noSync && shouldSyncRoutes(siteDir, cmsRoutesFile)) {
+    syncAstroRoutes(siteDir);
+  }
+  const staticRoutes = [];
+  const seenPatterns = /* @__PURE__ */ new Set();
+  let astroRoutes = [];
+  if (fs3.existsSync(cmsRoutesFile)) {
+    try {
+      const raw = fs3.readFileSync(cmsRoutesFile, "utf-8");
+      astroRoutes = JSON.parse(raw);
+    } catch {
+    }
+  }
+  const scannedRoutes = scanPagesDirectory(siteDir);
+  const combinedRoutes = [...astroRoutes, ...scannedRoutes];
+  const knownAstroPatterns = /* @__PURE__ */ new Set();
+  for (const r of combinedRoutes) {
+    if (r.type === "endpoint") continue;
+    let pattern = r.route || "";
+    if (!pattern && r.component) {
+      pattern = deriveRouteFromComponent(r.component);
+    }
+    if (!pattern || pattern === "/404" || pattern.startsWith("/_")) continue;
+    knownAstroPatterns.add(pattern);
+    if (!r.params || r.params.length === 0) {
+      if (!seenPatterns.has(pattern)) {
+        seenPatterns.add(pattern);
+        let relComponent;
+        if (r.component) {
+          const absComp = path3.isAbsolute(r.component) ? r.component : path3.resolve(siteDir, r.component);
+          relComponent = path3.relative(siteDir, absComp).replace(/\\/g, "/");
+        }
+        staticRoutes.push({
+          pathOrPattern: pattern,
+          kind: "static",
+          sourcePath: relComponent || void 0
+        });
+      }
+    }
+  }
+  for (const [key, coll] of Object.entries(collections)) {
+    if (coll.routePattern) {
+      const normalizedRoute = coll.routePattern.startsWith("/") ? coll.routePattern : `/${coll.routePattern}`;
+      if (knownAstroPatterns.size > 0 && !knownAstroPatterns.has(normalizedRoute)) {
+        diagnostics.push({
+          type: "error",
+          message: `Collection '${key}' specifies route '${coll.routePattern}' with no matching dynamic route found in Astro pages`,
+          file: coll.location.file,
+          line: coll.location.line,
+          column: coll.location.column
+        });
+      }
+    }
+  }
+  return { routes: staticRoutes, diagnostics };
+}
+
+// src/extract/check.ts
+async function extractProject(siteDir = process.cwd(), options = {}) {
+  const srcDir = path4.join(siteDir, "src");
+  const targetDir = fs4.existsSync(srcDir) ? srcDir : siteDir;
+  const files = globSourceFiles(targetDir);
+  const fileResults = [];
+  const cachedParsedFiles = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const parsed = await parseFile(file, siteDir);
+    cachedParsedFiles.set(file, parsed);
+    const context = await resolveFileContext(parsed, siteDir, cachedParsedFiles);
+    const collected = collectFromFile(parsed, context);
+    fileResults.push(collected);
+  }
+  const merged = mergeExtractionResults(fileResults);
+  const { routes, diagnostics: routeDiagnostics } = loadDerivedRoutes(siteDir, merged.collections, {
+    noSync: options.noSync
+  });
+  const { manifest, diagnostics } = buildSiteManifest(merged, routes);
+  diagnostics.push(...routeDiagnostics);
+  const errors = diagnostics.filter((d) => d.type === "error");
+  const warnings = diagnostics.filter((d) => d.type === "warning");
+  return {
+    manifest,
+    diagnostics,
+    errors,
+    warnings,
+    merged
+  };
+}
+function formatDiagnostics(diagnostics) {
+  if (diagnostics.length === 0) {
+    return "\u2728 All checks passed cleanly with 0 errors.";
+  }
+  const lines = [];
+  for (const d of diagnostics) {
+    const prefix = d.type === "error" ? "\u274C" : "\u26A0\uFE0F";
+    const loc = `${d.file}:${d.line}:${d.column}`;
+    lines.push(`${prefix} ${loc}: ${d.message}`);
+  }
+  const errors = diagnostics.filter((d) => d.type === "error").length;
+  const warnings = diagnostics.filter((d) => d.type === "warning").length;
+  lines.push(`
+Found ${errors} error(s) and ${warnings} warning(s).`);
+  return lines.join("\n");
+}
+
+// src/commands/check.ts
+async function executeCheck(options = {}) {
+  const result = await extractProject(options.siteDir, { noSync: options.noSync });
+  const report = formatDiagnostics(result.diagnostics);
+  return {
+    success: result.errors.length === 0,
+    errorsCount: result.errors.length,
+    warningsCount: result.warnings.length,
+    report
+  };
+}
+
+// src/commands/extract.ts
+async function executeExtract(options = {}) {
+  const result = await extractProject(options.siteDir, { noSync: options.noSync });
+  if (options.json) {
+    return JSON.stringify(result.manifest, null, 2);
+  }
+  const lines = [];
+  lines.push("\u{1F4E6} Extracted Site Manifest:");
+  lines.push(`  Fields: ${Object.keys(result.manifest.fields).length}`);
+  lines.push(`  Collections: ${Object.keys(result.manifest.collections || {}).length}`);
+  lines.push(`  Routes: ${(result.manifest.routes || []).length}`);
+  if (result.errors.length > 0) {
+    lines.push(`
+\u274C Found ${result.errors.length} error(s):`);
+    for (const e of result.errors) {
+      lines.push(`  - ${e.file}:${e.line}:${e.column}: ${e.message}`);
+    }
+  }
+  if (result.warnings.length > 0) {
+    lines.push(`
+\u26A0\uFE0F Found ${result.warnings.length} warning(s):`);
+    for (const w of result.warnings) {
+      lines.push(`  - ${w.file}:${w.line}:${w.column}: ${w.message}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/link.ts
+import fs7 from "fs";
+import path7 from "path";
+import readline from "readline/promises";
+
+// ../config/src/index.ts
+var DEFAULT_DEV_API_URL = "http://127.0.0.1:8787";
+var DEFAULT_DEV_CONTENT_URL = "http://127.0.0.1:8788";
+var DEFAULT_DEV_WEB_URL = "https://web.localhost";
+
+// ../events/dist/index.js
+var LIVE_EVENTS_WINDOW_MS = 5 * 6e4;
+var ROLLUP_QUERIES = [
+  "allTimeSummary",
+  "allTimeTimeseries",
+  "allTimeTopPages",
+  "allTimeReferrers",
+  "allTimeCountries",
+  "allTimeCustomEvents",
+  "allTimeVitalsPercentiles"
+];
+var DEEP_QUERIES = [
+  "funnel",
+  "funnelBreakdown",
+  "entryExitPaths",
+  "pathTransitions",
+  "retentionCohorts",
+  "longRangeTimeseries",
+  "longRangeTopPages",
+  "longRangeReferrers",
+  "longRangeCountries",
+  "longRangeCustomEvents",
+  "longRangeSummary",
+  "vitalsPercentiles",
+  "visitorList",
+  "visitorEvents",
+  ...ROLLUP_QUERIES
+];
+function generateLogEdges(min, max, count, decimals = 0) {
+  const edges = [];
+  const factor = (max / min) ** (1 / count);
+  let cur = min;
+  for (let i = 1; i <= count; i++) {
+    cur *= factor;
+    const factorDec = 10 ** decimals;
+    edges.push(Math.round(cur * factorDec) / factorDec);
+  }
+  return edges;
+}
+var VITALS_HISTOGRAM_EDGES = {
+  lcp: generateLogEdges(100, 1e4, 48, 1),
+  inp: generateLogEdges(10, 2e3, 48, 1),
+  cls: generateLogEdges(5e-3, 1, 48, 4),
+  fcp: generateLogEdges(100, 1e4, 48, 1),
+  ttfb: generateLogEdges(10, 5e3, 48, 1)
+};
+
+// ../api-client/src/index.ts
+function createApiClient(options) {
+  const getHeaders = () => {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (options.authToken) {
+      headers.Authorization = `Bearer ${options.authToken}`;
+    }
+    if (options.workspaceId) {
+      headers["x-workspace-id"] = options.workspaceId;
+    }
+    return headers;
+  };
+  const request = async (path10, init) => {
+    try {
+      const url = path10.startsWith("http") ? path10 : `${options.baseUrl}${path10.startsWith("/") ? "" : "/"}${path10}`;
+      const res = await fetch(url, {
+        ...init,
+        headers: {
+          ...getHeaders(),
+          ...init?.headers || {}
+        }
+      });
+      const json = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        return {
+          data: null,
+          ok: false,
+          error: json.error || res.statusText,
+          errors: json.errors
+        };
+      }
+      return {
+        data: json.data !== void 0 ? json.data : json,
+        ok: true
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { data: null, ok: false, error: message };
+    }
+  };
+  return {
+    baseUrl: options.baseUrl,
+    async get(path10) {
+      return request(path10, { method: "GET" });
+    },
+    async post(path10, body) {
+      return request(path10, {
+        method: "POST",
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+    },
+    async patch(path10, body) {
+      return request(path10, {
+        method: "PATCH",
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+    },
+    async put(path10, body) {
+      return request(path10, {
+        method: "PUT",
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+    },
+    async delete(path10, body) {
+      return request(path10, {
+        method: "DELETE",
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+    },
+    // Sites
+    async getSites(workspaceId) {
+      const ws = workspaceId || options.workspaceId;
+      const query = ws ? `?workspace_id=${ws}` : "";
+      return this.get(`/sites${query}`);
+    },
+    async getSite(id) {
+      return this.get(`/sites/${id}`);
+    },
+    async createSite(input) {
+      return this.post("/sites", input);
+    },
+    async updateSite(siteId, updates) {
+      return this.patch(`/sites/${siteId}`, updates);
+    },
+    async deleteSite(siteId) {
+      return this.delete(`/sites/${siteId}`);
+    },
+    async reprovisionPreviewHost(siteId) {
+      return this.post(`/sites/${siteId}/preview-host`);
+    },
+    async checkPagesProject(name, workspaceId) {
+      const ws = workspaceId || options.workspaceId || "";
+      const query = `?name=${encodeURIComponent(name)}&workspace_id=${encodeURIComponent(ws)}`;
+      return this.get(`/sites/pages-project-status${query}`);
+    },
+    // Change Requests & Comments
+    async getChangeRequests(siteId, status) {
+      const query = status ? `?status=${encodeURIComponent(status)}` : "";
+      return this.get(`/sites/${siteId}/change-requests${query}`);
+    },
+    async getOrCreateDraftChangeRequest(siteId, input) {
+      return this.post(`/sites/${siteId}/change-requests`, input || {});
+    },
+    async updateChangeRequest(id, input) {
+      return this.patch(`/change-requests/${id}`, input);
+    },
+    async sendChangeRequest(id) {
+      return this.post(`/change-requests/${id}/send`, {});
+    },
+    async getChangeRequestComments(changeRequestId) {
+      return this.get(`/change-requests/${changeRequestId}/comments`);
+    },
+    async createChangeRequestComment(changeRequestId, input) {
+      return this.post(`/change-requests/${changeRequestId}/comments`, input);
+    },
+    async updateChangeRequestComment(commentId, input) {
+      return this.patch(`/change-request-comments/${commentId}`, input);
+    },
+    async deleteChangeRequestComment(commentId) {
+      return this.delete(`/change-request-comments/${commentId}`);
+    },
+    async createCommentReply(commentId, body) {
+      return this.post(`/change-request-comments/${commentId}/replies`, {
+        body
+      });
+    },
+    async listChangeRequests(options2) {
+      const params = new URLSearchParams();
+      if (options2?.siteId) params.set("siteId", options2.siteId);
+      if (options2?.status) params.set("status", options2.status);
+      const query = params.toString() ? `?${params.toString()}` : "";
+      return this.get(`/change-requests${query}`);
+    },
+    // Notifications & Channels
+    async getNotifications(options2) {
+      const params = new URLSearchParams();
+      if (options2?.unread) params.set("unread", "1");
+      if (options2?.limit) params.set("limit", String(options2.limit));
+      const query = params.toString() ? `?${params.toString()}` : "";
+      return this.get(`/notifications${query}`);
+    },
+    async markNotificationsRead(input) {
+      return this.post("/notifications/read", input);
+    },
+    async getEmailPrefs() {
+      return this.get("/notifications/email-prefs");
+    },
+    async updateEmailPrefs(input) {
+      return this.patch("/notifications/email-prefs", input);
+    },
+    async listNotificationChannels(workspaceId) {
+      return this.get(`/workspaces/${workspaceId}/notification-channels`);
+    },
+    async createNotificationChannel(workspaceId, input) {
+      return this.post(
+        `/workspaces/${workspaceId}/notification-channels`,
+        input
+      );
+    },
+    async updateNotificationChannel(id, input) {
+      return this.patch(`/notification-channels/${id}`, input);
+    },
+    async deleteNotificationChannel(id) {
+      return this.delete(`/notification-channels/${id}`);
+    },
+    async testNotificationChannel(id) {
+      return this.post(
+        `/notification-channels/${id}/test`,
+        {}
+      );
+    },
+    // Manifest Push
+    async pushManifest(siteId, manifest, renames) {
+      return this.put(`/sites/${siteId}/manifest`, {
+        manifest,
+        renames
+      });
+    },
+    // Fields
+    async getFields(siteId, opts) {
+      const query = opts?.include_orphaned ? "?include_orphaned=1" : "";
+      return this.get(`/sites/${siteId}/fields${query}`);
+    },
+    async setFieldValue(siteId, key, value, type) {
+      return this.patch(
+        `/sites/${siteId}/fields/${encodeURIComponent(key)}`,
+        { value, type }
+      );
+    },
+    async setFieldValues(siteId, values, types) {
+      return this.patch(`/sites/${siteId}/fields`, { values, types });
+    },
+    async deleteOrphanedFields(siteId, keys) {
+      return this.delete(`/sites/${siteId}/fields/orphaned`, { keys });
+    },
+    // Collections
+    async getCollections(siteId, opts) {
+      const query = opts?.include_orphaned ? "?include_orphaned=1" : "";
+      return this.get(`/sites/${siteId}/collections${query}`);
+    },
+    async getCollectionStats(siteId) {
+      return this.get(`/sites/${siteId}/collections/stats`);
+    },
+    // Stream videos (Cloudflare Stream) — distinct from `assets`, which is the R2 pipeline.
+    async createStreamDirectUpload(siteId, body) {
+      return this.post(
+        `/sites/${siteId}/stream/direct-upload`,
+        body ?? {}
+      );
+    },
+    async getStreamVideos(siteId) {
+      return this.get(`/sites/${siteId}/stream/videos`);
+    },
+    async getStreamVideo(siteId, uid) {
+      return this.get(`/sites/${siteId}/stream/videos/${uid}`);
+    },
+    async updateStreamVideo(siteId, uid, updates) {
+      return this.patch(`/sites/${siteId}/stream/videos/${uid}`, updates);
+    },
+    async getStreamVideoUsage(siteId, uid) {
+      return this.get(`/sites/${siteId}/stream/videos/${uid}/usage`);
+    },
+    async deleteStreamVideo(siteId, uid) {
+      return this.delete(`/sites/${siteId}/stream/videos/${uid}`);
+    },
+    async listDeployTokens(siteId) {
+      return this.get(`/sites/${siteId}/deploy-tokens`);
+    },
+    async createDeployToken(siteId, name) {
+      return this.post(`/sites/${siteId}/deploy-tokens`, { name });
+    },
+    async revokeDeployToken(siteId, tokenId) {
+      return this.delete(`/sites/${siteId}/deploy-tokens/${tokenId}`);
+    },
+    async createCliSession() {
+      return this.post("/cli/sessions");
+    },
+    async listEntries(siteId, collectionKey, opts) {
+      const query = opts?.status ? `?status=${opts.status}` : "";
+      return this.get(
+        `/sites/${siteId}/collections/${encodeURIComponent(collectionKey)}/entries${query}`
+      );
+    },
+    async createEntry(siteId, collectionKey, input) {
+      return this.post(
+        `/sites/${siteId}/collections/${encodeURIComponent(collectionKey)}/entries`,
+        input
+      );
+    },
+    async getEntry(id) {
+      return this.get(`/entries/${id}`);
+    },
+    async updateEntry(id, input) {
+      return this.patch(`/entries/${id}`, input);
+    },
+    async setEntryStatus(id, status, scheduled_at) {
+      return this.patch(`/entries/${id}`, { status, scheduled_at });
+    },
+    async reorderEntry(id, input) {
+      return this.post(`/entries/${id}/reorder`, input);
+    },
+    async deleteEntry(id) {
+      return this.delete(`/entries/${id}`);
+    },
+    // Routes (read-only list derived from manifest)
+    async getRoutes(siteId) {
+      return this.get(`/sites/${siteId}/routes`);
+    },
+    // Site Status & Publishing
+    async getSiteStatus(siteId) {
+      return this.get(`/sites/${siteId}/status`);
+    },
+    async publishSite(siteId) {
+      return this.post(`/sites/${siteId}/publish`);
+    },
+    async getSiteVersions(siteId, limit = 50) {
+      return this.get(`/sites/${siteId}/versions?limit=${limit}`);
+    },
+    async diffSiteVersion(siteId, versionId, scope) {
+      return this.post(
+        `/sites/${siteId}/versions/${versionId}/diff`,
+        scope || {}
+      );
+    },
+    async restoreSiteVersion(siteId, versionId, scope) {
+      return this.post(
+        `/sites/${siteId}/versions/${versionId}/restore`,
+        scope || {}
+      );
+    },
+    // Assets
+    async getAssets(siteId) {
+      return this.get(`/assets?site_id=${siteId}`);
+    },
+    async getAsset(id) {
+      return this.get(`/assets/${id}`);
+    },
+    async createAsset(input) {
+      const workspace_id = input.workspace_id || options.workspaceId;
+      return this.post("/assets", { ...input, workspace_id });
+    },
+    async uploadAsset(siteId, file, filename, opts) {
+      const baseUrl = options.baseUrl.replace(/\/+$/, "");
+      const query = new URLSearchParams({
+        site_id: siteId,
+        filename
+      });
+      if (opts?.width) query.set("width", String(opts.width));
+      if (opts?.height) query.set("height", String(opts.height));
+      const headers = {
+        "Content-Type": opts?.contentType || file.type || "application/octet-stream"
+      };
+      if (options.authToken) {
+        headers.Authorization = `Bearer ${options.authToken}`;
+      }
+      if (options.workspaceId) {
+        headers["x-workspace-id"] = options.workspaceId;
+      }
+      try {
+        const res = await fetch(`${baseUrl}/assets/upload?${query.toString()}`, {
+          method: "POST",
+          headers,
+          body: file
+        });
+        const json = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          return {
+            data: null,
+            ok: false,
+            error: json.error || `HTTP ${res.status}: ${res.statusText}`
+          };
+        }
+        return json;
+      } catch (err) {
+        return {
+          data: null,
+          ok: false,
+          error: err instanceof Error ? err.message : "Network request failed"
+        };
+      }
+    },
+    async updateAsset(id, updates) {
+      return this.patch(`/assets/${id}`, updates);
+    },
+    async deleteAsset(id) {
+      return this.delete(`/assets/${id}`);
+    },
+    async getAssetUsage(id) {
+      return this.get(`/assets/${id}/usage`);
+    },
+    async startMultipartUpload(input) {
+      return this.post("/assets/multipart/start", input);
+    },
+    async uploadMultipartPart(params) {
+      const baseUrl = options.baseUrl.replace(/\/+$/, "");
+      const query = new URLSearchParams({
+        assetId: params.assetId,
+        uploadId: params.uploadId,
+        n: String(params.partNumber)
+      });
+      const headers = {
+        "Content-Type": "application/octet-stream"
+      };
+      if (options.authToken) {
+        headers.Authorization = `Bearer ${options.authToken}`;
+      }
+      if (options.workspaceId) {
+        headers["x-workspace-id"] = options.workspaceId;
+      }
+      try {
+        const res = await fetch(`${baseUrl}/assets/multipart/part?${query.toString()}`, {
+          method: "PUT",
+          headers,
+          body: params.data
+        });
+        const json = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          return {
+            data: null,
+            ok: false,
+            error: json.error || `HTTP ${res.status}: ${res.statusText}`
+          };
+        }
+        return json;
+      } catch (err) {
+        return {
+          data: null,
+          ok: false,
+          error: err instanceof Error ? err.message : "Network request failed"
+        };
+      }
+    },
+    async completeMultipartUpload(input) {
+      return this.post("/assets/multipart/complete", input);
+    },
+    async abortMultipartUpload(input) {
+      return this.post("/assets/multipart/abort", input);
+    },
+    async uploadAssetMultipart(siteId, file, opts) {
+      let assetId = opts?.resume?.assetId;
+      let uploadId = opts?.resume?.uploadId;
+      const partSize = 8 * 1024 * 1024;
+      const uploadedParts = [
+        ...opts?.resume?.parts || []
+      ];
+      if (!assetId || !uploadId) {
+        const startRes = await this.startMultipartUpload({
+          site_id: siteId,
+          filename: file.name,
+          mime: file.type || "application/octet-stream",
+          size: file.size,
+          preset_set: opts?.presetSet
+        });
+        if (!startRes.ok || !startRes.data) {
+          return {
+            data: null,
+            ok: false,
+            error: startRes.error || "Failed to start multipart upload"
+          };
+        }
+        assetId = startRes.data.assetId;
+        uploadId = startRes.data.uploadId;
+      }
+      const totalParts = Math.ceil(file.size / partSize);
+      try {
+        for (let i = 0; i < totalParts; i++) {
+          const partNumber = i + 1;
+          if (uploadedParts.some((p) => p.partNumber === partNumber)) {
+            if (opts?.onProgress) {
+              opts.onProgress(Math.round((i + 1) / totalParts * 100));
+            }
+            continue;
+          }
+          const start = i * partSize;
+          const end = Math.min(start + partSize, file.size);
+          const chunk = file.slice(start, end);
+          let partSuccess = false;
+          let lastErr = "";
+          for (let attempt = 1; attempt <= 3; attempt++) {
+            const partRes = await this.uploadMultipartPart({
+              assetId,
+              uploadId,
+              partNumber,
+              data: chunk
+            });
+            if (partRes.ok && partRes.data?.etag) {
+              uploadedParts.push({ partNumber, etag: partRes.data.etag });
+              partSuccess = true;
+              break;
+            }
+            lastErr = partRes.error || "Part upload failed";
+            await new Promise((r) => setTimeout(r, attempt * 500));
+          }
+          if (!partSuccess) {
+            if (opts?.abortOnFailure) {
+              await this.abortMultipartUpload({ assetId, uploadId }).catch(() => {
+              });
+            }
+            return {
+              data: null,
+              ok: false,
+              error: `Failed to upload part ${partNumber}/${totalParts}: ${lastErr}`,
+              resumeState: { assetId, uploadId, parts: uploadedParts }
+            };
+          }
+          if (opts?.onProgress) {
+            opts.onProgress(Math.round((i + 1) / totalParts * 100));
+          }
+        }
+        return await this.completeMultipartUpload({
+          assetId,
+          uploadId,
+          parts: uploadedParts.sort((a, b) => a.partNumber - b.partNumber)
+        });
+      } catch (err) {
+        if (opts?.abortOnFailure) {
+          await this.abortMultipartUpload({ assetId, uploadId }).catch(() => {
+          });
+        }
+        return {
+          data: null,
+          ok: false,
+          error: err instanceof Error ? err.message : "Multipart upload failed",
+          resumeState: { assetId, uploadId, parts: uploadedParts }
+        };
+      }
+    },
+    // Redirects
+    async getRedirects(siteId) {
+      return this.get(`/redirects?site_id=${siteId}`);
+    },
+    async getRedirect(id) {
+      return this.get(`/redirects/${id}`);
+    },
+    async createRedirect(input) {
+      const workspace_id = input.workspace_id || options.workspaceId;
+      return this.post("/redirects", { ...input, workspace_id });
+    },
+    async updateRedirect(id, updates) {
+      return this.patch(`/redirects/${id}`, updates);
+    },
+    async deleteRedirect(id) {
+      return this.delete(`/redirects/${id}`);
+    },
+    async reorderRedirect(id, prevOrderKey, nextOrderKey) {
+      return this.post(`/redirects/${id}/reorder`, {
+        prev_order_key: prevOrderKey,
+        next_order_key: nextOrderKey
+      });
+    },
+    // Site Settings
+    async getSiteSettings(siteId) {
+      return this.get(`/sites/${siteId}/settings`);
+    },
+    async updateSiteSettings(siteId, settings) {
+      return this.put(`/sites/${siteId}/settings`, settings);
+    },
+    // Preview Tokens
+    async createPreviewToken(siteId) {
+      return this.post(`/sites/${siteId}/preview-token`);
+    },
+    // Builds
+    async retryBuild(buildId) {
+      return this.post(`/builds/${buildId}/retry`);
+    },
+    // Auth
+    async getAccountAuthMethod(email) {
+      return this.post("/auth/account-type", { email });
+    },
+    // Portal: Orgs
+    async getOrgs(workspaceId) {
+      const ws = workspaceId || options.workspaceId;
+      const query = ws ? `?workspace_id=${ws}` : "";
+      return this.get(`/orgs${query}`);
+    },
+    async getOrg(id) {
+      return this.get(`/orgs/${id}`);
+    },
+    async createOrg(input) {
+      const workspace_id = input.workspace_id || options.workspaceId;
+      return this.post("/orgs", { ...input, workspace_id });
+    },
+    async updateOrg(id, updates) {
+      return this.patch(`/orgs/${id}`, updates);
+    },
+    async deleteOrg(id) {
+      return this.delete(`/orgs/${id}`);
+    },
+    async inviteOrgMember(orgId, input) {
+      return this.post(`/orgs/${orgId}/members`, input);
+    },
+    // Workspaces
+    async listWorkspaces() {
+      return this.get("/workspaces");
+    },
+    async listWorkspaceMembers(workspaceId) {
+      const ws = workspaceId || options.workspaceId;
+      return this.get(`/workspaces/${ws}/members`);
+    },
+    async inviteWorkspaceMember(workspaceId, input) {
+      return this.post(`/workspaces/${workspaceId}/members`, input);
+    },
+    async updateWorkspaceMemberRole(workspaceId, userId, role) {
+      return this.patch(`/workspaces/${workspaceId}/members/${userId}`, {
+        role
+      });
+    },
+    async removeWorkspaceMember(workspaceId, userId) {
+      return this.delete(`/workspaces/${workspaceId}/members/${userId}`);
+    },
+    // Portal: Projects
+    async getProjects(workspaceId) {
+      const ws = workspaceId || options.workspaceId;
+      const query = ws ? `?workspace_id=${ws}` : "";
+      return this.get(`/projects${query}`);
+    },
+    async getProject(id) {
+      return this.get(`/projects/${id}`);
+    },
+    async getOrgProjects(orgId) {
+      return this.get(`/orgs/${orgId}/projects`);
+    },
+    async createProject(orgId, input) {
+      return this.post(`/orgs/${orgId}/projects`, input);
+    },
+    async updateProject(id, updates) {
+      return this.patch(`/projects/${id}`, updates);
+    },
+    async deleteProject(id) {
+      return this.delete(`/projects/${id}`);
+    },
+    async advanceProjectStage(projectId, to) {
+      return this.post(
+        `/projects/${projectId}/advance-stage`,
+        { to }
+      );
+    },
+    // Portal: Deliverables
+    async getProjectDeliverables(projectId) {
+      return this.get(`/projects/${projectId}/deliverables`);
+    },
+    async getProjectDeliverableFolders(projectId) {
+      return this.get(`/projects/${projectId}/deliverable-folders`);
+    },
+    async createDeliverableFolder(projectId, payload) {
+      return this.post(
+        `/projects/${projectId}/deliverable-folders`,
+        payload
+      );
+    },
+    async updateDeliverableFolder(id, updates) {
+      return this.patch(`/deliverable-folders/${id}`, updates);
+    },
+    async deleteDeliverableFolder(id) {
+      return this.delete(`/deliverable-folders/${id}`);
+    },
+    async getOrgDeliverables(orgId) {
+      return this.get(`/orgs/${orgId}/deliverables`);
+    },
+    async uploadDeliverable(projectId, file, opts) {
+      const baseUrl = options.baseUrl.replace(/\/+$/, "");
+      const query = new URLSearchParams({
+        title: opts.title,
+        filename: opts.filename
+      });
+      if (opts.kind) query.set("kind", opts.kind);
+      if (opts.folderId) query.set("folder_id", opts.folderId);
+      const headers = {
+        "Content-Type": opts.contentType || file.type || "application/octet-stream"
+      };
+      if (options.authToken) {
+        headers.Authorization = `Bearer ${options.authToken}`;
+      }
+      if (options.workspaceId) {
+        headers["x-workspace-id"] = options.workspaceId;
+      }
+      try {
+        const res = await fetch(
+          `${baseUrl}/projects/${projectId}/deliverables/upload?${query.toString()}`,
+          {
+            method: "POST",
+            headers,
+            body: file
+          }
+        );
+        const json = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          return {
+            data: null,
+            ok: false,
+            error: json.error || `HTTP ${res.status}: ${res.statusText}`
+          };
+        }
+        return json;
+      } catch (err) {
+        return {
+          data: null,
+          ok: false,
+          error: err instanceof Error ? err.message : "Network request failed"
+        };
+      }
+    },
+    async updateDeliverable(id, updates) {
+      return this.patch(`/deliverables/${id}`, updates);
+    },
+    async deleteDeliverable(id) {
+      return this.delete(`/deliverables/${id}`);
+    },
+    async getDeliverableDownloadUrl(id, opts) {
+      return this.post(`/deliverables/${id}/download-url`, opts);
+    },
+    async getDeliverableShare(deliverableId) {
+      return this.get(`/deliverables/${deliverableId}/share`);
+    },
+    async createDeliverableShare(deliverableId, payload) {
+      return this.post(`/deliverables/${deliverableId}/share`, payload || {});
+    },
+    async revokeDeliverableShare(deliverableId) {
+      return this.delete(`/deliverables/${deliverableId}/share`);
+    },
+    async getPublicShare(token) {
+      return this.get(`/share/${token}`);
+    },
+    // Portal: Documents (Proposals & Contracts) & E-Signature
+    async getProjectDocuments(projectId) {
+      return this.get(`/projects/${projectId}/documents`);
+    },
+    async getDocument(documentId) {
+      return this.get(`/documents/${documentId}`);
+    },
+    async getDocumentEvents(documentId) {
+      return this.get(`/documents/${documentId}/events`);
+    },
+    async createDocument(projectId, file, opts) {
+      const baseUrl = options.baseUrl.replace(/\/+$/, "");
+      const query = new URLSearchParams({
+        title: opts.title,
+        type: opts.type || "proposal",
+        filename: opts.filename || "document.pdf"
+      });
+      const headers = {
+        "Content-Type": file.type || "application/pdf"
+      };
+      if (options.authToken) {
+        headers.Authorization = `Bearer ${options.authToken}`;
+      }
+      if (options.workspaceId) {
+        headers["x-workspace-id"] = options.workspaceId;
+      }
+      try {
+        const res = await fetch(`${baseUrl}/projects/${projectId}/documents?${query.toString()}`, {
+          method: "POST",
+          headers,
+          body: file
+        });
+        const json = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          return {
+            data: null,
+            ok: false,
+            error: json.error || `HTTP ${res.status}: ${res.statusText}`
+          };
+        }
+        return json;
+      } catch (err) {
+        return {
+          data: null,
+          ok: false,
+          error: err instanceof Error ? err.message : "Network request failed"
+        };
+      }
+    },
+    async approveDocument(documentId) {
+      return this.post(`/documents/${documentId}/approve`);
+    },
+    async uploadDocumentVersion(documentId, file, opts) {
+      const baseUrl = options.baseUrl.replace(/\/+$/, "");
+      const query = new URLSearchParams({
+        filename: opts?.filename || "document.pdf"
+      });
+      const headers = {
+        "Content-Type": file.type || "application/pdf"
+      };
+      if (options.authToken) {
+        headers.Authorization = `Bearer ${options.authToken}`;
+      }
+      if (options.workspaceId) {
+        headers["x-workspace-id"] = options.workspaceId;
+      }
+      try {
+        const res = await fetch(`${baseUrl}/documents/${documentId}/versions?${query.toString()}`, {
+          method: "POST",
+          headers,
+          body: file
+        });
+        const json = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          return {
+            data: null,
+            ok: false,
+            error: json.error || `HTTP ${res.status}: ${res.statusText}`
+          };
+        }
+        return json;
+      } catch (err) {
+        return {
+          data: null,
+          ok: false,
+          error: err instanceof Error ? err.message : "Network request failed"
+        };
+      }
+    },
+    async uploadDocumentThumbnail(versionId, blob) {
+      const baseUrl = options.baseUrl.replace(/\/+$/, "");
+      const headers = { "Content-Type": "image/png" };
+      if (options.authToken) {
+        headers.Authorization = `Bearer ${options.authToken}`;
+      }
+      if (options.workspaceId) {
+        headers["x-workspace-id"] = options.workspaceId;
+      }
+      try {
+        const res = await fetch(`${baseUrl}/document-versions/${versionId}/thumbnail`, {
+          method: "POST",
+          headers,
+          body: blob
+        });
+        const json = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          return {
+            data: null,
+            ok: false,
+            error: json.error || `HTTP ${res.status}: ${res.statusText}`
+          };
+        }
+        return json;
+      } catch (err) {
+        return {
+          data: null,
+          ok: false,
+          error: err instanceof Error ? err.message : "Network request failed"
+        };
+      }
+    },
+    async sendDocument(documentId, input) {
+      return this.post(`/documents/${documentId}/send`, input);
+    },
+    async voidDocument(documentId, reason) {
+      return this.post(`/documents/${documentId}/void`, { reason });
+    },
+    async getDocumentSigningLinks(documentId) {
+      return this.get(`/documents/${documentId}/signing-links`);
+    },
+    async syncDocumentStatus(documentId) {
+      return this.post(`/documents/${documentId}/sync-status`);
+    },
+    async getDocumentVersionViewUrl(versionId, kind = "original") {
+      return this.post(`/document-versions/${versionId}/view-url?kind=${kind}`);
+    },
+    async getDocumentSignedUrl(envelopeId, kind = "signed") {
+      return this.post(
+        `/document-envelopes/${envelopeId}/signed-url?kind=${kind}`
+      );
+    },
+    async getProjectDocumentRecipients(projectId) {
+      return this.get(`/projects/${projectId}/document-recipients`);
+    },
+    // Backwards-compatible aliases for proposals
+    async getProjectProposals(projectId) {
+      return this.getProjectDocuments(projectId);
+    },
+    async getProposal(proposalId) {
+      return this.getDocument(proposalId);
+    },
+    async getProposalEvents(proposalId) {
+      return this.getDocumentEvents(proposalId);
+    },
+    async createProposal(projectId, file, opts) {
+      return this.createDocument(projectId, file, { ...opts, type: "proposal" });
+    },
+    async uploadProposalVersion(proposalId, file, opts) {
+      return this.uploadDocumentVersion(proposalId, file, opts);
+    },
+    async sendProposal(proposalId, input) {
+      return this.sendDocument(proposalId, input);
+    },
+    async voidProposal(proposalId, reason) {
+      return this.voidDocument(proposalId, reason);
+    },
+    async getProposalSigningLinks(proposalId) {
+      return this.getDocumentSigningLinks(proposalId);
+    },
+    async getProposalVersionViewUrl(versionId, kind = "original") {
+      return this.getDocumentVersionViewUrl(versionId, kind);
+    },
+    async getProposalSignedUrl(envelopeId, kind = "signed") {
+      return this.getDocumentSignedUrl(envelopeId, kind);
+    },
+    async getProjectProposalRecipients(projectId) {
+      return this.getProjectDocumentRecipients(projectId);
+    },
+    // Site Services (form submissions inbox)
+    async getSiteSubmissions(siteId, opts) {
+      const params = new URLSearchParams();
+      if (opts?.status) params.set("status", opts.status);
+      if (opts?.cursor) params.set("cursor", opts.cursor);
+      if (opts?.limit) params.set("limit", String(opts.limit));
+      const query = params.toString();
+      return this.get(`/sites/${siteId}/submissions${query ? `?${query}` : ""}`);
+    },
+    async getSiteSubmission(siteId, submissionId) {
+      return this.get(`/sites/${siteId}/submissions/${submissionId}`);
+    },
+    async updateSiteSubmission(siteId, submissionId, updates) {
+      return this.patch(`/sites/${siteId}/submissions/${submissionId}`, updates);
+    },
+    async getSiteServicesHealth(siteId) {
+      return this.get(`/sites/${siteId}/services/health`);
+    },
+    // Site Insights / Analytics
+    async getSiteInsights(siteId, query, opts) {
+      const params = new URLSearchParams();
+      if (opts?.from !== void 0) params.set("from", String(opts.from));
+      if (opts?.to !== void 0) params.set("to", String(opts.to));
+      if (opts?.interval) params.set("interval", opts.interval);
+      if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+      if (opts?.tier) params.set("tier", opts.tier);
+      if (opts?.sessionization) params.set("sessionization", opts.sessionization);
+      if (opts?.dimension) params.set("dimension", opts.dimension);
+      if (opts?.filters && opts.filters.length > 0) {
+        params.set("filters", JSON.stringify(opts.filters));
+      }
+      const q = params.toString();
+      return this.get(`/sites/${siteId}/insights/${query}${q ? `?${q}` : ""}`);
+    },
+    async getSiteInsightsDeep(siteId, query, params) {
+      const sp = new URLSearchParams();
+      if (params) {
+        for (const [k, v] of Object.entries(params)) {
+          if (v !== void 0 && v !== null) {
+            if (typeof v === "object") {
+              sp.set(k, JSON.stringify(v));
+            } else {
+              sp.set(k, String(v));
+            }
+          }
+        }
+      }
+      const q = sp.toString();
+      return this.get(
+        `/sites/${siteId}/insights/deep/${query}${q ? `?${q}` : ""}`
+      );
+    },
+    async getSiteInsightsCoverage(siteId) {
+      return this.get(`/sites/${siteId}/insights/coverage`);
+    },
+    async getSiteContentPerformance(siteId, opts) {
+      const params = new URLSearchParams();
+      if (opts?.from !== void 0) params.set("from", String(opts.from));
+      if (opts?.to !== void 0) params.set("to", String(opts.to));
+      if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+      if (opts?.collection) params.set("collection", opts.collection);
+      const q = params.toString();
+      return this.get(
+        `/sites/${siteId}/insights/content${q ? `?${q}` : ""}`
+      );
+    },
+    async getSiteInsightsDrift(siteId) {
+      return this.get(`/sites/${siteId}/insights/drift`);
+    },
+    async getSiteVisitors(siteId, opts) {
+      const params = new URLSearchParams();
+      if (opts?.day) params.set("day", opts.day);
+      if (opts?.from !== void 0) params.set("from", String(opts.from));
+      if (opts?.to !== void 0) params.set("to", String(opts.to));
+      if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+      if (opts?.before !== void 0) params.set("before", String(opts.before));
+      if (opts?.filters && opts.filters.length > 0) {
+        params.set("filters", JSON.stringify(opts.filters));
+      }
+      const q = params.toString();
+      return this.get(
+        `/sites/${siteId}/insights/visitors${q ? `?${q}` : ""}`
+      );
+    },
+    async getSiteVisitorJourney(siteId, visitor, opts) {
+      const params = new URLSearchParams();
+      if (opts?.day) params.set("day", opts.day);
+      if (opts?.from !== void 0) params.set("from", String(opts.from));
+      if (opts?.to !== void 0) params.set("to", String(opts.to));
+      const q = params.toString();
+      return this.get(
+        `/sites/${siteId}/insights/visitors/${encodeURIComponent(visitor)}${q ? `?${q}` : ""}`
+      );
+    },
+    // Google Search Console
+    async getSearchConsoleConnection(siteId) {
+      return this.get(`/sites/${siteId}/search-console`);
+    },
+    async startSearchConsoleOAuth(siteId) {
+      return this.post(`/sites/${siteId}/search-console/oauth/start`, {});
+    },
+    async listSearchConsoleProperties(siteId) {
+      return this.get(
+        `/sites/${siteId}/search-console/properties`
+      );
+    },
+    async bindSearchConsoleProperty(siteId, payload) {
+      return this.post(
+        `/sites/${siteId}/search-console/property`,
+        payload
+      );
+    },
+    async syncSearchConsole(siteId) {
+      return this.post(
+        `/sites/${siteId}/search-console/sync`,
+        {}
+      );
+    },
+    async disconnectSearchConsole(siteId) {
+      return this.delete(`/sites/${siteId}/search-console`);
+    },
+    async getSearchConsoleQueries(siteId, opts) {
+      const params = new URLSearchParams();
+      if (opts?.from !== void 0) params.set("from", String(opts.from));
+      if (opts?.to !== void 0) params.set("to", String(opts.to));
+      if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+      const q = params.toString();
+      return this.get(
+        `/sites/${siteId}/search-console/queries${q ? `?${q}` : ""}`
+      );
+    },
+    async getSearchConsolePages(siteId, opts) {
+      const params = new URLSearchParams();
+      if (opts?.from !== void 0) params.set("from", String(opts.from));
+      if (opts?.to !== void 0) params.set("to", String(opts.to));
+      if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+      const q = params.toString();
+      return this.get(
+        `/sites/${siteId}/search-console/pages${q ? `?${q}` : ""}`
+      );
+    },
+    // Marketing & Campaigns
+    async listCampaignEntries(siteId) {
+      return this.get(`/sites/${siteId}/campaigns/entries`);
+    },
+    async getCampaignPreview(siteId, entryId) {
+      return this.get(
+        `/sites/${siteId}/campaigns/preview?entryId=${encodeURIComponent(entryId)}`
+      );
+    },
+    async createCampaignSend(siteId, entryId) {
+      return this.post(`/sites/${siteId}/campaigns/sends`, { entryId });
+    },
+    async dispatchCampaignSend(siteId, sendId) {
+      return this.post(`/sites/${siteId}/campaigns/sends/${sendId}/dispatch`);
+    },
+    async testSendCampaign(siteId, entryId, to) {
+      return this.post(`/sites/${siteId}/campaigns/test-send`, {
+        entryId,
+        to
+      });
+    },
+    async listCampaignSends(siteId, opts) {
+      const params = new URLSearchParams();
+      if (opts?.limit) params.set("limit", String(opts.limit));
+      if (opts?.cursor) params.set("cursor", opts.cursor);
+      const q = params.toString();
+      return this.get(
+        `/sites/${siteId}/campaigns/sends${q ? `?${q}` : ""}`
+      );
+    },
+    async getCampaignSend(siteId, sendId) {
+      return this.get(`/sites/${siteId}/campaigns/sends/${sendId}`);
+    },
+    async listSubscribers(siteId, opts) {
+      const params = new URLSearchParams();
+      if (opts?.status) params.set("status", opts.status);
+      if (opts?.limit) params.set("limit", String(opts.limit));
+      if (opts?.cursor) params.set("cursor", opts.cursor);
+      const q = params.toString();
+      return this.get(
+        `/sites/${siteId}/subscribers${q ? `?${q}` : ""}`
+      );
+    },
+    async getSubscriberStats(siteId) {
+      return this.get(`/sites/${siteId}/subscribers/stats`);
+    },
+    async getMarketingConfig(siteId) {
+      return this.get(`/sites/${siteId}/marketing/config`);
+    },
+    // SMS Marketing
+    async listSmsCampaignEntries(siteId) {
+      return this.get(`/sites/${siteId}/sms/entries`);
+    },
+    async getSmsPreview(siteId, entryId) {
+      return this.get(
+        `/sites/${siteId}/sms/preview?entryId=${encodeURIComponent(entryId)}`
+      );
+    },
+    async createSmsSend(siteId, entryId) {
+      return this.post(`/sites/${siteId}/sms/sends`, { entryId });
+    },
+    async dispatchSmsSend(siteId, sendId) {
+      return this.post(`/sites/${siteId}/sms/sends/${sendId}/dispatch`);
+    },
+    async testSendSms(siteId, entryId, to) {
+      return this.post(`/sites/${siteId}/sms/test-send`, {
+        entryId,
+        to
+      });
+    },
+    async listSmsSends(siteId, opts) {
+      const params = new URLSearchParams();
+      if (opts?.limit) params.set("limit", String(opts.limit));
+      if (opts?.cursor) params.set("cursor", opts.cursor);
+      const q = params.toString();
+      return this.get(
+        `/sites/${siteId}/sms/sends${q ? `?${q}` : ""}`
+      );
+    },
+    async getSmsSend(siteId, sendId) {
+      return this.get(`/sites/${siteId}/sms/sends/${sendId}`);
+    },
+    async listSmsSubscribers(siteId, opts) {
+      const params = new URLSearchParams();
+      if (opts?.status) params.set("status", opts.status);
+      if (opts?.limit) params.set("limit", String(opts.limit));
+      if (opts?.cursor) params.set("cursor", opts.cursor);
+      const q = params.toString();
+      return this.get(
+        `/sites/${siteId}/sms/subscribers${q ? `?${q}` : ""}`
+      );
+    },
+    async getSmsSubscriberStats(siteId) {
+      return this.get(`/sites/${siteId}/sms/subscribers/stats`);
+    },
+    async getSmsConfig(siteId) {
+      return this.get(`/sites/${siteId}/sms/config`);
+    },
+    async provisionSms(siteId) {
+      return this.post(
+        `/sites/${siteId}/sms/provision`
+      );
+    },
+    async setSmsMessagingServiceSid(siteId, sid) {
+      return this.put(
+        `/sites/${siteId}/sms/messaging-service-sid`,
+        { sid }
+      );
+    },
+    async listSiteMembers(siteId, opts) {
+      const params = new URLSearchParams();
+      if (opts?.limit) params.set("limit", String(opts.limit));
+      if (opts?.cursor) params.set("cursor", opts.cursor);
+      const q = params.toString();
+      return this.get(
+        `/sites/${siteId}/members${q ? `?${q}` : ""}`
+      );
+    },
+    async getSiteMemberStats(siteId) {
+      return this.get(`/sites/${siteId}/members/stats`);
+    },
+    async deleteSiteMember(siteId, memberId) {
+      return this.delete(`/sites/${siteId}/members/${memberId}`);
+    },
+    // Linear Mirror & Status Board
+    async getProjectBoard(projectId) {
+      return this.get(`/projects/${projectId}/board`);
+    },
+    async getProjectActivity(projectId, days = 30) {
+      return this.get(`/projects/${projectId}/activity?days=${days}`);
+    },
+    async getProjectLinearLink(projectId) {
+      return this.get(`/projects/${projectId}/linear-link`);
+    },
+    async setProjectLinearLink(projectId, linearProjectId) {
+      return this.put(`/projects/${projectId}/linear-link`, {
+        linear_project_id: linearProjectId
+      });
+    },
+    async deleteProjectLinearLink(projectId) {
+      return this.delete(`/projects/${projectId}/linear-link`);
+    },
+    async listLinearProjects() {
+      return this.get("/linear/projects");
+    },
+    async refreshLinearProjects() {
+      return this.post("/linear/projects/refresh");
+    },
+    async resyncProjectLinear(projectId) {
+      return this.post(`/projects/${projectId}/linear-resync`);
+    },
+    // Billing & Stripe Mirror
+    async getProjectBilling(projectId) {
+      return this.get(`/projects/${projectId}/billing`);
+    },
+    async getOrgBilling(orgId, projectId) {
+      const q = projectId ? `?project_id=${encodeURIComponent(projectId)}` : "";
+      return this.get(`/orgs/${orgId}/billing${q}`);
+    },
+    async getBillingOverview() {
+      return this.get("/billing/overview");
+    },
+    async getAgencyHome() {
+      return this.get("/home/agency");
+    },
+    async createBillingPortalSession(orgId) {
+      return this.post(`/orgs/${orgId}/billing/portal-session`);
+    },
+    async linkBillingAccount(orgId, stripeCustomerId) {
+      return this.put(`/orgs/${orgId}/billing/account`, {
+        stripe_customer_id: stripeCustomerId
+      });
+    },
+    async unlinkBillingAccount(orgId) {
+      return this.delete(`/orgs/${orgId}/billing/account`);
+    },
+    async getBillingCustomerDefaults(orgId) {
+      return this.get(`/orgs/${orgId}/billing/customer-defaults`);
+    },
+    async createBillingCustomer(orgId, input) {
+      return this.post(`/orgs/${orgId}/billing/customer`, {
+        name: input.name,
+        email: input.email,
+        description: input.description,
+        allow_duplicate: input.allowDuplicate
+      });
+    },
+    // Price Book, Monthly Close, and Usage
+    async getBillingUsage(orgId, period) {
+      const q = period ? `&period=${encodeURIComponent(period)}` : "";
+      return this.get(`/billing/usage?orgId=${encodeURIComponent(orgId)}${q}`);
+    },
+    async getPriceBook(orgId) {
+      const q = orgId ? `?orgId=${encodeURIComponent(orgId)}` : "";
+      return this.get(
+        `/billing/price-book${q}`
+      );
+    },
+    async updatePriceBook(entry) {
+      return this.put("/billing/price-book", entry);
+    },
+    async previewClose(orgId, period) {
+      return this.post("/billing/closes/preview", { orgId, period });
+    },
+    async commitClose(closeRunId) {
+      return this.post(`/billing/closes/${closeRunId}/commit`);
+    },
+    async getCloseRuns(params) {
+      const q = new URLSearchParams();
+      if (params?.org) q.set("org", params.org);
+      if (params?.period) q.set("period", params.period);
+      const queryStr = q.toString() ? `?${q.toString()}` : "";
+      return this.get(`/billing/closes${queryStr}`);
+    },
+    async getBillingWorklist() {
+      return this.get("/billing/worklist");
+    },
+    async getBillingMargin(period) {
+      const q = period ? `?period=${encodeURIComponent(period)}` : "";
+      return this.get(`/billing/margin${q}`);
+    },
+    // Global search across sites, projects, deliverables, documents, invoices, routes, collections, assets
+    async search(q, opts) {
+      const params = new URLSearchParams();
+      params.set("q", q);
+      if (opts?.siteId) params.set("site_id", opts.siteId);
+      if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+      return this.get(`/search?${params.toString()}`);
+    }
+  };
+}
+
+// src/credentials.ts
+import fs5 from "fs";
+import os from "os";
+import path5 from "path";
+import { createClient } from "@supabase/supabase-js";
+function normalizeApiUrl(url) {
+  return url.trim().replace(/\/+$/, "");
+}
+function getDefaultCredentialsPath() {
+  if (process.env.CMS_CREDENTIALS_PATH) {
+    return path5.resolve(process.env.CMS_CREDENTIALS_PATH);
+  }
+  return path5.join(os.homedir(), ".config", "407dev", "credentials.json");
+}
+function loadAllCredentials(customPath) {
+  const filePath = customPath || getDefaultCredentialsPath();
+  if (!fs5.existsSync(filePath)) {
+    return {};
+  }
+  try {
+    const raw = fs5.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function getStoredCredentials(apiUrl, customPath) {
+  const all = loadAllCredentials(customPath);
+  const normalized = normalizeApiUrl(apiUrl);
+  return all[normalized] || null;
+}
+function saveStoredCredentials(apiUrl, creds, customPath) {
+  const filePath = customPath || getDefaultCredentialsPath();
+  const dir = path5.dirname(filePath);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true, mode: 448 });
+  } else {
+    try {
+      fs5.chmodSync(dir, 448);
+    } catch {
+    }
+  }
+  const all = loadAllCredentials(customPath);
+  const normalized = normalizeApiUrl(apiUrl);
+  all[normalized] = creds;
+  fs5.writeFileSync(filePath, JSON.stringify(all, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+  try {
+    fs5.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function removeStoredCredentials(apiUrl, customPath) {
+  const filePath = customPath || getDefaultCredentialsPath();
+  if (!fs5.existsSync(filePath)) {
+    return false;
+  }
+  const all = loadAllCredentials(customPath);
+  const normalized = normalizeApiUrl(apiUrl);
+  if (!(normalized in all)) {
+    return false;
+  }
+  delete all[normalized];
+  fs5.writeFileSync(filePath, JSON.stringify(all, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+  try {
+    fs5.chmodSync(filePath, 384);
+  } catch {
+  }
+  return true;
+}
+async function refreshCredentialsIfNeeded(apiUrl, creds, customPath, fetchFn = fetch) {
+  const now = Math.floor(Date.now() / 1e3);
+  if (creds.expires_at - now >= 60) {
+    return creds;
+  }
+  const normalized = normalizeApiUrl(apiUrl);
+  const configRes = await fetchFn(`${normalized}/cli/config`);
+  if (!configRes.ok) {
+    throw new Error(
+      `Failed to fetch CLI config from ${normalized} (status ${configRes.status}): ${configRes.statusText}`
+    );
+  }
+  const configData = await configRes.json();
+  const supabaseUrl = configData.supabaseUrl || configData.data?.supabaseUrl || configData.supabase_url;
+  const supabaseAnonKey = configData.supabaseAnonKey || configData.data?.supabaseAnonKey || configData.supabase_anon_key;
+  if (!supabaseUrl || !supabaseAnonKey) {
+    throw new Error(`Invalid CLI config returned from ${normalized}: missing Supabase credentials`);
+  }
+  const supabase = createClient(supabaseUrl, supabaseAnonKey, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false
+    }
+  });
+  const { data, error } = await supabase.auth.refreshSession({
+    refresh_token: creds.refresh_token
+  });
+  if (error || !data.session) {
+    throw new Error(`Failed to refresh session: ${error?.message || "unknown error"}`);
+  }
+  const updated = {
+    access_token: data.session.access_token,
+    refresh_token: data.session.refresh_token,
+    expires_at: data.session.expires_at || Math.floor(Date.now() / 1e3) + 3600,
+    email: data.session.user?.email || creds.email
+  };
+  saveStoredCredentials(apiUrl, updated, customPath);
+  return updated;
+}
+
+// src/jwt.ts
+import crypto2 from "crypto";
+function signDevJwt(secret, workspaceId = "00000000-0000-0000-0000-000000000001") {
+  const header = { alg: "HS256", typ: "JWT" };
+  const payload = {
+    aud: "authenticated",
+    role: "authenticated",
+    sub: "00000000-0000-0000-0000-000000000003",
+    email: "dev@example.com",
+    app_metadata: {
+      workspace_id: workspaceId,
+      role: "owner",
+      workspaces: {
+        [workspaceId]: { role: "owner" }
+      }
+    },
+    user_metadata: { role: "owner" },
+    iat: Math.floor(Date.now() / 1e3),
+    exp: Math.floor(Date.now() / 1e3) + 3600 * 24 * 365
+  };
+  const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
+  const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
+  const data = `${encodedHeader}.${encodedPayload}`;
+  const signature = crypto2.createHmac("sha256", secret).update(data).digest("base64url");
+  return `${data}.${signature}`;
+}
+
+// src/auth.ts
+async function resolveAuthToken(apiUrl = process.env.CMS_API_URL || DEFAULT_DEV_API_URL, customCredentialsPath) {
+  const envToken = process.env.CMS_AUTH_TOKEN || process.env.SUPABASE_ACCESS_TOKEN;
+  if (envToken?.trim()) {
+    return envToken.trim();
+  }
+  const normalized = normalizeApiUrl(apiUrl);
+  const creds = getStoredCredentials(normalized, customCredentialsPath);
+  if (creds) {
+    try {
+      const refreshed = await refreshCredentialsIfNeeded(normalized, creds, customCredentialsPath);
+      return refreshed.access_token;
+    } catch {
+    }
+  }
+  if (normalized.includes("127.0.0.1") || normalized.includes("localhost")) {
+    const secret = process.env.SUPABASE_JWT_SECRET || "super-secret-jwt-token-with-at-least-32-characters-long";
+    try {
+      return await signDevJwt(secret);
+    } catch {
+    }
+  }
+  throw new Error(`Not logged in to ${normalized}. Run: cms login`);
+}
+
+// src/env.ts
+import fs6 from "fs";
+import path6 from "path";
+function loadEnvFiles(siteDir = process.cwd()) {
+  const envFiles = [
+    path6.join(siteDir, ".env"),
+    path6.join(siteDir, ".env.local"),
+    path6.join(siteDir, ".env.development"),
+    path6.join(process.cwd(), ".env"),
+    path6.join(process.cwd(), ".env.local")
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of envFiles) {
+    const resolved = path6.resolve(file);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    if (fs6.existsSync(resolved)) {
+      try {
+        const content = fs6.readFileSync(resolved, "utf-8");
+        for (const line of content.split("\n")) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("#")) continue;
+          const eqIdx = trimmed.indexOf("=");
+          if (eqIdx > 0) {
+            const key = trimmed.slice(0, eqIdx).trim();
+            let val = trimmed.slice(eqIdx + 1).trim();
+            if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+              val = val.slice(1, -1);
+            }
+            if (process.env[key] === void 0) {
+              process.env[key] = val;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+}
+
+// src/commands/link.ts
+function mergeEnvContent(content, vars) {
+  const lines = content ? content.split("\n") : [];
+  const remainingKeys = new Set(Object.keys(vars));
+  const updatedLines = lines.map((line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return line;
+    const eqIdx = line.indexOf("=");
+    if (eqIdx > 0) {
+      const key = line.slice(0, eqIdx).trim();
+      if (remainingKeys.has(key)) {
+        remainingKeys.delete(key);
+        return `${key}=${vars[key]}`;
+      }
+    }
+    return line;
+  });
+  if (updatedLines.length > 0 && updatedLines[updatedLines.length - 1].trim() !== "" && remainingKeys.size > 0) {
+    updatedLines.push("");
+  }
+  for (const key of remainingKeys) {
+    updatedLines.push(`${key}=${vars[key]}`);
+  }
+  let result = updatedLines.join("\n");
+  if (!result.endsWith("\n")) {
+    result += "\n";
+  }
+  return result;
+}
+function mergeEnvFile(filePath, vars) {
+  const existing = fs7.existsSync(filePath) ? fs7.readFileSync(filePath, "utf-8") : "";
+  const merged = mergeEnvContent(existing, vars);
+  fs7.writeFileSync(filePath, merged, "utf-8");
+}
+async function defaultSelectPrompt(sites) {
+  if (!process.stdin.isTTY) {
+    if (sites.length === 1) {
+      return sites[0];
+    }
+    throw new Error("Multiple sites available. Non-interactive shell must specify --site <id>.");
+  }
+  console.log("\nAvailable sites:");
+  sites.forEach((s, idx) => {
+    console.log(`  [${idx + 1}] ${s.name} (${s.id})`);
+  });
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    while (true) {
+      const ans = await rl.question(`
+Select site [1-${sites.length}]: `);
+      const num = Number.parseInt(ans.trim(), 10);
+      if (!Number.isNaN(num) && num >= 1 && num <= sites.length) {
+        return sites[num - 1];
+      }
+      console.log(`Invalid selection. Please enter a number between 1 and ${sites.length}.`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function executeLink(options = {}) {
+  const siteDir = options.siteDir || process.cwd();
+  loadEnvFiles(siteDir);
+  const apiUrl = normalizeApiUrl(options.apiUrl || process.env.CMS_API_URL || DEFAULT_DEV_API_URL);
+  let contentUrl = DEFAULT_DEV_CONTENT_URL;
+  try {
+    const configRes = await fetch(`${apiUrl}/cli/config`);
+    if (configRes.ok) {
+      const configJson = await configRes.json();
+      contentUrl = configJson.contentUrl || configJson.data?.contentUrl || configJson.content_url || DEFAULT_DEV_CONTENT_URL;
+    }
+  } catch {
+  }
+  let apiClient = options.apiClient;
+  if (!apiClient) {
+    const authToken = await resolveAuthToken(apiUrl);
+    apiClient = createApiClient({
+      baseUrl: apiUrl,
+      authToken
+    });
+  }
+  let selectedSiteId = options.siteId;
+  let selectedSiteName = "";
+  if (selectedSiteId) {
+    const siteRes = await apiClient.getSite(selectedSiteId);
+    if (siteRes.ok && siteRes.data) {
+      selectedSiteName = siteRes.data.name;
+    }
+  } else {
+    const sitesRes = await apiClient.getSites();
+    if (!sitesRes.ok || !sitesRes.data || sitesRes.data.length === 0) {
+      throw new Error("No sites found in workspace. Create a site in the web dashboard first.");
+    }
+    const sites = sitesRes.data;
+    const promptFn = options.selectPrompt || defaultSelectPrompt;
+    const chosen = await promptFn(sites);
+    selectedSiteId = chosen.id;
+    selectedSiteName = chosen.name;
+  }
+  if (!selectedSiteId) {
+    throw new Error("Failed to resolve site ID to link");
+  }
+  const envPath = path7.join(siteDir, ".env");
+  mergeEnvFile(envPath, {
+    CMS_SITE_ID: selectedSiteId,
+    CMS_API_URL: apiUrl,
+    CMS_CONTENT_URL: contentUrl
+  });
+  let astroConfigCheck = "";
+  const possibleConfigs = [
+    "astro.config.mjs",
+    "astro.config.ts",
+    "astro.config.js",
+    "astro.config.cjs"
+  ];
+  let configFound = false;
+  let configConfigured = false;
+  for (const cfg of possibleConfigs) {
+    const fullPath = path7.join(siteDir, cfg);
+    if (fs7.existsSync(fullPath)) {
+      configFound = true;
+      try {
+        const content = fs7.readFileSync(fullPath, "utf-8");
+        if (content.includes("cmsAstro") || content.includes("@407dev/cms-astro")) {
+          configConfigured = true;
+        }
+      } catch {
+      }
+      break;
+    }
+  }
+  if (!configConfigured) {
+    astroConfigCheck = `
+Next steps:
+Add @407dev/cms-astro to your astro.config.mjs:
+  import { cmsAstro } from '@407dev/cms-astro';
+
+  export default defineConfig({
+    integrations: [cmsAstro()],
+  });
+`;
+  }
+  const siteDisplay = selectedSiteName ? `"${selectedSiteName}" (${selectedSiteId})` : selectedSiteId;
+  return `\u2728 Linked site ${siteDisplay}
+Updated .env:
+  CMS_SITE_ID=${selectedSiteId}
+  CMS_API_URL=${apiUrl}
+  CMS_CONTENT_URL=${contentUrl}
+${astroConfigCheck ? `${astroConfigCheck}
+` : ""}Ready to push schema: run "cms push"`;
+}
+
+// src/commands/login.ts
+import { spawn } from "child_process";
+import crypto3 from "crypto";
+import http from "http";
+async function executeLogin(options = {}) {
+  const apiUrl = normalizeApiUrl(options.apiUrl || process.env.CMS_API_URL || DEFAULT_DEV_API_URL);
+  const openBrowser = options.openBrowser ?? true;
+  const timeoutMs = options.timeoutMs ?? 3e5;
+  let webUrl = DEFAULT_DEV_WEB_URL;
+  try {
+    const configRes = await fetch(`${apiUrl}/cli/config`);
+    if (configRes.ok) {
+      const configJson = await configRes.json();
+      webUrl = configJson.webUrl || configJson.data?.webUrl || configJson.web_url || DEFAULT_DEV_WEB_URL;
+    }
+  } catch {
+  }
+  const state = crypto3.randomBytes(16).toString("hex");
+  return new Promise((resolve3, reject) => {
+    let timeoutId = null;
+    const server = http.createServer((req, res) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      if (req.method === "POST" && req.url === "/callback") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk;
+        });
+        req.on("end", () => {
+          let payload = {};
+          const contentType = req.headers["content-type"] || "";
+          if (contentType.includes("application/json")) {
+            try {
+              payload = JSON.parse(body);
+            } catch {
+              payload = {};
+            }
+          } else {
+            const params = new URLSearchParams(body);
+            payload = Object.fromEntries(params.entries());
+          }
+          if (!payload.state || payload.state !== state) {
+            res.writeHead(400, { "Content-Type": "text/plain" });
+            res.end("Invalid state parameter");
+            return;
+          }
+          const accessToken = typeof payload.access_token === "string" ? payload.access_token : void 0;
+          const refreshToken = typeof payload.refresh_token === "string" ? payload.refresh_token : void 0;
+          const expiresAt = Number(payload.expires_at) || Math.floor(Date.now() / 1e3) + 3600;
+          const email = typeof payload.email === "string" ? payload.email : void 0;
+          if (!accessToken || !refreshToken) {
+            res.writeHead(400, { "Content-Type": "text/plain" });
+            res.end("Missing access_token or refresh_token in callback payload");
+            return;
+          }
+          saveStoredCredentials(apiUrl, {
+            access_token: accessToken,
+            refresh_token: refreshToken,
+            expires_at: expiresAt,
+            email
+          });
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(`<!DOCTYPE html>
+<html>
+<head><title>Authenticated</title></head>
+<body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; background: #fafafa;">
+  <div style="background: #ffffff; padding: 2rem 3rem; border-radius: 8px; border: 1px solid #eaeaea; text-align: center; max-width: 420px; box-shadow: 0 4px 12px rgba(0,0,0,0.05);">
+    <h2 style="margin-top: 0; color: #111;">Authenticated Successfully</h2>
+    <p style="color: #666; font-size: 14px;">You can now close this tab and return to your terminal.</p>
+  </div>
+</body>
+</html>`);
+          if (timeoutId) clearTimeout(timeoutId);
+          server.close();
+          const emailMsg = email ? ` as ${email}` : "";
+          resolve3(`\u2728 Logged in successfully${emailMsg} (${apiUrl})`);
+        });
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      const port = address.port;
+      const authorizeUrl = `${webUrl.replace(/\/+$/, "")}/cli/authorize?port=${port}&state=${state}`;
+      console.log(`
+Opening browser to authenticate:
+  ${authorizeUrl}
+`);
+      if (openBrowser) {
+        const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        try {
+          spawn(cmd, [authorizeUrl], { detached: true, stdio: "ignore" }).unref();
+        } catch {
+        }
+      }
+      timeoutId = setTimeout(() => {
+        server.close();
+        reject(new Error("Login timed out after 5 minutes. Please try again."));
+      }, timeoutMs);
+    });
+    server.on("error", (err) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      reject(err);
+    });
+  });
+}
+
+// src/commands/logout.ts
+function executeLogout(options = {}) {
+  const apiUrl = normalizeApiUrl(options.apiUrl || process.env.CMS_API_URL || DEFAULT_DEV_API_URL);
+  const removed = removeStoredCredentials(apiUrl, options.customCredentialsPath);
+  if (removed) {
+    return `Logged out from ${apiUrl}.`;
+  }
+  return `Not currently logged in to ${apiUrl}.`;
+}
+
+// src/commands/push.ts
+import fs8 from "fs";
+import path8 from "path";
+import { hashSchema } from "@407dev/blocks";
+
+// src/manifest-loader.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+async function loadManifest(pathOrObject) {
+  if (typeof pathOrObject === "object" && pathOrObject !== null) {
+    if (pathOrObject.manifestVersion !== 1) {
+      throw new Error(`Unsupported manifestVersion: ${pathOrObject.manifestVersion}`);
+    }
+    return pathOrObject;
+  }
+  const manifestPath = pathOrObject ? resolve(pathOrObject) : [
+    resolve(process.cwd(), "cms.manifest.ts"),
+    resolve(process.cwd(), "cms.manifest.js"),
+    resolve(process.cwd(), "cms.config.ts"),
+    resolve(process.cwd(), "cms.config.js")
+  ].find((p) => existsSync(p));
+  if (!manifestPath || !existsSync(manifestPath)) {
+    throw new Error(`Manifest file not found. Expected cms.manifest.ts in ${process.cwd()}`);
+  }
+  const fileUrl = pathToFileURL(manifestPath).href;
+  const mod = await import(fileUrl);
+  const manifest = mod.manifest || (mod.default && "manifestVersion" in mod.default ? mod.default : mod.default?.manifest);
+  if (!manifest) {
+    throw new Error(`No manifest export found in ${manifestPath}`);
+  }
+  if (manifest.manifestVersion !== 1) {
+    throw new Error(`Unsupported manifestVersion: ${manifest.manifestVersion}`);
+  }
+  return manifest;
+}
+
+// src/migrations.ts
+async function runEntryMigrations(apiClient, siteId, migrations) {
+  let migratedCount = 0;
+  const errors = [];
+  for (const m of migrations) {
+    const listRes = await apiClient.listEntries(siteId, m.collection);
+    if (!listRes.ok || !listRes.data) {
+      errors.push(`Failed to list entries for collection '${m.collection}': ${listRes.error}`);
+      continue;
+    }
+    const entriesToMigrate = listRes.data.filter((e) => e.schema_version === m.fromVersion);
+    for (const entry of entriesToMigrate) {
+      try {
+        const migratedContent = m.migrate(entry.content || {});
+        const updateRes = await apiClient.updateEntry(entry.id, {
+          content: migratedContent,
+          expected_updated_at: entry.updated_at
+        });
+        if (updateRes.ok) {
+          migratedCount++;
+        } else {
+          errors.push(
+            `Failed to migrate entry '${entry.slug}' in '${m.collection}': ${updateRes.error}`
+          );
+        }
+      } catch (err) {
+        errors.push(
+          `Exception in migration for entry '${entry.slug}' in '${m.collection}': ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  return { migratedCount, errors };
+}
+
+// src/state-store.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+var StateStore = class {
+  filePath;
+  constructor(customPath) {
+    this.filePath = customPath ? resolve2(customPath) : resolve2(process.cwd(), ".cms", "state.json");
+  }
+  load() {
+    if (!existsSync2(this.filePath)) {
+      return { sites: {} };
+    }
+    try {
+      const content = readFileSync(this.filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return { sites: {} };
+    }
+  }
+  getSiteManifestHash(siteId) {
+    const data = this.load();
+    return data.sites[siteId]?.manifestHash || null;
+  }
+  saveSiteManifestHash(siteId, hash) {
+    const data = this.load();
+    if (!data.sites) {
+      data.sites = {};
+    }
+    data.sites[siteId] = {
+      manifestHash: hash,
+      lastPushedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const dir = dirname(this.filePath);
+      if (!existsSync2(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`[CMS Warning] Could not save CLI state: ${message}`);
+    }
+  }
+};
+
+// src/commands/push.ts
+async function defaultConfirm(message) {
+  if (!process.stdin.isTTY) {
+    return false;
+  }
+  const readline2 = await import("readline/promises");
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`${message} [y/N] `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function previewOrphans(apiClient, siteId, manifest) {
+  if (typeof apiClient.getFields !== "function" || !manifest) {
+    return { fieldKeys: [], collectionKeys: [] };
+  }
+  const [fieldsRes, collectionsRes] = await Promise.all([
+    apiClient.getFields(siteId),
+    typeof apiClient.getCollections === "function" ? apiClient.getCollections(siteId) : Promise.resolve({ ok: true, data: [] })
+  ]);
+  const existingFields = fieldsRes.ok ? fieldsRes.data || [] : [];
+  const existingCollections = collectionsRes.ok ? collectionsRes.data || [] : [];
+  return {
+    fieldKeys: existingFields.filter((f) => !f.orphaned_at && !(f.key in manifest.fields)).map((f) => f.key),
+    collectionKeys: existingCollections.filter((c) => !manifest.collections?.[c.key]).map((c) => c.key)
+  };
+}
+async function executePush(options) {
+  const siteDir = options.siteDir || process.cwd();
+  loadEnvFiles(siteDir);
+  const siteId = options.siteId || process.env.CMS_SITE_ID;
+  if (!siteId) {
+    return {
+      success: false,
+      hash: "",
+      warnings: [],
+      errors: ["site ID is required. Pass --site <id> or set CMS_SITE_ID in .env."]
+    };
+  }
+  const { configPath, force, dryRun, check, yes, noSync, statePath, renames, migrations } = options;
+  const warnings = [];
+  const errors = [];
+  let manifest = options.manifest;
+  if (!manifest) {
+    const srcDir = path8.join(siteDir, "src");
+    const hasSourceDir = fs8.existsSync(srcDir) && fs8.statSync(srcDir).isDirectory();
+    if (hasSourceDir && !configPath) {
+      try {
+        const extractResult = await extractProject(siteDir, { noSync });
+        for (const w of extractResult.warnings) {
+          warnings.push(`${w.file}:${w.line}:${w.column}: ${w.message}`);
+        }
+        if (extractResult.errors.length > 0) {
+          const formattedErrors = extractResult.errors.map(
+            (e) => `${e.file}:${e.line}:${e.column}: ${e.message}`
+          );
+          if (check) {
+            return {
+              success: false,
+              hash: "",
+              warnings,
+              errors: formattedErrors
+            };
+          }
+          errors.push(...formattedErrors);
+        }
+        manifest = extractResult.manifest;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          success: false,
+          hash: "",
+          warnings,
+          errors: [`Extraction failed: ${msg}`]
+        };
+      }
+    } else {
+      try {
+        manifest = await loadManifest(configPath);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          success: false,
+          hash: "",
+          warnings,
+          errors: [msg]
+        };
+      }
+    }
+  }
+  const hash = hashSchema(manifest);
+  const stateStore = new StateStore(statePath);
+  const lastHash = stateStore.getSiteManifestHash(siteId);
+  if (lastHash === hash && !force) {
+    return {
+      success: true,
+      skipped: true,
+      hash,
+      warnings: ["Manifest is unchanged. Use --force to push anyway."],
+      errors: []
+    };
+  }
+  const baseUrl = process.env.CMS_API_URL || DEFAULT_DEV_API_URL;
+  let apiClient = options.apiClient;
+  if (!apiClient) {
+    try {
+      const authToken = await resolveAuthToken(baseUrl);
+      apiClient = createApiClient({
+        baseUrl,
+        authToken
+      });
+    } catch (err) {
+      if (!dryRun) {
+        const message = err instanceof Error ? err.message : "Authentication required. Run: cms login";
+        return {
+          success: false,
+          hash,
+          warnings,
+          errors: [message]
+        };
+      }
+    }
+  }
+  if (dryRun) {
+    const dryRunWarnings = ["Dry run complete. No changes were applied."];
+    if (apiClient && manifest?.collections) {
+      try {
+        const [collectionsRes, statsRes] = await Promise.all([
+          typeof apiClient.getCollections === "function" ? apiClient.getCollections(siteId) : Promise.resolve({ ok: true, data: [] }),
+          typeof apiClient.getCollectionStats === "function" ? apiClient.getCollectionStats(siteId) : Promise.resolve({ ok: true, data: {} })
+        ]);
+        const existingCollections = collectionsRes.ok ? collectionsRes.data || [] : [];
+        const existingStats = statsRes.ok && statsRes.data ? statsRes.data : {};
+        const wouldSeed = [];
+        for (const [key, coll] of Object.entries(manifest.collections)) {
+          if (coll.seed && coll.seed.length > 0) {
+            const existing = existingCollections.find((c) => c.key === key);
+            const stats = existingStats[key];
+            const entryCount = stats ? stats.draft + stats.published + stats.scheduled : 0;
+            if (!existing || !existing.seeded_at && entryCount === 0) {
+              wouldSeed.push({ key, count: coll.seed.length });
+            }
+          }
+        }
+        if (wouldSeed.length > 0) {
+          const list = wouldSeed.map((s) => `${s.key} (${s.count} ${s.count === 1 ? "entry" : "entries"})`).join(", ");
+          dryRunWarnings.push(`Would seed ${list}.`);
+        }
+      } catch {
+      }
+    }
+    return {
+      success: true,
+      hash,
+      warnings: dryRunWarnings,
+      errors: []
+    };
+  }
+  if (!apiClient) {
+    return {
+      success: false,
+      hash,
+      warnings,
+      errors: ["Authentication required. Run: cms login"]
+    };
+  }
+  if (!yes) {
+    const { fieldKeys, collectionKeys } = await previewOrphans(apiClient, siteId, manifest);
+    if (fieldKeys.length > 0 || collectionKeys.length > 0) {
+      const parts = [];
+      if (fieldKeys.length > 0) parts.push(`${fieldKeys.length} field(s): ${fieldKeys.join(", ")}`);
+      if (collectionKeys.length > 0) {
+        parts.push(`${collectionKeys.length} collection(s): ${collectionKeys.join(", ")}`);
+      }
+      const confirmFn = options.confirm || defaultConfirm;
+      const proceed = await confirmFn(
+        `This push will orphan ${parts.join("; ")}. Stored values are preserved but will stop syncing from code. Continue?`
+      );
+      if (!proceed) {
+        return {
+          success: false,
+          aborted: true,
+          hash,
+          warnings,
+          errors: [
+            "Push aborted: orphaned fields/collections were not confirmed. Re-run with --yes to skip this prompt."
+          ]
+        };
+      }
+    }
+  }
+  const pushRes = await apiClient.pushManifest(siteId, manifest, renames);
+  if (!pushRes.ok || !pushRes.data) {
+    return {
+      success: false,
+      hash,
+      warnings,
+      errors: [pushRes.error || "Failed to push manifest to CMS API"]
+    };
+  }
+  const report = pushRes.data;
+  if (report.warnings && report.warnings.length > 0) {
+    warnings.push(...report.warnings);
+  }
+  let migrationsRun = 0;
+  if (migrations && migrations.length > 0) {
+    const migrationResult = await runEntryMigrations(apiClient, siteId, migrations);
+    migrationsRun = migrationResult.migratedCount;
+    if (migrationResult.errors.length > 0) {
+      errors.push(...migrationResult.errors);
+    }
+  }
+  stateStore.saveSiteManifestHash(siteId, hash);
+  return {
+    success: errors.length === 0,
+    hash,
+    report,
+    migrationsRun,
+    warnings,
+    errors
+  };
+}
+
+// src/commands/skills.ts
+import fs9 from "fs";
+import path9 from "path";
+import { fileURLToPath } from "url";
+function resolveBundledSkillsDir() {
+  let dir = path9.dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const pkgPath = path9.join(dir, "package.json");
+    if (fs9.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
+      if (pkg.name === "@407dev/cli") return path9.join(dir, "skills");
+    }
+    const parent = path9.dirname(dir);
+    if (parent === dir) throw new Error("Could not locate bundled skills for @407dev/cli");
+    dir = parent;
+  }
+}
+function listBundledSkills(sourceDir = resolveBundledSkillsDir()) {
+  return fs9.readdirSync(sourceDir, { withFileTypes: true }).filter((d) => d.isDirectory() && fs9.existsSync(path9.join(sourceDir, d.name, "SKILL.md"))).map((d) => d.name).sort();
+}
+function listFilesRecursive(root, rel = "") {
+  const files = [];
+  for (const entry of fs9.readdirSync(path9.join(root, rel), { withFileTypes: true })) {
+    const entryRel = path9.join(rel, entry.name);
+    if (entry.isDirectory()) files.push(...listFilesRecursive(root, entryRel));
+    else if (entry.isFile()) files.push(entryRel);
+  }
+  return files.sort();
+}
+function installSkills(options = {}) {
+  const sourceDir = options.sourceDir || resolveBundledSkillsDir();
+  const destRoot = path9.join(options.targetDir || process.cwd(), ".claude", "skills");
+  const results = [];
+  for (const name of listBundledSkills(sourceDir)) {
+    const srcSkillDir = path9.join(sourceDir, name);
+    const destSkillDir = path9.join(destRoot, name);
+    const existedBefore = fs9.existsSync(destSkillDir);
+    const conflicts = [];
+    let wroteAny = false;
+    for (const rel of listFilesRecursive(srcSkillDir)) {
+      const srcContent = fs9.readFileSync(path9.join(srcSkillDir, rel));
+      const destPath = path9.join(destSkillDir, rel);
+      if (fs9.existsSync(destPath)) {
+        if (fs9.readFileSync(destPath).equals(srcContent)) continue;
+        if (!options.force) {
+          conflicts.push(rel);
+          continue;
+        }
+      }
+      fs9.mkdirSync(path9.dirname(destPath), { recursive: true });
+      fs9.writeFileSync(destPath, srcContent);
+      wroteAny = true;
+    }
+    let status = "unchanged";
+    if (conflicts.length > 0) status = "conflict";
+    else if (!existedBefore) status = "installed";
+    else if (wroteAny) status = "updated";
+    results.push({ name, status, conflicts });
+  }
+  return results;
+}
+function executeSkillsInstall(options = {}) {
+  const targetDir = path9.resolve(options.targetDir || process.cwd());
+  const results = installSkills({ ...options, targetDir });
+  const lines = [`Agent skills in ${path9.join(targetDir, ".claude", "skills")}:`];
+  for (const r of results) {
+    if (r.status === "conflict") {
+      lines.push(
+        `  ! ${r.name}: kept local edits to ${r.conflicts.join(", ")} (re-run with --force to overwrite)`
+      );
+    } else {
+      lines.push(`  \u2713 ${r.name} (${r.status})`);
+    }
+  }
+  return lines.join("\n");
+}
+function executeSkillsList() {
+  return ["Bundled agent skills:", ...listBundledSkills().map((n) => `  - ${n}`)].join("\n");
+}
+
+// src/commands/whoami.ts
+async function executeWhoami(options = {}) {
+  const apiUrl = normalizeApiUrl(options.apiUrl || process.env.CMS_API_URL || DEFAULT_DEV_API_URL);
+  const creds = getStoredCredentials(apiUrl, options.customCredentialsPath);
+  if (creds) {
+    try {
+      const refreshed = await refreshCredentialsIfNeeded(
+        apiUrl,
+        creds,
+        options.customCredentialsPath
+      );
+      const email = refreshed.email || "authenticated user";
+      return `Logged in to ${apiUrl} as ${email}`;
+    } catch {
+      return `Logged in to ${apiUrl} (stored credentials expired or refresh failed)`;
+    }
+  }
+  const envToken = process.env.CMS_AUTH_TOKEN || process.env.SUPABASE_ACCESS_TOKEN;
+  if (envToken?.trim()) {
+    return `Logged in to ${apiUrl} via environment token (CMS_AUTH_TOKEN)`;
+  }
+  if (apiUrl.includes("127.0.0.1") || apiUrl.includes("localhost")) {
+    return `Using local development credentials for ${apiUrl}`;
+  }
+  return `Not logged in to ${apiUrl}. Run "cms login" to authenticate.`;
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+function printHelp() {
+  return `
+407dev CMS CLI - v${VERSION}
+
+Usage:
+  cms login [options]     Authenticate CLI via browser session
+  cms logout [options]    Log out and remove local credentials
+  cms whoami [options]    Show current authentication status
+  cms link [options]      Link local repository to a CMS site
+  cms push [options]      Push code-first site manifest to the CMS API
+  cms check [options]     Validate templates, scopes, groups, collections, and routes
+  cms extract [options]   Extract code-first site manifest from AST
+  cms skills install [dir] Install CMS agent skills into <dir>/.claude/skills
+  cms skills list         List bundled CMS agent skills
+
+Commands & Options:
+  login:
+    --api-url <url>          API URL (default: CMS_API_URL or local dev)
+
+  logout:
+    --api-url <url>          API URL (default: CMS_API_URL or local dev)
+
+  whoami:
+    --api-url <url>          API URL (default: CMS_API_URL or local dev)
+
+  link:
+    -s, --site <id>          Site ID to link (prompted interactively if omitted)
+    --api-url <url>          API URL (default: CMS_API_URL or local dev)
+
+  push:
+    -s, --site <id>          Site ID (default: env CMS_SITE_ID)
+    -c, --config <path>      Path to cms.manifest.ts (default: static AST extraction)
+    --check                  Run static AST validation checks before pushing
+    -y, --yes                Automatically accept orphaned fields and changes
+    --no-sync                Skip running 'astro sync' when deriving routes
+    --force                  Force push even if local manifest hash matches state
+    --dry-run                Validate manifest and compute diff without modifying database
+
+  check & extract:
+    --json                   Output raw manifest as JSON (extract only)
+    --no-sync                Skip running 'astro sync' when deriving routes
+
+  skills install:
+    --force                  Overwrite skill files that were edited locally
+
+Global Options:
+  -v, --version              Show CLI version
+  -h, --help                 Show help information
+`;
+}
+function formatPushReport(result) {
+  if (result.skipped) {
+    return "\u2728 Manifest is unchanged. Nothing to push.";
+  }
+  if (result.aborted) {
+    return `\u{1F6D1} ${result.errors.join("\n")}`;
+  }
+  const lines = [];
+  lines.push("\u{1F4E6} Manifest Push Summary:");
+  lines.push(`  Hash: ${result.hash}`);
+  if (result.report) {
+    const r = result.report;
+    lines.push(`  Created items: ${r.created}`);
+    lines.push(`  Updated items: ${r.updated}`);
+    lines.push(`  Unchanged items: ${r.unchanged}`);
+    lines.push(`  Renamed items: ${r.renamed}`);
+    if (r.orphaned_fields.length > 0) {
+      lines.push(`  Orphaned fields: ${r.orphaned_fields.map((f) => f.key).join(", ")}`);
+    }
+    if (r.orphaned_collections.length > 0) {
+      lines.push(
+        `  Orphaned collections: ${r.orphaned_collections.map((c) => `${c.key} (${c.entry_count} entries)`).join(", ")}`
+      );
+    }
+    if (r.seeded && r.seeded.length > 0) {
+      const seededList = r.seeded.map((s) => `${s.key} (${s.count} ${s.count === 1 ? "entry" : "entries"})`).join(", ");
+      lines.push(`  Seeded ${seededList} \u2014 publish to make them live.`);
+    }
+    if (r.unpublished_collections && r.unpublished_collections.length > 0) {
+      const unpublishedList = r.unpublished_collections.map((c) => `${c.key} (${c.entry_count} entries)`).join(", ");
+      lines.push(
+        `  \u26A0\uFE0F  Unpublished: ${unpublishedList} \u2014 publish in the dashboard to make them live (rebuilding or redeploying won't).`
+      );
+    }
+    lines.push(`  Routes: +${r.routes.added} / -${r.routes.removed}`);
+  }
+  if (result.migrationsRun) {
+    lines.push(`  Entry migrations applied: ${result.migrationsRun}`);
+  }
+  if (result.warnings.length > 0) {
+    lines.push("\n\u26A0\uFE0F  Warnings:");
+    for (const w of result.warnings) {
+      lines.push(`  - ${w}`);
+    }
+  }
+  if (result.errors.length > 0) {
+    lines.push("\n\u274C Errors:");
+    for (const e of result.errors) {
+      lines.push(`  - ${e}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function runCli(args = []) {
+  const targetDir = args[1] && !args[1].startsWith("-") ? args[1] : process.cwd();
+  loadEnvFiles(targetDir);
+  if (args.includes("--version") || args.includes("-v")) {
+    return VERSION;
+  }
+  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    return printHelp();
+  }
+  const command = args[0];
+  if (command === "login") {
+    const rawOptions = parseArgs({
+      args: args.slice(1),
+      options: {
+        "api-url": { type: "string" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: true,
+      strict: false
+    });
+    if (rawOptions.values.help) {
+      return printHelp();
+    }
+    return await executeLogin({
+      apiUrl: rawOptions.values["api-url"] || void 0
+    });
+  }
+  if (command === "logout") {
+    const rawOptions = parseArgs({
+      args: args.slice(1),
+      options: {
+        "api-url": { type: "string" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: true,
+      strict: false
+    });
+    if (rawOptions.values.help) {
+      return printHelp();
+    }
+    return executeLogout({
+      apiUrl: rawOptions.values["api-url"] || void 0
+    });
+  }
+  if (command === "whoami") {
+    const rawOptions = parseArgs({
+      args: args.slice(1),
+      options: {
+        "api-url": { type: "string" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: true,
+      strict: false
+    });
+    if (rawOptions.values.help) {
+      return printHelp();
+    }
+    return await executeWhoami({
+      apiUrl: rawOptions.values["api-url"] || void 0
+    });
+  }
+  if (command === "link") {
+    const rawOptions = parseArgs({
+      args: args.slice(1),
+      options: {
+        site: { type: "string", short: "s" },
+        "site-id": { type: "string" },
+        "api-url": { type: "string" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: true,
+      strict: false
+    });
+    if (rawOptions.values.help) {
+      return printHelp();
+    }
+    const siteId = rawOptions.values.site || rawOptions.values["site-id"] || void 0;
+    return await executeLink({
+      siteId,
+      apiUrl: rawOptions.values["api-url"] || void 0,
+      siteDir: rawOptions.positionals[0] || void 0
+    });
+  }
+  if (command === "extract") {
+    const rawOptions = parseArgs({
+      args: args.slice(1),
+      options: {
+        json: { type: "boolean" },
+        "no-sync": { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: true,
+      strict: false
+    });
+    if (rawOptions.values.help) {
+      return printHelp();
+    }
+    return await executeExtract({
+      siteDir: rawOptions.positionals[0] || void 0,
+      json: Boolean(rawOptions.values.json),
+      noSync: Boolean(rawOptions.values["no-sync"])
+    });
+  }
+  if (command === "check") {
+    const rawOptions = parseArgs({
+      args: args.slice(1),
+      options: {
+        "no-sync": { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: true,
+      strict: false
+    });
+    if (rawOptions.values.help) {
+      return printHelp();
+    }
+    const checkRes = await executeCheck({
+      siteDir: rawOptions.positionals[0] || void 0,
+      noSync: Boolean(rawOptions.values["no-sync"])
+    });
+    if (!checkRes.success) {
+      throw new Error(checkRes.report);
+    }
+    return checkRes.report;
+  }
+  if (command === "push") {
+    const rawOptions = parseArgs({
+      args: args.slice(1),
+      options: {
+        site: { type: "string", short: "s" },
+        "site-id": { type: "string" },
+        config: { type: "string", short: "c" },
+        check: { type: "boolean" },
+        yes: { type: "boolean", short: "y" },
+        "no-sync": { type: "boolean" },
+        force: { type: "boolean" },
+        "dry-run": { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: true,
+      strict: false
+    });
+    if (rawOptions.values.help) {
+      return printHelp();
+    }
+    const siteId = rawOptions.values.site || rawOptions.values["site-id"] || process.env.CMS_SITE_ID;
+    if (!siteId) {
+      throw new Error("site ID is required. Pass --site <id> or set CMS_SITE_ID.");
+    }
+    const result = await executePush({
+      siteId,
+      siteDir: rawOptions.positionals[0] || void 0,
+      configPath: rawOptions.values.config,
+      check: Boolean(rawOptions.values.check),
+      yes: Boolean(rawOptions.values.yes),
+      noSync: Boolean(rawOptions.values["no-sync"]),
+      force: Boolean(rawOptions.values.force),
+      dryRun: Boolean(rawOptions.values["dry-run"])
+    });
+    const report = formatPushReport(result);
+    if (!result.success) {
+      throw new Error(report);
+    }
+    return report;
+  }
+  if (command === "skills") {
+    const rawOptions = parseArgs({
+      args: args.slice(1),
+      options: {
+        force: { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: true,
+      strict: false
+    });
+    if (rawOptions.values.help) {
+      return printHelp();
+    }
+    const [subcommand, targetDir2] = rawOptions.positionals;
+    if (subcommand === "install") {
+      return executeSkillsInstall({ targetDir: targetDir2, force: Boolean(rawOptions.values.force) });
+    }
+    if (subcommand === "list") {
+      return executeSkillsList();
+    }
+    throw new Error(`Unknown skills subcommand: "${subcommand ?? ""}". Use "install" or "list".`);
+  }
+  throw new Error(`Unknown command: "${command}". Run "cms --help" for available commands.`);
+}
+function isDirectExecution() {
+  if (!process.argv[1]) return false;
+  try {
+    const scriptPath = fileURLToPath2(import.meta.url);
+    const invokedPath = fs10.realpathSync(process.argv[1]);
+    return scriptPath === invokedPath;
+  } catch {
+    return false;
+  }
+}
+if (isDirectExecution()) {
+  runCli(process.argv.slice(2)).then((output) => {
+    console.log(output);
+  }).catch((err) => {
+    console.error(`
+\u274C Error: ${err.message}
+`);
+    process.exit(1);
+  });
+}
+export {
+  StateStore,
+  VERSION,
+  buildSiteManifest,
+  collectFromFile,
+  deriveRouteFromComponent,
+  executeCheck,
+  executeExtract,
+  executeLink,
+  executeLogin,
+  executeLogout,
+  executePush,
+  executeSkillsInstall,
+  executeSkillsList,
+  executeWhoami,
+  extractGroupFromCall,
+  extractProject,
+  findPackageRoot,
+  formatDiagnostics,
+  formatPushReport,
+  getDefaultCredentialsPath,
+  getStoredCredentials,
+  getStringLiteralValue,
+  globSourceFiles,
+  installSkills,
+  listBundledSkills,
+  loadAllCredentials,
+  loadDerivedRoutes,
+  loadManifest,
+  mergeEnvContent,
+  mergeEnvFile,
+  mergeExtractionResults,
+  normalizeApiUrl,
+  parseBareSpecifier,
+  parseFile,
+  printHelp,
+  refreshCredentialsIfNeeded,
+  removeStoredCredentials,
+  resolveAuthToken,
+  resolveBundledSkillsDir,
+  resolveFileContext,
+  resolveModulePath,
+  resolvePackageExport,
+  runCli,
+  runEntryMigrations,
+  saveStoredCredentials,
+  scanPagesDirectory,
+  shouldSyncRoutes,
+  syncAstroRoutes
+};
+//# sourceMappingURL=index.js.map