rafters 0.0.69 → 0.0.70

package/dist/index.js

@@ -12635,7 +12635,7 @@ var RegistryFileSchema = external_exports.object({
   devDependencies: external_exports.array(external_exports.string()).default([])
   // e.g., ["vitest"] - from @devDependencies JSDoc
 });
-var RegistryItemTypeSchema = external_exports.enum(["ui", "primitive", "composite"]);
+var RegistryItemTypeSchema = external_exports.enum(["ui", "primitive", "composite", "rule"]);
 var RegistryItemIntelligenceSchema = external_exports.object({
   cognitiveLoad: external_exports.number().optional(),
   attentionEconomics: external_exports.string().optional(),
@@ -12668,134 +12668,94 @@ var RegistryIndexSchema = external_exports.object({
 
 // src/registry/client.ts
 var DEFAULT_REGISTRY_URL = "https://rafters.studio";
+var REGISTRY_SOURCE = {
+  ui: { folder: "components", label: "Component" },
+  primitive: { folder: "primitives", label: "Primitive" },
+  composite: { folder: "composites", label: "Composite" },
+  rule: { folder: "rules", label: "Rule" }
+};
+var FETCH_ORDER = Object.keys(REGISTRY_SOURCE);
 var RegistryClient = class {
   baseUrl;
   cache = /* @__PURE__ */ new Map();
+  fetchByType;
+  /** Typed fetchers -- one shared body, specialized per type. */
+  fetchComponent;
+  fetchPrimitive;
+  fetchComposite;
+  fetchRule;
   constructor(baseUrl = DEFAULT_REGISTRY_URL) {
     this.baseUrl = baseUrl.replace(/\/$/, "");
+    const fetchFrom = (type2) => async (name) => {
+      const { folder, label } = REGISTRY_SOURCE[type2];
+      const cacheKey = `${type2}:${name}`;
+      const cached2 = this.cache.get(cacheKey);
+      if (cached2) return cached2;
+      const response = await fetch(`${this.baseUrl}/registry/${folder}/${name}.json`);
+      if (response.status === 404) {
+        throw new Error(`${label} "${name}" not found`);
+      }
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch ${label.toLowerCase()} "${name}": ${response.status} ${response.statusText}`
+        );
+      }
+      const item = RegistryItemSchema.parse(await response.json());
+      this.cache.set(cacheKey, item);
+      return item;
+    };
+    this.fetchByType = {
+      ui: fetchFrom("ui"),
+      primitive: fetchFrom("primitive"),
+      composite: fetchFrom("composite"),
+      rule: fetchFrom("rule")
+    };
+    this.fetchComponent = this.fetchByType.ui;
+    this.fetchPrimitive = this.fetchByType.primitive;
+    this.fetchComposite = this.fetchByType.composite;
+    this.fetchRule = this.fetchByType.rule;
   }
   /**
-   * Fetch the registry index
+   * Fetch the registry index.
    */
   async fetchIndex() {
-    const url3 = `${this.baseUrl}/registry/index.json`;
-    const response = await fetch(url3);
+    const response = await fetch(`${this.baseUrl}/registry/index.json`);
     if (!response.ok) {
       throw new Error(`Failed to fetch registry index: ${response.status} ${response.statusText}`);
     }
-    const data = await response.json();
-    return RegistryIndexSchema.parse(data);
-  }
-  /**
-   * Fetch a component by name
-   */
-  async fetchComponent(name) {
-    const cacheKey = `component:${name}`;
-    const cached2 = this.cache.get(cacheKey);
-    if (cached2) {
-      return cached2;
-    }
-    const url3 = `${this.baseUrl}/registry/components/${name}.json`;
-    const response = await fetch(url3);
-    if (response.status === 404) {
-      throw new Error(`Component "${name}" not found`);
-    }
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch component "${name}": ${response.status} ${response.statusText}`
-      );
-    }
-    const data = await response.json();
-    const item = RegistryItemSchema.parse(data);
-    this.cache.set(cacheKey, item);
-    return item;
+    return RegistryIndexSchema.parse(await response.json());
   }
   /**
-   * Fetch a primitive by name
-   */
-  async fetchPrimitive(name) {
-    const cacheKey = `primitive:${name}`;
-    const cached2 = this.cache.get(cacheKey);
-    if (cached2) {
-      return cached2;
-    }
-    const url3 = `${this.baseUrl}/registry/primitives/${name}.json`;
-    const response = await fetch(url3);
-    if (response.status === 404) {
-      throw new Error(`Primitive "${name}" not found`);
-    }
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch primitive "${name}": ${response.status} ${response.statusText}`
-      );
-    }
-    const data = await response.json();
-    const item = RegistryItemSchema.parse(data);
-    this.cache.set(cacheKey, item);
-    return item;
-  }
-  /**
-   * Fetch a composite by name
-   */
-  async fetchComposite(name) {
-    const cacheKey = `composite:${name}`;
-    const cached2 = this.cache.get(cacheKey);
-    if (cached2) {
-      return cached2;
-    }
-    const url3 = `${this.baseUrl}/registry/composites/${name}.json`;
-    const response = await fetch(url3);
-    if (response.status === 404) {
-      throw new Error(`Composite "${name}" not found`);
-    }
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch composite "${name}": ${response.status} ${response.statusText}`
-      );
-    }
-    const data = await response.json();
-    const item = RegistryItemSchema.parse(data);
-    this.cache.set(cacheKey, item);
-    return item;
-  }
-  /**
-   * Fetch a registry item by name
-   * Tries component, then primitive, then composite
+   * Fetch a registry item by name when the type is unknown.
+   * Tries each source in order; a non-"not found" error (network, 5xx) aborts.
    */
   async fetchItem(name) {
-    try {
-      return await this.fetchComponent(name);
-    } catch (err) {
-      if (err instanceof Error && err.message.includes("not found")) {
-        try {
-          return await this.fetchPrimitive(name);
-        } catch {
-          try {
-            return await this.fetchComposite(name);
-          } catch {
-            throw err;
-          }
-        }
+    for (const type2 of FETCH_ORDER) {
+      try {
+        return await this.fetchByType[type2](name);
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("not found")) continue;
+        throw err;
       }
-      throw err;
     }
+    throw new Error(`"${name}" not found in registry (component, primitive, composite, or rule)`);
   }
   /**
-   * List all available components
+   * List all available components.
    */
   async listComponents() {
     const index = await this.fetchIndex();
     return index.components.map((name) => ({ name }));
   }
   /**
-   * List all available composites
+   * List all available composites.
    */
   async listComposites() {
     const index = await this.fetchIndex();
     return index.composites.map((name) => ({ name }));
   }
   /**
-   * Check if a component exists in the registry
+   * Check if a component exists in the registry.
    */
   async componentExists(name) {
     try {
@@ -12806,7 +12766,7 @@ var RegistryClient = class {
     }
   }
   /**
-   * Check if a primitive exists in the registry
+   * Check if a primitive exists in the registry.
    */
   async primitiveExists(name) {
     try {
@@ -12817,20 +12777,17 @@ var RegistryClient = class {
     }
   }
   /**
-   * Resolve all dependencies for a component recursively
-   * Returns items in installation order (dependencies first)
+   * Resolve all dependencies for an item recursively.
+   * Returns items in installation order (dependencies first).
    */
   async resolveDependencies(name, resolved = /* @__PURE__ */ new Set()) {
-    if (resolved.has(name)) {
-      return [];
-    }
+    if (resolved.has(name)) return [];
     const item = await this.fetchItem(name);
     resolved.add(name);
     const deps = [];
     for (const dep of item.primitives) {
       if (!resolved.has(dep)) {
-        const depItems = await this.resolveDependencies(dep, resolved);
-        deps.push(...depItems);
+        deps.push(...await this.resolveDependencies(dep, resolved));
       }
     }
     deps.push(item);
@@ -12954,7 +12911,7 @@ var FRAMEWORK_SPECS = {
       components: "components/ui",
       primitives: "lib/primitives",
       composites: "composites",
-      rules: "rules"
+      rules: "lib/rules"
     }
   },
   vite: {
@@ -12964,7 +12921,7 @@ var FRAMEWORK_SPECS = {
       components: "src/components/ui",
       primitives: "src/lib/primitives",
       composites: "src/composites",
-      rules: "src/rules"
+      rules: "src/lib/rules"
     }
   },
   remix: {
@@ -12974,7 +12931,7 @@ var FRAMEWORK_SPECS = {
       components: "app/components/ui",
       primitives: "app/lib/primitives",
       composites: "app/composites",
-      rules: "app/rules"
+      rules: "app/lib/rules"
     }
   },
   "react-router": {
@@ -12984,7 +12941,7 @@ var FRAMEWORK_SPECS = {
       components: "app/components/ui",
       primitives: "app/lib/primitives",
       composites: "app/composites",
-      rules: "app/rules"
+      rules: "app/lib/rules"
     }
   },
   astro: {
@@ -12994,7 +12951,7 @@ var FRAMEWORK_SPECS = {
       components: "src/components/ui",
       primitives: "src/lib/primitives",
       composites: "src/composites",
-      rules: "src/rules"
+      rules: "src/lib/rules"
     }
   },
   wc: {
@@ -13004,7 +12961,7 @@ var FRAMEWORK_SPECS = {
       components: "src/components/ui",
       primitives: "src/lib/primitives",
       composites: "src/composites",
-      rules: "src/rules"
+      rules: "src/lib/rules"
     }
   },
   vanilla: {
@@ -13014,7 +12971,7 @@ var FRAMEWORK_SPECS = {
       components: "src/components/ui",
       primitives: "src/lib/primitives",
       composites: "src/composites",
-      rules: "src/rules"
+      rules: "src/lib/rules"
     }
   },
   unknown: {
@@ -13023,7 +12980,7 @@ var FRAMEWORK_SPECS = {
       components: "components/ui",
       primitives: "lib/primitives",
       composites: "composites",
-      rules: "rules"
+      rules: "lib/rules"
     }
   }
 };
@@ -13671,6 +13628,9 @@ async function loadConfig(cwd) {
     return null;
   }
 }
+function resolveRegistryUrl(options, config2) {
+  return options.registryUrl ?? config2?.registryUrl;
+}
 async function saveConfig(cwd, config2) {
   const paths = getRaftersPaths(cwd);
   await writeFile(paths.config, JSON.stringify(config2, null, 2));
@@ -13709,16 +13669,26 @@ function selectFilesForFramework(files, target) {
   }
   return { files, fallback: false };
 }
+var TARGET_GATED_COMPOSITE_FILES = [
+  { suffix: "Composite.astro", target: "astro" }
+];
+function selectCompositeFiles(files, target) {
+  return files.filter((file2) => {
+    const gate = TARGET_GATED_COMPOSITE_FILES.find((g2) => file2.path.endsWith(g2.suffix));
+    return gate ? gate.target === target : true;
+  });
+}
 var FOLDER_NAMES = /* @__PURE__ */ new Set(["composites"]);
 function isAlreadyInstalled(config2, item) {
   if (!config2?.installed) return false;
-  if (item.type === "ui") {
-    return config2.installed.components.includes(item.name);
-  }
-  if (item.type === "composite") {
-    return (config2.installed.composites ?? []).includes(item.name);
-  }
-  return config2.installed.primitives.includes(item.name);
+  const { components, primitives, composites: composites2, rules } = config2.installed;
+  const bucketByType = {
+    ui: components,
+    primitive: primitives,
+    composite: composites2 ?? [],
+    rule: rules ?? []
+  };
+  return bucketByType[item.type].includes(item.name);
 }
 function isInstalledOnDisk(config2, item, cwd) {
   if (!isAlreadyInstalled(config2, item)) return false;
@@ -13735,8 +13705,14 @@ function trackInstalled(config2, items) {
   const installed = config2.installed;
   if (!installed.composites) installed.composites = [];
   if (!installed.rules) installed.rules = [];
+  const bucketByType = {
+    ui: installed.components,
+    primitive: installed.primitives,
+    composite: installed.composites,
+    rule: installed.rules
+  };
   for (const item of items) {
-    const bucket = item.type === "ui" ? installed.components : item.type === "composite" ? installed.composites : installed.primitives;
+    const bucket = bucketByType[item.type];
     if (!bucket.includes(item.name)) bucket.push(item.name);
   }
   installed.components.sort();
@@ -13753,7 +13729,7 @@ function transformPath(registryPath, config2, cwd) {
     ["components/ui/", config2.componentsPath, "components/ui"],
     ["lib/primitives/", config2.primitivesPath, "lib/primitives"],
     ["composites/", config2.compositesPath, "composites"],
-    ["rules/", config2.rulesPath, "rules"]
+    ["rules/", config2.rulesPath, "lib/rules"]
   ];
   for (const [prefix, field, fallback] of replacements) {
     if (registryPath.startsWith(prefix)) {
@@ -13815,6 +13791,8 @@ async function installItem(cwd, item, options, config2) {
         message: `No ${targetToExtension(target)} version available for ${item.name}. Installing React version.`
       });
     }
+  } else if (item.type === "composite") {
+    filesToInstall = selectCompositeFiles(item.files, getComponentTarget(config2));
   }
   for (const file2 of filesToInstall) {
     const projectPath2 = transformPath(file2.path, config2, cwd);
@@ -13846,7 +13824,9 @@ async function installItem(cwd, item, options, config2) {
 async function add(componentArgs, options) {
   setAgentMode(options.agent ?? false);
   let components = componentArgs;
-  const client = new RegistryClient(options.registryUrl);
+  const cwd = process.cwd();
+  const config2 = await loadConfig(cwd);
+  const client = new RegistryClient(resolveRegistryUrl(options, config2));
   let folder;
   const firstArg = components[0];
   if (firstArg && FOLDER_NAMES.has(firstArg)) {
@@ -13876,14 +13856,12 @@ async function add(componentArgs, options) {
     }
     return;
   }
-  const cwd = process.cwd();
   const initialized = await isInitialized(cwd);
   if (!initialized) {
     error46("Project not initialized. Run `rafters init` first.");
     process.exitCode = 1;
     return;
   }
-  const config2 = await loadConfig(cwd);
   if (options.update) {
     options.overwrite = true;
   }
@@ -13988,6 +13966,7 @@ async function add(componentArgs, options) {
       }
       if (result.skipped && !result.installed) {
         skipped.push(item.name);
+        installedItems.push(item);
       }
     } catch (err) {
       if (err instanceof Error) {
@@ -14034,7 +14013,7 @@ async function add(componentArgs, options) {
       componentsPath: "components/ui",
       primitivesPath: "lib/primitives",
       compositesPath: "composites",
-      rulesPath: "rules",
+      rulesPath: "lib/rules",
       cssPath: null,
       shadcn: false,
       exports: DEFAULT_EXPORTS,
@@ -21167,12 +21146,23 @@ var SemanticSelectionError = class extends Error {
     this.name = "SemanticSelectionError";
   }
 };
-var STATE_USES = ["hover", "active", "focus", "disabled"];
+var STATE_USES = [
+  "hover",
+  "active",
+  "focus",
+  "disabled",
+  "border",
+  "ring",
+  "subtle"
+];
 var STATE_RANK_STEP = {
   hover: (rank, _l, s) => rank + s,
   active: (rank, _l, s) => rank + 2 * s,
   focus: (rank, _l, s) => rank + s,
-  disabled: (_rank, ladder) => closestRankTo(ladder, 5)
+  disabled: (_rank, ladder) => closestRankTo(ladder, 5),
+  border: (rank, _l, s) => rank + 2 * s,
+  ring: (rank) => rank,
+  subtle: (rank, _l, s) => rank - 2 * s
 };
 function partnerForBase(pairs, base) {
   if (!pairs) return void 0;
@@ -22868,7 +22858,7 @@ async function registryToCompiled(registry2, options = {}) {
   const themeCss = registryToTailwind(registry2, { includeImport });
   const { execFileSync } = await import("child_process");
   const { mkdtempSync, writeFileSync: writeFileSync2, readFileSync: readFileSync3, rmSync } = await import("fs");
-  const { join: join13, dirname: dirname4 } = await import("path");
+  const { join: join14, dirname: dirname4 } = await import("path");
   const { createRequire: createRequire2 } = await import("module");
   const require2 = createRequire2(import.meta.url);
   let pkgDir;
@@ -22878,10 +22868,10 @@ async function registryToCompiled(registry2, options = {}) {
   } catch {
     throw new Error("Failed to resolve @tailwindcss/cli");
   }
-  const binPath = join13(pkgDir, "dist", "index.mjs");
-  const tempDir = mkdtempSync(join13(pkgDir, ".tmp-compile-"));
-  const tempInput = join13(tempDir, "input.css");
-  const tempOutput = join13(tempDir, "output.css");
+  const binPath = join14(pkgDir, "dist", "index.mjs");
+  const tempDir = mkdtempSync(join14(pkgDir, ".tmp-compile-"));
+  const tempInput = join14(tempDir, "input.css");
+  const tempOutput = join14(tempDir, "output.css");
   try {
     writeFileSync2(tempInput, themeCss);
     const args = [binPath, "-i", tempInput, "-o", tempOutput];
@@ -24233,12 +24223,12 @@ var DEFAULT_SEMANTIC_COLOR_MAPPINGS = {
     never: ["Use for dividers within cards"]
   },
   panel: {
-    light: { family: "neutral", position: "100" },
+    light: { family: "neutral", position: "200" },
     dark: { family: "neutral", position: "800" },
-    meaning: "Elevated panel surface -- one level above the page",
+    meaning: "Persistent elevated chrome -- headers, docks, fixed toolbars",
     contexts: ["panels", "toolbars", "headers", "docks"],
     do: ["Use for persistent elevated chrome", "Pair with panel-foreground"],
-    never: ["Use for page-level backgrounds", "Stack directly on card without a border"]
+    never: ["Use for page-level backgrounds", "Use for transient surfaces"]
   },
   "panel-foreground": {
     light: { family: "neutral", position: "950" },
@@ -24291,12 +24281,12 @@ var DEFAULT_SEMANTIC_COLOR_MAPPINGS = {
   },
   // Generic surface
   surface: {
-    light: { family: "neutral", position: "50" },
+    light: { family: "neutral", position: "100" },
     dark: { family: "neutral", position: "900" },
-    meaning: "Elevated surface background",
-    contexts: ["elevated-elements"],
-    do: ["Use for elevated surfaces"],
-    never: ["Use for page background"]
+    meaning: "Base chrome surface -- toolbars, app shell, UI frame",
+    contexts: ["chrome", "app-shell", "toolbars"],
+    do: ["Use for application chrome"],
+    never: ["Use for page background", "Use for content containers"]
   },
   "surface-foreground": {
     light: { family: "neutral", position: "950" },
@@ -25381,9 +25371,9 @@ var DEFAULT_SEMANTIC_COLOR_MAPPINGS = {
   // SIDEBAR TOKENS (shadcn compatible + extended)
   // ============================================================================
   sidebar: {
-    light: { family: "neutral", position: "50" },
+    light: { family: "neutral", position: "100" },
     dark: { family: "neutral", position: "900" },
-    meaning: "Sidebar background",
+    meaning: "Sidebar background -- almost on the surface",
     contexts: ["navigation-sidebar", "side-panels"],
     do: ["Use for sidebar backgrounds"],
     never: ["Use for main content areas"]
@@ -27043,7 +27033,7 @@ function generateRadiusTokens(config2, radiusDefs) {
 
 // ../design-tokens/src/generators/semantic.ts
 var FOREGROUND_SUFFIXES = ["-foreground", "-text", "-contrast"];
-var STATE_SUFFIXES = ["-hover", "-active", "-focus", "-disabled"];
+var STATE_SUFFIXES = STATE_USES.map((s) => `-${s}`);
 function toColorRef(mapping) {
   return { family: mapping.light.family, position: mapping.light.position };
 }
@@ -28744,7 +28734,7 @@ var scalePlugin = definePlugin({
 });
 
 // ../design-tokens/src/plugins/state.ts
-var StateTypeSchema = external_exports.enum(["hover", "active", "focus", "disabled"]);
+var StateTypeSchema = external_exports.enum(STATE_USES);
 var StateInputSchema = external_exports.object({
   from: external_exports.string(),
   stateType: StateTypeSchema
@@ -29618,7 +29608,7 @@ async function init(options) {
 
 // src/commands/mcp.ts
 import { existsSync as existsSync6 } from "fs";
-import { basename as basename2, join as join11, resolve as resolve4 } from "path";
+import { basename as basename2, join as join12, resolve as resolve4 } from "path";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -29626,8 +29616,8 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
 // src/mcp/tools.ts
-import { readdir, readFile as readFile5 } from "fs/promises";
-import { join as join10 } from "path";
+import { readFile as readFile6 } from "fs/promises";
+import { join as join11 } from "path";
 
 // ../composites/src/built-in-rules/email.ts
 var email3 = external_exports.string().email();
@@ -29656,6 +29646,10 @@ var AppliedRuleSchema = external_exports.union([
 var CompositeBlockSchema = external_exports.object({
   id: external_exports.string().min(1),
   type: external_exports.string().min(1),
+  /** Signatures this block consumes / produces (rule names) -- the typed I/O edges.
+   * Within a composite, an output named X feeds any block input named X. */
+  input: external_exports.array(external_exports.string()).optional(),
+  output: external_exports.array(external_exports.string()).optional(),
   content: external_exports.unknown().optional(),
   children: external_exports.array(external_exports.string()).optional(),
   parentId: external_exports.string().optional(),
@@ -29685,6 +29679,60 @@ var CompositeFileSchema = external_exports.object({
   blocks: external_exports.array(CompositeBlockSchema).min(1)
 });
 
+// ../composites/src/discovery.ts
+function discoverComposites(entries) {
+  const registry2 = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const entry of entries) {
+    let parsed;
+    try {
+      parsed = JSON.parse(entry.raw);
+    } catch (e) {
+      errors.push({
+        source: entry.source,
+        error: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`
+      });
+      continue;
+    }
+    const result = CompositeFileSchema.safeParse(parsed);
+    if (!result.success) {
+      errors.push({ source: entry.source, error: result.error.message });
+      continue;
+    }
+    const { id } = result.data.manifest;
+    if (registry2.has(id)) {
+      errors.push({
+        source: entry.source,
+        error: `Duplicate composite id "${id}" (already registered)`
+      });
+      continue;
+    }
+    registry2.set(id, result.data);
+  }
+  reportUnresolvedReferences(registry2, errors);
+  return { registry: registry2, errors };
+}
+var COMPOSITE_PREFIX = "composite:";
+function reportUnresolvedReferences(registry2, errors) {
+  for (const [id, composite] of registry2) {
+    const missing = /* @__PURE__ */ new Set();
+    for (const block of composite.blocks) {
+      if (block.type.startsWith(COMPOSITE_PREFIX)) {
+        const refId = block.type.slice(COMPOSITE_PREFIX.length);
+        if (!registry2.has(refId)) {
+          missing.add(refId);
+        }
+      }
+    }
+    if (missing.size > 0) {
+      errors.push({
+        source: id,
+        error: `Unresolved composite reference(s): ${[...missing].map((m3) => `composite:${m3}`).join(", ")}`
+      });
+    }
+  }
+}
+
 // ../ui/src/primitives/typeahead.ts
 function fuzzyScore(query, target) {
   if (query.length === 0) return 1;
@@ -29742,17 +29790,56 @@ function search(query) {
 // ../composites/src/to-mdx.ts
 var import_escape_html = __toESM(require_escape_html(), 1);
 
+// ../composites/src/discovery-node.ts
+import { readdir, readFile as readFile5 } from "fs/promises";
+import { join as join8 } from "path";
+var COMPOSITE_SUFFIX = ".composite.json";
+async function readDir(directory) {
+  const entries = [];
+  let dirents;
+  try {
+    dirents = await readdir(directory, { withFileTypes: true });
+  } catch {
+    return entries;
+  }
+  for (const dirent of dirents) {
+    const fullPath = join8(directory, dirent.name);
+    if (dirent.isDirectory()) {
+      entries.push(...await readDir(fullPath));
+      continue;
+    }
+    if (dirent.isFile() && dirent.name.endsWith(COMPOSITE_SUFFIX)) {
+      const raw = await readFile5(fullPath, "utf-8");
+      entries.push({ raw, source: fullPath });
+    }
+  }
+  return entries;
+}
+function nodeFsAdapter(...directories) {
+  return async () => {
+    const entries = [];
+    for (const directory of directories) {
+      entries.push(...await readDir(directory));
+    }
+    return entries;
+  };
+}
+async function discoverFromDirs(...directories) {
+  const adapter = nodeFsAdapter(...directories);
+  return discoverComposites(await adapter());
+}
+
 // src/utils/workspaces.ts
 import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
-import { basename, dirname as dirname3, join as join9, resolve as resolve3 } from "path";
+import { basename, dirname as dirname3, join as join10, resolve as resolve3 } from "path";
 
 // src/utils/discover.ts
 import { existsSync as existsSync4 } from "fs";
-import { dirname as dirname2, join as join8, resolve as resolve2 } from "path";
+import { dirname as dirname2, join as join9, resolve as resolve2 } from "path";
 function discoverProjectRoot(startDir) {
   let current = resolve2(startDir);
   for (; ; ) {
-    const configPath = join8(current, ".rafters", "config.rafters.json");
+    const configPath = join9(current, ".rafters", "config.rafters.json");
     if (existsSync4(configPath)) {
       return current;
     }
@@ -29769,14 +29856,14 @@ function findMonorepoRoot(startDir, boundary) {
   let current = resolve3(startDir);
   const stopAt = boundary ? resolve3(boundary) : null;
   for (; ; ) {
-    const pnpmWorkspace = join9(current, "pnpm-workspace.yaml");
+    const pnpmWorkspace = join10(current, "pnpm-workspace.yaml");
     if (existsSync5(pnpmWorkspace)) {
       const patterns = parsePnpmWorkspaceYaml(readFileSync2(pnpmWorkspace, "utf-8"));
       if (patterns.length > 0) {
         return { root: current, patterns };
       }
     }
-    const pkgJson = join9(current, "package.json");
+    const pkgJson = join10(current, "package.json");
     if (existsSync5(pkgJson)) {
       const patterns = parsePackageJsonWorkspaces(readFileSync2(pkgJson, "utf-8"));
       if (patterns.length > 0) {
@@ -29832,9 +29919,9 @@ function expandPattern(monorepoRoot, pattern) {
   const trimmed = pattern.replace(/\/+$/, "");
   if (trimmed.endsWith("/*")) {
     const parentRel = trimmed.slice(0, -2);
-    const parent = join9(monorepoRoot, parentRel);
+    const parent = join10(monorepoRoot, parentRel);
     if (!existsSync5(parent)) return [];
-    return readdirSync2(parent).map((entry) => join9(parent, entry)).filter((path) => {
+    return readdirSync2(parent).map((entry) => join10(parent, entry)).filter((path) => {
       try {
         return statSync2(path).isDirectory();
       } catch {
@@ -29842,7 +29929,7 @@ function expandPattern(monorepoRoot, pattern) {
       }
     });
   }
-  const literal2 = join9(monorepoRoot, trimmed);
+  const literal2 = join10(monorepoRoot, trimmed);
   if (existsSync5(literal2)) {
     try {
       if (statSync2(literal2).isDirectory()) return [literal2];
@@ -29866,13 +29953,13 @@ function discoverWorkspaces(startDir = process.cwd(), options = {}) {
     for (const dir of expandPattern(layout.root, pattern)) {
       if (seen.has(dir)) continue;
       seen.add(dir);
-      const config2 = join9(dir, ".rafters", "config.rafters.json");
+      const config2 = join10(dir, ".rafters", "config.rafters.json");
       if (existsSync5(config2)) {
         workspaces.push({ name: basename(dir), root: dir });
       }
     }
   }
-  const rootConfig = join9(layout.root, ".rafters", "config.rafters.json");
+  const rootConfig = join10(layout.root, ".rafters", "config.rafters.json");
   if (existsSync5(rootConfig) && !seen.has(layout.root)) {
     workspaces.unshift({ name: basename(layout.root), root: layout.root });
   }
@@ -29924,29 +30011,6 @@ var TOOL_DEFINITIONS = [
       required: []
     }
   },
-  {
-    name: "rafters_rule",
-    description: "Query validation rules or create new ones. Rules are named validation patterns (required, email, password, etc.) that composites can apply.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        ...WORKSPACE_PARAM,
-        name: { type: "string", description: "Get a specific rule by name" },
-        query: { type: "string", description: "Search rules by name/description" },
-        create: {
-          type: "object",
-          properties: {
-            name: { type: "string", description: "Rule name (kebab-case)" },
-            description: { type: "string", description: "What this rule validates" },
-            zodSchema: { type: "string", description: "Zod schema as a string" }
-          },
-          required: ["name", "description", "zodSchema"],
-          description: "Create a new rule (provide all three fields)"
-        }
-      },
-      required: []
-    }
-  },
   {
     name: "rafters_pattern",
     description: 'Get design pattern guidance by querying composites. Search by what the pattern solves (e.g., "authentication", "data entry", "navigation") to get do/never rules, cognitive load, and designer intent.',
@@ -29999,20 +30063,22 @@ var RaftersToolHandler = class {
         return this.handleWorkspaces();
       case "rafters_composite":
         return this.handleComposite(args);
-      case "rafters_rule":
-        return this.handleRule(args);
       case "rafters_pattern":
         return this.handlePattern(args);
       case "rafters_component":
         return this.handleComponent(args.name);
-      default: {
-        const suggestion = name === "rafters_onboard" ? "rafters_onboard was removed. Token import is now a CLI operation: run `rafters init` (auto-detects and prompts) or `rafters import` (standalone)." : "Available tools: rafters_workspaces, rafters_composite, rafters_rule, rafters_pattern, rafters_component.";
+      default:
         return {
           content: [
-            { type: "text", text: JSON.stringify({ error: `Unknown tool: ${name}`, suggestion }) }
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Unknown tool: ${name}`,
+                suggestion: "Available tools: rafters_workspaces, rafters_composite, rafters_pattern, rafters_component."
+              })
+            }
           ]
         };
-      }
     }
   }
   /**
@@ -30063,42 +30129,30 @@ var RaftersToolHandler = class {
       ]
     };
   }
-  async loadCompositesFromDir(dir) {
-    try {
-      const entries = await readdir(dir);
-      const files = entries.filter((f) => f.endsWith(".composite.json"));
-      for (const file2 of files) {
-        try {
-          const { readFile: readFile6 } = await import("fs/promises");
-          const raw = await readFile6(join10(dir, file2), "utf-8");
-          const parsed = JSON.parse(raw);
-          const result = CompositeFileSchema.safeParse(parsed);
-          if (result.success) {
-            try {
-              register2(result.data);
-            } catch {
-            }
-          }
-        } catch {
-        }
+  /**
+   * Recursively discover composites under the given directories via the shared
+   * discovery core (node-fs adapter), then register each into the in-memory
+   * registry. Duplicate ids -- across this call or against already-registered
+   * composites -- are ignored: the first registration wins.
+   */
+  async loadCompositesFromDirs(...dirs) {
+    const { registry: registry2 } = await discoverFromDirs(...dirs);
+    for (const composite of registry2.values()) {
+      try {
+        register2(composite);
+      } catch {
       }
-    } catch {
     }
   }
   async ensureCompositesLoaded(workspace) {
     if (!this.builtInCompositesLoaded) {
-      const builtInDirs = ["typography"];
-      for (const dir of builtInDirs) {
-        await this.loadCompositesFromDir(
-          join10(process.cwd(), "node_modules/@rafters/composites/src", dir)
-        );
-      }
+      await this.loadCompositesFromDirs(
+        join11(process.cwd(), "node_modules/@rafters/composites/src/typography")
+      );
       this.builtInCompositesLoaded = true;
     }
     if (workspace && !this.compositesLoadedFor.has(workspace.root)) {
-      for (const dir of await this.compositeReadRoots(workspace.root)) {
-        await this.loadCompositesFromDir(dir);
-      }
+      await this.loadCompositesFromDirs(...await this.compositeReadRoots(workspace.root));
       this.compositesLoadedFor.add(workspace.root);
     }
   }
@@ -30113,11 +30167,11 @@ var RaftersToolHandler = class {
     const paths = getRaftersPaths(workspaceRoot);
     let config2 = null;
     try {
-      config2 = JSON.parse(await readFile5(paths.config, "utf-8"));
+      config2 = JSON.parse(await readFile6(paths.config, "utf-8"));
     } catch {
     }
     if (!config2?.compositesPath) {
-      return [join10(paths.root, "composites")];
+      return [join11(paths.root, "composites")];
     }
     return resolveReadSet(config2.compositesPath, workspaceRoot);
   }
@@ -30150,49 +30204,15 @@ var RaftersToolHandler = class {
       usagePatterns: c4.manifest.usagePatterns,
       input: c4.input,
       output: c4.output,
-      blockCount: c4.blocks.length
+      blockCount: c4.blocks.length,
+      // Surface which blocks carry which validation rules. Rules compile to
+      // native HTML5 constraint attributes at build, so agents need to see
+      // them to reason about a composite's behavior. Only blocks with rules
+      // are listed -- the array is empty when nothing is constrained.
+      blockRules: c4.blocks.filter((b2) => b2.rules && b2.rules.length > 0).map((b2) => ({ id: b2.id, type: b2.type, rules: b2.rules }))
     }));
     return { content: [{ type: "text", text: JSON.stringify({ composites: result }, null, 2) }] };
   }
-  async handleRule(args) {
-    const { name, query, create } = args;
-    const builtInRules = [
-      { name: "required", description: "Field must have a value", source: "registry" },
-      { name: "email", description: "Must be a valid email address", source: "registry" },
-      {
-        name: "password",
-        description: "Password strength requirements",
-        source: "registry"
-      },
-      { name: "url", description: "Must be a valid URL", source: "registry" },
-      {
-        name: "credentials",
-        description: "Combined username/password validation",
-        source: "registry"
-      }
-    ];
-    if (create) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              error: "Rule creation not yet implemented",
-              suggestion: "Rules will be written to .rafters/rules/<name>.ts"
-            })
-          }
-        ]
-      };
-    }
-    let rules = builtInRules;
-    if (name) {
-      rules = rules.filter((r) => r.name === name);
-    } else if (query) {
-      const q = query.toLowerCase();
-      rules = rules.filter((r) => r.name.includes(q) || r.description.toLowerCase().includes(q));
-    }
-    return { content: [{ type: "text", text: JSON.stringify({ rules }, null, 2) }] };
-  }
   async handlePattern(args) {
     const { solves, query, workspace } = args;
     const resolved = this.resolve(workspace);
@@ -30332,7 +30352,7 @@ async function mcp(options) {
   let defaultWorkspace;
   if (options.projectRoot) {
     const explicit = resolve4(options.projectRoot);
-    const configPath = join11(explicit, ".rafters", "config.rafters.json");
+    const configPath = join12(explicit, ".rafters", "config.rafters.json");
     if (!existsSync6(configPath)) {
       process.stderr.write(
         `--project-root ${explicit} does not contain .rafters/config.rafters.json
@@ -30358,7 +30378,7 @@ import { resolve as resolve5 } from "path";
 
 // ../studio/src/api/vite-plugin.ts
 import { writeFile as writeFile3 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var REGISTRY_PLUGINS2 = [scalePlugin, contrastPlugin, statePlugin, invertPlugin];
 var STUDIO_REASON_DEFAULT = "studio interactive edit";
 var TokenResponseSchema = external_exports.object({
@@ -30384,7 +30404,7 @@ var ColorBuildOptionsSchema = external_exports.object({
   states: external_exports.record(external_exports.string(), external_exports.string()).optional()
 });
 var projectPath = process.env.RAFTERS_PROJECT_PATH || process.cwd();
-var outputPath = join12(projectPath, ".rafters", "output", "rafters.css");
+var outputPath = join13(projectPath, ".rafters", "output", "rafters.css");
 var SetTokenMessageSchema = external_exports.object({
   name: external_exports.string().min(1),
   value: external_exports.union([external_exports.string(), ColorValueSchema, ColorReferenceSchema]),
@@ -30754,7 +30774,7 @@ function studioApiPlugin() {
   return {
     name: "rafters-studio-api",
     async configureServer(server) {
-      const tokensDir = join12(projectPath, ".rafters", "tokens");
+      const tokensDir = join13(projectPath, ".rafters", "tokens");
       try {
         registry2 = loadRegistryFromDir(tokensDir, REGISTRY_PLUGINS2);
         initialized = true;

package/dist/registry/types.d.ts

@@ -25,6 +25,7 @@ declare const RegistryItemTypeSchema: z.ZodEnum<{
     ui: "ui";
     primitive: "primitive";
     composite: "composite";
+    rule: "rule";
 }>;
 type RegistryItemType = z.infer<typeof RegistryItemTypeSchema>;
 /**
@@ -57,6 +58,7 @@ declare const RegistryItemSchema: z.ZodObject<{
         ui: "ui";
         primitive: "primitive";
         composite: "composite";
+        rule: "rule";
     }>;
     description: z.ZodOptional<z.ZodString>;
     primitives: z.ZodArray<z.ZodString>;

package/dist/registry/types.js

@@ -8,7 +8,7 @@ var RegistryFileSchema = z.object({
   devDependencies: z.array(z.string()).default([])
   // e.g., ["vitest"] - from @devDependencies JSDoc
 });
-var RegistryItemTypeSchema = z.enum(["ui", "primitive", "composite"]);
+var RegistryItemTypeSchema = z.enum(["ui", "primitive", "composite", "rule"]);
 var RegistryItemIntelligenceSchema = z.object({
   cognitiveLoad: z.number().optional(),
   attentionEconomics: z.string().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rafters",
-  "version": "0.0.69",
+  "version": "0.0.70",
   "description": "Design Intelligence CLI. Scaffold tokens, import existing shadcn/Tailwind v4 sources, add components, and serve an MCP server so AI agents read decisions instead of guessing.",
   "homepage": "https://rafters.studio",
   "license": "MIT",