@astryxdesign/cli 0.2.0 → 0.3.0

package/lib/levenshtein.mjs

@@ -1,35 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Levenshtein edit distance — pure, dependency-free.
- *
- * Lives apart from string-utils.mjs (which dynamically imports node:fs/path
- * for component search) so browser-bundled code — the XLE/XLO layout
- * language — can use fuzzy matching without dragging node: schemes into the
- * webpack graph.
- *
- * @input  two strings
- * @output edit distance (number)
- * @position lib — shared by string-utils.mjs and lib/xle/validate.mjs
- */
-
-/**
- * @param {string} a
- * @param {string} b
- * @returns {number}
- */
-export function levenshteinDistance(a, b) {
-  const m = a.length, n = b.length;
-  /** @type {number[][]} */
-  const dp = Array.from({length: m + 1}, () => Array(n + 1).fill(0));
-  for (let i = 0; i <= m; i++) dp[i][0] = i;
-  for (let j = 0; j <= n; j++) dp[0][j] = j;
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      dp[i][j] = a[i-1] === b[j-1]
-        ? dp[i-1][j-1]
-        : 1 + Math.min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]);
-    }
-  }
-  return dp[m][n];
-}

package/lib/manifest.mjs

@@ -1,271 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Capability manifest — self-describing CLI surface for agents.
- *
- * `astryx --json` (and `astryx manifest --json`) emit a structured manifest that
- * lets an AI agent drive the entire CLI WITHOUT scraping `--help` text. It is
- * to the CLI what an OpenAPI spec is to an HTTP API.
- *
- * Most of the manifest is DERIVED from Commander metadata (program.commands,
- * cmd.options, cmd.registeredArguments, cmd.description()) so it cannot drift
- * out of sync with the real command definitions. The two pieces Commander does
- * not know about — whether a command supports `--json`, and which response
- * `type` discriminators it can emit — are layered on from:
- *
- *   - JSON_SUPPORTED  (the allowlist in index.mjs), and
- *   - RESPONSE_TYPES  (the declarative map below).
- *
- * A drift-guard test (manifest.test.mjs) asserts every registered command
- * appears in the manifest and every JSON-supported command has a response-type
- * entry, so adding a command without describing it fails CI.
- *
- * DESIGN DECISION — manifest stays CLI-special; there is intentionally NO
- * `api/manifest`. It describes the CLI's own Commander tree, so it takes the live
- * `program` as a parameter and lives in `lib/` (shared infra the CLI can import
- * without a cycle). An `api/manifest` entry would have to import the program from
- * `cli/index.mjs` — the `api → cli` cycle that bit #4302 — or force programmatic
- * callers to construct a program themselves. So `buildManifest(program)` is the
- * intended shape, and the bare `astryx --json` / `astryx manifest --json` handlers
- * are its only consumers. Do not "extract" this to `api/` in the reorg.
- *
- * @input  a configured Commander `program` + the JSON_SUPPORTED allowlist
- * @output a `{ name, version, globalOptions, commands, responseTypes }` object
- * @position consumed by the bare `astryx --json` action and the `manifest` command
- */
-
-import {API_VERSION} from './json.mjs';
-
-/**
- * Response `type` discriminators each fully-qualified command can emit in
- * `--json` mode. Keyed by the same name Commander reports (parent + leaf,
- * space-joined), e.g. `theme build`. Commander has no knowledge of these —
- * they come from each command's `jsonOut(...)` call sites — so we keep them
- * here, close to the JSON_SUPPORTED allowlist, and guard them with a test.
- *
- * @type {Record<string, string[]>}
- */
-export const RESPONSE_TYPES = {
-  component: [
-    'component.list',
-    'component.detail',
-    'component.detail.props',
-    'component.detail.source',
-    'component.detail.showcase',
-    'component.detail.blocks',
-  ],
-  docs: ['docs.list', 'docs.detail', 'docs.detail.section'],
-  blog: ['blog.list', 'blog.detail'],
-  discover: ['discover.list', 'discover.detail', 'discover.detail.doc', 'discover.search'],
-  search: ['search'],
-  build: ['build.help', 'build.kit'],
-  swizzle: ['swizzle.list', 'swizzle.copy'],
-  template: [
-    'template.list',
-    'template.show',
-    'template.skeleton',
-    'template.copy',
-  ],
-  hook: ['hook.list', 'hook.detail', 'hook.detail.params'],
-  'theme build': ['theme.build'],
-  'theme list': ['theme.list'],
-  'theme add': ['theme.list', 'theme.add'],
-  upgrade: ['upgrade.list', 'upgrade.status', 'upgrade.run'],
-  manifest: ['manifest'],
-  doctor: ['doctor'],
-  'validate-integration': ['integration.validate'],
-  'layout expand': ['layout.expand'],
-  'layout check': ['layout.check'],
-  'layout grammar': ['layout.grammar'],
-};
-
-/**
- * Example invocations per fully-qualified command. Optional, agent-facing.
- * @type {Record<string, string[]>}
- */
-const EXAMPLES = {
-  component: ['astryx component', 'astryx component XDSButton', 'astryx component XDSButton --props --json'],
-  docs: ['astryx docs', 'astryx docs spacing --json'],
-  discover: ['astryx discover --json'],
-  search: ['astryx search modal --json', 'astryx search button --type component --json'],
-  build: ['astryx build', 'astryx build "analytics dashboard" --json'],
-  swizzle: ['astryx swizzle XDSButton'],
-  template: ['astryx template --json', 'astryx template dashboard ./src/app'],
-  hook: ['astryx hook', 'astryx hook useToggle --json'],
-  'theme build': ['astryx theme build ./src/themes/ocean.ts --out ./dist/ocean.css'],
-  'theme list': ['astryx theme list --json'],
-  'theme add': ['astryx theme add matcha', 'astryx theme add matcha ./src/themes/matcha'],
-  upgrade: ['astryx upgrade --json'],
-  manifest: ['astryx manifest --json', 'astryx --json'],
-  doctor: ['astryx doctor', 'astryx doctor --json'],
-  'validate-integration': [
-    'astryx validate-integration',
-    'astryx validate-integration @acme/widgets --json',
-  ],
-  init: ['astryx init'],
-  'layout expand': [`astryx layout expand 'V[g6] > C{card-callout}*4' ./src/Page.tsx`],
-  'layout check': [`astryx layout check 'A[cp6] > L > LC > S[p6]' --json`],
-  'layout grammar': ['astryx layout grammar'],
-};
-
-/**
- * Map a Commander Option to a flag descriptor. Derives type from whether the
- * option takes a value (boolean vs string), surfaces `choices` and `default`.
- *
- * @param {import('commander').Option} opt
- * @returns {import('../types/manifest').ManifestOption}
- */
-function describeOption(opt) {
-  const o = /** @type {any} */ (opt);
-  const takesValue = o.required || o.optional;
-  /** @type {any} */
-  const d = {
-    flag: o.flags,
-    description: o.description || '',
-    type: takesValue ? 'string' : 'boolean',
-  };
-  if (Array.isArray(o.argChoices) && o.argChoices.length > 0) {
-    d.choices = [...o.argChoices];
-    d.type = 'enum';
-  }
-  if (o.defaultValue !== undefined) d.default = o.defaultValue;
-  // `--no-foo` style negation flags
-  if (o.negate) d.negate = true;
-  return d;
-}
-
-/**
- * Map a Commander positional argument to an arg descriptor.
- * @param {import('commander').Argument} arg
- * @returns {import('../types/manifest').ManifestArgument}
- */
-function describeArgument(arg) {
-  const a = /** @type {any} */ (arg);
-  return {
-    name: a.name(),
-    required: a.required === true,
-    variadic: a.variadic === true,
-    description: a.description || '',
-  };
-}
-
-/**
- * Compute the fully-qualified command name relative to the root program,
- * e.g. `theme build`. The root program itself maps to ''.
- * @param {import('commander').Command} cmd
- * @param {import('commander').Command} root
- * @returns {string}
- */
-function fullName(cmd, root) {
-  const parts = [];
-  /** @type {import('commander').Command | null} */
-  let c = cmd;
-  while (c && c !== root) {
-    parts.unshift(c.name());
-    c = c.parent;
-  }
-  return parts.join(' ');
-}
-
-/**
- * Recursively describe a Commander command and its subcommands.
- *
- * @param {import('commander').Command} cmd
- * @param {import('commander').Command} root
- * @param {Set<string>} jsonSupported  fully-qualified names that support --json
- * @returns {import('../types/manifest').ManifestCommand | null}  null for hidden/internal commands
- */
-function describeCommand(cmd, root, jsonSupported) {
-  const name = fullName(cmd, root);
-  // Skip the auto-generated help command and any hidden/internal commands
-  // (e.g. the postinstall shim) — agents never invoke these directly.
-  // `_hidden` is a Commander internal not present on its public types.
-  if (!name || /** @type {any} */ (cmd)._hidden || name === 'help') return null;
-
-  const subcommands = /** @type {object[]} */ ((cmd.commands || [])
-    .map((sub) => describeCommand(sub, root, jsonSupported))
-    .filter(Boolean));
-
-  // `registeredArguments` is Commander 12's public-ish accessor; `_args` is the
-  // older internal. Cast through any to read whichever exists.
-  const args =
-    /** @type {any[]} */ (/** @type {any} */ (cmd).registeredArguments || /** @type {any} */ (cmd)._args || []);
-
-  /** @type {any} */
-  const entry = {
-    name,
-    description: cmd.description() || '',
-    arguments: args.map(describeArgument),
-    options: (cmd.options || []).map(describeOption),
-    json: jsonSupported.has(name),
-  };
-
-  const aliases = cmd.aliases ? cmd.aliases() : [];
-  if (aliases && aliases.length > 0) entry.aliases = [...aliases];
-
-  // Response types this command can emit in --json mode (only meaningful for
-  // JSON-supported leaves). Subcommand groups (e.g. bare `theme`) have none.
-  if (RESPONSE_TYPES[name]) entry.responseTypes = [...RESPONSE_TYPES[name]];
-
-  if (EXAMPLES[name]) entry.examples = [...EXAMPLES[name]];
-
-  if (subcommands.length > 0) entry.subcommands = subcommands;
-
-  return entry;
-}
-
-/**
- * Describe the global options declared on the root program (--json, --lang,
- * --detail, --zh, --dense, --version). Documented once at top level so each
- * command entry doesn't repeat them.
- *
- * @param {import('commander').Command} program
- * @returns {import('../types/manifest').ManifestOption[]}
- */
-function describeGlobalOptions(program) {
-  const opts = (program.options || []).map(describeOption);
-  // Commander registers a built-in --version flag; if for some reason it
-  // isn't present in program.options, surface it so the manifest is complete.
-  if (!opts.some((o) => /(^|[\s,])--version\b/.test(o.flag))) {
-    opts.push({
-      flag: '-V, --version',
-      description: 'Output the version number',
-      type: 'boolean',
-    });
-  }
-  return opts;
-}
-
-/**
- * Build the full capability manifest from a configured Commander program.
- *
- * @param {import('commander').Command} program  the root program
- * @param {object} [opts]
- * @param {Set<string>} [opts.jsonSupported]  the JSON_SUPPORTED allowlist
- * @param {string} [opts.version]  CLI version (defaults to program.version())
- * @returns {import('../types/manifest').CLIManifest}  the manifest `data` payload (sans envelope)
- */
-export function buildManifest(program, opts = {}) {
-  const jsonSupported = opts.jsonSupported || new Set();
-  const version = opts.version || /** @type {any} */ (program)._version || '';
-
-  const commands = /** @type {any[]} */ ((program.commands || [])
-    .map((cmd) => describeCommand(cmd, program, jsonSupported))
-    .filter(Boolean))
-    .sort((a, b) => a.name.localeCompare(b.name));
-
-  return {
-    name: 'astryx',
-    version,
-    apiVersion: API_VERSION,
-    description: program.description() || '',
-    globalOptions: describeGlobalOptions(program),
-    commands,
-    jsonSupported: [...jsonSupported].sort(),
-    // Flat index of every response `type` discriminator the CLI can emit,
-    // keyed by command — lets an agent know what to expect back per call.
-    responseTypes: Object.fromEntries(
-      Object.entries(RESPONSE_TYPES).map(([k, v]) => [k, [...v]]),
-    ),
-  };
-}

package/lib/manifest.test.mjs

@@ -1,166 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Tests for the CLI capability manifest.
- *
- * Two jobs:
- *   1. DRIFT GUARDS — the manifest is the agent-facing contract for the whole
- *      CLI surface. These tests fail if a command is added without describing
- *      it: every registered command must appear in the manifest, every
- *      JSON-supported command must declare its response types, and every
- *      response-type key must map to a real command.
- *   2. SHAPE — each command entry carries the required fields, global options
- *      are described once, and the bare `xds --json` / `astryx manifest --json`
- *      surfaces emit valid, enriched JSON.
- */
-
-import {describe, it, expect} from 'vitest';
-import {program, JSON_SUPPORTED} from '../cli/index.mjs';
-import {buildManifest, RESPONSE_TYPES} from './manifest.mjs';
-import {runCli} from '../test-utils/run-cli.mjs';
-
-const manifest = buildManifest(program, {jsonSupported: JSON_SUPPORTED, version: '0.0.0-test'});
-
-/** Flatten the manifest command tree into fully-qualified names. */
-function flatten(cmds, out = []) {
-  for (const c of cmds) {
-    out.push(c);
-    if (c.subcommands) flatten(c.subcommands, out);
-  }
-  return out;
-}
-const allEntries = flatten(manifest.commands);
-const allNames = new Set(allEntries.map((c) => c.name));
-
-/** Fully-qualified names of every registered, non-hidden command in the program. */
-function registeredNames() {
-  const names = [];
-  const walk = (cmd, prefix) => {
-    for (const sub of cmd.commands || []) {
-      if (sub._hidden || sub.name() === 'help') continue;
-      const full = prefix ? `${prefix} ${sub.name()}` : sub.name();
-      names.push(full);
-      walk(sub, full);
-    }
-  };
-  walk(program, '');
-  return names;
-}
-
-describe('manifest: drift guards', () => {
-  it('lists every registered (non-hidden) command', () => {
-    for (const name of registeredNames()) {
-      expect(allNames.has(name), `manifest is missing command "${name}"`).toBe(true);
-    }
-  });
-
-  it('marks every JSON_SUPPORTED command as json:true', () => {
-    for (const name of JSON_SUPPORTED) {
-      const entry = allEntries.find((c) => c.name === name);
-      expect(entry, `JSON_SUPPORTED command "${name}" not in manifest`).toBeDefined();
-      expect(entry.json, `"${name}" should be json:true`).toBe(true);
-    }
-  });
-
-  it('declares response types for every JSON-supported command', () => {
-    for (const name of JSON_SUPPORTED) {
-      expect(
-        RESPONSE_TYPES[name],
-        `JSON-supported command "${name}" has no response-type entry`,
-      ).toBeDefined();
-      expect(RESPONSE_TYPES[name].length).toBeGreaterThan(0);
-    }
-  });
-
-  it('has no response-type entry for a command that does not exist', () => {
-    for (const name of Object.keys(RESPONSE_TYPES)) {
-      expect(allNames.has(name), `RESPONSE_TYPES key "${name}" is not a real command`).toBe(true);
-    }
-  });
-
-  it('every command with response types is json-supported', () => {
-    for (const entry of allEntries) {
-      if (entry.responseTypes) {
-        expect(entry.json, `"${entry.name}" emits types but isn't json-supported`).toBe(true);
-      }
-    }
-  });
-});
-
-describe('manifest: shape', () => {
-  it('has top-level metadata', () => {
-    expect(manifest.name).toBe('astryx');
-    expect(manifest.apiVersion).toBe(1);
-    expect(typeof manifest.description).toBe('string');
-    expect(Array.isArray(manifest.commands)).toBe(true);
-    expect(Array.isArray(manifest.globalOptions)).toBe(true);
-  });
-
-  it('describes global options once at top level (--json, --lang, --detail, --version)', () => {
-    const flags = manifest.globalOptions.map((o) => o.flag).join(' ');
-    expect(flags).toContain('--json');
-    expect(flags).toContain('--lang');
-    expect(flags).toContain('--detail');
-    expect(flags).toContain('--version');
-    // No duplicate --version
-    const versionCount = manifest.globalOptions.filter((o) => /--version\b/.test(o.flag)).length;
-    expect(versionCount).toBe(1);
-  });
-
-  it('surfaces enum choices and defaults on options', () => {
-    const detail = manifest.globalOptions.find((o) => o.flag.includes('--detail'));
-    expect(detail.type).toBe('enum');
-    expect(detail.choices).toEqual(['full', 'compact', 'brief']);
-    expect(detail.default).toBe('full');
-  });
-
-  it('each command entry carries the required fields', () => {
-    for (const c of allEntries) {
-      expect(typeof c.name).toBe('string');
-      expect(typeof c.description).toBe('string');
-      expect(Array.isArray(c.arguments)).toBe(true);
-      expect(Array.isArray(c.options)).toBe(true);
-      expect(typeof c.json).toBe('boolean');
-    }
-  });
-
-  it('derives arguments from Commander metadata', () => {
-    const component = allEntries.find((c) => c.name === 'component');
-    expect(component.arguments.map((a) => a.name)).toContain('name');
-    const themeBuild = allEntries.find((c) => c.name === 'theme build');
-    expect(themeBuild.arguments.map((a) => a.name)).toContain('file');
-    expect(themeBuild.arguments.find((a) => a.name === 'file').required).toBe(true);
-  });
-});
-
-describe('manifest: e2e', () => {
-  it('astryx manifest --json emits a valid manifest envelope', async () => {
-    const {status, stdout} = await runCli(['manifest', '--json']);
-    expect(status).toBe(0);
-    const parsed = JSON.parse(stdout);
-    expect(parsed.apiVersion).toBe(1);
-    expect(parsed.type).toBe('manifest');
-    expect(parsed.data.name).toBe('astryx');
-    const names = parsed.data.commands.map((c) => c.name);
-    expect(names).toContain('component');
-    expect(names).toContain('theme');
-    expect(names).toContain('manifest');
-  });
-
-  it('bare xds --json stays backwards-compatible AND embeds the manifest', async () => {
-    const {status, stdout} = await runCli(['--json']);
-    expect(status).toBe(0);
-    const parsed = JSON.parse(stdout);
-    // Back-compat: still type:'help' with name/version/commands(names)/jsonSupported
-    expect(parsed.type).toBe('help');
-    expect(parsed.data.name).toBe('astryx');
-    expect(Array.isArray(parsed.data.commands)).toBe(true);
-    expect(parsed.data.commands.every((c) => typeof c === 'string')).toBe(true);
-    expect(parsed.data.commands).toContain('component');
-    expect(Array.isArray(parsed.data.jsonSupported)).toBe(true);
-    // Enriched: the full structured manifest is embedded.
-    expect(parsed.data.manifest).toBeDefined();
-    expect(parsed.data.manifest.commands.find((c) => c.name === 'component').responseTypes)
-      .toContain('component.list');
-  });
-});

package/lib/module-loader.mjs

@@ -1,81 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Shared module-loading + conventional-file-discovery primitives.
- *
- * Both config loading and integration loading need to (a) import a
- * user-authored module (`.ts` via jiti, `.mjs`/`.js` via native dynamic
- * import) and (b) find conventional files by basename in a fixed
- * load-precedence order. These helpers centralize that so the two callers stay
- * in lockstep.
- *
- * `loadModuleWithSchema` builds on these primitives to provide the single
- * load/validation boundary shared by config, integration, codemod, and
- * template discovery: import the module, take its default export, and validate
- * it against the expected zod schema.
- */
-
-import * as path from 'node:path';
-import {pathToFileURL} from 'node:url';
-import * as fs from 'node:fs';
-import {createJiti} from 'jiti';
-import {formatZodError} from './config-schema.mjs';
-
-/** @type {ReturnType<typeof createJiti> | undefined} */
-let jitiInstance;
-function getJiti() {
-  if (!jitiInstance) {
-    jitiInstance = createJiti(import.meta.url);
-  }
-  return jitiInstance;
-}
-
-/**
- * Import a user-authored module. `.ts` is loaded via jiti; `.mjs`/`.js` via
- * native dynamic import (file:// URL). Returns the full module namespace.
- * @param {string} file absolute path
- * @returns {Promise<Record<string, unknown>>}
- */
-export async function importUserModule(file) {
-  if (file.endsWith('.ts')) {
-    return await getJiti().import(file);
-  }
-  return await import(pathToFileURL(file).href);
-}
-
-/**
- * Return the conventional files (by basename, in the given precedence order)
- * that exist directly in `dir`, as absolute paths. Never throws.
- * @param {string} dir
- * @param {string[]} basenames precedence-ordered
- * @returns {string[]} absolute paths of present files, in basenames order
- */
-export function findPresentFiles(dir, basenames) {
-  return basenames
-    .filter(name => fs.existsSync(path.join(dir, name)))
-    .map(name => path.join(dir, name));
-}
-
-/**
- * Import a user-authored module, take its default export, and validate it
- * against a zod schema. This is the single load/validation boundary for all
- * user-authored modules (config, integration, codemod, template): execute the
- * module, take the default export, validate it against the expected schema.
- * Throws a clear, readable error if the default export is missing or fails
- * validation.
- *
- * @template {import('zod').ZodType} S
- * @param {string} file absolute path
- * @param {S} schema
- * @param {{label?: string}} [opts] label used in error messages
- * @returns {Promise<import('zod').infer<S>>} parsed + typed value
- */
-export async function loadModuleWithSchema(file, schema, {label} = {}) {
-  const mod = await importUserModule(file);
-  const exported = mod?.default;
-  const result = schema.safeParse(exported);
-  if (!result.success) {
-    throw new Error(formatZodError(label ?? file, result.error));
-  }
-  return result.data;
-}

package/lib/module-loader.test.mjs

@@ -1,106 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {afterEach, beforeEach, describe, expect, it} from 'vitest';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import {z} from 'zod';
-import {
-  findPresentFiles,
-  importUserModule,
-  loadModuleWithSchema,
-} from './module-loader.mjs';
-
-let tmpDir;
-
-beforeEach(() => {
-  tmpDir = fs.mkdtempSync(path.join(process.cwd(), '.astryx-module-loader-test-'));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpDir, {recursive: true, force: true});
-});
-
-describe('findPresentFiles', () => {
-  const basenames = ['a.ts', 'b.mjs', 'c.js'];
-
-  it('returns [] when none of the basenames are present', () => {
-    expect(findPresentFiles(tmpDir, basenames)).toEqual([]);
-  });
-
-  it('returns only the present files, in basenames precedence order', () => {
-    // Create out of order to prove the result follows `basenames`, not disk order.
-    fs.writeFileSync(path.join(tmpDir, 'c.js'), '');
-    fs.writeFileSync(path.join(tmpDir, 'a.ts'), '');
-    const present = findPresentFiles(tmpDir, basenames);
-    expect(present.map(p => path.basename(p))).toEqual(['a.ts', 'c.js']);
-  });
-
-  it('returns absolute paths joined to the given directory', () => {
-    fs.writeFileSync(path.join(tmpDir, 'b.mjs'), '');
-    const present = findPresentFiles(tmpDir, basenames);
-    expect(present).toEqual([path.join(tmpDir, 'b.mjs')]);
-    expect(path.isAbsolute(present[0])).toBe(true);
-  });
-
-  it('does not match files in nested subdirectories', () => {
-    const nested = path.join(tmpDir, 'nested');
-    fs.mkdirSync(nested);
-    fs.writeFileSync(path.join(nested, 'a.ts'), '');
-    expect(findPresentFiles(tmpDir, basenames)).toEqual([]);
-  });
-});
-
-describe('importUserModule', () => {
-  it('imports a .mjs file and returns its module namespace', async () => {
-    const file = path.join(tmpDir, 'mod.mjs');
-    fs.writeFileSync(
-      file,
-      `export default {answer: 42};\nexport const named = 'hi';\n`,
-    );
-    const mod = await importUserModule(file);
-    expect(mod.default).toEqual({answer: 42});
-    expect(mod.named).toBe('hi');
-  });
-});
-
-describe('loadModuleWithSchema', () => {
-  // Temp module files live under a repo-local dir (not /tmp): Vite's dynamic
-  // import blocks /tmp, so we mirror the existing repo-local temp pattern.
-  const schema = z
-    .object({
-      name: z.string(),
-      count: z.number().optional(),
-    })
-    .strict();
-
-  it('returns the parsed default export when it satisfies the schema', async () => {
-    const file = path.join(tmpDir, 'valid.mjs');
-    fs.writeFileSync(file, `export default {name: 'ok', count: 3};\n`);
-    const value = await loadModuleWithSchema(file, schema, {label: 'thing'});
-    expect(value).toEqual({name: 'ok', count: 3});
-  });
-
-  it('throws a readable error when there is no default export', async () => {
-    const file = path.join(tmpDir, 'no-default.mjs');
-    fs.writeFileSync(file, `export const named = {name: 'x'};\n`);
-    await expect(
-      loadModuleWithSchema(file, schema, {label: 'thing'}),
-    ).rejects.toThrow(/thing is invalid/i);
-  });
-
-  it('throws a readable error when the default export fails the schema', async () => {
-    const file = path.join(tmpDir, 'invalid.mjs');
-    fs.writeFileSync(file, `export default {count: 'not-a-number'};\n`);
-    await expect(
-      loadModuleWithSchema(file, schema, {label: 'thing'}),
-    ).rejects.toThrow(/thing is invalid:.*name/i);
-  });
-
-  it('falls back to the file path in the message when no label is given', async () => {
-    const file = path.join(tmpDir, 'unlabeled.mjs');
-    fs.writeFileSync(file, `export default {bogus: true};\n`);
-    await expect(loadModuleWithSchema(file, schema)).rejects.toThrow(
-      new RegExp(`${path.basename(file)} is invalid`),
-    );
-  });
-});