climaybe 3.0.9 → 3.1.1

package/src/cursor/rules/schemas.mdc

@@ -1,150 +1,170 @@
 ---
-description: Schema design rules — minimal settings, translation keys, no redundancy
+description: Schema design rules and schema builder — _schemas/, partials, dynamic generation, inline markers
 globs:
   - "sections/**/*.liquid"
   - "**/sections/*.liquid"
   - "blocks/**/*.liquid"
   - "**/blocks/*.liquid"
+  - "_schemas/**/*.js"
+  - "_schemas/**/*.json"
 alwaysApply: false
 ---
-# Schema Design Rules for Electric Maybe Shopify Theme
+# Schema Design Rules
 
-## Core Principles
+## Schema Builder (`climaybe build-schemas`)
 
-### 1. **Start Simple, Expand Gradually**
+This project uses the climaybe schema builder to generate schemas from JavaScript/JSON source files. Schemas are defined in `_schemas/` and injected into `sections/*.liquid` and `blocks/*.liquid` at build time.
+
+### How it works
+
+A section or block file contains an inline-comment marker at the end:
+
+```liquid
+<section class="hero">{{ section.settings.title }}</section>
+
+{% # schema 'hero-banner' %}
+```
+
+`{% # ... %}` is a Liquid inline comment — Shopify ignores it. The builder finds the marker, resolves `_schemas/hero-banner.js` (or `.json`), and writes the generated `{% schema %}...{% endschema %}` block below it. On rebuild, only the generated block is replaced. Everything above the marker (including theme editor changes) is preserved.
+
+### Directory structure
+
+```
+_schemas/              ← schema definitions (JS or JSON)
+├── partials/          ← shared settings, fieldsets, factory functions
+│   ├── link.js
+│   ├── create-links.js
+│   └── spacing.js
+├── hero-banner.js     ← referenced by sections via marker
+├── landing-page.js
+└── page-schema.js
+```
+
+### When creating or editing schemas
+
+1. **Define schemas in `_schemas/`**, not inline in section files. The `{% schema %}...{% endschema %}` block in `sections/` is generated output — never edit it directly.
+
+2. **Use JS files** (CommonJS `module.exports`) when you need imports, computation, or comments. Use JSON for simple static schemas.
+
+3. **Extract shared settings into `_schemas/partials/`** — these are imported via `require()` and are never referenced directly by section markers.
+
+4. **Spread partials into settings arrays:**
+```js
+const linkSettings = require('./partials/link.js');
+const spacingSettings = require('./partials/spacing.js');
+
+module.exports = {
+  name: 'Featured Collection',
+  settings: [
+    { type: 'text', id: 'title', label: 'Heading' },
+    ...linkSettings,
+    ...spacingSettings,
+  ],
+};
+```
+
+5. **Use factory functions for repeated field groups:**
+```js
+const createLinks = require('./partials/create-links.js');
+
+module.exports = {
+  name: 'Hero',
+  settings: [
+    { type: 'text', id: 'heading', label: 'Heading' },
+    ...createLinks(3),
+  ],
+};
+```
+
+6. **Use function exports for per-section overrides:**
+```js
+module.exports = function (filename, content) {
+  return {
+    name: content.name || filename.replace('.liquid', ''),
+    settings: [/* ... */],
+  };
+};
+```
+
+The function receives `(filename, inlineContent)`. Inline content comes from a second inline comment in the section file:
+```liquid
+{% # schema 'page-schema' %}
+{% # { "name": "About Us" } %}
+```
+
+7. **For static exports**, inline JSON is shallow-merged on top (inline wins):
+```liquid
+{% # schema 'newsletter' %}
+{% # { "name": "Footer Newsletter" } %}
+```
+
+### Commands
+
+```bash
+npx climaybe build-schemas              # generate schemas in sections/
+npx climaybe build-schemas --dry-run    # preview without writing
+npx climaybe build-schemas --list       # list schema files and markers
+```
+
+Schemas also rebuild automatically during `climaybe serve` (watch mode, tagged `[schema]` in console).
+
+### Rules for AI assistants
+
+- When asked to create a new section or block with a schema, create the schema definition in `_schemas/` and add the `{% # schema 'name' %}` marker to the liquid file. Do not write raw `{% schema %}` JSON.
+- When asked to edit a schema, edit the file in `_schemas/`, not the generated block in `sections/` or `blocks/`.
+- When adding fields that are reused across schemas (links, spacing, colors), extract them into `_schemas/partials/` and spread them.
+- When duplicating a schema for a variant section, use a shared schema file instead. Add the same marker to both sections.
+- After editing `_schemas/` files, remind the user to run `npx climaybe build-schemas` (or note that `climaybe serve` rebuilds automatically).
+
+---
+
+## Schema Design Principles
+
+### 1. Start Simple, Expand Gradually
 - Begin with minimal, essential settings only
 - Add complexity only when there's a clear, demonstrated need
-- Ask for permission before adding multiple settings at once
 
-### 2. **Avoid Redundancy**
+### 2. Avoid Redundancy
 - If text content exists in translation files (`en.default.json`), don't duplicate it in schema
 - Use translation keys for all text content, not schema text inputs
 - Schema should focus on functionality, not content
 
-### 3. **Question Every Setting**
+### 3. Question Every Setting
 Before adding any schema setting, ask:
 - Is this truly necessary for the user?
 - Can this be handled by translation files instead?
 - Will this setting be used by most merchants?
 - Does this add value or just complexity?
 
-### 4. **Limit Settings Per Section**
+### 4. Limit Settings Per Section
 - **Maximum 5 settings per section** (excluding headers)
 - If more are needed, consider splitting into multiple sections
 - Group related settings under headers
 
 ## Schema Setting Guidelines
 
-### **Essential Settings (Always Include)**
+### Essential Settings (Always Include)
 - Link list selectors for menus
 - Image upload fields for key visuals
 - Color scheme selectors (if theme supports multiple schemes)
 
-### **Optional Settings (Add Only When Needed)**
+### Optional Settings (Add Only When Needed)
 - Layout toggles (show/hide elements)
 - Spacing adjustments
 - Text alignment options
 - Background color/image options
 
-### **Avoid These Settings**
+### Avoid These Settings
 - Text content inputs (use translation files)
 - Toggle switches for every element
 - Complex layout selectors
 - Settings that duplicate existing functionality
 
-## Implementation Rules
-
-### **Before Adding Settings**
-1. Check if the functionality can be achieved through:
-   - Translation files
-   - CSS classes
-   - Existing theme settings
-   - Liquid conditionals
-
-2. Consider the user experience:
-   - Will merchants actually use this setting?
-   - Is it intuitive and discoverable?
-   - Does it solve a real problem?
-
-3. Evaluate maintenance cost:
-   - Will this setting need updates?
-   - Does it create technical debt?
-   - Is it worth the complexity?
-
-### **When Adding Multiple Settings**
-- **Ask for permission first**
-- Explain the reasoning for each setting
-- Consider if they can be grouped or simplified
-- Test with a small subset first
-
-## Examples
-
-### ✅ Good Schema (Simple)
-```json
-{
-  "settings": [
-    {
-      "type": "link_list",
-      "id": "main_menu",
-      "label": "Main menu"
-    },
-    {
-      "type": "image_picker",
-      "id": "logo",
-      "label": "Logo"
-    }
-  ]
-}
-```
-
-### ❌ Bad Schema (Over-engineered)
-```json
-{
-  "settings": [
-    {
-      "type": "link_list",
-      "id": "main_menu",
-      "label": "Main menu"
-    },
-    {
-      "type": "checkbox",
-      "id": "show_menu",
-      "label": "Show menu",
-      "default": true
-    },
-    {
-      "type": "select",
-      "id": "menu_style",
-      "label": "Menu style",
-      "options": [
-        {"value": "horizontal", "label": "Horizontal"},
-        {"value": "vertical", "label": "Vertical"},
-        {"value": "dropdown", "label": "Dropdown"}
-      ]
-    },
-    {
-      "type": "range",
-      "id": "menu_spacing",
-      "min": 0,
-      "max": 50,
-      "step": 5,
-      "label": "Menu spacing"
-    }
-  ]
-}
-```
-
 ## Review Process
 
 Before committing any schema changes:
-1. **Count the settings** - Keep under 5 per section
-2. **Check for redundancy** - Ensure no duplicate functionality
-3. **Verify necessity** - Each setting should solve a real problem
-4. **Consider alternatives** - Could this be handled differently?
-5. **Get approval** - For multiple settings or complex changes
-
-## Remember
-- **Simplicity is a feature**
-- **Less is more**
-- **When in doubt, leave it out**
-- **Ask before expanding** 
+1. **Count the settings** — keep under 5 per section
+2. **Check for redundancy** — ensure no duplicate functionality
+3. **Verify necessity** — each setting should solve a real problem
+4. **Check partials** — could this field group be extracted and shared?
+5. **Consider alternatives** — could this be handled via translations, CSS, or existing settings?

package/src/cursor/rules/sections.mdc

@@ -11,11 +11,13 @@ alwaysApply: false
 
 Every section must include:
 
-- `{% schema %}` tag with valid JSON
+- Schema definition — either a `{% schema %}` tag with valid JSON, or a `{% # schema 'name' %}` marker referencing a schema from `_schemas/` (see `schemas.mdc` for the schema builder)
 - Proper HTML semantic structure
 - CSS scoping with section classes
 - Translation keys for all text
 
+When using the schema builder, add the inline-comment marker at the end of the section file and define the schema in `_schemas/`. The generated `{% schema %}...{% endschema %}` block is build output — do not edit it directly.
+
 ## Section Patterns
 
 _(To be filled in on review.)_

package/src/cursor/skills/changelog-release/SKILL.md

@@ -12,9 +12,9 @@ Builds a changelog or release notes from commits since a ref (e.g. last tag), gr
 When grouping and labeling commits, read and apply:
 
 1. `.cursor/rules/00-rule-index.mdc` — rule index
-2. `.cursor/rules/commit-rules.mdc` — commit types (🔨 fix, 🚀 feat, ♻️ refactor, 🎨 style, etc.) and format
+2. `.cursor/rules/commit-rules.mdc` — commit types (fix, feat, refactor, style, etc.) and format
 
-Use the same type labels and emoji for changelog sections so the output matches how the team writes commits.
+Use the same type labels for changelog sections so the output matches how the team writes commits.
 
 ## Workflow
 
@@ -23,8 +23,8 @@ Use the same type labels and emoji for changelog sections so the output matches
 3. **Group by type** — Map each commit to a type from commit-rules.mdc (fix, feat, refactor, style, remove, wip, docs, ai, chore, upgrade). Ignore merge commits. Put "unknown" or "other" for non-matching messages.
 4. **Format** — Output markdown:
    - Optional title (e.g. "Changelog since v1.2.0")
-   - Sections by type (e.g. "## 🚀 Features", "## 🔨 Fixes")
-   - Under each section: list of commit descriptions (one line each, link to commit if desired). Strip emoji+type prefix for readability if you want, or keep for consistency.
+   - Sections by type (e.g. "## Features", "## Fixes")
+   - Under each section: list of commit descriptions (one line each, link to commit if desired).
 5. **Optional** — Add "Breaking changes" subsection if any commit message indicates breaking change (e.g. `!` or "BREAKING CHANGE").
 
 ## Output Format
@@ -32,15 +32,15 @@ Use the same type labels and emoji for changelog sections so the output matches
 ```markdown
 # Changelog (since [ref])
 
-## 🚀 Features
+## Features
 - add product quick view modal
 - implement infinite scroll for collections
 
-## 🔨 Fixes
+## Fixes
 - resolve cart total calculation error
 - modal close button not working
 
-## ♻️ Refactor
+## Refactor
 - optimize product card rendering
 ```
 

package/src/cursor/skills/commit-in-groups/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: commit-in-groups
-description: Groups current working tree changes into logical commits and suggests commit messages per project convention. Use when the user says "/commit-in-groups", "commit in groups", "group my commits", "suggest separate commits", or "split my changes into commits". Follows commit-rules.mdc (emoji + type + description).
+description: Groups current working tree changes into logical commits and suggests commit messages per project convention. Use when the user says "/commit-in-groups", "commit in groups", "group my commits", "suggest separate commits", or "split my changes into commits". Follows commit-rules.mdc (type + description).
 ---
 
 # Commit in Groups
@@ -14,7 +14,7 @@ Analyzes uncommitted changes, groups them into logical commits, and suggests one
 Before suggesting any commit messages, read and apply:
 
 1. `.cursor/rules/00-rule-index.mdc` — rule index
-2. `.cursor/rules/commit-rules.mdc` — commit format (emoji + type + description), types (fix, feat, refactor, style, etc.), imperative mood, optional scope
+2. `.cursor/rules/commit-rules.mdc` — commit format (type + description), types (fix, feat, refactor, style, etc.), imperative mood, optional scope
 
 Use the exact format and types from commit-rules; no period at end; lowercase description.
 
@@ -27,8 +27,8 @@ Use the exact format and types from commit-rules; no period at end; lowercase de
    - Refactor in one area, fix in another → separate commits
    - Locale/schema/docs can be separate if they form a clear unit
    - When in doubt, split rather than combine
-3. **Assign type** — For each group, pick the best type from commit-rules (🔨 fix, 🚀 feat, ♻️ refactor, 🎨 style, 🗑️ remove, 📝 docs, 🔧 chore, etc.) and optional scope (e.g. `sections`, `cart`, `locales`).
-4. **Write messages** — One line per commit: `<emoji> <type>(scope): <description>`. Imperative, lowercase, no period. Multi-line body only if the change is complex and warrants bullets.
+3. **Assign type** — For each group, pick the best type from commit-rules (fix, feat, refactor, style, remove, docs, chore, etc.) and optional scope (e.g. `sections`, `cart`, `locales`).
+4. **Write messages** — One line per commit: `<type>(scope): <description>`. Imperative, lowercase, no period. Multi-line body only if the change is complex and warrants bullets.
 5. **Output and execute** — List the suggested commits (message + files per commit), then **run the commits yourself**: for each group, run `git add` on the listed files and `git commit -m "..."` with the exact message. Do not only suggest commands; execute them so the working tree is left with the changes committed. Summarize what was committed at the end.
 
 ## Output Format
@@ -38,11 +38,11 @@ Show the plan briefly, then run it:
 ```markdown
 ## Suggested commits
 
-**Commit 1:** `🚀 feat(sections): add featured collection section`
+**Commit 1:** `feat(sections): add featured collection section`
 - `sections/s--featured-collection.liquid`
 - `snippets/m--product-card.liquid`
 
-**Commit 2:** `🎨 style(cart): adjust drawer spacing`
+**Commit 2:** `style(cart): adjust drawer spacing`
 - `sections/cart--drawer.liquid`
 - `assets/style.css`
 ```

package/src/index.js

@@ -12,6 +12,7 @@ import { appInitCommand } from './commands/app-init.js';
 import { migrateLegacyConfigCommand } from './commands/migrate-legacy-config.js';
 import { buildScriptsCommand } from './commands/build-scripts.js';
 import { createEntrypointsCommand } from './commands/create-entrypoints.js';
+import { buildSchemasCommand } from './commands/build-schemas.js';
 import { serveAll, serveAssets, serveShopify, lintAll, buildAll } from './lib/dev-runtime.js';
 
 /**
@@ -84,6 +85,13 @@ function registerThemeCommands(cmd) {
     .description('Create _scripts/main.js and _styles/main.css (optional)')
     .action(createEntrypointsCommand);
 
+  cmd
+    .command('build-schemas')
+    .description('Generate schemas from _schemas/ JS/JSON into sections/ and blocks/ (uses inline-comment markers)')
+    .option('--dry-run', 'Show what would be injected without writing files')
+    .option('--list', 'List available schema files and section references')
+    .action(buildSchemasCommand);
+
   cmd
     .command('update')
     .alias('update-workflows')

package/src/lib/build-scripts.js

@@ -1,25 +1,29 @@
 import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync } from 'node:fs';
 import { join, basename, dirname, normalize } from 'node:path';
 
-function extractImports(content) {
+function extractImportRecords(content) {
   const imports = [];
   // Supports compact imports (import{a}from"./x"), multiline forms,
   // and import attributes (with { type: "json" }).
   const fromImportRegex =
-    /(^|\n)\s*import(?:\s+type)?\s*[\s\S]*?\s*\bfrom\b\s*['"]([^'"]+)['"](?:\s+with\s*\{[\s\S]*?\})?\s*;?/g;
+    /(^|\n)\s*import(?:\s+type)?\s*([\s\S]*?)\s*\bfrom\b\s*['"]([^'"]+)['"](?:\s+with\s*\{[\s\S]*?\})?\s*;?/g;
   const sideEffectImportRegex = /(^|\n)\s*import\s*['"]([^'"]+)['"](?:\s+with\s*\{[\s\S]*?\})?\s*;?/g;
   let match;
 
   while ((match = fromImportRegex.exec(content)) !== null) {
-    imports.push(match[2]);
+    imports.push({ importPath: match[3], hasBindings: Boolean(match[2]?.trim()) });
   }
   while ((match = sideEffectImportRegex.exec(content)) !== null) {
-    imports.push(match[2]);
+    imports.push({ importPath: match[2], hasBindings: false });
   }
 
   return imports;
 }
 
+function extractImports(content) {
+  return extractImportRecords(content).map((record) => record.importPath);
+}
+
 function stripModuleSyntax(content) {
   // Remove import statements (including multiline/compact forms and import attributes).
   let cleaned = content.replace(
@@ -58,7 +62,7 @@ function minifyScriptContent(content) {
   return minified;
 }
 
-function processScriptFile({ scriptsDir, filePath, processedFiles, minify = false }) {
+function processScriptFile({ scriptsDir, filePath, processedFiles, minify = false, isolateFiles = new Set() }) {
   if (processedFiles.has(filePath)) return '';
   processedFiles.add(filePath);
 
@@ -78,11 +82,20 @@ function processScriptFile({ scriptsDir, filePath, processedFiles, minify = fals
   for (const importPath of imports) {
     const resolvedImport = resolveImportPath(filePath, importPath);
     if (!resolvedImport) continue;
-    importedContent += processScriptFile({ scriptsDir, filePath: resolvedImport, processedFiles, minify });
+    importedContent += processScriptFile({
+      scriptsDir,
+      filePath: resolvedImport,
+      processedFiles,
+      minify,
+      isolateFiles
+    });
   }
 
   content = stripModuleSyntax(content);
   if (minify) content = minifyScriptContent(content);
+  if (isolateFiles.has(filePath)) {
+    content = `(function () {\n${content.trim()}\n})();`;
+  }
 
   return importedContent + '\n' + content;
 }
@@ -113,6 +126,39 @@ function collectImportedFiles({ scriptsDir, entryFile, seen = new Set() }) {
   return seen;
 }
 
+function collectFilesToIsolate({ scriptsDir, entryFile }) {
+  const seen = new Set();
+  const importedWithBindings = new Set();
+
+  function visit(filePath) {
+    if (seen.has(filePath)) return;
+    seen.add(filePath);
+
+    const fullPath = join(scriptsDir, filePath);
+    if (!existsSync(fullPath)) return;
+    const content = readFileSync(fullPath, 'utf8');
+    const imports = extractImportRecords(content);
+
+    for (const record of imports) {
+      const resolved = resolveImportPath(filePath, record.importPath);
+      if (!resolved) continue;
+      if (record.hasBindings) importedWithBindings.add(resolved);
+      visit(resolved);
+    }
+  }
+
+  visit(entryFile);
+
+  const isolateFiles = new Set();
+  for (const file of seen) {
+    if (file !== entryFile && !importedWithBindings.has(file)) {
+      isolateFiles.add(file);
+    }
+  }
+
+  return isolateFiles;
+}
+
 function listTopLevelEntrypoints(scriptsDir) {
   if (!existsSync(scriptsDir)) return [];
   return readdirSync(scriptsDir, { withFileTypes: true })
@@ -134,7 +180,14 @@ function buildSingleEntrypoint({ cwd, entryFile, minify = false }) {
   }
 
   const processedFiles = new Set();
-  let finalContent = processScriptFile({ scriptsDir, filePath: entryFile, processedFiles, minify });
+  const isolateFiles = collectFilesToIsolate({ scriptsDir, entryFile });
+  let finalContent = processScriptFile({
+    scriptsDir,
+    filePath: entryFile,
+    processedFiles,
+    minify,
+    isolateFiles
+  });
   finalContent = stripModuleSyntax(finalContent);
   if (minify) finalContent = minifyScriptContent(finalContent);
 

package/src/lib/dev-runtime.js

@@ -5,6 +5,7 @@ import { isAbsolute, join, relative } from 'node:path';
 import pc from 'picocolors';
 import { readConfig } from './config.js';
 import { buildScripts } from './build-scripts.js';
+import { buildSchemas } from './schema-builder.js';
 import { runShopify } from './shopify-cli.js';
 
 function tagLabel(tag, color = (s) => s) {
@@ -260,6 +261,49 @@ export function serveAssets({ cwd = process.cwd(), includeThemeCheck = false } =
       })
     : null;
 
+  const schemasDir = join(cwd, '_schemas');
+  const hasSchemas = existsSync(schemasDir);
+  if (hasSchemas) {
+    try {
+      const result = buildSchemas({ cwd });
+      if (result.processed.length > 0) {
+        writeTaggedLine('schema', pc.green, `built ${result.processed.length} file(s) (initial)`);
+      }
+      if (result.errors.length > 0) {
+        for (const e of result.errors) {
+          writeTaggedLine('schema', pc.green, `error: ${e.section} — ${e.error}`, process.stderr);
+        }
+      }
+    } catch (err) {
+      writeTaggedLine('schema', pc.green, `initial build failed: ${err.message}`, process.stderr);
+    }
+  } else {
+    writeTaggedLine('schema', pc.green, 'skipped (missing _schemas/)');
+  }
+
+  const schemasWatch = hasSchemas
+    ? watchTree({
+        rootDir: schemasDir,
+        ignore: (p) => p.includes('node_modules') || p.includes('/.git/'),
+        debounceMs: 300,
+        onChange: () => {
+          try {
+            const result = buildSchemas({ cwd });
+            if (result.processed.length > 0) {
+              writeTaggedLine('schema', pc.green, `rebuilt ${result.processed.length} file(s)`);
+            }
+            if (result.errors.length > 0) {
+              for (const e of result.errors) {
+                writeTaggedLine('schema', pc.green, `error: ${e.section} — ${e.error}`, process.stderr);
+              }
+            }
+          } catch (err) {
+            writeTaggedLine('schema', pc.green, `build failed: ${err.message}`, process.stderr);
+          }
+        },
+      })
+    : null;
+
   let themeCheckRunning = false;
   let themeCheckQueued = false;
   const runThemeCheck = () => {
@@ -287,7 +331,8 @@ export function serveAssets({ cwd = process.cwd(), includeThemeCheck = false } =
             p.includes('/assets/') ||
             p.includes('/.git/') ||
             p.includes('/_scripts/') ||
-            p.includes('/_styles/'),
+            p.includes('/_styles/') ||
+            p.includes('/_schemas/'),
           debounceMs: 800,
           onChange: () => {
             runThemeCheck();
@@ -304,12 +349,13 @@ export function serveAssets({ cwd = process.cwd(), includeThemeCheck = false } =
 
   const cleanup = () => {
     safeClose(scriptsWatch);
+    safeClose(schemasWatch);
     safeClose(themeCheckWatch);
     safeKill(tailwind);
     safeKill(devMcp);
   };
 
-  return { tailwind, devMcp, scriptsWatch, themeCheckWatch, cleanup };
+  return { tailwind, devMcp, scriptsWatch, schemasWatch, themeCheckWatch, cleanup };
 }
 
 export function serveAll({ cwd = process.cwd(), includeThemeCheck = false } = {}) {
@@ -355,6 +401,24 @@ export function lintAll({ cwd = process.cwd() } = {}) {
 
 export function buildAll({ cwd = process.cwd() } = {}) {
   const env = { ...process.env, NODE_ENV: 'production' };
+
+  let schemasOk = true;
+  try {
+    const schemaResult = buildSchemas({ cwd });
+    if (schemaResult.processed.length > 0) {
+      writeTaggedLine('schema', pc.green, `built ${schemaResult.processed.length} section(s)`);
+    }
+    if (schemaResult.errors.length > 0) {
+      for (const e of schemaResult.errors) {
+        writeTaggedLine('schema', pc.green, `error: ${e.section} — ${e.error}`, process.stderr);
+      }
+      schemasOk = false;
+    }
+  } catch (err) {
+    console.log(pc.red(`\n  build-schemas failed: ${err.message}\n`));
+    schemasOk = false;
+  }
+
   let scriptsOk = true;
   try {
     buildScripts({ cwd });
@@ -367,6 +431,6 @@ export function buildAll({ cwd = process.cwd() } = {}) {
     env,
     name: 'tailwind',
   });
-  return { scriptsOk, tailwind };
+  return { schemasOk, scriptsOk, tailwind };
 }