blockend-cli 2.0.2 → 2.1.1

package/dist/index.js

@@ -4,22 +4,537 @@
 import { defineCommand, runMain } from "citty";
 
 // src/commands/add.ts
-import path, { join, dirname } from "path";
-import fs from "fs/promises";
+import path5, { dirname as dirname4, join as join3 } from "path";
+import fs5 from "fs/promises";
 import { exec } from "child_process";
 import { intro, outro, select, multiselect, spinner, confirm, isCancel, log } from "@clack/prompts";
 import pc from "picocolors";
-var REPO_OWNER = "codewithnuh";
-var REPO_NAME = "blockend";
-var BRANCH = "master";
-var RAW_CDN_BASE = `https://raw.githubusercontent.com/${REPO_OWNER}/${REPO_NAME}/${BRANCH}`;
-var MANIFEST_URL = `${RAW_CDN_BASE}/registry/index.json`;
-function blockSupportsEnv(block, envKey) {
+
+// ../registry/dist/index.js
+import { z } from "zod";
+var FRAMEWORK_KEYS = ["express", "fastify", "hono", "next", "*"];
+var FRAMEWORK_NAMES = ["express", "fastify", "hono", "next"];
+var BLOCK_SLUG_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var DEPENDENCY_PATTERN = /^[a-z@][a-z0-9._/-]*(@[~^>=<]*[0-9]+(\.[0-9]+)*)?$/;
+var RELEASED_AT_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+var FrameworkKeySchema = z.enum(FRAMEWORK_KEYS);
+var FrameworkNameSchema = z.enum(FRAMEWORK_NAMES);
+var nonEmptyString = z.string().min(1, "must not be empty");
+function isValidCalendarDate(value) {
+  if (!RELEASED_AT_PATTERN.test(value)) return false;
+  const [year, month, day] = value.split("-").map(Number);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+var AssetMappingSchema = z.object({
+  source: z.string().min(1, "source path must not be empty").describe("Repo-relative source path."),
+  target: z.string().min(1, "target path must not be empty").describe("Block-folder-relative destination path.")
+}).strict();
+var AssetReferenceSchema = z.union([z.string().min(1), AssetMappingSchema]);
+var VariantSchema = z.object({
+  dependencies: z.array(z.string()).describe("Variant-specific production dependencies.").optional(),
+  devDependencies: z.array(z.string()).describe("Variant-specific development dependencies.").optional(),
+  files: z.array(AssetReferenceSchema).describe("Files copied for this variant.")
+}).strict();
+var FrameworkMappingSchema = z.object({
+  core: z.string().describe("Optional fallback template.").optional(),
+  dependencies: z.array(z.string()).describe("Dependencies for this framework mapping.").optional(),
+  devDependencies: z.array(z.string()).describe("Development dependencies for this framework mapping.").optional(),
+  variants: z.record(z.string(), VariantSchema).describe("Storage or implementation variants.")
+}).strict();
+function blockSlugArray(label) {
+  return z.array(
+    z.string().regex(BLOCK_SLUG_PATTERN, `${label} entries must be valid registry slugs`).min(1, `${label} entries must not be empty`)
+  ).meta({ uniqueItems: true }).optional();
+}
+var BlockSchema = z.object({
+  name: z.string().min(1, "block name must not be empty").describe("Human-readable block name."),
+  description: z.string().min(1, "block description must not be empty").describe("Short description of the block."),
+  version: z.string().describe('Semantic version of this block (e.g. "1.0.0"). Used for update tracking.').optional(),
+  frameworks: z.array(FrameworkKeySchema).meta({ uniqueItems: true }).refine(
+    (frameworks) => new Set(frameworks).size === frameworks.length,
+    "frameworks must not contain duplicates"
+  ).describe(
+    'Explicit framework support list. Named keys mean the block only supports that environment; "*" means framework-agnostic.'
+  ).optional(),
+  releasedAt: z.string().regex(RELEASED_AT_PATTERN, "releasedAt must be a valid ISO date (YYYY-MM-DD)").refine(isValidCalendarDate, "releasedAt must be a valid ISO date (YYYY-MM-DD)").describe("ISO calendar date (YYYY-MM-DD) when this block was first released.").optional(),
+  runtimes: z.record(z.enum(["node"]), z.string().min(1, "runtime version range must not be empty")).describe('Supported runtime engine ranges, e.g. {"node": ">=20"}.').optional(),
+  requires: blockSlugArray("requires").describe(
+    "Registry slugs that must be installed alongside this block."
+  ),
+  related: blockSlugArray("related").describe("Registry slugs that pair well with this block."),
+  conflicts: blockSlugArray("conflicts").describe(
+    "Registry slugs that must not be installed together with this block."
+  ),
+  dependencies: z.array(z.string().regex(DEPENDENCY_PATTERN, "invalid dependency format")).describe("Production dependencies, optionally with version ranges.").optional(),
+  devDependencies: z.array(z.string().regex(DEPENDENCY_PATTERN, "invalid devDependency format")).describe("Development dependencies, optionally with version ranges.").optional(),
+  baseFiles: z.array(AssetMappingSchema).describe("Files copied for every install of this block.").optional(),
+  adapters: z.partialRecord(FrameworkKeySchema, FrameworkMappingSchema).describe("Framework adapter mappings.").optional(),
+  environments: z.partialRecord(FrameworkKeySchema, FrameworkMappingSchema).describe("Legacy framework mappings.").optional()
+}).strict().refine(
+  (block) => block.baseFiles || block.adapters || block.environments,
+  "block must define at least one of: baseFiles, adapters, or environments"
+);
+var BlockDeclarationSchema = BlockSchema.safeExtend({
+  $schema: z.string().optional().describe("JSON Schema reference for editor support.")
+});
+var RegistrySchema = z.object({
+  $schema: z.string().optional(),
+  version: z.string().min(1, "registry version must not be empty").describe("Semantic version of the registry schema layout."),
+  blocks: z.record(z.string().min(1, "block key must not be empty"), BlockSchema).describe("Dictionary lookup table of all available ingestible component blocks.")
+}).strict();
+var blockSlug = z.string().regex(BLOCK_SLUG_PATTERN, "must be a valid registry block slug");
+var uniqueBlockSlugs = z.array(blockSlug).meta({ uniqueItems: true }).refine(
+  (slugs) => new Set(slugs).size === slugs.length,
+  "must not contain duplicate block slugs"
+);
+var requiredBlockSlugs = z.array(blockSlug).min(1).meta({ uniqueItems: true }).refine(
+  (slugs) => new Set(slugs).size === slugs.length,
+  "must not contain duplicate block slugs"
+);
+var RecipeSchema = z.object({
+  slug: blockSlug.describe("Stable URL-safe recipe identifier."),
+  title: nonEmptyString,
+  outcome: nonEmptyString.describe("What a developer will have after following the recipe."),
+  includedBlocks: requiredBlockSlugs,
+  optionalBlocks: uniqueBlockSlugs,
+  integrationOrder: uniqueBlockSlugs.describe(
+    "A complete ordering of included and optional blocks, respecting registry requirements."
+  ),
+  architecture: z.object({
+    overview: nonEmptyString,
+    components: z.array(
+      z.object({
+        name: nonEmptyString,
+        description: nonEmptyString,
+        block: blockSlug.optional()
+      }).strict()
+    )
+  }).strict(),
+  assumptions: z.array(nonEmptyString),
+  configuration: z.array(
+    z.object({
+      name: nonEmptyString,
+      description: nonEmptyString,
+      required: z.boolean(),
+      default: z.string().optional()
+    }).strict()
+  ),
+  tradeoffs: z.array(
+    z.object({
+      choice: nonEmptyString,
+      tradeoff: nonEmptyString
+    }).strict()
+  ),
+  alternatives: z.array(
+    z.object({
+      title: nonEmptyString,
+      description: nonEmptyString
+    }).strict()
+  ).optional(),
+  failureBehavior: z.array(
+    z.object({
+      scenario: nonEmptyString,
+      behavior: nonEmptyString
+    }).strict()
+  ),
+  commands: z.array(
+    z.object({
+      label: nonEmptyString,
+      command: nonEmptyString
+    }).strict()
+  ),
+  relatedContent: z.array(
+    z.object({
+      title: nonEmptyString,
+      href: z.string().regex(/^(https:\/\/|\/)/, "must be an HTTPS URL or site-relative path")
+    }).strict()
+  )
+}).strict();
+var RecipeCollectionSchema = z.object({
+  $schema: z.string().optional(),
+  version: nonEmptyString.describe("Version of the recipe collection format."),
+  recipes: z.array(RecipeSchema).describe("Production-ready backend recipes published by Blockend.")
+}).strict();
+var RegistryParseError = class extends Error {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+    this.name = "RegistryParseError";
+  }
+  issues;
+};
+function formatIssues(issues) {
+  return issues.map((issue) => {
+    const path22 = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
+    return `${path22}${issue.message}`;
+  }).join("\n");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLegacyRegistry(input) {
+  if (!isRecord(input)) return false;
+  const blocks = input.blocks;
+  if (!isRecord(blocks)) {
+    return typeof input.version !== "string";
+  }
+  return "name" in blocks || "description" in blocks;
+}
+function parseRegistry(input, options = {}) {
+  let result = RegistrySchema.safeParse(input);
+  if (!result.success && options.allowLegacy && isLegacyRegistry(input)) {
+    result = RegistrySchema.safeParse({ version: "0.0.0", blocks: input });
+  }
+  if (!result.success) {
+    throw new RegistryParseError(
+      `Invalid registry:
+${formatIssues(result.error.issues)}`,
+      result.error.issues
+    );
+  }
+  return result.data;
+}
+
+// src/block-install/registry.ts
+var DEFAULT_REPO_OWNER = "codewithnuh";
+var DEFAULT_REPO_NAME = "blockend";
+var DEFAULT_BRANCH = "master";
+function createGitHubRegistrySource(options = {}) {
+  const baseUrl = options.baseUrl ?? `https://raw.githubusercontent.com/${options.owner ?? DEFAULT_REPO_OWNER}/${options.repo ?? DEFAULT_REPO_NAME}/${options.branch ?? DEFAULT_BRANCH}`;
+  return {
+    async fetchRegistry() {
+      const response = await fetch(`${baseUrl}/registry/index.json`);
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      return parseRegistry(await response.json(), { allowLegacy: true });
+    },
+    async fetchFile(sourcePath) {
+      const response = await fetch(`${baseUrl}/${sourcePath}`);
+      if (!response.ok) {
+        throw new Error(`Download failed: ${sourcePath} (HTTP ${response.status})`);
+      }
+      return response.text();
+    }
+  };
+}
+async function loadRegistry(source) {
+  return source.fetchRegistry();
+}
+function getBlockMap(registry) {
+  return registry.blocks;
+}
+
+// src/block-install/plan.ts
+import path from "path";
+
+// src/block-install/variants.ts
+import { join } from "path";
+import fs from "fs/promises";
+function selectVariant(variantKeys, preferredVariant) {
+  if (preferredVariant && variantKeys.includes(preferredVariant)) {
+    return preferredVariant;
+  }
+  if (variantKeys.includes("memory")) return "memory";
+  if (variantKeys.includes("default")) return "default";
+  return variantKeys[0];
+}
+async function resolvePreferredVariant(variantKeys, recordedVariant, targetFolder) {
+  if (recordedVariant && variantKeys.includes(recordedVariant)) {
+    return recordedVariant;
+  }
+  if (variantKeys.includes("redis")) {
+    const markers = [
+      join(targetFolder, "variants", "redis-store.ts"),
+      join(targetFolder, "variants", "redis-store.test.ts"),
+      join(targetFolder, "variants", "redis.test.ts")
+    ];
+    for (const marker of markers) {
+      try {
+        await fs.access(marker);
+        return "redis";
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/block-install/plan.ts
+function blockSupportsEnv(block, environment) {
   if (block.frameworks && block.frameworks.length > 0) {
-    return block.frameworks.includes("*") || block.frameworks.includes(envKey);
+    return block.frameworks.includes("*") || block.frameworks.includes(environment);
+  }
+  const framework = environment;
+  return block.adapters?.[framework] !== void 0 || block.environments?.[framework] !== void 0;
+}
+function resolveAdapterContext(block, environment) {
+  const framework = environment;
+  return block.adapters?.[framework] ?? block.adapters?.["*"] ?? block.environments?.[framework] ?? block.environments?.["*"] ?? null;
+}
+function normalizeFiles(files) {
+  if (!files) return [];
+  return files.map(
+    (entry) => typeof entry === "string" ? { source: entry, target: path.basename(entry) } : entry
+  );
+}
+function planError(code, blockName, environment) {
+  if (code === "not-found") {
+    return {
+      code,
+      blockName,
+      environment,
+      message: `Block "${blockName}" not found in the registry.`
+    };
+  }
+  if (code === "unsupported-environment") {
+    return {
+      code,
+      blockName,
+      environment,
+      message: `Block "${blockName}" does not support environment: ${environment}`
+    };
+  }
+  if (code === "no-adapter") {
+    return {
+      code,
+      blockName,
+      environment,
+      message: `Block "${blockName}" has no adapter or environment entry for: ${environment}. This is a registry configuration issue \u2014 please open an issue.`
+    };
+  }
+  return {
+    code,
+    blockName,
+    environment,
+    message: `No variants found for "${blockName}" / "${environment}".`
+  };
+}
+async function planBlock(registry, blockName, environment, options = {}) {
+  const block = getBlockMap(registry)[blockName];
+  if (!block) {
+    return { ok: false, error: planError("not-found", blockName, environment) };
+  }
+  if (!blockSupportsEnv(block, environment)) {
+    return { ok: false, error: planError("unsupported-environment", blockName, environment) };
+  }
+  const adapterContext = resolveAdapterContext(block, environment);
+  if (!adapterContext) {
+    return { ok: false, error: planError("no-adapter", blockName, environment) };
+  }
+  const variantKeys = Object.keys(adapterContext.variants ?? {});
+  if (variantKeys.length === 0) {
+    return { ok: false, error: planError("no-variants", blockName, environment) };
+  }
+  let preferred = options.variant ?? options.recordedVariant;
+  if (options.targetFolder && (!preferred || !variantKeys.includes(preferred))) {
+    preferred = await resolvePreferredVariant(variantKeys, preferred, options.targetFolder) ?? preferred;
+  }
+  const selectedVariant = selectVariant(variantKeys, preferred);
+  const variantMeta = adapterContext.variants[selectedVariant];
+  const files = [];
+  if (block.baseFiles?.length) files.push(...block.baseFiles);
+  if (adapterContext.core) {
+    files.push({ source: adapterContext.core, target: path.basename(adapterContext.core) });
+  }
+  files.push(...normalizeFiles(variantMeta?.files));
+  const plan = {
+    blockName,
+    block,
+    environment,
+    variant: selectedVariant,
+    variantKeys,
+    files,
+    dependencies: [
+      ...block.dependencies ?? [],
+      ...adapterContext.dependencies ?? [],
+      ...variantMeta?.dependencies ?? []
+    ],
+    devDependencies: [
+      ...block.devDependencies ?? [],
+      ...adapterContext.devDependencies ?? [],
+      ...variantMeta?.devDependencies ?? []
+    ]
+  };
+  return { ok: true, plan };
+}
+async function listAvailableBlocks(registry, environment) {
+  const available = [];
+  for (const [name, block] of Object.entries(getBlockMap(registry))) {
+    if (!block) continue;
+    const result = await planBlock(registry, name, environment);
+    if (!result.ok) continue;
+    available.push({
+      name,
+      description: block.description,
+      variants: result.plan.variantKeys
+    });
+  }
+  return available;
+}
+
+// src/block-install/preview.ts
+import path2 from "path";
+import fs2 from "fs/promises";
+async function previewBlock(plan, options) {
+  const previews = [];
+  for (const file of plan.files) {
+    const targetPath = path2.join(options.targetFolder, file.target);
+    let newContent;
+    try {
+      newContent = await options.source.fetchFile(file.source);
+    } catch (error) {
+      if (options.onDownloadError === "empty") {
+        newContent = "";
+      } else {
+        throw error;
+      }
+    }
+    let existingContent = null;
+    let status = "new";
+    try {
+      existingContent = await fs2.readFile(targetPath, "utf-8");
+      status = existingContent === newContent ? "unchanged" : "modified";
+    } catch {
+    }
+    previews.push({
+      name: file.target,
+      sourcePath: file.source,
+      targetPath,
+      existingContent,
+      newContent,
+      status
+    });
   }
-  return block.adapters?.[envKey] !== void 0 || block.environments?.[envKey] !== void 0;
+  return previews;
+}
+
+// src/block-install/apply.ts
+import path4, { dirname as dirname3 } from "path";
+import fs4 from "fs/promises";
+
+// src/block-install/imports.ts
+import path3, { dirname } from "path";
+function resolveIndexImport(importPath, sourceFileDir, downloadedFiles, blockRoot) {
+  const resolved = path3.resolve(sourceFileDir, importPath);
+  for (const downloaded of downloadedFiles) {
+    const downloadedAbs = path3.resolve(blockRoot, downloaded);
+    const dirOfDownloaded = dirname(downloadedAbs);
+    const basenameOfDownloaded = path3.basename(downloadedAbs);
+    if (dirOfDownloaded === resolved && basenameOfDownloaded.startsWith("index.")) {
+      return true;
+    }
+  }
+  return false;
+}
+function rewriteFileImports(fileContent, writtenFilePath, blocksRoot, aliasBase, strategy, downloadedFiles = /* @__PURE__ */ new Set(), blockRoot = dirname(writtenFilePath)) {
+  const importRegex = /((?:from|import)\s*)(['"`])(\.\.?\/[^'"` \n\r]+)(['"`])/g;
+  const fileDir = dirname(writtenFilePath);
+  return fileContent.replace(importRegex, (match, keyword, openQuote, importPath, closeQuote) => {
+    let targetPath = importPath;
+    if (aliasBase && !aliasBase.startsWith(".")) {
+      const absoluteTarget = path3.resolve(fileDir, importPath);
+      const fromBlocksRoot = path3.relative(blocksRoot, absoluteTarget).replace(/\\/g, "/");
+      if (!fromBlocksRoot.startsWith("..")) {
+        targetPath = `${aliasBase}/${fromBlocksRoot}`.replace(/\/+/g, "/");
+      }
+    }
+    const hasJsExt = targetPath.endsWith(".js");
+    if (strategy === "rewrite" && !hasJsExt) {
+      targetPath = targetPath.replace(/\.(ts|tsx|mts|cts)$/, "");
+      if (downloadedFiles.size > 0) {
+        if (resolveIndexImport(importPath, fileDir, downloadedFiles, blockRoot)) {
+          targetPath = `${targetPath}/index`;
+        }
+      }
+      targetPath = `${targetPath}.js`;
+    } else if (strategy === "remove" && hasJsExt) {
+      targetPath = targetPath.slice(0, -3);
+    }
+    return `${keyword}${openQuote}${targetPath}${closeQuote}`;
+  });
+}
+
+// src/block-install/config.ts
+import { dirname as dirname2, join as join2 } from "path";
+import fs3 from "fs/promises";
+async function findUp(filename, startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join2(dir, filename);
+    try {
+      await fs3.access(candidate);
+      return candidate;
+    } catch {
+      const parent = dirname2(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return null;
+}
+async function recordInstalledBlock(configPath, record) {
+  try {
+    const raw = await fs3.readFile(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    if (!Array.isArray(config.installed)) config.installed = [];
+    config.installed = config.installed.filter((block) => block.name !== record.name);
+    config.installed.push(record);
+    await fs3.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+  } catch {
+  }
+}
+
+// src/block-install/apply.ts
+function hashContent(content, previous) {
+  let hash = previous;
+  for (let i = 0; i < content.length; i++) {
+    hash = (hash << 5) - hash + content.charCodeAt(i) | 0;
+  }
+  return hash;
+}
+async function applyBlock(plan, options) {
+  const targetFolder = path4.resolve(options.blocksRoot, plan.blockName);
+  const downloadedTargets = new Set(plan.files.map((file) => file.target));
+  const downloaded = [];
+  for (const file of plan.files) {
+    downloaded.push({ file, raw: await options.source.fetchFile(file.source) });
+  }
+  const filesWritten = [];
+  let contentHash = 0;
+  for (const { file, raw } of downloaded) {
+    const writtenFilePath = path4.join(targetFolder, file.target);
+    const content = rewriteFileImports(
+      raw,
+      writtenFilePath,
+      options.blocksRoot,
+      options.aliasBase,
+      options.rewriteStrategy,
+      downloadedTargets,
+      targetFolder
+    );
+    await fs4.mkdir(dirname3(writtenFilePath), { recursive: true });
+    await fs4.writeFile(writtenFilePath, content, "utf-8");
+    filesWritten.push(writtenFilePath);
+    contentHash = hashContent(content, contentHash);
+  }
+  const record = {
+    name: plan.blockName,
+    version: plan.block.version ?? "0.0.0",
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: filesWritten.map((file) => path4.relative(targetFolder, file).replace(/\\/g, "/")),
+    contentHash: contentHash.toString(16),
+    variant: plan.variant
+  };
+  await recordInstalledBlock(options.configPath, record);
+  return {
+    block: plan.blockName,
+    variant: plan.variant,
+    files: filesWritten,
+    record
+  };
 }
+
+// src/block-install/deps.ts
 function parseDepSpec(dep) {
   const atIndex = dep.lastIndexOf("@");
   if (atIndex > 0) {
@@ -77,49 +592,8 @@ var getMissingDependencies = (deps, installed, forceLatest = false) => {
   }
   return result;
 };
-function resolveAdapterContext(block, envKey) {
-  return block.adapters?.[envKey] ?? block.adapters?.["*"] ?? block.environments?.[envKey] ?? block.environments?.["*"] ?? null;
-}
-function resolveIndexImport(importPath, sourceFileDir, downloadedFiles) {
-  const resolved = path.resolve(sourceFileDir, importPath);
-  for (const downloaded of downloadedFiles) {
-    const downloadedAbs = path.resolve(sourceFileDir, downloaded);
-    const dirOfDownloaded = dirname(downloadedAbs);
-    const basenameOfDownloaded = path.basename(downloadedAbs);
-    if (dirOfDownloaded === resolved && basenameOfDownloaded.startsWith("index.")) {
-      return `${importPath}/index`;
-    }
-  }
-  return null;
-}
-function rewriteFileImports(fileContent, writtenFilePath, blocksRoot, aliasBase, strategy, downloadedFiles = /* @__PURE__ */ new Set()) {
-  const importRegex = /((?:from|import)\s*)(['"`])(\.\.?\/[^'"` \n\r]+)(['"`])/g;
-  const fileDir = dirname(writtenFilePath);
-  return fileContent.replace(importRegex, (match, keyword, openQuote, importPath, closeQuote) => {
-    let targetPath = importPath;
-    if (aliasBase && !aliasBase.startsWith(".")) {
-      const absoluteTarget = path.resolve(fileDir, importPath);
-      const fromBlocksRoot = path.relative(blocksRoot, absoluteTarget).replace(/\\/g, "/");
-      if (!fromBlocksRoot.startsWith("..")) {
-        targetPath = `${aliasBase}/${fromBlocksRoot}`.replace(/\/+/g, "/");
-      }
-    }
-    const hasJsExt = targetPath.endsWith(".js");
-    if (strategy === "rewrite" && !hasJsExt) {
-      targetPath = targetPath.replace(/\.(ts|tsx|mts|cts)$/, "");
-      if (downloadedFiles.size > 0) {
-        const indexResolved = resolveIndexImport(targetPath, fileDir, downloadedFiles);
-        if (indexResolved) {
-          targetPath = indexResolved;
-        }
-      }
-      targetPath = `${targetPath}.js`;
-    } else if (strategy === "remove" && hasJsExt) {
-      targetPath = targetPath.slice(0, -3);
-    }
-    return `${keyword}${openQuote}${targetPath}${closeQuote}`;
-  });
-}
+
+// src/commands/add.ts
 function outputError(json, message) {
   if (json) {
     process.stdout.write(JSON.stringify({ success: false, error: message }) + "\n");
@@ -140,46 +614,37 @@ function handleCancel(value) {
     process.exit(0);
   }
 }
-async function findUp(filename, startDir) {
-  let dir = startDir;
-  while (true) {
-    const candidate = join(dir, filename);
-    try {
-      await fs.access(candidate);
-      return candidate;
-    } catch {
-      const parent = dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-  }
-  return null;
+function failureMessage(code, blockName) {
+  if (code === "not-found") return `Block "${blockName}" not found`;
+  if (code === "unsupported-environment") return `Block "${blockName}" incompatible`;
+  if (code === "no-adapter") return `No adapter for "${blockName}"`;
+  return `No variants for "${blockName}"`;
 }
-async function addSingleBlock(targetBlock, blockMap, config, rootDir, physicalBlocksPath, blocksRootAbsolute, aliasBase, envKey, rewriteStrategy, options) {
-  const { yes = false, json = false } = options;
+async function addSingleBlock(targetBlock, context) {
+  const { yes = false, json = false } = context.options;
+  const {
+    registry,
+    source,
+    config,
+    configPath,
+    rootDir,
+    physicalBlocksPath,
+    blocksRootAbsolute,
+    aliasBase,
+    envKey,
+    rewriteStrategy
+  } = context;
   const s = spinner();
-  const blockMeta = blockMap[targetBlock];
-  if (!blockMeta) {
-    outputError(json, `Block "${targetBlock}" not found in the registry.`);
-    return { success: false, filesWritten: [], message: `Block "${targetBlock}" not found` };
-  }
-  if (!blockSupportsEnv(blockMeta, envKey)) {
-    outputError(json, `Block "${targetBlock}" does not support environment: ${envKey}`);
-    return { success: false, filesWritten: [], message: `Block "${targetBlock}" incompatible` };
-  }
-  const adapterContext = resolveAdapterContext(blockMeta, envKey);
-  if (!adapterContext) {
-    outputError(
-      json,
-      `Block "${targetBlock}" has no adapter or environment entry for: ${envKey}. This is a registry configuration issue \u2014 please open an issue.`
-    );
-    return { success: false, filesWritten: [], message: `No adapter for "${targetBlock}"` };
-  }
-  const variantKeys = Object.keys(adapterContext.variants ?? {});
-  if (variantKeys.length === 0) {
-    outputError(json, `No variants found for "${targetBlock}" / "${envKey}".`);
-    return { success: false, filesWritten: [], message: `No variants for "${targetBlock}"` };
+  const initialPlan = await planBlock(registry, targetBlock, envKey);
+  if (!initialPlan.ok) {
+    outputError(json, initialPlan.error.message);
+    return {
+      success: false,
+      filesWritten: [],
+      message: failureMessage(initialPlan.error.code, targetBlock)
+    };
   }
+  const variantKeys = initialPlan.plan.variantKeys;
   let selectedVariant;
   if (yes) {
     selectedVariant = variantKeys.includes("memory") ? "memory" : variantKeys[0];
@@ -190,22 +655,36 @@ async function addSingleBlock(targetBlock, blockMap, config, rootDir, physicalBl
   } else {
     const variantPrompt = await select({
       message: `Select a storage variant for ${targetBlock}:`,
-      options: variantKeys.map((v) => ({ value: v, label: v.toUpperCase() }))
+      options: variantKeys.map((variant) => ({ value: variant, label: variant.toUpperCase() }))
     });
     handleCancel(variantPrompt);
     selectedVariant = variantPrompt;
   }
-  const variantMeta = adapterContext.variants[selectedVariant];
-  const targetFolder = path.resolve(blocksRootAbsolute, targetBlock);
+  let plan = initialPlan.plan;
+  if (selectedVariant !== initialPlan.plan.variant) {
+    const selectedPlan = await planBlock(registry, targetBlock, envKey, {
+      variant: selectedVariant
+    });
+    if (!selectedPlan.ok) {
+      outputError(json, selectedPlan.error.message);
+      return {
+        success: false,
+        filesWritten: [],
+        message: failureMessage(selectedPlan.error.code, targetBlock)
+      };
+    }
+    plan = selectedPlan.plan;
+  }
+  const targetFolder = path5.resolve(blocksRootAbsolute, targetBlock);
   const packageJsonPath = await findUp("package.json", rootDir);
   if (!packageJsonPath) {
     outputError(json, "Could not locate package.json.");
     return { success: false, filesWritten: [], message: "package.json not found" };
   }
-  const packageJsonDir = dirname(packageJsonPath);
+  const packageJsonDir = dirname4(packageJsonPath);
   let packageJson;
   try {
-    packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+    packageJson = JSON.parse(await fs5.readFile(packageJsonPath, "utf-8"));
   } catch (err) {
     outputError(json, "Failed to parse package.json.");
     if (!json) log.error(pc.dim(String(err)));
@@ -215,20 +694,10 @@ async function addSingleBlock(targetBlock, blockMap, config, rootDir, physicalBl
     ...packageJson.dependencies ?? {},
     ...packageJson.devDependencies ?? {}
   };
-  const allBlockDeps = [
-    ...blockMeta.dependencies ?? [],
-    ...adapterContext.dependencies ?? [],
-    ...variantMeta?.dependencies ?? []
-  ];
-  const allBlockDevDeps = [
-    ...blockMeta.devDependencies ?? [],
-    ...adapterContext.devDependencies ?? [],
-    ...variantMeta?.devDependencies ?? []
-  ];
-  const missingProd = getMissingDependencies(allBlockDeps, installedDeps, true);
-  const missingDev = getMissingDependencies(allBlockDevDeps, installedDeps, true);
-  const prodConflicts = getVersionConflicts(allBlockDeps, installedDeps);
-  const devConflicts = getVersionConflicts(allBlockDevDeps, installedDeps);
+  const missingProd = getMissingDependencies(plan.dependencies, installedDeps, true);
+  const missingDev = getMissingDependencies(plan.devDependencies, installedDeps, true);
+  const prodConflicts = getVersionConflicts(plan.dependencies, installedDeps);
+  const devConflicts = getVersionConflicts(plan.devDependencies, installedDeps);
   const allConflicts = [...prodConflicts, ...devConflicts];
   if (allConflicts.length > 0 && !json) {
     log.warn(`Version conflicts detected:`);
@@ -244,7 +713,7 @@ async function addSingleBlock(targetBlock, blockMap, config, rootDir, physicalBl
     });
     if (!yes) handleCancel(shouldInstall);
     if (shouldInstall) {
-      const pm = await fs.readFile(join(packageJsonDir, "blockend.json"), "utf8").then((data) => JSON.parse(data).packageManager).catch(() => "npm");
+      const pm = config.packageManager || "npm";
       if (!json) s.start(`Installing via ${pm}...`);
       const tasks = [];
       if (missingProd.length > 0) {
@@ -284,27 +753,10 @@ async function addSingleBlock(targetBlock, blockMap, config, rootDir, physicalBl
       }
     }
   }
-  const filesToDownload = [];
-  if (blockMeta.baseFiles?.length) {
-    filesToDownload.push(...blockMeta.baseFiles);
-  }
-  if (adapterContext.core) {
-    filesToDownload.push({
-      source: adapterContext.core,
-      target: path.basename(adapterContext.core)
-    });
-  }
-  if (variantMeta && Array.isArray(variantMeta.files)) {
-    for (const entry of variantMeta.files) {
-      filesToDownload.push(
-        typeof entry === "string" ? { source: entry, target: path.basename(entry) } : entry
-      );
-    }
-  }
   let hasConflict = false;
-  for (const fm of filesToDownload) {
+  for (const file of plan.files) {
     try {
-      await fs.access(join(targetFolder, fm.target));
+      await fs5.access(join3(targetFolder, file.target));
       hasConflict = true;
       break;
     } catch {
@@ -321,56 +773,18 @@ async function addSingleBlock(targetBlock, blockMap, config, rootDir, physicalBl
     }
   }
   if (!json) s.start(`Downloading ${targetBlock}...`);
-  const filesWritten = [];
-  const downloadedTargets = /* @__PURE__ */ new Set();
   try {
-    const fileBatches = [];
-    for (const fm of filesToDownload) {
-      const res = await fetch(`${RAW_CDN_BASE}/${fm.source}`);
-      if (!res.ok) throw new Error(`Download failed: ${fm.source} (HTTP ${res.status})`);
-      fileBatches.push({ fm, raw: await res.text() });
-      downloadedTargets.add(fm.target);
-    }
-    let contentHash = 0;
-    for (const { fm, raw } of fileBatches) {
-      const writtenFilePath = path.join(targetFolder, fm.target);
-      const content = rewriteFileImports(
-        raw,
-        writtenFilePath,
-        blocksRootAbsolute,
-        aliasBase,
-        rewriteStrategy,
-        downloadedTargets
-      );
-      await fs.mkdir(dirname(writtenFilePath), { recursive: true });
-      await fs.writeFile(writtenFilePath, content, "utf-8");
-      filesWritten.push(writtenFilePath);
-      for (let i = 0; i < content.length; i++) {
-        contentHash = (contentHash << 5) - contentHash + content.charCodeAt(i) | 0;
-      }
-    }
-    const blockVersion = blockMeta.version ?? "0.0.0";
-    const installedRecord = {
-      name: targetBlock,
-      version: blockVersion,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      files: filesWritten.map((f) => path.relative(targetFolder, f).replace(/\\/g, "/")),
-      contentHash: contentHash.toString(16)
-    };
-    try {
-      const blockendPath = join(rootDir, "blockend.json");
-      const cfgRaw = await fs.readFile(blockendPath, "utf-8");
-      const cfgData = JSON.parse(cfgRaw);
-      if (!Array.isArray(cfgData.installed)) cfgData.installed = [];
-      cfgData.installed = cfgData.installed.filter((b) => b.name !== targetBlock);
-      cfgData.installed.push(installedRecord);
-      await fs.writeFile(blockendPath, JSON.stringify(cfgData, null, 2), "utf-8");
-    } catch {
-    }
+    const applied = await applyBlock(plan, {
+      source,
+      blocksRoot: blocksRootAbsolute,
+      aliasBase,
+      rewriteStrategy,
+      configPath
+    });
     if (!json) s.stop("Files written.");
     return {
       success: true,
-      filesWritten,
+      filesWritten: applied.files,
       message: `${targetBlock} added to ${physicalBlocksPath}/${targetBlock}`
     };
   } catch (err) {
@@ -393,10 +807,10 @@ async function addCommand(blockName, options = {}) {
     outputError(json, "blockend.json not found. Run 'npx blockend init' first.");
     return;
   }
-  const rootDir = dirname(configPath);
+  const rootDir = dirname4(configPath);
   let config;
   try {
-    config = JSON.parse(await fs.readFile(configPath, "utf-8"));
+    config = JSON.parse(await fs5.readFile(configPath, "utf-8"));
   } catch (err) {
     outputError(json, "Failed to parse blockend.json.");
     if (!json) log.error(pc.dim(String(err)));
@@ -407,17 +821,16 @@ async function addCommand(blockName, options = {}) {
     return;
   }
   const physicalBlocksPath = config.paths.blocks;
-  const blocksRootAbsolute = path.resolve(rootDir, physicalBlocksPath);
+  const blocksRootAbsolute = path5.resolve(rootDir, physicalBlocksPath);
   const aliasBase = config.aliases.blocks;
   const envKey = config.environment;
   const rewriteStrategy = config.importRewriteStrategy ?? "remove";
+  const source = createGitHubRegistrySource();
   const s = spinner();
   if (!json) s.start("Fetching registry...");
   let registry;
   try {
-    const res = await fetch(MANIFEST_URL);
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    registry = await res.json();
+    registry = await loadRegistry(source);
     if (!json) s.stop("Registry synced.");
   } catch (err) {
     if (!json) {
@@ -426,26 +839,38 @@ async function addCommand(blockName, options = {}) {
     } else outputError(json, "Failed to fetch registry from GitHub.");
     return;
   }
-  const blockMap = registry.blocks && typeof registry.blocks === "object" && !Array.isArray(registry.blocks) ? registry.blocks : registry;
+  const context = {
+    registry,
+    source,
+    config,
+    configPath,
+    rootDir,
+    physicalBlocksPath,
+    blocksRootAbsolute,
+    aliasBase,
+    envKey,
+    rewriteStrategy,
+    options
+  };
   if (yes && !blockName) {
     outputError(json, "Block name required with --yes. Usage: blockend add <block> --yes");
     return;
   }
   if (multi && !blockName) {
-    const available = Object.entries(blockMap).filter(
-      ([, block]) => block != null && blockSupportsEnv(block, envKey)
-    );
+    const available = await listAvailableBlocks(registry, envKey);
     if (available.length === 0) {
       outputError(json, `No blocks available for environment: ${envKey}`);
       if (!json) outro(pc.dim("Exiting."));
       return;
     }
-    const maxKeyLen = Math.max(...available.map(([k]) => k.length), 0);
+    const maxKeyLen = Math.max(...available.map((block) => block.name.length), 0);
     const multiSelectPrompt = await multiselect({
       message: "Select blocks to add (space to select, enter to confirm):",
-      options: available.map(([key, block], i) => ({
-        value: key,
-        label: `${pc.dim(`${i + 1}.`)} ${pc.bold(pc.cyan(key.padEnd(maxKeyLen + 4)))}${pc.dim(
+      options: available.map((block, i) => ({
+        value: block.name,
+        label: `${pc.dim(`${i + 1}.`)} ${pc.bold(
+          pc.cyan(block.name.padEnd(maxKeyLen + 4))
+        )}${pc.dim(
           block.description.length > 60 ? `${block.description.slice(0, 60)}...` : block.description
         )}`
       }))
@@ -461,18 +886,7 @@ Adding ${selectedBlocks.length} block(s)...
 `);
     const results = [];
     for (const block of selectedBlocks) {
-      const result2 = await addSingleBlock(
-        block,
-        blockMap,
-        config,
-        rootDir,
-        physicalBlocksPath,
-        blocksRootAbsolute,
-        aliasBase,
-        envKey,
-        rewriteStrategy,
-        options
-      );
+      const result2 = await addSingleBlock(block, context);
       if (result2.success) {
         results.push(result2.message);
       }
@@ -487,20 +901,20 @@ Adding ${selectedBlocks.length} block(s)...
   }
   let targetBlock = blockName;
   if (!targetBlock) {
-    const available = Object.entries(blockMap).filter(
-      ([, block]) => block != null && blockSupportsEnv(block, envKey)
-    );
+    const available = await listAvailableBlocks(registry, envKey);
     if (available.length === 0) {
       outputError(json, `No blocks available for environment: ${envKey}`);
       if (!json) outro(pc.dim("Exiting."));
       return;
     }
-    const maxKeyLen = Math.max(...available.map(([k]) => k.length), 0);
+    const maxKeyLen = Math.max(...available.map((block) => block.name.length), 0);
     const selectPrompt = await select({
       message: "Which block would you like to add?",
-      options: available.map(([key, block], i) => ({
-        value: key,
-        label: `${pc.dim(`${i + 1}.`)} ${pc.bold(pc.cyan(key.padEnd(maxKeyLen + 4)))}${pc.dim(
+      options: available.map((block, i) => ({
+        value: block.name,
+        label: `${pc.dim(`${i + 1}.`)} ${pc.bold(
+          pc.cyan(block.name.padEnd(maxKeyLen + 4))
+        )}${pc.dim(
           block.description.length > 60 ? `${block.description.slice(0, 60)}...` : block.description
         )}`
       }))
@@ -508,18 +922,7 @@ Adding ${selectedBlocks.length} block(s)...
     handleCancel(selectPrompt);
     targetBlock = selectPrompt;
   }
-  const result = await addSingleBlock(
-    targetBlock,
-    blockMap,
-    config,
-    rootDir,
-    physicalBlocksPath,
-    blocksRootAbsolute,
-    aliasBase,
-    envKey,
-    rewriteStrategy,
-    options
-  );
+  const result = await addSingleBlock(targetBlock, context);
   outputResult(json, {
     success: result.success,
     block: targetBlock,
@@ -529,20 +932,20 @@ Adding ${selectedBlocks.length} block(s)...
 }
 
 // src/commands/init.ts
-import path2, { join as join7 } from "path";
-import fs2 from "fs/promises";
+import path7, { join as join9 } from "path";
+import fs6 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { intro as intro2, outro as outro2, select as select2, text, confirm as confirm2, spinner as spinner2, isCancel as isCancel2, log as log2 } from "@clack/prompts";
 import pc3 from "picocolors";
 
 // src/detectors/index.ts
-import { join as join6 } from "path";
+import path6, { join as join8 } from "path";
 
 // src/detectors/readers/package.ts
 import { readFile } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join4 } from "path";
 async function readPackageJson(cwd) {
-  const pkgPath = join2(cwd, "package.json");
+  const pkgPath = join4(cwd, "package.json");
   try {
     const content = await readFile(pkgPath, "utf-8");
     return JSON.parse(content);
@@ -550,34 +953,126 @@ async function readPackageJson(cwd) {
     throw new Error(`No package.json found at ${pkgPath}. Run blockend from your project root.`);
   }
 }
-
-// src/detectors/readers/tsconfig.ts
-import { readFile as readFile2 } from "fs/promises";
-import { existsSync } from "fs";
-import { join as join3 } from "path";
-async function readTsConfig(cwd) {
-  const tsconfigPath = join3(cwd, "tsconfig.json");
-  if (!existsSync(tsconfigPath)) return null;
-  try {
-    const content = await readFile2(tsconfigPath, "utf-8");
-    const cleanLines = content.split(/\r?\n/).filter((line) => {
-      const trimmed = line.trim();
-      return !trimmed.startsWith("//") && !trimmed.startsWith("/*");
-    }).join("\n").replace(/,(\s*[}\]])/g, "$1");
-    return JSON.parse(cleanLines);
-  } catch {
-    return null;
+
+// src/detectors/readers/tsconfig.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync } from "fs";
+import { join as join5 } from "path";
+var CONFIG_FILES = [
+  { filename: "tsconfig.json", kind: "tsconfig" },
+  { filename: "jsconfig.json", kind: "jsconfig" }
+];
+async function readCompilerConfig(cwd) {
+  for (const { filename, kind } of CONFIG_FILES) {
+    const configPath = join5(cwd, filename);
+    if (!existsSync(configPath)) continue;
+    try {
+      const content = await readFile2(configPath, "utf-8");
+      const clean = stripTrailingCommas(stripJsonComments(content));
+      return {
+        kind,
+        config: JSON.parse(clean)
+      };
+    } catch {
+    }
+  }
+  return null;
+}
+function stripJsonComments(input) {
+  let output = "";
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escaped = false;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const next = input[i + 1];
+    if (inLineComment) {
+      if (char === "\n" || char === "\r") {
+        inLineComment = false;
+        output += char;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === "*" && next === "/") {
+        inBlockComment = false;
+        i++;
+      } else if (char === "\n" || char === "\r") {
+        output += char;
+      }
+      continue;
+    }
+    if (inString) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+function stripTrailingCommas(input) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (inString) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+      continue;
+    }
+    if (char === ",") {
+      let next = i + 1;
+      while (next < input.length && /\s/.test(input[next])) next++;
+      if (input[next] === "}" || input[next] === "]") continue;
+    }
+    output += char;
   }
+  return output;
 }
 
 // src/detectors/readers/filesystem.ts
 import { existsSync as existsSync2 } from "fs";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 async function inferSrcDir(cwd) {
   const candidates = ["src", "app", "lib"];
   for (const dir of candidates) {
-    if (existsSync2(join4(cwd, dir))) {
-      return join4(cwd, dir);
+    if (existsSync2(join6(cwd, dir))) {
+      return join6(cwd, dir);
     }
   }
   return cwd;
@@ -600,9 +1095,9 @@ function detectRuntime(deps) {
 
 // src/detectors/package-manager.ts
 import { existsSync as existsSync3, readFileSync } from "fs";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 function detectPackageManager(cwd) {
-  const pkgJsonPath = join5(cwd, "package.json");
+  const pkgJsonPath = join7(cwd, "package.json");
   if (existsSync3(pkgJsonPath)) {
     try {
       const packageJson = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
@@ -615,52 +1110,76 @@ function detectPackageManager(cwd) {
     } catch {
     }
   }
-  if (existsSync3(join5(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync3(join5(cwd, "bun.lockb"))) return "bun";
-  if (existsSync3(join5(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync3(join7(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(join7(cwd, "bun.lockb"))) return "bun";
+  if (existsSync3(join7(cwd, "yarn.lock"))) return "yarn";
   return "npm";
 }
 
+// src/detectors/alias.ts
+function flattenTsPaths(paths) {
+  const result = {};
+  for (const [alias, targets] of Object.entries(paths)) {
+    if (Array.isArray(targets) && typeof targets[0] === "string" && targets[0].length > 0) {
+      result[alias.replace("/*", "/")] = targets[0].replace("/*", "/");
+    }
+  }
+  return result;
+}
+function deriveBlocksAlias(tsPaths, blocksPhysicalPath) {
+  const normalizedBlocksPath = blocksPhysicalPath.replace(/^\.\//, "").replace(/\\/g, "/");
+  for (const [aliasKey, targets] of Object.entries(tsPaths)) {
+    if (!Array.isArray(targets) || typeof targets[0] !== "string") continue;
+    const rawTarget = targets[0].replace(/\\/g, "/");
+    const targetRoot = rawTarget.replace(/\*$/, "").replace(/\/$/, "").replace(/^\.\//, "");
+    const aliasRoot = aliasKey.replace(/\/\*$/, "").replace(/\*$/, "");
+    if (targetRoot === "") {
+      return `${aliasRoot}/${normalizedBlocksPath}`.replace(/\/+/g, "/");
+    }
+    if (normalizedBlocksPath === targetRoot || normalizedBlocksPath.startsWith(`${targetRoot}/`)) {
+      const suffix = normalizedBlocksPath.slice(targetRoot.length).replace(/^\//, "");
+      const alias = suffix ? `${aliasRoot}/${suffix}` : aliasRoot;
+      return alias.replace(/\/+/g, "/");
+    }
+  }
+  return void 0;
+}
+
 // src/detectors/index.ts
-async function detectProject(cwd) {
-  const [pkg, tsConfig] = await Promise.all([readPackageJson(cwd), readTsConfig(cwd)]);
+async function detectProject(cwd, options = {}) {
+  const [pkg, compilerConfig] = await Promise.all([readPackageJson(cwd), readCompilerConfig(cwd)]);
   const allDeps = {
     ...pkg.dependencies,
     ...pkg.devDependencies,
     ...pkg.peerDependencies
   };
   const srcDir = await inferSrcDir(cwd);
-  const moduleOpt = tsConfig?.compilerOptions?.module?.toLocaleLowerCase();
-  const resolutionOpt = tsConfig?.compilerOptions?.moduleResolution?.toLocaleLowerCase();
+  const compilerOptions = compilerConfig?.config.compilerOptions;
+  const moduleOpt = compilerOptions?.module?.toLocaleLowerCase();
+  const resolutionOpt = compilerOptions?.moduleResolution?.toLocaleLowerCase();
   let importRewriteStrategy = "remove";
   if (moduleOpt === "nodenext" || moduleOpt === "node16" || resolutionOpt === "nodenext" || resolutionOpt === "node16" || pkg.type === "module" && !resolutionOpt) {
     importRewriteStrategy = "rewrite";
   }
+  const blocksDir = options.blocksDir ? path6.resolve(cwd, options.blocksDir) : join8(srcDir, "lib", "blocks");
+  const relativeBlocksDir = path6.relative(cwd, blocksDir).replace(/\\/g, "/");
+  const tsPaths = compilerOptions?.paths;
   return {
     root: cwd,
-    language: tsConfig !== null ? "typescript" : "javascript",
+    language: compilerConfig?.kind === "tsconfig" ? "typescript" : "javascript",
     runtime: detectRuntime(allDeps),
     framework: detectFramework(allDeps),
     packageManager: detectPackageManager(cwd),
     hasRedis: "ioredis" in allDeps || "redis" in allDeps,
     hasPrisma: "@prisma/client" in allDeps,
     hasDrizzle: "drizzle-orm" in allDeps,
-    aliasMap: tsConfig?.compilerOptions?.paths ? flattenTsPaths(tsConfig.compilerOptions.paths) : {},
+    aliasMap: tsPaths ? flattenTsPaths(tsPaths) : {},
     srcDir,
-    // Default blocks directory: srcDir/lib/blocks
-    blocksDir: join6(srcDir, "lib", "blocks"),
+    blocksDir,
+    blocksAlias: tsPaths ? deriveBlocksAlias(tsPaths, relativeBlocksDir) : void 0,
     importRewriteStrategy
   };
 }
-function flattenTsPaths(paths) {
-  const result = {};
-  for (const [alias, targets] of Object.entries(paths)) {
-    if (targets[0]) {
-      result[alias.replace("/*", "/")] = targets[0].replace("/*", "/");
-    }
-  }
-  return result;
-}
 
 // src/ui/theme.ts
 import pc2 from "picocolors";
@@ -699,41 +1218,6 @@ var format = {
 };
 
 // src/commands/init.ts
-async function resolveTsConfigPaths(cwd) {
-  const candidates = [join7(cwd, "tsconfig.json"), join7(cwd, "jsconfig.json")];
-  for (const configPath of candidates) {
-    if (!existsSync4(configPath)) continue;
-    try {
-      const raw = await fs2.readFile(configPath, "utf-8");
-      const clean = raw.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, "$1");
-      const parsed = JSON.parse(clean);
-      return {
-        baseUrl: parsed.compilerOptions?.baseUrl ?? ".",
-        paths: parsed.compilerOptions?.paths ?? {}
-      };
-    } catch {
-    }
-  }
-  return { baseUrl: ".", paths: {} };
-}
-function deriveBlockAlias(tsPaths, blocksPhysicalPath) {
-  const normalizedBlocksPath = blocksPhysicalPath.replace(/^\.\//, "").replace(/\\/g, "/");
-  for (const [aliasKey, targets] of Object.entries(tsPaths)) {
-    if (!Array.isArray(targets) || targets.length === 0) continue;
-    const rawTarget = targets[0].replace(/\\/g, "/");
-    const targetRoot = rawTarget.replace(/\*$/, "").replace(/\/$/, "").replace(/^\.\//, "");
-    const aliasRoot = aliasKey.replace(/\/\*$/, "").replace(/\*$/, "");
-    if (targetRoot === "") {
-      return `${aliasRoot}/${normalizedBlocksPath}`.replace(/\/+/g, "/");
-    }
-    if (normalizedBlocksPath === targetRoot || normalizedBlocksPath.startsWith(`${targetRoot}/`)) {
-      const suffix = normalizedBlocksPath.slice(targetRoot.length).replace(/^\//, "");
-      const alias = suffix ? `${aliasRoot}/${suffix}` : aliasRoot;
-      return alias.replace(/\/+/g, "/");
-    }
-  }
-  return void 0;
-}
 function outputInitError(json, message) {
   if (json) {
     process.stdout.write(JSON.stringify({ success: false, error: message }) + "\n");
@@ -752,7 +1236,7 @@ function outputInitResult(json, result) {
 async function initCommand(options = {}) {
   const { yes = false, json = false } = options;
   const cwd = process.cwd();
-  const configPath = join7(cwd, "blockend.json");
+  const configPath = join9(cwd, "blockend.json");
   if (!json) {
     console.log("");
     intro2(`${pc3.bgCyan(pc3.black(" blockend "))} ${theme.text.muted("setup")}`);
@@ -784,15 +1268,35 @@ async function initCommand(options = {}) {
       action = actionPrompt;
     }
     if (action === "regenerate") {
-      await fs2.unlink(configPath);
+      await fs6.unlink(configPath);
       if (!json) log2.warn("Existing configuration deleted.");
     }
   }
+  const hasSrcDir = existsSync4(join9(cwd, "src"));
+  const defaultDir = hasSrcDir ? "src/blocks" : "blocks";
+  let rawPhysicalInput = defaultDir;
+  if (!yes) {
+    const directoryPrompt = await text({
+      message: "Where would you like to install blocks?",
+      placeholder: defaultDir,
+      initialValue: defaultDir,
+      validate(value) {
+        if (!value || value.trim().length === 0) return "Directory path cannot be empty.";
+      }
+    });
+    if (isCancel2(directoryPrompt)) {
+      if (json) {
+        outputInitResult(json, { success: false, message: "Setup cancelled." });
+      } else {
+        outro2(format.muted("Setup cancelled."));
+      }
+      return;
+    }
+    rawPhysicalInput = String(directoryPrompt).trim();
+  }
   const s = spinner2();
   if (!json) s.start("Scanning project architecture...");
-  const context = await detectProject(cwd);
-  const hasSrcDir = existsSync4(join7(cwd, "src"));
-  const tsConfig = await resolveTsConfigPaths(cwd);
+  const context = await detectProject(cwd, { blocksDir: rawPhysicalInput });
   if (!json) s.stop("Project scanned.");
   let framework = context.framework;
   if (!framework) {
@@ -821,27 +1325,9 @@ async function initCommand(options = {}) {
   } else if (!json) {
     log2.info(`Framework detected: ${theme.state.info(framework)}`);
   }
-  const defaultDir = hasSrcDir ? "src/blocks" : "blocks";
-  let rawPhysicalInput = defaultDir;
-  if (!yes) {
-    const directoryPrompt = await text({
-      message: "Where would you like to install blocks?",
-      placeholder: defaultDir,
-      initialValue: defaultDir,
-      validate(value) {
-        if (!value || value.trim().length === 0) return "Directory path cannot be empty.";
-      }
-    });
-    if (isCancel2(directoryPrompt)) {
-      outro2(format.muted("Setup cancelled."));
-      return;
-    }
-    rawPhysicalInput = String(directoryPrompt).trim();
-  }
-  const relativeBlocksPath = path2.relative(cwd, path2.resolve(cwd, rawPhysicalInput)).replace(/\\/g, "/");
+  const relativeBlocksPath = path7.relative(cwd, context.blocksDir).replace(/\\/g, "/");
   const finalPath = relativeBlocksPath.startsWith(".") ? relativeBlocksPath : `./${relativeBlocksPath}`;
-  const hasTsPaths = Object.keys(tsConfig.paths).length > 0;
-  const finalBlockAlias = hasTsPaths ? deriveBlockAlias(tsConfig.paths, relativeBlocksPath) : void 0;
+  const finalBlockAlias = context.blocksAlias;
   if (!json) {
     log2.info(
       `Import alias: ${theme.state.info(finalBlockAlias === void 0 ? " relative imports" : finalBlockAlias)}`
@@ -880,7 +1366,7 @@ async function initCommand(options = {}) {
   };
   if (!json) s.start("Writing configuration...");
   try {
-    await fs2.writeFile(configPath, JSON.stringify(configPayload, null, 2), "utf-8");
+    await fs6.writeFile(configPath, JSON.stringify(configPayload, null, 2), "utf-8");
     if (!json) s.stop("Configuration saved.");
     outputInitResult(json, {
       success: true,
@@ -938,33 +1424,13 @@ async function detectCommand(options = {}) {
 }
 
 // src/commands/list.ts
-import { dirname as dirname2, join as join8 } from "path";
-import fs3 from "fs/promises";
+import fs7 from "fs/promises";
 import pc5 from "picocolors";
 import { outro as outro4, spinner as spinner3 } from "@clack/prompts";
-var REPO_OWNER2 = "codewithnuh";
-var REPO_NAME2 = "blockend";
-var BRANCH2 = "master";
-var MANIFEST_URL2 = `https://raw.githubusercontent.com/${REPO_OWNER2}/${REPO_NAME2}/${BRANCH2}/registry/index.json`;
-async function findUp2(filename, startDir) {
-  let dir = startDir;
-  while (true) {
-    const checkPath = join8(dir, filename);
-    try {
-      await fs3.access(checkPath);
-      return checkPath;
-    } catch {
-      const parent = dirname2(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-  }
-  return null;
-}
 async function listCommand(options = {}) {
   const { json = false } = options;
   const cwd = process.cwd();
-  const configPath = await findUp2("blockend.json", cwd);
+  const configPath = await findUp("blockend.json", cwd);
   if (!configPath) {
     if (json) {
       process.stdout.write(
@@ -977,7 +1443,7 @@ async function listCommand(options = {}) {
   }
   let config;
   try {
-    const configFile = await fs3.readFile(configPath, "utf-8");
+    const configFile = await fs7.readFile(configPath, "utf-8");
     config = JSON.parse(configFile);
   } catch {
     if (json) {
@@ -990,15 +1456,14 @@ async function listCommand(options = {}) {
     return;
   }
   const envKey = String(config.environment);
+  const source = createGitHubRegistrySource();
   const s = spinner3();
   if (!json) {
     s.start("Syncing registry metadata blocks...");
   }
   let registry;
   try {
-    const response = await fetch(MANIFEST_URL2);
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    registry = await response.json();
+    registry = await loadRegistry(source);
     if (!json) s.stop(pc5.green("\u2714 Synced available block registries."));
   } catch {
     if (json) {
@@ -1010,25 +1475,12 @@ async function listCommand(options = {}) {
     }
     return;
   }
-  let blockMap = {};
-  if (registry.blocks && typeof registry.blocks === "object" && !Array.isArray(registry.blocks)) {
-    blockMap = registry.blocks;
-  } else {
-    blockMap = registry;
-  }
-  const blocksForEnv = Object.entries(blockMap).filter(([_, block]) => {
-    if (!block) return false;
-    const hasAdapter = block.adapters?.[envKey] !== void 0;
-    const hasEnvironment = block.environments?.[envKey] !== void 0;
-    return hasAdapter || hasEnvironment;
-  }).map(([key, block]) => {
-    const context = block.adapters?.[envKey] ?? block.environments?.[envKey];
-    return {
-      name: key,
-      description: block.description,
-      variants: Object.keys(context?.variants || {})
-    };
-  });
+  const available = await listAvailableBlocks(registry, envKey);
+  const blocksForEnv = available.map((block) => ({
+    name: block.name,
+    description: block.description,
+    variants: block.variants
+  }));
   if (json) {
     process.stdout.write(
       JSON.stringify({ success: true, environment: envKey, blocks: blocksForEnv }) + "\n"
@@ -1039,11 +1491,13 @@ Available backend blocks for ${pc5.magenta(envKey)}:`);
     if (blocksForEnv.length === 0) {
       console.log(pc5.dim("  No blocks found for this framework."));
     } else {
-      blocksForEnv.forEach((b) => {
+      blocksForEnv.forEach((block) => {
         console.log(`
-  ${pc5.cyan(b.name)}`);
-        console.log(`    ${pc5.dim(b.description)}`);
-        console.log(`    Storage Variants: ${b.variants.map((v) => pc5.yellow(v)).join(", ")}`);
+  ${pc5.cyan(block.name)}`);
+        console.log(`    ${pc5.dim(block.description)}`);
+        console.log(
+          `    Storage Variants: ${block.variants.map((variant) => pc5.yellow(variant)).join(", ")}`
+        );
       });
       console.log();
     }
@@ -1051,8 +1505,8 @@ Available backend blocks for ${pc5.magenta(envKey)}:`);
 }
 
 // src/commands/mcp.ts
-import path3, { join as join9 } from "path";
-import fs4 from "fs/promises";
+import path8, { join as join10 } from "path";
+import fs8 from "fs/promises";
 import pc6 from "picocolors";
 import { outro as outro5, spinner as spinner4, select as select3, confirm as confirm3 } from "@clack/prompts";
 var CLIENT_MATRIX = {
@@ -1098,7 +1552,7 @@ args = [${args}]
 async function mcpStartCommand() {
   const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
   const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
-  const { z } = await import("zod");
+  const { z: z2 } = await import("zod");
   const { execa } = await import("execa");
   const server = new McpServer({
     name: "blockend",
@@ -1117,7 +1571,7 @@ async function mcpStartCommand() {
   }
   server.tool(
     "list_blocks",
-    "Lists all available Blockend blocks with names, descriptions, and tags",
+    "Lists all available Blockend blocks with names, descriptions, and variants",
     {},
     async () => {
       const result = await safeExec("npx", ["--no-install", "blockend", "list", "--json"]);
@@ -1128,8 +1582,8 @@ async function mcpStartCommand() {
     "add_block",
     "Installs a Blockend block into a project.",
     {
-      blockName: z.string().describe("Block name e.g. rate-limit, error-handler, logger"),
-      projectPath: z.string().describe("Absolute path to the project root where blockend should install")
+      blockName: z2.string().describe("Block name, e.g. rate-limiter, error-handler, logger"),
+      projectPath: z2.string().describe("Absolute path to the project root where blockend should install")
     },
     async ({ blockName, projectPath }) => {
       const result = await safeExec(
@@ -1144,7 +1598,7 @@ async function mcpStartCommand() {
     "detect_project",
     "Analyzes a project context: framework, language, package manager, etc.",
     {
-      projectPath: z.string().describe("Absolute path to the project root")
+      projectPath: z2.string().describe("Absolute path to the project root")
     },
     async ({ projectPath }) => {
       const result = await safeExec("npx", ["--no-install", "blockend", "detect", "--json"], {
@@ -1157,8 +1611,8 @@ async function mcpStartCommand() {
     "diff_block",
     "Preview what files a block would generate without writing to disk. Shows new/modified/unchanged files.",
     {
-      blockName: z.string().describe("Block name to preview, e.g. rate-limiter, pino-logger"),
-      projectPath: z.string().describe("Absolute path to the project root")
+      blockName: z2.string().describe("Block name to preview, e.g. rate-limiter, logger"),
+      projectPath: z2.string().describe("Absolute path to the project root")
     },
     async ({ blockName, projectPath }) => {
       const result = await safeExec(
@@ -1173,7 +1627,7 @@ async function mcpStartCommand() {
     "doctor",
     "Check project health: validates blockend.json, detects framework, checks for issues.",
     {
-      projectPath: z.string().describe("Absolute path to the project root")
+      projectPath: z2.string().describe("Absolute path to the project root")
     },
     async ({ projectPath }) => {
       const result = await safeExec("npx", ["--no-install", "blockend", "doctor", "--json"], {
@@ -1186,7 +1640,7 @@ async function mcpStartCommand() {
     "update_check",
     "Check for available updates to installed blocks. Shows version comparison and diffs.",
     {
-      projectPath: z.string().describe("Absolute path to the project root")
+      projectPath: z2.string().describe("Absolute path to the project root")
     },
     async ({ projectPath }) => {
       const result = await safeExec("npx", ["--no-install", "blockend", "update", "--json"], {
@@ -1199,12 +1653,12 @@ async function mcpStartCommand() {
     "update_apply",
     "Apply updates to all installed blocks. Downloads new versions, rewrites imports, and updates blockend.json.",
     {
-      projectPath: z.string().describe("Absolute path to the project root")
+      projectPath: z2.string().describe("Absolute path to the project root")
     },
     async ({ projectPath }) => {
       const result = await safeExec(
         "npx",
-        ["--no-install", "blockend", "update", "--apply", "--yes", "--json"],
+        ["--no-install", "blockend", "update", "--apply", "--json"],
         { cwd: projectPath }
       );
       return { content: [{ type: "text", text: result.text }], isError: result.isError };
@@ -1212,17 +1666,25 @@ async function mcpStartCommand() {
   );
   server.tool(
     "add_blocks",
-    "Install multiple blocks at once via interactive selection.",
+    "Install multiple blocks into a project.",
     {
-      projectPath: z.string().describe("Absolute path to the project root")
+      blockNames: z2.array(z2.string()).min(1).describe("Block names, e.g. rate-limiter, logger"),
+      projectPath: z2.string().describe("Absolute path to the project root where blockend should install")
     },
-    async ({ projectPath }) => {
-      const result = await safeExec(
-        "npx",
-        ["--no-install", "blockend", "add", "--multi", "--yes", "--json"],
-        { cwd: projectPath }
-      );
-      return { content: [{ type: "text", text: result.text }], isError: result.isError };
+    async ({ blockNames, projectPath }) => {
+      const results = [];
+      for (const blockName of blockNames) {
+        const result = await safeExec(
+          "npx",
+          ["--no-install", "blockend", "add", blockName, "--yes", "--json"],
+          { cwd: projectPath }
+        );
+        results.push({ blockName, output: result.text, isError: result.isError });
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        isError: results.some((result) => result.isError)
+      };
     }
   );
   const transport = new StdioServerTransport();
@@ -1251,7 +1713,7 @@ async function mcpInitCommand(options) {
     outro5(pc6.red(`\u2716 Unsupported client identifier profile: ${options.client}`));
     return;
   }
-  const absoluteConfigTarget = join9(cwd, meta.relativePath);
+  const absoluteConfigTarget = join10(cwd, meta.relativePath);
   if (options.dryRun) {
     console.log(
       pc6.cyan(`
@@ -1268,7 +1730,7 @@ async function mcpInitCommand(options) {
   }
   let fileConflict = false;
   try {
-    await fs4.access(absoluteConfigTarget);
+    await fs8.access(absoluteConfigTarget);
     fileConflict = true;
   } catch {
   }
@@ -1285,12 +1747,12 @@ async function mcpInitCommand(options) {
   const s = spinner4();
   s.start(`Writing localized project configurations inside ${pc6.dim(meta.relativePath)}...`);
   try {
-    await fs4.mkdir(path3.dirname(absoluteConfigTarget), { recursive: true });
+    await fs8.mkdir(path8.dirname(absoluteConfigTarget), { recursive: true });
     if (meta.format === "json") {
       let workingConfig = {};
       if (fileConflict) {
         try {
-          const rawContent = await fs4.readFile(absoluteConfigTarget, "utf-8");
+          const rawContent = await fs8.readFile(absoluteConfigTarget, "utf-8");
           workingConfig = JSON.parse(rawContent);
         } catch {
           workingConfig = {};
@@ -1303,9 +1765,9 @@ async function mcpInitCommand(options) {
         const existingServers = workingConfig.mcpServers || {};
         workingConfig.mcpServers = { ...existingServers, blockend: BLOCKEND_SERVER };
       }
-      await fs4.writeFile(absoluteConfigTarget, JSON.stringify(workingConfig, null, 2), "utf-8");
+      await fs8.writeFile(absoluteConfigTarget, JSON.stringify(workingConfig, null, 2), "utf-8");
     } else {
-      await fs4.writeFile(absoluteConfigTarget, generateToml(BLOCKEND_SERVER), "utf-8");
+      await fs8.writeFile(absoluteConfigTarget, generateToml(BLOCKEND_SERVER), "utf-8");
     }
     s.stop(
       pc6.green(`\u2714 Local workspace integration fully complete! File target: ${meta.relativePath}`)
@@ -1317,47 +1779,10 @@ async function mcpInitCommand(options) {
 }
 
 // src/commands/diff.ts
-import path4, { join as join10, dirname as dirname3 } from "path";
-import fs5 from "fs/promises";
+import path9 from "path";
+import fs9 from "fs/promises";
 import { intro as intro3, outro as outro6, spinner as spinner5, log as log3 } from "@clack/prompts";
 import pc7 from "picocolors";
-var REPO_OWNER3 = "codewithnuh";
-var REPO_NAME3 = "blockend";
-var BRANCH3 = "master";
-var RAW_CDN_BASE2 = `https://raw.githubusercontent.com/${REPO_OWNER3}/${REPO_NAME3}/${BRANCH3}`;
-var MANIFEST_URL3 = `${RAW_CDN_BASE2}/registry/index.json`;
-function blockSupportsEnv2(block, envKey) {
-  if (block.frameworks && block.frameworks.length > 0) {
-    return block.frameworks.includes("*") || block.frameworks.includes(envKey);
-  }
-  return block.adapters?.[envKey] !== void 0 || block.environments?.[envKey] !== void 0;
-}
-function resolveAdapterContext2(block, envKey) {
-  return block.adapters?.[envKey] ?? block.adapters?.["*"] ?? block.environments?.[envKey] ?? block.environments?.["*"] ?? null;
-}
-async function findUp3(filename, startDir) {
-  let dir = startDir;
-  while (true) {
-    const candidate = join10(dir, filename);
-    try {
-      await fs5.access(candidate);
-      return candidate;
-    } catch {
-      const parent = dirname3(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-  }
-  return null;
-}
-async function fileExists(filePath) {
-  try {
-    await fs5.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function diffCommand(blockName, options = {}) {
   const { json = false } = options;
   if (!json) {
@@ -1368,7 +1793,7 @@ async function diffCommand(blockName, options = {}) {
     return { block: "", files: [], error: "Block name is required. Usage: blockend diff <block>" };
   }
   const cwd = process.cwd();
-  const configPath = await findUp3("blockend.json", cwd);
+  const configPath = await findUp("blockend.json", cwd);
   if (!configPath) {
     const error = "blockend.json not found. Run 'npx blockend init' first.";
     if (json) {
@@ -1378,10 +1803,10 @@ async function diffCommand(blockName, options = {}) {
     }
     return { block: blockName, files: [], error };
   }
-  const rootDir = dirname3(configPath);
+  const rootDir = path9.dirname(configPath);
   let config;
   try {
-    config = JSON.parse(await fs5.readFile(configPath, "utf-8"));
+    config = JSON.parse(await fs9.readFile(configPath, "utf-8"));
   } catch {
     const error = "Failed to parse blockend.json.";
     if (json) {
@@ -1392,15 +1817,14 @@ async function diffCommand(blockName, options = {}) {
     return { block: blockName, files: [], error };
   }
   const physicalBlocksPath = config.paths.blocks;
-  const blocksRootAbsolute = path4.resolve(rootDir, physicalBlocksPath);
+  const blocksRootAbsolute = path9.resolve(rootDir, physicalBlocksPath);
   const envKey = config.environment;
+  const source = createGitHubRegistrySource();
   const s = spinner5();
   if (!json) s.start("Fetching registry...");
   let registry;
   try {
-    const res = await fetch(MANIFEST_URL3);
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    registry = await res.json();
+    registry = await loadRegistry(source);
     if (!json) s.stop("Registry synced.");
   } catch (err) {
     const error = `Failed to fetch registry: ${String(err)}`;
@@ -1410,97 +1834,32 @@ async function diffCommand(blockName, options = {}) {
     }
     return { block: blockName, files: [], error };
   }
-  const blockMap = registry.blocks && typeof registry.blocks === "object" && !Array.isArray(registry.blocks) ? registry.blocks : registry;
-  const blockMeta = blockMap[blockName];
-  if (!blockMeta) {
-    const error = `Block "${blockName}" not found in the registry.`;
-    if (json) {
-      process.stdout.write(JSON.stringify({ block: blockName, files: [], error }) + "\n");
-    } else {
-      log3.error(error);
-      outro6(pc7.dim("Block not found."));
-    }
-    return { block: blockName, files: [], error };
-  }
-  if (!blockSupportsEnv2(blockMeta, envKey)) {
-    const error = `Block "${blockName}" does not support environment: ${envKey}`;
-    if (json) {
-      process.stdout.write(JSON.stringify({ block: blockName, files: [], error }) + "\n");
-    } else {
-      log3.error(error);
-    }
-    return { block: blockName, files: [], error };
-  }
-  const adapterContext = resolveAdapterContext2(blockMeta, envKey);
-  if (!adapterContext) {
-    const error = `Block "${blockName}" has no adapter for: ${envKey}`;
-    if (json) {
-      process.stdout.write(JSON.stringify({ block: blockName, files: [], error }) + "\n");
-    } else {
-      log3.error(error);
-    }
-    return { block: blockName, files: [], error };
-  }
-  const variantKeys = Object.keys(adapterContext.variants ?? {});
-  if (variantKeys.length === 0) {
-    const error = `No variants found for "${blockName}" / "${envKey}".`;
+  const targetFolder = path9.resolve(blocksRootAbsolute, blockName);
+  const installedRecord = config.installed?.find((block) => block.name === blockName);
+  const planResult = await planBlock(registry, blockName, envKey, {
+    recordedVariant: installedRecord?.variant,
+    targetFolder
+  });
+  if (!planResult.ok) {
+    const error = planResult.error.code === "no-adapter" ? `Block "${blockName}" has no adapter for: ${envKey}` : planResult.error.message;
     if (json) {
       process.stdout.write(JSON.stringify({ block: blockName, files: [], error }) + "\n");
     } else {
       log3.error(error);
+      if (planResult.error.code === "not-found") outro6(pc7.dim("Block not found."));
     }
     return { block: blockName, files: [], error };
   }
-  const selectedVariant = variantKeys[0];
-  const variantMeta = adapterContext.variants[selectedVariant];
-  const targetFolder = path4.resolve(blocksRootAbsolute, blockName);
-  const filesToDownload = [];
-  if (blockMeta.baseFiles?.length) {
-    filesToDownload.push(...blockMeta.baseFiles);
-  }
-  if (adapterContext.core) {
-    filesToDownload.push({
-      source: adapterContext.core,
-      target: path4.basename(adapterContext.core)
-    });
-  }
-  if (variantMeta && Array.isArray(variantMeta.files)) {
-    for (const entry of variantMeta.files) {
-      filesToDownload.push(
-        typeof entry === "string" ? { source: entry, target: path4.basename(entry) } : entry
-      );
-    }
-  }
+  const plan = planResult.plan;
   if (!json) s.start(`Comparing ${blockName} files...`);
   const diffFiles = [];
   try {
-    for (const fm of filesToDownload) {
-      const res = await fetch(`${RAW_CDN_BASE2}/${fm.source}`);
-      if (!res.ok) throw new Error(`Download failed: ${fm.source} (HTTP ${res.status})`);
-      const newContent = await res.text();
-      const targetPath = path4.join(targetFolder, fm.target);
-      let existingContent = null;
-      let status = "new";
-      if (await fileExists(targetPath)) {
-        try {
-          existingContent = await fs5.readFile(targetPath, "utf-8");
-          status = existingContent === newContent ? "unchanged" : "modified";
-        } catch {
-        }
-      }
-      diffFiles.push({
-        name: fm.target,
-        sourcePath: fm.source,
-        targetPath,
-        existingContent,
-        newContent,
-        status
-      });
-    }
+    const previews = await previewBlock(plan, { source, targetFolder });
+    diffFiles.push(...previews);
     if (!json) s.stop("Comparison complete.");
     if (!json) {
       console.log(`
-  ${pc7.bold(pc7.cyan(blockName))} \u2014 ${pc7.dim(selectedVariant)} variant
+  ${pc7.bold(pc7.cyan(blockName))} \u2014 ${pc7.dim(plan.variant)} variant
 `);
       for (const file of diffFiles) {
         const icon = file.status === "new" ? pc7.green("+") : file.status === "modified" ? pc7.yellow("~") : pc7.dim("=");
@@ -1528,11 +1887,13 @@ async function diffCommand(blockName, options = {}) {
         }
       }
       console.log("");
-      const newCount = diffFiles.filter((f) => f.status === "new").length;
-      const modCount = diffFiles.filter((f) => f.status === "modified").length;
-      const unchangedCount = diffFiles.filter((f) => f.status === "unchanged").length;
+      const newCount = diffFiles.filter((file) => file.status === "new").length;
+      const modCount = diffFiles.filter((file) => file.status === "modified").length;
+      const unchangedCount = diffFiles.filter((file) => file.status === "unchanged").length;
       outro6(
-        `${pc7.green(`${newCount} new`)} | ${pc7.yellow(`${modCount} modified`)} | ${pc7.dim(`${unchangedCount} unchanged`)}`
+        `${pc7.green(`${newCount} new`)} | ${pc7.yellow(`${modCount} modified`)} | ${pc7.dim(
+          `${unchangedCount} unchanged`
+        )}`
       );
     }
     const result = { block: blockName, files: diffFiles };
@@ -1555,8 +1916,8 @@ async function diffCommand(blockName, options = {}) {
 }
 
 // src/commands/doctor.ts
-import path5, { join as join11, dirname as dirname4 } from "path";
-import fs6 from "fs/promises";
+import path10, { join as join11, dirname as dirname5 } from "path";
+import fs10 from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 import { intro as intro4, outro as outro7, spinner as spinner6 } from "@clack/prompts";
 import pc8 from "picocolors";
@@ -1587,15 +1948,15 @@ function outputDoctorResult(json, result) {
     }
   }
 }
-async function findUp4(filename, startDir) {
+async function findUp2(filename, startDir) {
   let dir = startDir;
   while (true) {
     const candidate = join11(dir, filename);
     try {
-      await fs6.access(candidate);
+      await fs10.access(candidate);
       return candidate;
     } catch {
-      const parent = dirname4(dir);
+      const parent = dirname5(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -1619,7 +1980,7 @@ async function doctorCommand(options = {}) {
   }
   const s = spinner6();
   if (!json) s.start("Scanning project health...");
-  const packageJsonPath = await findUp4("package.json", cwd);
+  const packageJsonPath = await findUp2("package.json", cwd);
   if (packageJsonPath) {
     addCheck({ name: "package.json", status: "ok", message: "Found" });
   } else {
@@ -1629,7 +1990,7 @@ async function doctorCommand(options = {}) {
       message: "Not found. Run 'npm init' or 'pnpm init' first."
     });
   }
-  const configPath = await findUp4("blockend.json", cwd);
+  const configPath = await findUp2("blockend.json", cwd);
   if (configPath) {
     addCheck({ name: "blockend.json", status: "ok", message: "Found" });
   } else {
@@ -1639,7 +2000,7 @@ async function doctorCommand(options = {}) {
       message: "Not found. Run 'npx blockend init' first."
     });
   }
-  const tsConfigPath = await findUp4("tsconfig.json", cwd);
+  const tsConfigPath = await findUp2("tsconfig.json", cwd);
   if (tsConfigPath) {
     addCheck({ name: "tsconfig.json", status: "ok", message: "Found" });
   } else {
@@ -1701,7 +2062,7 @@ async function doctorCommand(options = {}) {
   }
   if (configPath) {
     try {
-      const raw = await fs6.readFile(configPath, "utf-8");
+      const raw = await fs10.readFile(configPath, "utf-8");
       const config = JSON.parse(raw);
       if (!config.environment) {
         addCheck({
@@ -1723,7 +2084,7 @@ async function doctorCommand(options = {}) {
           message: "Missing 'paths.blocks' in blockend.json"
         });
       } else {
-        const blocksDir = path5.resolve(dirname4(configPath), config.paths.blocks);
+        const blocksDir = path10.resolve(dirname5(configPath), config.paths.blocks);
         if (existsSync5(blocksDir)) {
           addCheck({
             name: "Config: blocks directory",
@@ -1756,39 +2117,10 @@ async function doctorCommand(options = {}) {
 }
 
 // src/commands/update.ts
-import path6, { join as join12, dirname as dirname5 } from "path";
-import fs7 from "fs/promises";
+import path11 from "path";
+import fs11 from "fs/promises";
 import { intro as intro5, outro as outro8, spinner as spinner7, log as log4, multiselect as multiselect2, confirm as confirm4, isCancel as isCancel3 } from "@clack/prompts";
 import pc9 from "picocolors";
-var REPO_OWNER4 = "codewithnuh";
-var REPO_NAME4 = "blockend";
-var BRANCH4 = "master";
-var RAW_CDN_BASE3 = `https://raw.githubusercontent.com/${REPO_OWNER4}/${REPO_NAME4}/${BRANCH4}`;
-var MANIFEST_URL4 = `${RAW_CDN_BASE3}/registry/index.json`;
-function blockSupportsEnv3(block, envKey) {
-  if (block.frameworks && block.frameworks.length > 0) {
-    return block.frameworks.includes("*") || block.frameworks.includes(envKey);
-  }
-  return block.adapters?.[envKey] !== void 0 || block.environments?.[envKey] !== void 0;
-}
-function resolveAdapterContext3(block, envKey) {
-  return block.adapters?.[envKey] ?? block.adapters?.["*"] ?? block.environments?.[envKey] ?? block.environments?.["*"] ?? null;
-}
-async function findUp5(filename, startDir) {
-  let dir = startDir;
-  while (true) {
-    const candidate = join12(dir, filename);
-    try {
-      await fs7.access(candidate);
-      return candidate;
-    } catch {
-      const parent = dirname5(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-  }
-  return null;
-}
 function computeLineDiff(oldContent, newContent) {
   const oldLines = oldContent.split("\n");
   const newLines = newContent.split("\n");
@@ -1880,7 +2212,9 @@ function outputUpdateResult(json, result) {
 `);
     for (const block of updates) {
       console.log(
-        `    ${pc9.yellow("~")} ${pc9.bold(block.name)} ${pc9.dim(`${block.localVersion} \u2192 ${block.remoteVersion}`)}`
+        `    ${pc9.yellow("~")} ${pc9.bold(block.name)} ${pc9.dim(
+          `${block.localVersion} \u2192 ${block.remoteVersion}`
+        )}`
       );
     }
     console.log("");
@@ -1909,27 +2243,6 @@ function outputUpdateResult(json, result) {
     outro8(pc9.green("All tracked blocks are up to date."));
   }
 }
-function resolveBlockFiles(blockMeta, envKey) {
-  const adapterContext = resolveAdapterContext3(blockMeta, envKey);
-  if (!adapterContext) return null;
-  const variantKeys = Object.keys(adapterContext.variants ?? {});
-  if (variantKeys.length === 0) return null;
-  const selectedVariant = variantKeys[0];
-  const variantMeta = adapterContext.variants[selectedVariant];
-  const expectedFiles = [];
-  if (blockMeta.baseFiles?.length) expectedFiles.push(...blockMeta.baseFiles);
-  if (adapterContext.core) {
-    expectedFiles.push({ source: adapterContext.core, target: path6.basename(adapterContext.core) });
-  }
-  if (variantMeta && Array.isArray(variantMeta.files)) {
-    for (const entry of variantMeta.files) {
-      expectedFiles.push(
-        typeof entry === "string" ? { source: entry, target: path6.basename(entry) } : entry
-      );
-    }
-  }
-  return { files: expectedFiles, variant: selectedVariant };
-}
 async function updateCommand(options = {}) {
   const { json = false, diff: diff2 = true, apply = false } = options;
   if (!json) {
@@ -1937,17 +2250,17 @@ async function updateCommand(options = {}) {
     intro5(`${pc9.bgCyan(pc9.black(" blockend "))} ${pc9.dim("update")}`);
   }
   const cwd = process.cwd();
-  const configPath = await findUp5("blockend.json", cwd);
+  const configPath = await findUp("blockend.json", cwd);
   if (!configPath) {
     const error = "blockend.json not found. Run 'npx blockend init' first.";
     if (json) process.stdout.write(JSON.stringify({ blocks: [], error }) + "\n");
     else log4.error(error);
     return { blocks: [], error };
   }
-  const rootDir = dirname5(configPath);
+  const rootDir = path11.dirname(configPath);
   let config;
   try {
-    config = JSON.parse(await fs7.readFile(configPath, "utf-8"));
+    config = JSON.parse(await fs11.readFile(configPath, "utf-8"));
   } catch {
     const error = "Failed to parse blockend.json.";
     if (json) process.stdout.write(JSON.stringify({ blocks: [], error }) + "\n");
@@ -1955,18 +2268,17 @@ async function updateCommand(options = {}) {
     return { blocks: [], error };
   }
   const physicalBlocksPath = config.paths.blocks;
-  const blocksRootAbsolute = path6.resolve(rootDir, physicalBlocksPath);
+  const blocksRootAbsolute = path11.resolve(rootDir, physicalBlocksPath);
   const envKey = config.environment;
   const aliasBase = config.aliases.blocks;
   const rewriteStrategy = config.importRewriteStrategy ?? "remove";
   const installedRecords = Array.isArray(config.installed) ? config.installed : [];
+  const source = createGitHubRegistrySource();
   const s = spinner7();
   if (!json) s.start("Fetching registry...");
   let registry;
   try {
-    const res = await fetch(MANIFEST_URL4);
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    registry = await res.json();
+    registry = await loadRegistry(source);
     if (!json) s.stop("Registry synced.");
   } catch (err) {
     const error = `Failed to fetch registry: ${String(err)}`;
@@ -1976,14 +2288,17 @@ async function updateCommand(options = {}) {
     }
     return { blocks: [], error };
   }
-  const blockMap = registry.blocks && typeof registry.blocks === "object" && !Array.isArray(registry.blocks) ? registry.blocks : registry;
   if (!json) s.start("Comparing versions...");
   const blockResults = [];
   const diffs = {};
+  const plans = {};
   for (const record of installedRecords) {
-    const blockMeta = blockMap[record.name];
-    const remoteVersion = blockMeta?.version ?? "0.0.0";
-    if (!blockMeta || !blockSupportsEnv3(blockMeta, envKey)) {
+    const targetFolder = path11.resolve(blocksRootAbsolute, record.name);
+    const planResult = await planBlock(registry, record.name, envKey, {
+      recordedVariant: record.variant,
+      targetFolder
+    });
+    if (!planResult.ok) {
       blockResults.push({
         name: record.name,
         localVersion: record.version,
@@ -1992,6 +2307,9 @@ async function updateCommand(options = {}) {
       });
       continue;
     }
+    const plan = planResult.plan;
+    plans[record.name] = plan;
+    const remoteVersion = plan.block.version ?? "0.0.0";
     const hasUpdate = record.version !== remoteVersion || record.contentHash === "0";
     blockResults.push({
       name: record.name,
@@ -2000,55 +2318,39 @@ async function updateCommand(options = {}) {
       status: hasUpdate ? "update-available" : "up-to-date"
     });
     if (hasUpdate && diff2) {
-      const resolved = resolveBlockFiles(blockMeta, envKey);
-      if (!resolved) continue;
-      const targetFolder = path6.resolve(blocksRootAbsolute, record.name);
-      const fileDiffs = [];
-      for (const fm of resolved.files) {
-        const localPath = join12(targetFolder, fm.target);
-        let localContent = "";
-        let localExists = false;
-        try {
-          localContent = await fs7.readFile(localPath, "utf-8");
-          localExists = true;
-        } catch {
-          localContent = "";
-        }
-        let remoteContent = "";
-        try {
-          const res = await fetch(`${RAW_CDN_BASE3}/${fm.source}`);
-          if (res.ok) remoteContent = await res.text();
-        } catch {
-          remoteContent = "";
-        }
-        if (!localExists) {
-          fileDiffs.push({
-            name: fm.target,
-            file: fm.target,
+      const previews = await previewBlock(plan, {
+        source,
+        targetFolder,
+        onDownloadError: "empty"
+      });
+      diffs[record.name] = previews.map((preview) => {
+        if (preview.existingContent === null) {
+          return {
+            name: preview.name,
+            file: preview.name,
             status: "added",
-            lines: remoteContent.split("\n").map((l, i) => ({
+            lines: preview.newContent.split("\n").map((line, index) => ({
               type: "added",
-              content: l,
-              newLineNo: i + 1
+              content: line,
+              newLineNo: index + 1
             }))
-          });
-        } else if (localContent !== remoteContent) {
-          fileDiffs.push({
-            name: fm.target,
-            file: fm.target,
+          };
+        }
+        if (preview.existingContent !== preview.newContent) {
+          return {
+            name: preview.name,
+            file: preview.name,
             status: "modified",
-            lines: computeLineDiff(localContent, remoteContent)
-          });
-        } else {
-          fileDiffs.push({
-            name: fm.target,
-            file: fm.target,
-            status: "unchanged",
-            lines: []
-          });
+            lines: computeLineDiff(preview.existingContent, preview.newContent)
+          };
         }
-      }
-      diffs[record.name] = fileDiffs;
+        return {
+          name: preview.name,
+          file: preview.name,
+          status: "unchanged",
+          lines: []
+        };
+      });
     }
   }
   if (!json) s.stop("Comparison complete.");
@@ -2085,58 +2387,19 @@ async function updateCommand(options = {}) {
     }
     const applied = [];
     for (const blockName of selectedNames) {
-      const blockMeta = blockMap[blockName];
-      if (!blockMeta) continue;
-      const resolved = resolveBlockFiles(blockMeta, envKey);
-      if (!resolved) continue;
-      const targetFolder = path6.resolve(blocksRootAbsolute, blockName);
-      const downloadedTargets = /* @__PURE__ */ new Set();
+      const plan = plans[blockName];
+      if (!plan) continue;
       try {
-        const fileBatches = [];
-        for (const fm of resolved.files) {
-          const res = await fetch(`${RAW_CDN_BASE3}/${fm.source}`);
-          if (!res.ok) throw new Error(`Download failed: ${fm.source} (HTTP ${res.status})`);
-          fileBatches.push({ fm, raw: await res.text() });
-          downloadedTargets.add(fm.target);
-        }
-        let contentHash = 0;
-        for (const { fm, raw } of fileBatches) {
-          const writtenFilePath = path6.join(targetFolder, fm.target);
-          const content = rewriteFileImports(
-            raw,
-            writtenFilePath,
-            blocksRootAbsolute,
-            aliasBase,
-            rewriteStrategy,
-            downloadedTargets
-          );
-          await fs7.mkdir(dirname5(writtenFilePath), { recursive: true });
-          await fs7.writeFile(writtenFilePath, content, "utf-8");
-          for (let i = 0; i < content.length; i++) {
-            contentHash = (contentHash << 5) - contentHash + content.charCodeAt(i) | 0;
-          }
-        }
-        const blockVersion = blockMeta.version ?? "0.0.0";
-        const installedRecord = {
-          name: blockName,
-          version: blockVersion,
-          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          files: resolved.files.map((f) => f.target),
-          contentHash: contentHash.toString(16)
-        };
-        try {
-          const cfgRaw = await fs7.readFile(configPath, "utf-8");
-          const cfgData = JSON.parse(cfgRaw);
-          if (!Array.isArray(cfgData.installed)) cfgData.installed = [];
-          cfgData.installed = cfgData.installed.filter(
-            (b) => b.name !== blockName
-          );
-          cfgData.installed.push(installedRecord);
-          await fs7.writeFile(configPath, JSON.stringify(cfgData, null, 2), "utf-8");
-        } catch {
-        }
+        await applyBlock(plan, {
+          source,
+          blocksRoot: blocksRootAbsolute,
+          aliasBase,
+          rewriteStrategy,
+          configPath
+        });
         applied.push(blockName);
-        if (!json) log4.info(`  ${pc9.green("\u2714")} ${blockName} updated to v${blockVersion}`);
+        if (!json)
+          log4.info(`  ${pc9.green("\u2714")} ${blockName} updated to v${plan.block.version ?? "0.0.0"}`);
       } catch (err) {
         if (!json) log4.error(`  ${pc9.red("\u2716")} ${blockName}: ${String(err)}`);
       }