@chemx/starter-kit 26.9.11-481 → 26.9.11-631

package/cli/generator-templates.js

@@ -0,0 +1,264 @@
+export const toPascalCase = (str) =>
+  str
+    .replace(/^([a-z])-/, '')
+    .split('-')
+    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+    .join('');
+
+export const buildReactComponent = (name, pascalName) => `import React from 'react';
+import type { ${pascalName}Props } from './types';
+import { use${pascalName}Controller } from './${name}.controller';
+
+export const ${pascalName}: React.FC<${pascalName}Props> = ({
+  title,
+  subtitle,
+  variant = 'standard',
+  onAction
+}) => {
+  const { state, canProceed, descriptor, handleAction } = use${pascalName}Controller({
+    initialState: { status: 'idle' },
+    onAction
+  });
+
+  return (
+    <div className="${name}">
+      <div className="${name}__header">
+        <h3 className="${name}__title">{title}</h3>
+        {subtitle && <p className="${name}__subtitle">{subtitle}</p>}
+        <span className={descriptor.className}>{descriptor.text}</span>
+      </div>
+      <div className="${name}__body">
+        <button
+          type="button"
+          className="${name}__action"
+          disabled={!canProceed}
+          onClick={handleAction}
+        >
+          {variant}
+        </button>
+      </div>
+    </div>
+  );
+};
+
+export default ${pascalName};
+`;
+
+export const buildVueComponent = (name, pascalName) => `<script setup lang="ts">
+import type { ${pascalName}Props, ${pascalName}Emits } from './types';
+import { use${pascalName}Controller } from './${name}.controller';
+
+const props = withDefaults(defineProps<${pascalName}Props>(), {
+  variant: 'standard'
+});
+
+const emit = defineEmits<${pascalName}Emits>();
+
+const { state, canProceed, descriptor, handleAction } = use${pascalName}Controller({
+  initialState: { status: 'idle' },
+  onAction: () => emit('action', props.title)
+});
+</script>
+
+<template>
+  <div class="${name}">
+    <div class="${name}__header">
+      <h3 class="${name}__title">{{ title }}</h3>
+      <p v-if="subtitle" class="${name}__subtitle">{{ subtitle }}</p>
+      <span :class="descriptor.className">{{ descriptor.text }}</span>
+    </div>
+    <div class="${name}__body">
+      <button
+        type="button"
+        class="${name}__action"
+        :disabled="!canProceed"
+        @click="handleAction"
+      >
+        {{ variant }}
+      </button>
+    </div>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+@use './_${name}.scss';
+</style>
+`;
+
+export const buildSvelteComponent = (name, pascalName) => `<script lang="ts">
+import type { ${pascalName}Props } from './types';
+import { create${pascalName}Controller } from './${name}.controller';
+
+const {
+  title,
+  subtitle = '',
+  variant = 'standard',
+  onAction
+}: ${pascalName}Props = $props();
+
+const controller = create${pascalName}Controller({
+  initialState: { status: 'idle' },
+  onAction
+});
+</script>
+
+<div class="${name}">
+  <div class="${name}__header">
+    <h3 class="${name}__title">{title}</h3>
+    {#if subtitle}
+      <p class="${name}__subtitle">{subtitle}</p>
+    {/if}
+    <span class={controller.descriptor.className}>{controller.descriptor.text}</span>
+  </div>
+  <div class="${name}__body">
+    <button
+      type="button"
+      class="${name}__action"
+      disabled={!controller.canProceed}
+      onclick={controller.handleAction}
+    >
+      {variant}
+    </button>
+  </div>
+</div>
+
+<style lang="scss">
+@use './_${name}.scss';
+</style>
+`;
+
+export const buildController = (name, pascalName) => `import { useState, useMemo } from 'react';
+import type { ${pascalName}State, ${pascalName}Descriptor } from './types';
+
+interface ControllerOptions {
+  readonly initialState?: ${pascalName}State;
+  readonly onAction?: () => void;
+}
+
+export const use${pascalName}Controller = (options: ControllerOptions = {}) => {
+  const [state, setState] = useState<${pascalName}State>(
+    options.initialState || { status: 'idle' }
+  );
+
+  const isIdle = state.status === 'idle';
+  const isPending = state.status === 'loading';
+  const canProceed = isIdle && !isPending;
+
+  const descriptor: ${pascalName}Descriptor = useMemo(() => {
+    if (state.status === 'loading') {
+      return { text: 'Loading...', className: '${name}__badge ${name}__badge--pending' };
+    }
+    if (state.status === 'active') {
+      return { text: 'Active', className: '${name}__badge ${name}__badge--active' };
+    }
+    return { text: 'Ready', className: '${name}__badge ${name}__badge--ready' };
+  }, [state.status]);
+
+  const handleAction = () => {
+    if (!canProceed) return;
+    setState({ status: 'active', activeId: 'item-1' });
+    options.onAction?.();
+  };
+
+  return { state, canProceed, descriptor, handleAction };
+};
+`;
+
+export const buildTypes = (name, pascalName) => `export type ${pascalName}State =
+  | { readonly status: 'idle' }
+  | { readonly status: 'loading'; readonly progress: number }
+  | { readonly status: 'active'; readonly activeId: string }
+  | { readonly status: 'fault'; readonly faultMessage: string };
+
+export interface ${pascalName}Descriptor {
+  readonly text: string;
+  readonly className: string;
+}
+
+export interface ${pascalName}Props {
+  readonly title: string;
+  readonly subtitle?: string;
+  readonly variant?: 'standard' | 'highlight';
+  readonly onAction?: () => void;
+}
+
+export interface ${pascalName}Emits {
+  (e: 'action', title: string): void;
+}
+`;
+
+export const buildScss = (name) => `.${name} {
+  display: flex;
+  flex-direction: column;
+  padding: 16px;
+  background: rgba(19, 30, 58, 0.7);
+  backdrop-filter: blur(12px);
+  border: 1px solid rgba(98, 201, 255, 0.15);
+  border-radius: 8px;
+
+  &__header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+  }
+
+  &__title {
+    margin: 0;
+    font-size: 16px;
+    color: #ffffff;
+  }
+
+  &__subtitle {
+    margin: 4px 0 0;
+    font-size: 12px;
+    color: #94a3b8;
+  }
+
+  &__badge {
+    font-size: 11px;
+    padding: 2px 8px;
+    border-radius: 4px;
+    background: #0b1329;
+
+    &--ready { color: #62c9ff; }
+    &--active { color: #4ade80; }
+    &--pending { color: #facc15; }
+  }
+
+  &__body {
+    margin-top: 14px;
+    display: flex;
+    justify-content: flex-end;
+  }
+
+  &__action {
+    padding: 6px 14px;
+    border-radius: 4px;
+    background: #1e293b;
+    border: 1px solid #334155;
+    color: #ffffff;
+    cursor: pointer;
+
+    &:hover:not(:disabled) {
+      background: #334155;
+      border-color: #62c9ff;
+    }
+
+    &:disabled {
+      opacity: 0.5;
+      cursor: not-allowed;
+    }
+  }
+}
+`;
+
+export const buildIndex = (name, pascalName, ext) => {
+  const compExport = ext === 'vue' || ext === 'svelte'
+    ? `export { default as ${pascalName} } from './${name}.${ext}';`
+    : `export { ${pascalName} } from './${name}';`;
+
+  return `${compExport}
+export { use${pascalName}Controller } from './${name}.controller';
+export type { ${pascalName}Props, ${pascalName}State } from './types';
+`;
+};

package/cli/generator.d.ts

@@ -0,0 +1,10 @@
+export interface GeneratorOptions {
+  readonly name?: string;
+  readonly tier?: 'm' | 'a' | 'o' | 't';
+  readonly framework?: 'react' | 'vue' | 'svelte';
+  readonly dir?: string;
+  readonly isLean?: boolean;
+}
+
+export declare function runGenerateWizard(rawArgs?: string[]): Promise<void>;
+export declare function runGenerateCapsule(capsuleName: string): Promise<void>;

package/cli/generator.js

@@ -0,0 +1,151 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { hasGum, gumChoose, gumInput, promptQuestion, renderBanner } from './terminal.js';
+import { checkOrPromptEvaluation } from './license.js';
+import {
+  toPascalCase,
+  buildReactComponent,
+  buildVueComponent,
+  buildSvelteComponent,
+  buildController,
+  buildTypes,
+  buildScss,
+  buildIndex
+} from './generator-templates.js';
+
+const TIERS = [
+  { prefix: 'm-', label: '1. m- Molecule (Self-contained feature block < 100 lines - Recommended)', tier: 'm' },
+  { prefix: 'a-', label: '2. a- Atom (Single foundational UI element)', tier: 'a' },
+  { prefix: 'o-', label: '3. o- Organism (Complex module combining molecules)', tier: 'o' },
+  { prefix: 't-', label: '4. t- Template (Structural layout blueprint)', tier: 't' }
+];
+
+const FRAMEWORKS = [
+  { id: 'react', ext: 'tsx', label: '1. React 19 (TSX + Controller Hook)', builder: buildReactComponent },
+  { id: 'vue', ext: 'vue', label: '2. Vue 3.4+ (SFC <script setup lang="ts">)', builder: buildVueComponent },
+  { id: 'svelte', ext: 'svelte', label: '3. Svelte 5 (Runes + {prop} Shorthand)', builder: buildSvelteComponent }
+];
+
+const detectBaseDir = () => {
+  const candidates = ['src/components/molecules', 'src/components', 'components', 'src'];
+  for (const c of candidates) {
+    if (fs.existsSync(path.resolve(process.cwd(), c))) return c;
+  }
+  return '.';
+};
+
+export const runGenerateWizard = async (rawArgs = []) => {
+  renderBanner('Chemical X: Molecular Capsule Wizard');
+  await checkOrPromptEvaluation('generate capsule');
+
+  const useGum = hasGum();
+  const isYes = rawArgs.includes('-y') || rawArgs.includes('--yes');
+
+  const nameArg = rawArgs.find((a) => !a.startsWith('-') && a !== 'generate' && a !== 'capsule' && a !== 'add');
+  const frameworkArg = (rawArgs.find((a) => a.startsWith('--framework=')) || '').split('=')[1]
+    || (rawArgs.includes('-f') ? rawArgs[rawArgs.indexOf('-f') + 1] : null);
+  const tierArg = (rawArgs.find((a) => a.startsWith('--tier=')) || '').split('=')[1];
+  const dirArg = (rawArgs.find((a) => a.startsWith('--dir=')) || '').split('=')[1];
+  const isLean = rawArgs.includes('--lean');
+
+  let rawName = nameArg;
+  if (!rawName) {
+    rawName = useGum
+      ? gumInput('Capsule feature name (e.g. user-avatar, spark-kpi):', 'user-avatar')
+      : await promptQuestion('Capsule feature name [user-avatar]: ');
+  }
+  const cleanName = (rawName || 'user-avatar').trim().toLowerCase();
+
+  let selectedPrefix = 'm-';
+  const existingPrefixMatch = cleanName.match(/^([a-z])-+/);
+  if (tierArg) {
+    selectedPrefix = `${tierArg.replace(/[^a-z]/g, '')}-`;
+  } else if (!isYes && !existingPrefixMatch) {
+    const tierChoice = useGum
+      ? gumChoose(TIERS.map((t) => t.label), 'Select Architectural Tier')
+      : await promptQuestion('Select Architectural Tier [1=m, 2=a, 3=o, 4=t] (default: 1): ');
+    const matched = TIERS.find((t) => tierChoice && (tierChoice.includes(t.label) || tierChoice.startsWith(t.tier) || tierChoice === t.prefix));
+    if (matched) selectedPrefix = matched.prefix;
+  } else if (existingPrefixMatch) {
+    selectedPrefix = existingPrefixMatch[0];
+  }
+
+  const baseSlug = cleanName.replace(/^([a-z])-/, '');
+  const capsuleName = `${selectedPrefix}${baseSlug}`;
+  const pascalName = toPascalCase(capsuleName);
+
+  let selectedFramework = FRAMEWORKS[0];
+  if (frameworkArg) {
+    const found = FRAMEWORKS.find((f) => f.id === frameworkArg.toLowerCase() || f.ext === frameworkArg.toLowerCase());
+    if (found) selectedFramework = found;
+  } else if (!isYes) {
+    const fwChoice = useGum
+      ? gumChoose(FRAMEWORKS.map((f) => f.label), 'Select Framework Flavor')
+      : await promptQuestion('Select Framework Flavor [1=React, 2=Vue 3, 3=Svelte 5] (default: 1): ');
+    const found = FRAMEWORKS.find((f) => fwChoice && (fwChoice.includes(f.label) || fwChoice.toLowerCase().includes(f.id)));
+    if (found) selectedFramework = found;
+  }
+
+  const detectedDir = detectBaseDir();
+  let targetParent = dirArg || (isYes ? detectedDir : null);
+  if (!targetParent) {
+    const dirChoices = [
+      `1. Detected components directory (${detectedDir}/${capsuleName})`,
+      `2. Current working directory (./${capsuleName})`,
+      '3. Custom directory path'
+    ];
+    const dirPick = useGum
+      ? gumChoose(dirChoices, 'Select Destination Directory')
+      : await promptQuestion(`Destination Directory [1=${detectedDir}, 2=current, 3=custom] (default: 1): `);
+
+    if (dirPick && dirPick.startsWith('2.')) {
+      targetParent = '.';
+    } else if (dirPick && dirPick.startsWith('3.')) {
+      targetParent = useGum
+        ? gumInput('Enter custom parent directory path:', detectedDir)
+        : await promptQuestion(`Enter custom parent directory path [${detectedDir}]: `);
+    } else {
+      targetParent = detectedDir;
+    }
+  }
+
+  const resolvedParent = path.resolve(process.cwd(), targetParent || '.');
+  const targetDir = path.resolve(resolvedParent, capsuleName);
+
+  if (fs.existsSync(targetDir)) {
+    process.stderr.write(`\x1b[31m✕ Error: Directory ${capsuleName} already exists at ${targetDir}.\x1b[0m\n`);
+    process.exit(1);
+  }
+
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  const compFile = `${capsuleName}.${selectedFramework.ext}`;
+  const compContent = selectedFramework.builder(capsuleName, pascalName);
+  const typesContent = buildTypes(capsuleName, pascalName);
+  const indexContent = buildIndex(capsuleName, pascalName, selectedFramework.ext);
+
+  fs.writeFileSync(path.join(targetDir, compFile), compContent, 'utf-8');
+  fs.writeFileSync(path.join(targetDir, 'types.d.ts'), typesContent, 'utf-8');
+  fs.writeFileSync(path.join(targetDir, 'index.ts'), indexContent, 'utf-8');
+
+  const filesCreated = [compFile, 'types.d.ts', 'index.ts'];
+
+  if (!isLean) {
+    const controllerFile = `${capsuleName}.controller.ts`;
+    const scssFile = `_${capsuleName}.scss`;
+    fs.writeFileSync(path.join(targetDir, controllerFile), buildController(capsuleName, pascalName), 'utf-8');
+    fs.writeFileSync(path.join(targetDir, scssFile), buildScss(capsuleName), 'utf-8');
+    filesCreated.push(controllerFile, scssFile);
+  }
+
+  const relTargetDir = path.relative(process.cwd(), targetDir);
+  process.stdout.write(`\n\x1b[1m\x1b[32m✔ Successfully generated crystalline capsule:\x1b[0m \x1b[36m${relTargetDir}/\x1b[0m\n`);
+  for (const f of filesCreated) {
+    process.stdout.write(`  \x1b[32m✔\x1b[0m ${f}\n`);
+  }
+  process.stdout.write('\n\x1b[2mChemical X Standards verified: < 100 lines per file, 2-stage booleans, zero inline styles.\x1b[0m\n\n');
+};
+
+export const runGenerateCapsule = async (capsuleName) => {
+  return runGenerateWizard([capsuleName, '-y']);
+};

package/cli/help.js

@@ -23,13 +23,16 @@ export const printHelp = () => {
     `      Computes Molecular Health Index (MHI: 0-100) and letter grades (A+ to F).`,
     `      Defaults to interactive zero-scroll Gum terminal dashboard.`,
     '',
-    `  ${CYAN}generate${RESET} <m-name>  ${DIM}(aliases: capsule, add)${RESET}`,
-    `      Scaffold an isolated crystalline molecule capsule directory:`,
-    `        ${DIM}- ${RESET}<m-name>/<m-name>.tsx  ${DIM}(declarative component < 50 lines of code)${RESET}`,
-    `        ${DIM}- ${RESET}<m-name>/types.d.ts     ${DIM}(props and emits interfaces)${RESET}`,
-    `        ${DIM}- ${RESET}<m-name>/index.ts        ${DIM}(clean public barrel export)${RESET}`,
-    `      Free evaluation mode supported with non-blocking license reminder.`,
-    `      Example: ${CYAN}npx chemx generate m-user-avatar${RESET}`,
+    `  ${CYAN}generate${RESET} [name]  ${DIM}(aliases: capsule, add)${RESET}`,
+    `      Launch the interactive Molecular Capsule Generator wizard.`,
+    `      Scaffolds a compliant, crystalline capsule directory with:`,
+    `        ${DIM}- ${RESET}<name>.<ext>           ${DIM}(React .tsx, Vue .vue, or Svelte .svelte < 100 lines)${RESET}`,
+    `        ${DIM}- ${RESET}<name>.controller.ts   ${DIM}(pure reactive state & 2-stage booleans)${RESET}`,
+    `        ${DIM}- ${RESET}_<name>.scss          ${DIM}(mixin-only glass styling with zero inline styles)${RESET}`,
+    `        ${DIM}- ${RESET}types.d.ts             ${DIM}(discriminated union states and props interfaces)${RESET}`,
+    `        ${DIM}- ${RESET}index.ts               ${DIM}(clean public barrel export)${RESET}`,
+    `      Flags: ${CYAN}--tier=m|a|o|t${RESET}, ${CYAN}--framework=react|vue|svelte${RESET}, ${CYAN}--dir=<path>${RESET}, ${CYAN}-y${RESET}`,
+    `      Example: ${CYAN}npx chemx generate${RESET} or ${CYAN}npx chemx generate m-user-avatar -y${RESET}`,
     '',
     `  ${CYAN}init${RESET} [directory]`,
     `      ${YELLOW}[PAID]${RESET} Drop full Chemical X blueprints, core hooks (toResult,`,

package/cli/index.js

@@ -15,6 +15,7 @@ import {
   runScaffold,
   runInit,
   runGenerateCapsule,
+  runGenerateWizard,
   printHelp
 } from './scaffold.js';
 import {
@@ -163,13 +164,7 @@ const main = async () => {
     case 'generate':
     case 'capsule':
     case 'add':
-      if (!rawArgs[1]) {
-        process.stderr.write(
-          'Usage: npx chemx generate <capsule-name>\nExample: npx chemx generate m-user-avatar\n'
-        );
-        process.exit(1);
-      }
-      await runGenerateCapsule(rawArgs[1]);
+      await runGenerateWizard(rawArgs.slice(1));
       break;
     case 'help':
     case '--help':
@@ -177,8 +172,8 @@ const main = async () => {
       printHelp();
       break;
     default:
-      if (firstArg && firstArg.startsWith('m-')) {
-        await runGenerateCapsule(firstArg);
+      if (firstArg && (firstArg.startsWith('m-') || firstArg.startsWith('a-') || firstArg.startsWith('o-') || firstArg.startsWith('t-'))) {
+        await runGenerateWizard(rawArgs);
       } else if (firstArg && !firstArg.startsWith('-')) {
         await runScaffold(firstArg, rawArgs, runAudit);
       } else {

package/cli/license.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { spawnSync } from 'node:child_process';
 import {
   hasGum,
   gumChoose,

package/cli/scaffold.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { hasGum, gumInput, promptQuestion, renderBanner } from './terminal.js';
-import { obtainLicenseKey, fetchStarterKitFiles, checkOrPromptEvaluation } from './license.js';
+import { obtainLicenseKey, fetchStarterKitFiles } from './license.js';
 
 export const runScaffold = async (projectName, rawArgs = [], onRunAudit = null) => {
   renderBanner('Chemical X: Molecular Architecture Scaffolder (npm create chemx)');
@@ -92,57 +92,6 @@ export const runInit = async (targetSubDir = 'src/chemical-x', rawArgs = [], onR
   );
 };
 
-export const runGenerateCapsule = async (capsuleName) => {
-  await checkOrPromptEvaluation('generate capsule');
-
-  const normalizedName = capsuleName.startsWith('m-') ? capsuleName : `m-${capsuleName}`;
-  const targetDir = path.resolve(process.cwd(), normalizedName);
-
-  if (fs.existsSync(targetDir)) {
-    process.stderr.write(`\x1b[31m✕ Error: Directory ${normalizedName} already exists.\x1b[0m\n`);
-    process.exit(1);
-  }
-
-  fs.mkdirSync(targetDir, { recursive: true });
-
-  const pascalName = normalizedName
-    .split('-')
-    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
-    .join('');
-
-  const componentCode = `import React from 'react';
-import type { ${pascalName}Props } from './types';
-
-export const ${pascalName}: React.FC<${pascalName}Props> = ({ label }) => {
-  return (
-    <div className="${normalizedName}">
-      <span>{label}</span>
-    </div>
-  );
-};
-
-export default ${pascalName};
-`;
-
-  const typesCode = `export interface ${pascalName}Props {
-  readonly label: string;
-}
-`;
-
-  const indexCode = `export { ${pascalName} } from './${normalizedName}';
-export type { ${pascalName}Props } from './types';
-`;
-
-  fs.writeFileSync(path.join(targetDir, `${normalizedName}.tsx`), componentCode, 'utf-8');
-  fs.writeFileSync(path.join(targetDir, 'types.d.ts'), typesCode, 'utf-8');
-  fs.writeFileSync(path.join(targetDir, 'index.ts'), indexCode, 'utf-8');
-
-  process.stdout.write(
-    `\x1b[32m✔ Successfully generated crystalline capsule:\x1b[0m ${normalizedName}/\n`
-  );
-  process.stdout.write(`  - ${normalizedName}/${normalizedName}.tsx (< 50 lines)\n`);
-  process.stdout.write(`  - ${normalizedName}/types.d.ts\n`);
-  process.stdout.write(`  - ${normalizedName}/index.ts\n\n`);
-};
-
+export { runGenerateCapsule, runGenerateWizard } from './generator.js';
 export { printHelp } from './help.js';
+

package/docs/CHANGELOG.md

@@ -18,11 +18,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [2026-09-11]
 
+### Added
+- Interactive Molecular Capsule Generator wizard for `npx chemx generate` (and aliases `capsule`, `add`), supporting Gum and ANSI fallbacks (`cli/generator.js`, `cli/generator.d.ts`).
+- Multi-framework scaffolding support for React 19 (`.tsx`), Vue 3.4+ (`.vue`), and Svelte 5 (`.svelte`) with scoped SCSS, controllers, and discriminated union types (`cli/generator-templates.js`).
+- CLI flags for non-interactive and fast capsule generation (`--tier`, `--framework`, `--dir`, `--lean`, `-y` / `--yes`).
+
 ### Changed
 - Conditioned `[  Prompt   ] 📋 Copy AI Prompt Fix to Clipboard` dashboard action to hide when the codebase earns a pristine Grade A+ with no pending refactoring prompt (`cli/navigator.js`, `cli/navigator-actions.js`).
 - Added early-return guard clause to `handleCopyPromptAction` preventing empty clipboard copy operations on pristine Grade A+ audits (`cli/navigator-actions.js`).
 
 ### Fixed
+- Fixed missing `spawnSync` import from `node:child_process` in evaluation check prompt causing runtime reference error (`cli/license.js`).
 - Fixed typographical artifact (`and p`) in the interactive audit publication confirmation prompt across navigator and terminal handlers (`cli/navigator.js`, `cli/terminal.js`).
 
 ## [2026-09-10]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chemx/starter-kit",
-  "version": "26.9.11-481",
+  "version": "26.9.11-631",
   "description": "Chemical X Protocol: Private drop-in architecture starter kit and capsule generator",
   "type": "module",
   "bin": {