create-fornix 0.0.3 → 0.0.5

package/dist/index.js

@@ -8,9 +8,9 @@ import { defineCommand as defineCommand8 } from "citty";
 
 // src/cli/commands/create.ts
 import { defineCommand } from "citty";
-import { resolve, basename as basename2 } from "path";
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { resolve as resolve2, basename as basename2 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
 import * as p2 from "@clack/prompts";
 import pc3 from "picocolors";
 
@@ -213,7 +213,7 @@ function topologicalSort(blocks, manifests) {
 }
 
 // src/scaffold/structure-generator.ts
-function generateStructure(config) {
+function generateStructure(config, manifests = []) {
   const files = {};
   const adapterDeps = getAdapterDependencies(config);
   const pkg = {
@@ -278,16 +278,35 @@ pnpm-debug.log*
 .DS_Store
 Thumbs.db
 `.trim() + "\n";
-  files["src/pages/index.astro"] = `
+  const blockImports = [];
+  const blockComponents = [];
+  if (manifests.length > 0) {
+    for (const manifest2 of manifests) {
+      if (manifest2.type !== "section") continue;
+      const mainFile = manifest2.files.find((f) => f.destination.endsWith(".astro") || f.destination.endsWith(".tsx"));
+      if (mainFile) {
+        const componentName = manifest2.name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+        let importPath = mainFile.destination;
+        if (importPath.startsWith("src/")) {
+          importPath = "../" + importPath.substring(4);
+        }
+        blockImports.push(`import ${componentName} from '${importPath}';`);
+        blockComponents.push(`    <${componentName} />`);
+      }
+    }
+  }
+  const indexAstroContent = `
 ---
 import Layout from '../layouts/Layout.astro';
+${blockImports.join("\n")}
 ---
-<Layout title="Welcome to Astro.">
+<Layout title="Welcome to ${config.projectName}.">
   <main>
-    <h1>Welcome to <span class="text-gradient">${config.projectName}</span></h1>
+${blockComponents.length > 0 ? blockComponents.join("\n") : `    <h1>Welcome to <span class="text-gradient">${config.projectName}</span></h1>`}
   </main>
 </Layout>
-`.trim() + "\n";
+`.trim() + "\\n";
+  files["src/pages/index.astro"] = indexAstroContent;
   files["src/layouts/Layout.astro"] = `
 ---
 interface Props {
@@ -584,11 +603,12 @@ function generateContentConfig(blocks) {
     'import { defineCollection, z } from "astro:content";'
   ];
   const collections = [];
+  const dataCollections = /* @__PURE__ */ new Map();
   for (const block of blocks) {
     if (block.collections && block.collections.length > 0) {
       for (const col of block.collections) {
         const importName = `${block.name.replace(/-/g, "")}${col.name}Schema`;
-        const importPath = col.schemaSource.replace(/\.ts$/, "");
+        const importPath = col.schemaSource.replace(/\\.ts$/, "");
         imports.push(`import { schema as ${importName} } from "${importPath}";`);
         collections.push(
           `  "${col.name}": defineCollection({
@@ -600,17 +620,30 @@ function generateContentConfig(blocks) {
     }
     const slots = block.ai?.contentSlots;
     if (slots && Object.keys(slots).length > 0) {
-      const schemaFields = Object.entries(slots).map(([name, slot]) => `    ${name}: ${zodTypeForSlot(slot)},`).join("\n");
-      collections.push(
-        `  "${block.name}": defineCollection({
-    type: "data",
-    schema: z.object({
+      const schemaFields = Object.entries(slots).map(([name, slot]) => `      ${name}: ${zodTypeForSlot(slot)}.optional(),`).join("\n");
+      const subdirectory = TYPE_DIRECTORY[block.type] ?? block.type;
+      if (!dataCollections.has(subdirectory)) {
+        dataCollections.set(subdirectory, []);
+      }
+      dataCollections.get(subdirectory).push(
+        `    // ${block.name}
+    z.object({
 ${schemaFields}
-    }),
-  })`
+    })`
       );
     }
   }
+  for (const [colName, schemas] of dataCollections.entries()) {
+    const schemaStr = schemas.length === 1 ? schemas[0] : `z.union([
+${schemas.join(",\n")}
+    ])`;
+    collections.push(
+      `  "${colName}": defineCollection({
+    type: "data",
+    schema: ${schemaStr},
+  })`
+    );
+  }
   const lines = [
     ...imports,
     "",
@@ -789,13 +822,13 @@ function scaffold(input) {
   const selectedBlockNames = config.blocks.map((block) => block.name);
   const dependencyResult = resolveDependencies(selectedBlockNames, manifests);
   if (!isOk(dependencyResult)) {
-    return err(new Error(`Dependency resolution failed: ${dependencyResult.error.message}`));
+    return err(Object.assign(new Error(dependencyResult.error.message), dependencyResult.error));
   }
   const resolvedBlockNames = dependencyResult.value;
   const files = {};
-  const structureFiles = generateStructure(config);
-  Object.assign(files, structureFiles);
   const resolvedManifests = resolvedBlockNames.filter((name) => manifests[name] !== void 0).map((name) => manifests[name]);
+  const structureFiles = generateStructure(config, resolvedManifests);
+  Object.assign(files, structureFiles);
   const astroConfigResult = generateAstroConfig(config, resolvedManifests);
   if (!isOk(astroConfigResult)) {
     return err(astroConfigResult.error);
@@ -1735,7 +1768,6 @@ export function getStaticPaths() { return [{ params: { slug: '1' } }]; }
   "cta-newsletter": { "cta-newsletter.astro": "<section>CTA</section>\n" },
   "header-sticky": { "header-sticky.astro": "<header>Sticky</header>\n" }
 };
-var FIXTURE_DEFAULT_CONTENT = {};
 function loadAllPalettes() {
   if (BUILTIN_PALETTES.length > 0) {
     return [...BUILTIN_PALETTES];
@@ -1769,6 +1801,202 @@ function findRegistryPalettesDir() {
   }
 }
 
+// src/registry/registry-fetcher.ts
+import { existsSync, readFileSync as readFileSync2, mkdirSync, writeFileSync, statSync } from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+var DEFAULT_CONFIG = {
+  registryUrl: process.env.FORNIX_REGISTRY_URL || "https://raw.githubusercontent.com/kamsqe/fornix/main/packages/fornix-registry/registry.json",
+  cacheDir: join2(homedir(), ".cache", "fornix"),
+  force: process.env.FORNIX_NO_CACHE === "true",
+  maxCacheAge: 24 * 60 * 60 * 1e3
+  // 24 hours
+};
+async function fetchRegistryIndex(config = {}) {
+  if (process.env.FORNIX_E2E_MOCK === "true") {
+    return ok({ blocks: FIXTURE_MANIFESTS, palettes: BUILTIN_PALETTES });
+  }
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const cacheFile = join2(cfg.cacheDir, "registry.json");
+  const mapDataToIndex = (data) => {
+    const blocksArray = Array.isArray(data.blocks) ? data.blocks : [];
+    const blocksRecord = {};
+    for (const block of blocksArray) {
+      if (block.name) {
+        blocksRecord[block.name] = block;
+      }
+    }
+    return {
+      blocks: blocksRecord,
+      palettes: Array.isArray(data.palettes) ? data.palettes : []
+    };
+  };
+  if (!cfg.force && isCacheValid(cacheFile, cfg.maxCacheAge)) {
+    const cached = loadFromCache(cacheFile);
+    if (cached) return ok(mapDataToIndex(cached));
+  }
+  try {
+    const response = await fetch(cfg.registryUrl);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    mkdirSync(cfg.cacheDir, { recursive: true });
+    writeFileSync(cacheFile, JSON.stringify(data, null, 2));
+    return ok(mapDataToIndex(data));
+  } catch (error) {
+    const cached = loadFromCache(cacheFile);
+    if (cached) {
+      return ok(mapDataToIndex(cached));
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return err({
+      kind: "RegistryFetchError",
+      message: `Failed to fetch registry from ${cfg.registryUrl}: ${message}`
+    });
+  }
+}
+function isCacheValid(cachePath, maxAge) {
+  if (!existsSync(cachePath)) {
+    return false;
+  }
+  try {
+    const stat = statSync(cachePath);
+    const age = Date.now() - stat.mtimeMs;
+    return age < maxAge;
+  } catch {
+    return false;
+  }
+}
+function loadFromCache(cachePath) {
+  try {
+    if (!existsSync(cachePath)) return null;
+    const raw = readFileSync2(cachePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/registry/block-fetcher.ts
+import { downloadTemplate } from "giget";
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
+  mkdirSync as mkdirSync2,
+  statSync as statSync2
+} from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+var DEFAULT_CONFIG2 = {
+  repo: "kamsqe/fornix",
+  ref: "main",
+  cacheDir: join3(homedir2(), ".cache", "fornix", "blocks"),
+  blocksPrefix: "packages/fornix-blocks/blocks",
+  force: process.env.FORNIX_NO_CACHE === "true",
+  maxCacheAge: 24 * 60 * 60 * 1e3
+  // 24 hours
+};
+async function fetchBlock(blockName, config = {}) {
+  if (process.env.FORNIX_E2E_MOCK === "true") {
+    const manifest2 = FIXTURE_MANIFESTS[blockName];
+    const files = FIXTURE_BLOCK_SOURCES[blockName];
+    if (!manifest2 || !files) {
+      return err({
+        kind: "FetchError",
+        blockName,
+        message: `Mock block not found: ${blockName}`
+      });
+    }
+    return ok({ manifest: manifest2, files, fromCache: true });
+  }
+  const cfg = { ...DEFAULT_CONFIG2, ...config };
+  const blockCacheDir = join3(cfg.cacheDir, blockName);
+  if (!cfg.force && isCacheValid2(blockCacheDir, cfg.maxCacheAge)) {
+    return loadFromCache2(blockName, blockCacheDir);
+  }
+  try {
+    const source = `gh:${cfg.repo}/${cfg.blocksPrefix}/${blockName}#${cfg.ref}`;
+    mkdirSync2(cfg.cacheDir, { recursive: true });
+    await downloadTemplate(source, {
+      dir: blockCacheDir,
+      force: true
+      // overwrite cache
+    });
+    return loadFromCache2(blockName, blockCacheDir);
+  } catch (error) {
+    if (existsSync2(join3(blockCacheDir, "block.json"))) {
+      return loadFromCache2(blockName, blockCacheDir);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return err({
+      kind: "FetchError",
+      blockName,
+      message: `Failed to fetch block '${blockName}': ${message}`
+    });
+  }
+}
+async function fetchBlocks(blockNames, config = {}) {
+  return Promise.all(blockNames.map((name) => fetchBlock(name, config)));
+}
+function isCacheValid2(blockCacheDir, maxAge) {
+  const manifestPath = join3(blockCacheDir, "block.json");
+  if (!existsSync2(manifestPath)) {
+    return false;
+  }
+  try {
+    const stat = statSync2(manifestPath);
+    const age = Date.now() - stat.mtimeMs;
+    return age < maxAge;
+  } catch {
+    return false;
+  }
+}
+function loadFromCache2(blockName, blockCacheDir) {
+  try {
+    const manifestPath = join3(blockCacheDir, "block.json");
+    if (!existsSync2(manifestPath)) {
+      return err({
+        kind: "FetchError",
+        blockName,
+        message: `Cache miss: no block.json found in ${blockCacheDir}`
+      });
+    }
+    const raw = readFileSync3(manifestPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const result = BlockManifestSchema.safeParse(parsed);
+    if (!result.success) {
+      const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
+      return err({
+        kind: "FetchError",
+        blockName,
+        message: `Invalid manifest in cache: ${issues}`
+      });
+    }
+    const files = {};
+    const entries = readdirSync2(blockCacheDir);
+    for (const entry of entries) {
+      const fullPath = join3(blockCacheDir, entry);
+      if (statSync2(fullPath).isFile() && entry !== "block.json") {
+        files[entry] = readFileSync3(fullPath, "utf-8");
+      }
+    }
+    return ok({
+      manifest: result.data,
+      files,
+      fromCache: true
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return err({
+      kind: "FetchError",
+      blockName,
+      message: `Failed to load block from cache: ${message}`
+    });
+  }
+}
+
 // src/prompts/manual-flow.ts
 import * as p from "@clack/prompts";
 import pc from "picocolors";
@@ -1959,8 +2187,8 @@ function buildSummary(config, blockNames, palette) {
 
 // src/scaffold/post-scaffold.ts
 import { execSync } from "child_process";
-import { writeFileSync } from "fs";
-import { join as join2, basename } from "path";
+import { writeFileSync as writeFileSync2 } from "fs";
+import { join as join4, basename } from "path";
 import pc2 from "picocolors";
 function runPostScaffold(input, callbacks) {
   const log = callbacks?.onLog ?? ((msg) => console.log(msg));
@@ -2126,7 +2354,7 @@ function generateClaudeMd(projectDir, config, blockNames) {
   lines.push("```");
   lines.push("");
   const content = lines.join("\n");
-  writeFileSync(join2(projectDir, "CLAUDE.md"), content, "utf-8");
+  writeFileSync2(join4(projectDir, "CLAUDE.md"), content, "utf-8");
 }
 
 // src/ai/prompt-builder.ts
@@ -2154,7 +2382,8 @@ Your job:
 
 You MUST only select blocks that exist in the catalog below. Never invent block names.`;
 }
-function buildBlocksCatalog(blocks) {
+function buildBlocksCatalog(blocksRecord) {
+  const blocks = Object.values(blocksRecord);
   const lines = ["# Available Blocks\n"];
   const grouped = /* @__PURE__ */ new Map();
   for (const block of blocks) {
@@ -2234,7 +2463,8 @@ function buildPalettesCatalog(palettes) {
   }
   return lines.join("\n");
 }
-function buildConstraintRules(blocks) {
+function buildConstraintRules(blocksRecord) {
+  const blocks = Object.values(blocksRecord);
   const lines = ["# Constraint Rules\n"];
   lines.push("## Render Modes");
   lines.push("- `static` \u2014 Pre-rendered HTML, no server. Best for blogs, docs, landing pages.");
@@ -2960,8 +3190,8 @@ function createCloudflareProvider(opts = {}) {
 }
 
 // src/ai/providers/mock-provider.ts
-import { readFileSync as readFileSync2, existsSync } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var FIXTURE_ENTRIES = [
   {
@@ -3001,9 +3231,9 @@ function createMockProvider() {
         });
       }
       const fixtureDir = resolveFixtureDir();
-      const filePath = join3(fixtureDir, match.filename);
+      const filePath = join5(fixtureDir, match.filename);
       try {
-        const raw = readFileSync2(filePath, "utf-8");
+        const raw = readFileSync4(filePath, "utf-8");
         const parsed = JSON.parse(raw);
         const validated = IntentSchema.parse(parsed);
         return ok(validated);
@@ -3020,10 +3250,10 @@ function createMockProvider() {
 }
 function resolveFixtureDir() {
   const thisDir = dirname2(fileURLToPath2(import.meta.url));
-  const fromSource = join3(thisDir, "..", "..", "..", "tests", "fixtures", "ai-responses");
-  if (existsSync(fromSource)) return fromSource;
-  const fromDist = join3(thisDir, "..", "tests", "fixtures", "ai-responses");
-  if (existsSync(fromDist)) return fromDist;
+  const fromSource = join5(thisDir, "..", "..", "..", "tests", "fixtures", "ai-responses");
+  if (existsSync3(fromSource)) return fromSource;
+  const fromDist = join5(thisDir, "..", "tests", "fixtures", "ai-responses");
+  if (existsSync3(fromDist)) return fromDist;
   return fromSource;
 }
 
@@ -3330,30 +3560,37 @@ var createCommand = defineCommand({
     }
   },
   async run({ args: args2 }) {
-    const allPalettes = loadAllPalettes();
+    const registryResult = await fetchRegistryIndex();
+    if (!isOk(registryResult)) {
+      console.error(pc3.red(`\u2716 Failed to fetch block registry: ${registryResult.error.message}`));
+      process.exitCode = 1;
+      return;
+    }
+    const manifests = registryResult.value.blocks;
+    const allPalettes = registryResult.value.palettes.length > 0 ? registryResult.value.palettes : loadAllPalettes();
     const hasExplicitFlags = !!(args2.render || args2.deploy || args2.blocks || args2.database || args2.css || args2.locales || args2.palette || args2.recipe);
     if (args2.manual && !args2.yes) {
-      const defaultProjectName = args2.dir ? basename2(resolve(args2.dir)) : "my-project";
+      const defaultProjectName = args2.dir ? basename2(resolve2(args2.dir)) : "my-project";
       const config = await runManualFlow({
         defaultProjectName,
-        manifests: FIXTURE_MANIFESTS,
+        manifests,
         allPalettes
       });
       if (!config) {
         process.exitCode = 0;
         return;
       }
-      const projectDir = args2.dir ? resolve(args2.dir) : resolve(config.projectDir);
+      const projectDir = args2.dir ? resolve2(args2.dir) : resolve2(config.projectDir);
       const finalConfig = { ...config, projectDir };
-      return runScaffold(finalConfig, allPalettes, args2["dry-run"] ?? false, args2.verbose ?? false, !(args2.install ?? true), !(args2.git ?? true));
+      return runScaffold(finalConfig, manifests, allPalettes, args2["dry-run"] ?? false, args2.verbose ?? false, !(args2.install ?? true), !(args2.git ?? true));
     }
     if (args2.manual || hasExplicitFlags) {
-      return runFlagDrivenMode(args2, allPalettes);
+      return runFlagDrivenMode(args2, manifests, allPalettes);
     }
-    return runAIMode(args2, allPalettes);
+    return runAIMode(args2, manifests, allPalettes);
   }
 });
-async function runAIMode(args2, allPalettes) {
+async function runAIMode(args2, manifests, allPalettes) {
   const providerName = parseProviderName(args2.provider);
   if (args2.provider && !providerName) {
     console.error(pc3.red(`\u2716 Unknown provider: ${String(args2.provider)}`));
@@ -3377,10 +3614,10 @@ async function runAIMode(args2, allPalettes) {
     return;
   }
   const registry = {
-    blocks: Object.values(FIXTURE_MANIFESTS),
+    blocks: Object.values(manifests),
     palettes: [...allPalettes]
   };
-  const projectDir = resolve(String(args2.dir ?? "."));
+  const projectDir = resolve2(String(args2.dir ?? "."));
   const projectName = basename2(projectDir);
   const nameResult = validateProjectName(projectName);
   if (!nameResult.ok) {
@@ -3415,6 +3652,7 @@ async function runAIMode(args2, allPalettes) {
   }
   return runScaffold(
     config,
+    manifests,
     allPalettes,
     (args2["dry-run"] ?? false) === true,
     (args2.verbose ?? false) === true,
@@ -3422,8 +3660,8 @@ async function runAIMode(args2, allPalettes) {
     !((args2.git ?? true) === true)
   );
 }
-function runFlagDrivenMode(args2, allPalettes) {
-  const projectDir = resolve(String(args2.dir ?? "."));
+function runFlagDrivenMode(args2, manifests, allPalettes) {
+  const projectDir = resolve2(String(args2.dir ?? "."));
   const projectName = basename2(projectDir);
   const nameResult = validateProjectName(projectName);
   if (!nameResult.ok) {
@@ -3506,6 +3744,7 @@ function runFlagDrivenMode(args2, allPalettes) {
   };
   return runScaffold(
     config,
+    manifests,
     allPalettes,
     (args2["dry-run"] ?? false) === true,
     (args2.verbose ?? false) === true,
@@ -3513,12 +3752,36 @@ function runFlagDrivenMode(args2, allPalettes) {
     !((args2.git ?? true) === true)
   );
 }
-function runScaffold(config, allPalettes, dryRun, verbose, skipInstall, skipGit) {
+async function runScaffold(config, manifests, allPalettes, dryRun, verbose, skipInstall, skipGit) {
+  const spinner2 = p2.spinner();
+  spinner2.start("Fetching blocks from registry...");
+  const blockNames = config.blocks.map((b) => b.name);
+  const blockResults = await fetchBlocks(blockNames);
+  const blockSources = {};
+  const blockDefaultContent = {};
+  for (const result2 of blockResults) {
+    if (!isOk(result2)) {
+      spinner2.stop(`Failed to fetch block '${result2.error.blockName}'`, 1);
+      console.error(pc3.red(`\u2716 ${result2.error.message}`));
+      process.exitCode = 1;
+      return;
+    }
+    const { manifest: manifest2, files: files2 } = result2.value;
+    blockSources[manifest2.name] = files2;
+    try {
+      if (files2["default-content.json"]) {
+        blockDefaultContent[manifest2.name] = JSON.parse(files2["default-content.json"]);
+      }
+    } catch (e) {
+      console.error(pc3.yellow(`\u26A0 Warning: Failed to parse default-content.json for block '${manifest2.name}'`));
+    }
+  }
+  spinner2.stop("Blocks fetched successfully.");
   const input = {
     config,
-    manifests: FIXTURE_MANIFESTS,
-    blockSources: FIXTURE_BLOCK_SOURCES,
-    blockDefaultContent: FIXTURE_DEFAULT_CONTENT,
+    manifests,
+    blockSources: Object.freeze(blockSources),
+    blockDefaultContent: Object.freeze(blockDefaultContent),
     allPalettes
   };
   const result = scaffold(input);
@@ -3552,10 +3815,10 @@ function runScaffold(config, allPalettes, dryRun, verbose, skipInstall, skipGit)
   const files = result.value.files;
   let filesWritten = 0;
   for (const [relativePath, content] of Object.entries(files)) {
-    const fullPath = join4(config.projectDir, relativePath);
-    const parentDir = join4(fullPath, "..");
-    mkdirSync2(parentDir, { recursive: true });
-    writeFileSync2(fullPath, content, "utf-8");
+    const fullPath = join6(config.projectDir, relativePath);
+    const parentDir = join6(fullPath, "..");
+    mkdirSync4(parentDir, { recursive: true });
+    writeFileSync3(fullPath, content, "utf-8");
     filesWritten++;
     if (verbose) {
       console.log(pc3.dim(`  created ${relativePath}`));
@@ -3644,8 +3907,8 @@ function showNoProviderGuide() {
 // src/cli/commands/add.ts
 import { defineCommand as defineCommand2 } from "citty";
 import pc4 from "picocolors";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync2, mkdirSync as mkdirSync3 } from "fs";
-import { join as join5, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync5 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
 var addCommand = defineCommand2({
   meta: {
     name: "add",
@@ -3673,28 +3936,36 @@ var addCommand = defineCommand2({
       default: false
     }
   },
-  run({ args: args2 }) {
+  async run({ args: args2 }) {
     const typedArgs = args2;
     const cwd = process.cwd();
-    const manifestPath = join5(cwd, "fornix.json");
-    if (!existsSync2(manifestPath)) {
+    const manifestPath = join7(cwd, "fornix.json");
+    if (!existsSync4(manifestPath)) {
       console.error(
         pc4.red("\u2717 No fornix.json found. Are you in a Fornix project?")
       );
       process.exit(1);
     }
-    const manifestRaw = readFileSync3(manifestPath, "utf-8");
+    const manifestRaw = readFileSync5(manifestPath, "utf-8");
     const manifest2 = JSON.parse(manifestRaw);
+    const registryResult = await fetchRegistryIndex();
+    if (!isOk(registryResult)) {
+      console.error(pc4.red(`\u2716 Failed to fetch block registry: ${registryResult.error.message}`));
+      process.exitCode = 1;
+      return;
+    }
+    const manifests = registryResult.value.blocks;
     const blockName = typedArgs.block;
-    const blockManifest = FIXTURE_MANIFESTS[blockName];
+    const blockManifest = manifests[blockName];
     if (!blockManifest) {
       console.error(pc4.red(`\u2717 Block '${blockName}' not found in registry.`));
       console.error(
         pc4.dim(
-          `  Available: ${Object.keys(FIXTURE_MANIFESTS).join(", ")}`
+          `  Available: ${Object.keys(manifests).join(", ")}`
         )
       );
-      process.exit(1);
+      process.exitCode = 1;
+      return;
     }
     const installedNames = new Set(manifest2.blocks.map((b) => b.name));
     if (installedNames.has(blockName)) {
@@ -3703,26 +3974,32 @@ var addCommand = defineCommand2({
       );
       return;
     }
-    const blocksToAdd = resolveDependencies2(blockName, installedNames);
+    const blocksToAdd = resolveDependencies2(blockName, installedNames, manifests);
     for (const name of blocksToAdd) {
-      const m = FIXTURE_MANIFESTS[name];
+      const m = manifests[name];
       if (m?.requiredMode && manifest2.renderMode !== m.requiredMode) {
         console.error(
           pc4.red(
             `\u2717 Block '${name}' requires '${m.requiredMode}' mode, but project uses '${manifest2.renderMode}'.`
           )
         );
-        process.exit(1);
+        process.exitCode = 1;
+        return;
       }
     }
+    console.log(pc4.dim("Fetching blocks..."));
+    const blockResults = await fetchBlocks(blocksToAdd);
     const filesToWrite = [];
-    for (const name of blocksToAdd) {
-      const bManifest = FIXTURE_MANIFESTS[name];
-      const sources = FIXTURE_BLOCK_SOURCES[name];
-      if (!bManifest || !sources) {
-        console.error(pc4.red(`\u2717 Source files not found for block '${name}'.`));
-        process.exit(1);
+    for (let i = 0; i < blocksToAdd.length; i++) {
+      const name = blocksToAdd[i];
+      const result = blockResults[i];
+      if (!result || !isOk(result)) {
+        console.error(pc4.red(`\u2717 Failed to fetch files for block '${name}'.`));
+        process.exitCode = 1;
+        return;
       }
+      const bManifest = result.value.manifest;
+      const sources = result.value.files;
       for (const file of bManifest.files) {
         const content = sources[file.source];
         if (content === void 0) {
@@ -3731,10 +4008,11 @@ var addCommand = defineCommand2({
               `\u2717 Source file '${file.source}' not found for block '${name}'.`
             )
           );
-          process.exit(1);
+          process.exitCode = 1;
+          return;
         }
         filesToWrite.push({
-          path: join5(cwd, file.destination),
+          path: join7(cwd, file.destination),
           content
         });
       }
@@ -3755,15 +4033,15 @@ var addCommand = defineCommand2({
       return;
     }
     for (const file of filesToWrite) {
-      mkdirSync3(dirname3(file.path), { recursive: true });
-      writeFileSync3(file.path, file.content);
+      mkdirSync5(dirname3(file.path), { recursive: true });
+      writeFileSync4(file.path, file.content);
       if (typedArgs.verbose) {
         console.log(`  ${pc4.dim("\u2192")} ${file.path}`);
       }
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const name of blocksToAdd) {
-      const bManifest = FIXTURE_MANIFESTS[name];
+      const bManifest = manifests[name];
       if (!bManifest) continue;
       manifest2.blocks.push({
         name,
@@ -3772,7 +4050,7 @@ var addCommand = defineCommand2({
         installedAt: now
       });
     }
-    writeFileSync3(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
+    writeFileSync4(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
     console.log();
     for (const name of blocksToAdd) {
       const isDep = name !== blockName;
@@ -3793,13 +4071,13 @@ var addCommand = defineCommand2({
     console.log();
   }
 });
-function resolveDependencies2(blockName, installedNames) {
+function resolveDependencies2(blockName, installedNames, manifests) {
   const result = [];
   const visited = /* @__PURE__ */ new Set();
   function walk(name) {
     if (visited.has(name) || installedNames.has(name)) return;
     visited.add(name);
-    const manifest2 = FIXTURE_MANIFESTS[name];
+    const manifest2 = manifests[name];
     if (!manifest2) return;
     for (const dep of manifest2.requires) {
       walk(dep);
@@ -3813,8 +4091,8 @@ function resolveDependencies2(blockName, installedNames) {
 // src/cli/commands/remove.ts
 import { defineCommand as defineCommand3 } from "citty";
 import pc5 from "picocolors";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync3, unlinkSync, readdirSync as readdirSync2, rmdirSync } from "fs";
-import { join as join6, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync5, unlinkSync, readdirSync as readdirSync3, rmdirSync } from "fs";
+import { join as join8, dirname as dirname4 } from "path";
 var removeCommand = defineCommand3({
   meta: {
     name: "remove",
@@ -3842,18 +4120,25 @@ var removeCommand = defineCommand3({
       default: false
     }
   },
-  run({ args: args2 }) {
+  async run({ args: args2 }) {
     const typedArgs = args2;
     const cwd = process.cwd();
-    const manifestPath = join6(cwd, "fornix.json");
-    if (!existsSync3(manifestPath)) {
+    const manifestPath = join8(cwd, "fornix.json");
+    if (!existsSync5(manifestPath)) {
       console.error(
         pc5.red("\u2717 No fornix.json found. Are you in a Fornix project?")
       );
       process.exit(1);
     }
-    const manifestRaw = readFileSync4(manifestPath, "utf-8");
+    const manifestRaw = readFileSync6(manifestPath, "utf-8");
     const manifest2 = JSON.parse(manifestRaw);
+    const registryResult = await fetchRegistryIndex();
+    if (!isOk(registryResult)) {
+      console.error(pc5.red(`\u2716 Failed to fetch block registry: ${registryResult.error.message}`));
+      process.exitCode = 1;
+      return;
+    }
+    const manifests = registryResult.value.blocks;
     const blockName = typedArgs.block;
     const installedNames = new Set(manifest2.blocks.map((b) => b.name));
     if (!installedNames.has(blockName)) {
@@ -3862,7 +4147,7 @@ var removeCommand = defineCommand3({
       );
       return;
     }
-    const dependents = findDependents(blockName, installedNames);
+    const dependents = findDependents(blockName, installedNames, manifests);
     if (dependents.length > 0 && !typedArgs.force) {
       console.log(
         pc5.yellow(
@@ -3874,12 +4159,12 @@ var removeCommand = defineCommand3({
       );
       return;
     }
-    const blockManifest = FIXTURE_MANIFESTS[blockName];
+    const blockManifest = manifests[blockName];
     const filesToRemove = [];
     if (blockManifest) {
       for (const file of blockManifest.files) {
-        const filePath = join6(cwd, file.destination);
-        if (existsSync3(filePath)) {
+        const filePath = join8(cwd, file.destination);
+        if (existsSync5(filePath)) {
           filesToRemove.push(filePath);
         }
       }
@@ -3901,7 +4186,7 @@ var removeCommand = defineCommand3({
       tryRemoveEmptyDir(dirname4(filePath), cwd);
     }
     manifest2.blocks = manifest2.blocks.filter((b) => b.name !== blockName);
-    writeFileSync4(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
+    writeFileSync5(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
     console.log();
     console.log(`  ${pc5.red("-")} ${pc5.bold(blockName)} removed`);
     if (dependents.length > 0) {
@@ -3920,10 +4205,10 @@ var removeCommand = defineCommand3({
     console.log();
   }
 });
-function findDependents(blockName, installedNames) {
+function findDependents(blockName, installedNames, manifests) {
   const dependents = [];
   for (const name of installedNames) {
-    const manifest2 = FIXTURE_MANIFESTS[name];
+    const manifest2 = manifests[name];
     if (manifest2 && manifest2.requires.includes(blockName)) {
       dependents.push(name);
     }
@@ -3933,7 +4218,7 @@ function findDependents(blockName, installedNames) {
 function tryRemoveEmptyDir(dirPath, rootPath) {
   if (dirPath === rootPath || !dirPath.startsWith(rootPath)) return;
   try {
-    const entries = readdirSync2(dirPath);
+    const entries = readdirSync3(dirPath);
     if (entries.length === 0) {
       rmdirSync(dirPath);
       tryRemoveEmptyDir(dirname4(dirPath), rootPath);
@@ -3970,9 +4255,16 @@ var listCommand = defineCommand4({
       default: false
     }
   },
-  run({ args: args2 }) {
+  async run({ args: args2 }) {
     const typedArgs = args2;
-    const blocks = getFilteredBlocks(typedArgs);
+    const registryResult = await fetchRegistryIndex();
+    if (!isOk(registryResult)) {
+      console.error(pc6.red(`\u2716 Failed to fetch block registry: ${registryResult.error.message}`));
+      process.exitCode = 1;
+      return;
+    }
+    const manifests = registryResult.value.blocks;
+    const blocks = getFilteredBlocks(typedArgs, manifests);
     if (blocks.length === 0) {
       console.log(pc6.yellow("No blocks found matching your filters."));
       return;
@@ -3984,8 +4276,8 @@ var listCommand = defineCommand4({
     }
   }
 });
-function getFilteredBlocks(args2) {
-  let blocks = Object.values(FIXTURE_MANIFESTS);
+function getFilteredBlocks(args2, manifests) {
+  let blocks = Object.values(manifests);
   if (args2.type) {
     const filterType = args2.type.toLowerCase();
     blocks = blocks.filter((b) => b.type === filterType);
@@ -4066,8 +4358,8 @@ function printFormatted(blocks, verbose) {
 // src/cli/commands/status.ts
 import { defineCommand as defineCommand5 } from "citty";
 import pc7 from "picocolors";
-import { readFileSync as readFileSync5, existsSync as existsSync4 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync6 } from "fs";
+import { join as join9 } from "path";
 var statusCommand = defineCommand5({
   meta: {
     name: "status",
@@ -4088,8 +4380,8 @@ var statusCommand = defineCommand5({
   run({ args: args2 }) {
     const typedArgs = args2;
     const cwd = process.cwd();
-    const manifestPath = join7(cwd, "fornix.json");
-    if (!existsSync4(manifestPath)) {
+    const manifestPath = join9(cwd, "fornix.json");
+    if (!existsSync6(manifestPath)) {
       console.error(
         pc7.red("\u2717 No fornix.json found in the current directory.")
       );
@@ -4102,7 +4394,7 @@ var statusCommand = defineCommand5({
     }
     let manifest2;
     try {
-      const raw = readFileSync5(manifestPath, "utf-8");
+      const raw = readFileSync7(manifestPath, "utf-8");
       manifest2 = JSON.parse(raw);
     } catch {
       console.error(pc7.red("\u2717 Failed to parse fornix.json."));
@@ -4183,8 +4475,8 @@ function printStatus(manifest2, verbose) {
 // src/cli/commands/doctor.ts
 import { defineCommand as defineCommand6 } from "citty";
 import pc8 from "picocolors";
-import { readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync7 } from "fs";
+import { join as join10 } from "path";
 var doctorCommand = defineCommand6({
   meta: {
     name: "doctor",
@@ -4197,9 +4489,9 @@ var doctorCommand = defineCommand6({
       default: false
     }
   },
-  run({ args: args2 }) {
+  async run({ args: args2 }) {
     const cwd = process.cwd();
-    const manifestPath = join8(cwd, "fornix.json");
+    const manifestPath = join10(cwd, "fornix.json");
     let hasErrors = false;
     const errors = [];
     function reportError(msg) {
@@ -4209,7 +4501,7 @@ var doctorCommand = defineCommand6({
         console.error(pc8.red(`\u2717 ${msg}`));
       }
     }
-    if (!existsSync5(manifestPath)) {
+    if (!existsSync7(manifestPath)) {
       reportError("No fornix.json found in the current directory.");
       if (args2.json) {
         console.log(JSON.stringify({ healthy: false, errors }));
@@ -4218,7 +4510,7 @@ var doctorCommand = defineCommand6({
     }
     let manifest2;
     try {
-      const raw = readFileSync6(manifestPath, "utf-8");
+      const raw = readFileSync8(manifestPath, "utf-8");
       manifest2 = JSON.parse(raw);
     } catch {
       reportError("Failed to parse fornix.json.");
@@ -4227,24 +4519,34 @@ var doctorCommand = defineCommand6({
       }
       process.exit(1);
     }
+    const registryResult = await fetchRegistryIndex();
+    if (!isOk(registryResult)) {
+      reportError(`Failed to fetch block registry: ${registryResult.error.message}`);
+      if (args2.json) {
+        console.log(JSON.stringify({ healthy: false, errors }));
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const manifests = registryResult.value.blocks;
     const isMultiLocale = manifest2.locales && manifest2.locales.length >= 2;
     const locales = isMultiLocale ? manifest2.locales : [""];
     const installedBlocks = new Set(manifest2.blocks.map((b) => b.name));
     for (const block of manifest2.blocks) {
-      const bManifest = FIXTURE_MANIFESTS[block.name];
+      const bManifest = manifests[block.name];
       if (bManifest) {
         for (const file of bManifest.files) {
-          const filePath = join8(cwd, file.destination);
-          if (!existsSync5(filePath)) {
+          const filePath = join10(cwd, file.destination);
+          if (!existsSync7(filePath)) {
             reportError(`Missing expected file for installed block '${block.name}': ${file.destination}`);
           }
         }
       }
     }
-    for (const [name, bManifest] of Object.entries(FIXTURE_MANIFESTS)) {
+    for (const [name, bManifest] of Object.entries(manifests)) {
       if (!installedBlocks.has(name)) {
         const foundOrphaned = bManifest.files.some((file) => {
-          return existsSync5(join8(cwd, file.destination));
+          return existsSync7(join10(cwd, file.destination));
         });
         if (foundOrphaned) {
           reportError(`Orphaned block files detected for '${name}'. The block is not in fornix.json.`);
@@ -4254,7 +4556,7 @@ var doctorCommand = defineCommand6({
     let requiresContentConfig = false;
     const missingContentFiles = [];
     for (const block of manifest2.blocks) {
-      const bManifest = FIXTURE_MANIFESTS[block.name];
+      const bManifest = manifests[block.name];
       if (!bManifest) continue;
       const hasContentSlots = bManifest.ai?.contentSlots && Object.keys(bManifest.ai.contentSlots).length > 0;
       const hasCollections = bManifest.collections && bManifest.collections.length > 0;
@@ -4268,14 +4570,14 @@ var doctorCommand = defineCommand6({
           if (locale !== "") {
             pathFragment = `src/content/${locale}/${subdirectory}/${bManifest.name}.json`;
           }
-          if (!existsSync5(join8(cwd, pathFragment))) {
+          if (!existsSync7(join10(cwd, pathFragment))) {
             missingContentFiles.push(pathFragment);
           }
         }
       }
     }
     if (requiresContentConfig) {
-      if (!existsSync5(join8(cwd, "src/content/config.ts"))) {
+      if (!existsSync7(join10(cwd, "src/content/config.ts"))) {
         reportError("Missing expected file: src/content/config.ts");
       }
     }
@@ -4328,57 +4630,71 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 
 // src/mcp/tools/list-blocks.ts
-function listBlocks(input) {
-  let blocks = Object.values(FIXTURE_MANIFESTS);
-  if (input.type) {
-    const filterType = input.type.toLowerCase();
-    blocks = blocks.filter((block) => block.type === filterType);
-  }
-  if (input.category) {
-    const filterCategory = input.category.toLowerCase();
-    blocks = blocks.filter((block) => block.category === filterCategory);
-  }
-  if (input.search) {
-    const searchTerm = input.search.toLowerCase();
-    blocks = blocks.filter(
-      (block) => block.name.includes(searchTerm) || block.description.toLowerCase().includes(searchTerm) || block.tags.some((tag) => tag.includes(searchTerm))
-    );
+async function listBlocksHandler(args2) {
+  const result = await fetchRegistryIndex();
+  if (!isOk(result)) {
+    throw new Error(`Failed to fetch block registry: ${result.error.message}`);
+  }
+  const manifests = result.value.blocks;
+  const typedArgs = args2;
+  let blocks = Object.values(manifests);
+  if (typedArgs?.type) {
+    blocks = blocks.filter((b) => b.type === typedArgs.type);
   }
-  const entries = blocks.map((block) => ({
-    name: block.name,
-    type: block.type,
-    category: block.category,
-    description: block.description,
-    tags: block.tags,
-    requiredMode: block.requiredMode,
-    requires: block.requires
-  })).sort((a, b) => a.name.localeCompare(b.name));
-  return ok(entries);
+  if (typedArgs?.category) {
+    blocks = blocks.filter((b) => b.category === typedArgs.category);
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          blocks.map((b) => ({
+            name: b.name,
+            description: b.description,
+            type: b.type,
+            category: b.category,
+            requiredMode: b.requiredMode,
+            requires: b.requires,
+            conflicts: b.conflicts,
+            envVars: b.envVars
+          })),
+          null,
+          2
+        )
+      }
+    ]
+  };
 }
 
 // src/mcp/tools/add-block.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
-import { join as join9, dirname as dirname5 } from "path";
-function addBlock2(input) {
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync6 } from "fs";
+import { join as join11, dirname as dirname5 } from "path";
+async function addBlock2(input) {
   const { name, variant = "default", projectDirectory } = input;
-  const manifestPath = join9(projectDirectory, "fornix.json");
-  if (!existsSync6(manifestPath)) {
+  const manifestPath = join11(projectDirectory, "fornix.json");
+  if (!existsSync8(manifestPath)) {
     return err(
       new Error("No fornix.json found. Not a Fornix project directory.")
     );
   }
   let manifest2;
   try {
-    const raw = readFileSync7(manifestPath, "utf-8");
+    const raw = readFileSync9(manifestPath, "utf-8");
     manifest2 = JSON.parse(raw);
   } catch {
     return err(new Error("Failed to parse fornix.json."));
   }
-  const blockManifest = FIXTURE_MANIFESTS[name];
+  const registryResult = await fetchRegistryIndex();
+  if (!isOk(registryResult)) {
+    return err(new Error(`Failed to fetch block registry: ${registryResult.error.message}`));
+  }
+  const manifests = registryResult.value.blocks;
+  const blockManifest = manifests[name];
   if (!blockManifest) {
     return err(
       new Error(
-        `Block '${name}' not found in registry. Available: ${Object.keys(FIXTURE_MANIFESTS).join(", ")}`
+        `Block '${name}' not found in registry. Available: ${Object.keys(manifests).join(", ")}`
       )
     );
   }
@@ -4386,9 +4702,9 @@ function addBlock2(input) {
   if (installedNames.has(name)) {
     return ok({ addedBlocks: [], filesCreated: 0 });
   }
-  const blocksToAdd = resolveDependencies3(name, installedNames);
+  const blocksToAdd = resolveDependencies3(name, installedNames, manifests);
   for (const blockName of blocksToAdd) {
-    const dependencyManifest = FIXTURE_MANIFESTS[blockName];
+    const dependencyManifest = manifests[blockName];
     if (dependencyManifest?.requiredMode && manifest2.renderMode !== dependencyManifest.requiredMode) {
       return err(
         new Error(
@@ -4398,14 +4714,15 @@ function addBlock2(input) {
     }
   }
   let filesCreated = 0;
-  for (const blockName of blocksToAdd) {
-    const blockDef = FIXTURE_MANIFESTS[blockName];
-    const sources = FIXTURE_BLOCK_SOURCES[blockName];
-    if (!blockDef || !sources) {
-      return err(
-        new Error(`Source files not found for block '${blockName}'.`)
-      );
-    }
+  const blockResults = await fetchBlocks(blocksToAdd);
+  for (let i = 0; i < blocksToAdd.length; i++) {
+    const blockName = blocksToAdd[i];
+    const result = blockResults[i];
+    if (!result || !isOk(result)) {
+      return err(new Error(`Failed to fetch files for block '${blockName}'.`));
+    }
+    const blockDef = result.value.manifest;
+    const sources = result.value.files;
     for (const file of blockDef.files) {
       const content = sources[file.source];
       if (content === void 0) {
@@ -4415,15 +4732,15 @@ function addBlock2(input) {
           )
         );
       }
-      const filePath = join9(projectDirectory, file.destination);
-      mkdirSync4(dirname5(filePath), { recursive: true });
-      writeFileSync5(filePath, content);
+      const filePath = join11(projectDirectory, file.destination);
+      mkdirSync6(dirname5(filePath), { recursive: true });
+      writeFileSync6(filePath, content);
       filesCreated++;
     }
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const blockName of blocksToAdd) {
-    const blockDef = FIXTURE_MANIFESTS[blockName];
+    const blockDef = manifests[blockName];
     if (!blockDef) continue;
     manifest2.blocks.push({
       name: blockName,
@@ -4432,16 +4749,16 @@ function addBlock2(input) {
       installedAt: now
     });
   }
-  writeFileSync5(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
+  writeFileSync6(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
   return ok({ addedBlocks: blocksToAdd, filesCreated });
 }
-function resolveDependencies3(blockName, installedNames) {
+function resolveDependencies3(blockName, installedNames, manifests) {
   const result = [];
   const visited = /* @__PURE__ */ new Set();
   function walk(currentName) {
     if (visited.has(currentName) || installedNames.has(currentName)) return;
     visited.add(currentName);
-    const manifest2 = FIXTURE_MANIFESTS[currentName];
+    const manifest2 = manifests[currentName];
     if (!manifest2) return;
     for (const dependency of manifest2.requires) {
       walk(dependency);
@@ -4454,34 +4771,39 @@ function resolveDependencies3(blockName, installedNames) {
 
 // src/mcp/tools/remove-block.ts
 import {
-  readFileSync as readFileSync8,
-  writeFileSync as writeFileSync6,
-  existsSync as existsSync7,
+  readFileSync as readFileSync10,
+  writeFileSync as writeFileSync7,
+  existsSync as existsSync9,
   unlinkSync as unlinkSync2,
-  readdirSync as readdirSync3,
+  readdirSync as readdirSync4,
   rmdirSync as rmdirSync2
 } from "fs";
-import { join as join10, dirname as dirname6 } from "path";
-function removeBlock(input) {
+import { join as join12, dirname as dirname6 } from "path";
+async function removeBlock(input) {
   const { name, force = false, projectDirectory } = input;
-  const manifestPath = join10(projectDirectory, "fornix.json");
-  if (!existsSync7(manifestPath)) {
+  const manifestPath = join12(projectDirectory, "fornix.json");
+  if (!existsSync9(manifestPath)) {
     return err(
       new Error("No fornix.json found. Not a Fornix project directory.")
     );
   }
   let manifest2;
   try {
-    const raw = readFileSync8(manifestPath, "utf-8");
+    const raw = readFileSync10(manifestPath, "utf-8");
     manifest2 = JSON.parse(raw);
   } catch {
     return err(new Error("Failed to parse fornix.json."));
   }
+  const registryResult = await fetchRegistryIndex();
+  if (!isOk(registryResult)) {
+    return err(new Error(`Failed to fetch block registry: ${registryResult.error.message}`));
+  }
+  const manifests = registryResult.value.blocks;
   const installedNames = new Set(manifest2.blocks.map((block) => block.name));
   if (!installedNames.has(name)) {
     return err(new Error(`Block '${name}' is not installed.`));
   }
-  const dependents = findDependents2(name, installedNames);
+  const dependents = findDependents2(name, installedNames, manifests);
   if (dependents.length > 0 && !force) {
     return err(
       new Error(
@@ -4489,12 +4811,12 @@ function removeBlock(input) {
       )
     );
   }
-  const blockManifest = FIXTURE_MANIFESTS[name];
+  const blockManifest = manifests[name];
   const filesToRemove = [];
   if (blockManifest) {
     for (const file of blockManifest.files) {
-      const filePath = join10(projectDirectory, file.destination);
-      if (existsSync7(filePath)) {
+      const filePath = join12(projectDirectory, file.destination);
+      if (existsSync9(filePath)) {
         filesToRemove.push(filePath);
       }
     }
@@ -4504,17 +4826,17 @@ function removeBlock(input) {
     tryRemoveEmptyDirectory(dirname6(filePath), projectDirectory);
   }
   manifest2.blocks = manifest2.blocks.filter((block) => block.name !== name);
-  writeFileSync6(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
+  writeFileSync7(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
   return ok({
     removedBlock: name,
     filesRemoved: filesToRemove.length,
     dependentsWarning: dependents
   });
 }
-function findDependents2(blockName, installedNames) {
+function findDependents2(blockName, installedNames, manifests) {
   const dependents = [];
   for (const installedName of installedNames) {
-    const manifest2 = FIXTURE_MANIFESTS[installedName];
+    const manifest2 = manifests[installedName];
     if (manifest2 && manifest2.requires.includes(blockName)) {
       dependents.push(installedName);
     }
@@ -4524,7 +4846,7 @@ function findDependents2(blockName, installedNames) {
 function tryRemoveEmptyDirectory(directoryPath, rootPath) {
   if (directoryPath === rootPath || !directoryPath.startsWith(rootPath)) return;
   try {
-    const entries = readdirSync3(directoryPath);
+    const entries = readdirSync4(directoryPath);
     if (entries.length === 0) {
       rmdirSync2(directoryPath);
       tryRemoveEmptyDirectory(dirname6(directoryPath), rootPath);
@@ -4534,33 +4856,51 @@ function tryRemoveEmptyDirectory(directoryPath, rootPath) {
 }
 
 // src/mcp/tools/get-content-schema.ts
-function getContentSchema(input) {
-  const { collection } = input;
-  const manifest2 = FIXTURE_MANIFESTS[collection];
+async function getContentSchemaHandler(args2) {
+  const typedArgs = args2;
+  if (!typedArgs?.block) {
+    throw new Error("Missing required argument: block");
+  }
+  const result = await fetchRegistryIndex();
+  if (!isOk(result)) {
+    throw new Error(`Failed to fetch block registry: ${result.error.message}`);
+  }
+  const manifests = result.value.blocks;
+  const manifest2 = manifests[typedArgs.block];
   if (!manifest2) {
-    return err(
-      new Error(`Collection '${collection}' not found in registry.`)
-    );
+    throw new Error(`Block '${typedArgs.block}' not found in registry`);
   }
-  const contentSlots = manifest2.ai?.contentSlots;
-  if (!contentSlots || Object.keys(contentSlots).length === 0) {
-    return err(
-      new Error(
-        `Block '${collection}' does not define content slots.`
-      )
-    );
+  const slots = manifest2.ai?.contentSlots ?? {};
+  if (Object.keys(slots).length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Block '${typedArgs.block}' does not have any AI-configurable content slots.`
+        }
+      ]
+    };
   }
-  return ok({
-    collection,
-    slots: contentSlots
-  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(slots, null, 2)
+      }
+    ]
+  };
 }
 
 // src/mcp/tools/validate-content.ts
 import { z as z5 } from "zod";
-function validateContent(input) {
+async function validateContent(input) {
   const { collection, data } = input;
-  const manifest2 = FIXTURE_MANIFESTS[collection];
+  const registryResult = await fetchRegistryIndex();
+  if (!isOk(registryResult)) {
+    return err(new Error(`Failed to fetch block registry: ${registryResult.error.message}`));
+  }
+  const manifests = registryResult.value.blocks;
+  const manifest2 = manifests[collection];
   if (!manifest2) {
     return err(
       new Error(
@@ -4608,17 +4948,17 @@ function zodTypeForSlot2(slotType) {
 }
 
 // src/mcp/tools/get-project-status.ts
-import { readFileSync as readFileSync9, existsSync as existsSync8 } from "fs";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync11, existsSync as existsSync10 } from "fs";
+import { join as join13 } from "path";
 function getProjectStatus(input) {
-  const manifestPath = join11(input.projectDirectory, "fornix.json");
-  if (!existsSync8(manifestPath)) {
+  const manifestPath = join13(input.projectDirectory, "fornix.json");
+  if (!existsSync10(manifestPath)) {
     return err(
       new Error("No fornix.json found. Not a Fornix project directory.")
     );
   }
   try {
-    const raw = readFileSync9(manifestPath, "utf-8");
+    const raw = readFileSync11(manifestPath, "utf-8");
     const manifest2 = JSON.parse(raw);
     const blocks = manifest2.blocks;
     return ok({
@@ -4640,8 +4980,8 @@ function getProjectStatus(input) {
 }
 
 // src/mcp/tools/scaffold-project.ts
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync7 } from "fs";
-import { join as join12, basename as basename3 } from "path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
+import { join as join14, basename as basename3 } from "path";
 var DEFAULT_COLORS2 = {
   primary: "#6366f1",
   secondary: "#818cf8",
@@ -4649,7 +4989,7 @@ var DEFAULT_COLORS2 = {
   background: "#0f172a",
   foreground: "#f8fafc"
 };
-function scaffoldProject(input) {
+async function scaffoldProject(input) {
   const {
     projectDirectory,
     renderMode = "static",
@@ -4657,9 +4997,14 @@ function scaffoldProject(input) {
     blocks = [],
     locales = ["en"]
   } = input;
+  const registryResult = await fetchRegistryIndex();
+  if (!isOk(registryResult)) {
+    return err(new Error(`Failed to fetch block registry: ${registryResult.error.message}`));
+  }
+  const manifests = registryResult.value.blocks;
+  const allPalettes = registryResult.value.palettes.length > 0 ? registryResult.value.palettes : loadAllPalettes();
   const projectName = basename3(projectDirectory);
   const blockSelections = blocks.map((name) => ({ name, variant: "default" }));
-  const allPalettes = loadAllPalettes();
   const config = {
     projectName,
     projectDir: projectDirectory,
@@ -4677,11 +5022,27 @@ function scaffoldProject(input) {
     themeSwitcher: false,
     createdWith: "mcp"
   };
+  const blockResults = await fetchBlocks([...blocks]);
+  const blockSources = {};
+  const blockDefaultContent = {};
+  for (const result2 of blockResults) {
+    if (!isOk(result2)) {
+      return err(new Error(`Failed to fetch block '${result2.error.blockName}': ${result2.error.message}`));
+    }
+    const { manifest: manifest2, files: files2 } = result2.value;
+    blockSources[manifest2.name] = files2;
+    try {
+      if (files2["default-content.json"]) {
+        blockDefaultContent[manifest2.name] = JSON.parse(files2["default-content.json"]);
+      }
+    } catch {
+    }
+  }
   const scaffoldInput = {
     config,
-    manifests: FIXTURE_MANIFESTS,
-    blockSources: FIXTURE_BLOCK_SOURCES,
-    blockDefaultContent: FIXTURE_DEFAULT_CONTENT,
+    manifests,
+    blockSources,
+    blockDefaultContent,
     allPalettes
   };
   const result = scaffold(scaffoldInput);
@@ -4691,10 +5052,10 @@ function scaffoldProject(input) {
   const files = result.value.files;
   let filesCreated = 0;
   for (const [relativePath, content] of Object.entries(files)) {
-    const fullPath = join12(projectDirectory, relativePath);
-    const parentDirectory = join12(fullPath, "..");
-    mkdirSync5(parentDirectory, { recursive: true });
-    writeFileSync7(fullPath, content, "utf-8");
+    const fullPath = join14(projectDirectory, relativePath);
+    const parentDirectory = join14(fullPath, "..");
+    mkdirSync7(parentDirectory, { recursive: true });
+    writeFileSync8(fullPath, content, "utf-8");
     filesCreated++;
   }
   return ok({
@@ -4891,7 +5252,11 @@ var FornixMCPServer = class {
       async (request) => {
         const uri = request.params.uri;
         if (uri === "fornix://registry") {
-          const blocks = Object.values(FIXTURE_MANIFESTS).map((manifest2) => ({
+          const registryResult = await fetchRegistryIndex();
+          if (!isOk(registryResult)) {
+            throw new Error(`Failed to fetch block registry: ${registryResult.error.message}`);
+          }
+          const blocks = Object.values(registryResult.value.blocks).map((manifest2) => ({
             name: manifest2.name,
             type: manifest2.type,
             category: manifest2.category,
@@ -4934,16 +5299,19 @@ var FornixMCPServer = class {
   async executeTool(toolName, args2) {
     switch (toolName) {
       case "list_blocks": {
-        const result = listBlocks({
-          type: args2.type,
-          category: args2.category,
-          search: args2.search
-        });
-        if (!result.ok) return err(result.error);
-        return ok(JSON.stringify(result.value, null, 2));
+        try {
+          const response = await listBlocksHandler({
+            type: args2.type,
+            category: args2.category,
+            search: args2.search
+          });
+          return ok(response.content[0].text);
+        } catch (e) {
+          return err(e instanceof Error ? e : new Error(String(e)));
+        }
       }
       case "add_block": {
-        const result = addBlock2({
+        const result = await addBlock2({
           name: args2.name,
           variant: args2.variant,
           projectDirectory: args2.projectDirectory
@@ -4952,7 +5320,7 @@ var FornixMCPServer = class {
         return ok(JSON.stringify(result.value, null, 2));
       }
       case "remove_block": {
-        const result = removeBlock({
+        const result = await removeBlock({
           name: args2.name,
           force: args2.force,
           projectDirectory: args2.projectDirectory
@@ -4961,14 +5329,17 @@ var FornixMCPServer = class {
         return ok(JSON.stringify(result.value, null, 2));
       }
       case "get_content_schema": {
-        const result = getContentSchema({
-          collection: args2.collection
-        });
-        if (!result.ok) return err(result.error);
-        return ok(JSON.stringify(result.value, null, 2));
+        try {
+          const response = await getContentSchemaHandler({
+            block: args2.collection
+          });
+          return ok(response.content[0].text);
+        } catch (e) {
+          return err(e instanceof Error ? e : new Error(String(e)));
+        }
       }
       case "update_content": {
-        const validationResult = validateContent({
+        const validationResult = await validateContent({
           collection: args2.collection,
           data: args2.data
         });
@@ -4990,7 +5361,7 @@ var FornixMCPServer = class {
         );
       }
       case "validate_content": {
-        const result = validateContent({
+        const result = await validateContent({
           collection: args2.collection,
           data: args2.data
         });
@@ -5005,7 +5376,7 @@ var FornixMCPServer = class {
         return ok(JSON.stringify(result.value, null, 2));
       }
       case "scaffold_project": {
-        const result = scaffoldProject({
+        const result = await scaffoldProject({
           description: args2.description,
           projectDirectory: args2.projectDirectory,
           renderMode: args2.renderMode,