ink-cartridge 3.6.1

package/dist/cli/index.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { makeLanguageType } from './makeLanguageType.js';
+import { makeThemeType } from './makeThemeType.js';
+import { initTheme } from './initTheme.js';
+const args = process.argv.slice(2);
+const subcommand = args[0];
+function printHelp() {
+    console.log('');
+    console.log('  ink-cartridge init <project-name>              Scaffold a new project');
+    console.log('  ink-cartridge initTheme [--output <dir>]        Interactive theme scaffold');
+    console.log('  ink-cartridge makeLanguageType <source> <out>   Generate typed i18n bindings');
+    console.log('  ink-cartridge makeThemeType <source> <out>      Generate typed theme bindings');
+    console.log('');
+    console.log('Options for makeLanguageType / makeThemeType:');
+    console.log('  --watch          Re-generate on every file change');
+    console.log('  --debounce <ms>  Debounce delay (default 500)');
+    console.log('  --from <pkg>     Package name to import from (default ink-cartridge)');
+    console.log('');
+}
+if (!subcommand || subcommand === '--help' || subcommand === '-h') {
+    printHelp();
+    process.exit(subcommand ? 0 : 1);
+}
+if (subcommand === 'init') {
+    const projectName = args[1];
+    if (!projectName) {
+        console.error('Error: project name is required');
+        process.exit(1);
+    }
+    const root = path.resolve(projectName);
+    if (fs.existsSync(root)) {
+        console.error(`Error: directory "${projectName}" already exists`);
+        process.exit(1);
+    }
+    console.log(`Creating ink-cartridge project: ${projectName}`);
+    fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+    const pkg = {
+        name: projectName,
+        version: '0.0.1',
+        private: true,
+        type: 'module',
+        scripts: {
+            start: 'tsx src/index.tsx',
+            dev: 'tsx watch src/index.tsx',
+            build: 'tsc',
+            test: 'echo "No tests yet"',
+        },
+        dependencies: {
+            'ink-cartridge': 'latest',
+            ink: '^7.0.1',
+            react: '^19.2.4',
+        },
+        devDependencies: {
+            '@types/node': '^20.19.39',
+            '@types/react': '^19.2.14',
+            tsx: '^4',
+            typescript: '^5.9.3',
+        },
+    };
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify(pkg, null, 2) + '\n');
+    const tsconfig = {
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'Node16',
+            lib: ['ES2022'],
+            outDir: './dist',
+            rootDir: './src',
+            strict: true,
+            moduleResolution: 'Node16',
+            esModuleInterop: true,
+            skipLibCheck: true,
+            jsx: 'react',
+            types: ['node'],
+        },
+        include: ['src/**/*'],
+        exclude: ['node_modules', 'dist'],
+    };
+    fs.writeFileSync(path.join(root, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2) + '\n');
+    const entry = `import React from 'react';
+import { Box, Text, render } from 'ink';
+import {
+  registerComponent,
+  ScenarioManagementProvider,
+  CurrentScreen,
+  useScreenSystem,
+  KeyboardProvider,
+  useKeyboard,
+} from 'ink-cartridge';
+
+function Menu() {
+  const { skip } = useScreenSystem();
+  const { boundKeyboard } = useKeyboard();
+
+  React.useEffect(() => {
+    boundKeyboard(['s'], () => skip(Game));
+    boundKeyboard(['q'], () => process.exit(0));
+  }, []);
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>ink-cartridge Demo</Text>
+      <Text>[S] Start  [Q] Quit</Text>
+    </Box>
+  );
+}
+registerComponent(Menu, {});
+
+function Game() {
+  const { back } = useScreenSystem();
+  const { boundKeyboard } = useKeyboard();
+
+  React.useEffect(() => {
+    boundKeyboard(['b'], () => back());
+  }, []);
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>Game Screen</Text>
+      <Text>[B] Back to Menu</Text>
+    </Box>
+  );
+}
+registerComponent(Game, {}, { parent: Menu });
+
+function App() {
+  return (
+    <KeyboardProvider>
+      <CurrentScreen />
+    </KeyboardProvider>
+  );
+}
+
+render(
+  <ScenarioManagementProvider defaultScreen={Menu}>
+    <App />
+  </ScenarioManagementProvider>,
+);
+`;
+    fs.writeFileSync(path.join(root, 'src', 'index.tsx'), entry);
+    console.log('Installing dependencies...');
+    const result = spawnSync('npm', ['install'], { cwd: root, stdio: 'inherit' });
+    if (result.status !== 0) {
+        console.error('npm install failed. Run npm install manually.');
+        process.exit(1);
+    }
+    console.log('\nDone! Run:');
+    console.log(`  cd ${projectName}`);
+    console.log('  npm start');
+}
+/* ── initTheme ── */
+if (subcommand === 'initTheme') {
+    const outputIndex = args.indexOf('--output');
+    const outputDir = outputIndex !== -1 ? args[outputIndex + 1] : './themes';
+    initTheme({ outputDir });
+}
+/* ── makeLanguageType ── */
+if (subcommand === 'makeLanguageType') {
+    const sourceDir = args[1];
+    const outputDir = args[2];
+    if (!sourceDir || !outputDir) {
+        console.error('Error: ink-cartridge makeLanguageType <source-dir> <output-dir> [options]');
+        process.exit(1);
+    }
+    const watch = args.includes('--watch');
+    const debounceIndex = args.indexOf('--debounce');
+    const debounceMs = debounceIndex !== -1 ? parseInt(args[debounceIndex + 1], 10) : 500;
+    const fromIndex = args.indexOf('--from');
+    const packageName = fromIndex !== -1 ? args[fromIndex + 1] : 'ink-cartridge';
+    if (isNaN(debounceMs) || debounceMs < 0) {
+        console.error('Error: --debounce must be a non-negative number');
+        process.exit(1);
+    }
+    makeLanguageType({
+        sourceDir: path.resolve(sourceDir),
+        outputDir: path.resolve(outputDir),
+        watch,
+        debounceMs,
+        packageName,
+    });
+    process.exit(0);
+}
+/* ── makeThemeType ── */
+if (subcommand === 'makeThemeType') {
+    const sourceDir = args[1];
+    const outputDir = args[2];
+    if (!sourceDir || !outputDir) {
+        console.error('Error: ink-cartridge makeThemeType <source-dir> <output-dir> [options]');
+        process.exit(1);
+    }
+    const watch = args.includes('--watch');
+    const debounceIndex = args.indexOf('--debounce');
+    const debounceMs = debounceIndex !== -1 ? parseInt(args[debounceIndex + 1], 10) : 500;
+    const fromIndex = args.indexOf('--from');
+    const packageName = fromIndex !== -1 ? args[fromIndex + 1] : 'ink-cartridge';
+    if (isNaN(debounceMs) || debounceMs < 0) {
+        console.error('Error: --debounce must be a non-negative number');
+        process.exit(1);
+    }
+    makeThemeType({
+        sourceDir: path.resolve(sourceDir),
+        outputDir: path.resolve(outputDir),
+        watch,
+        debounceMs,
+        packageName,
+    });
+    process.exit(0);
+}
+/* ── unknown subcommand ── */
+console.error(`Error: unknown subcommand "${subcommand}"`);
+printHelp();
+process.exit(1);

package/dist/cli/initTheme.d.ts

@@ -0,0 +1,14 @@
+export interface InitThemeOptions {
+    /** Output directory for theme JSON files (default: "./themes"). */
+    outputDir: string;
+}
+/**
+ * Interactive theme scaffold command.
+ *
+ * Prompts the user for theme ids, keys (color or style), and per-theme values,
+ * then writes one {id}.json file per theme with identical key sets.
+ *
+ * @example
+ *   npx ink-cartridge initTheme --output ./my-themes
+ */
+export declare function initTheme(options: InitThemeOptions): void;

package/dist/cli/initTheme.js

@@ -0,0 +1,124 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as readline from 'node:readline';
+/**
+ * Interactive theme scaffold command.
+ *
+ * Prompts the user for theme ids, keys (color or style), and per-theme values,
+ * then writes one {id}.json file per theme with identical key sets.
+ *
+ * @example
+ *   npx ink-cartridge initTheme --output ./my-themes
+ */
+export function initTheme(options) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    (async () => {
+        console.log('');
+        console.log('  ink-cartridge theme scaffold');
+        console.log('  ─────────────────────');
+        console.log('');
+        // Step 1: theme ids
+        const idsRaw = await ask('  Theme ids (comma-separated, e.g. "dark,light"): ');
+        const ids = idsRaw
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+        if (ids.length < 2) {
+            console.error('Error: at least 2 theme ids are required.');
+            rl.close();
+            process.exit(1);
+        }
+        // Validate no duplicates
+        const seen = new Set();
+        for (const id of ids) {
+            if (seen.has(id)) {
+                console.error(`Error: duplicate theme id "${id}".`);
+                rl.close();
+                process.exit(1);
+            }
+            seen.add(id);
+        }
+        console.log('');
+        console.log(`  Themes: ${ids.join(', ')}`);
+        console.log('');
+        const keys = [];
+        console.log('  Define your theme keys one at a time.');
+        console.log('  Format: <key-name> <color|style>');
+        console.log('  Examples: primary color, titleBold style');
+        console.log('  Press Enter on an empty line when done.');
+        console.log('');
+        while (true) {
+            const line = await ask('  Key: ');
+            if (!line.trim())
+                break;
+            const parts = line.trim().split(/\s+/);
+            if (parts.length !== 2 || !['color', 'style'].includes(parts[1])) {
+                console.log('  Invalid format. Use: <key-name> <color|style>');
+                continue;
+            }
+            const name = parts[0];
+            const kind = parts[1];
+            if (keys.some((k) => k.name === name)) {
+                console.log(`  Key "${name}" already defined.`);
+                continue;
+            }
+            keys.push({ name, kind });
+            console.log(`  ✓ Added ${kind} key: "${name}"`);
+        }
+        if (keys.length === 0) {
+            console.error('Error: at least one key is required.');
+            rl.close();
+            process.exit(1);
+        }
+        console.log('');
+        console.log(`  Keys (${keys.length}): ${keys.map((k) => `${k.name}(${k.kind})`).join(', ')}`);
+        console.log('');
+        // Step 3: per-theme values
+        const themes = {};
+        for (const id of ids) {
+            console.log(`  ── Theme "${id}" ──`);
+            const values = { id };
+            for (const key of keys) {
+                const defaultVal = key.kind === 'color' ? 'white' : 'false';
+                const val = await ask(`    ${key.name} (${key.kind}, default: ${defaultVal}): `);
+                const trimmed = val.trim();
+                if (key.kind === 'color') {
+                    values[key.name] = trimmed || 'white';
+                }
+                else {
+                    const lower = trimmed.toLowerCase();
+                    values[key.name] = lower === 'true' || lower === '1' || lower === 'yes';
+                }
+            }
+            themes[id] = values;
+            console.log('');
+        }
+        // Step 4: write files
+        const outDir = path.resolve(options.outputDir);
+        fs.mkdirSync(outDir, { recursive: true });
+        for (const id of ids) {
+            const filePath = path.join(outDir, `${id}.json`);
+            const obj = { id, ...themes[id] };
+            delete obj.id; // id is already there, we set it above — need to restructure
+            // Build clean object with id first
+            const clean = { id };
+            for (const [k, v] of Object.entries(themes[id])) {
+                if (k !== 'id')
+                    clean[k] = v;
+            }
+            fs.writeFileSync(filePath, JSON.stringify(clean, null, 2) + '\n', 'utf-8');
+            console.log(`  ✓ Written: ${filePath}`);
+        }
+        console.log('');
+        console.log(`  Done! ${ids.length} themes with ${keys.length} keys → ${outDir}`);
+        rl.close();
+    })().catch((err) => {
+        console.error(`Error: ${err.message}`);
+        rl.close();
+        process.exit(1);
+    });
+}

package/dist/cli/makeLanguageType.d.ts

@@ -0,0 +1,46 @@
+interface LanguageFile {
+    /** Locale code derived from the file name (e.g. "en-US"). */
+    name: string;
+    /** Flattened key → template string map. */
+    keys: Record<string, string>;
+}
+export interface MakeLanguageTypeOptions {
+    /** Directory containing {locale}.json files. */
+    sourceDir: string;
+    /** Directory where the generated files will be written. */
+    outputDir: string;
+    /** Whether to re-generate on file changes. */
+    watch: boolean;
+    /** Debounce delay in milliseconds (default 500). */
+    debounceMs: number;
+    /** npm package name to import the original t / useI18n from. */
+    packageName: string;
+}
+/** @internal Exported for testing only. */
+export declare function flatJSON(obj: Record<string, unknown>, prefix?: string): Record<string, string>;
+/** Keys present in EVERY language file. */
+export declare function findCommonKeys(files: LanguageFile[]): string[];
+/** Keys that exist in at least one file but not in all. */
+export declare function findPartialKeys(files: LanguageFile[]): Map<string, string[]>;
+/** Extract {param} names from a template string. */
+export declare function extractParams(template: string): string[];
+/** Build an array of template strings for a given key across all files. */
+export declare function paramSetsForKey(key: string, files: LanguageFile[]): string[][];
+/** @internal Exported for testing only. */
+export declare function generateTypesContent(commonKeys: string[], keyParams: Record<string, string[]>): string;
+/** @internal Exported for testing only. */
+export declare function generateRuntimeContent(packageName: string): string;
+/** @internal Exported for testing only. */
+export declare function escapeSingleQuote(s: string): string;
+/**
+ * Generate type-safe i18n bindings from a directory of {locale}.json files.
+ *
+ * Produces two files in {@link MakeLanguageTypeOptions.outputDir}:
+ * - `i18n-types.d.ts` — type declarations (TranslationKey, TranslationParams)
+ * - `i18n.ts` — typed `t()` function and `useI18n()` hook
+ *
+ * In watch mode it re-generates whenever a .json file in sourceDir changes,
+ * debounced to avoid rapid rebuilds.
+ */
+export declare function makeLanguageType(options: MakeLanguageTypeOptions): void;
+export {};

package/dist/cli/makeLanguageType.js

@@ -0,0 +1,264 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/* ------------------------------------------------------------------ */
+/*  JSON flattening (must match src/language/provider.tsx)             */
+/* ------------------------------------------------------------------ */
+/** @internal Exported for testing only. */
+export function flatJSON(obj, prefix = '') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === 'string') {
+            result[fullKey] = value;
+        }
+        else if (typeof value === 'number' || typeof value === 'boolean') {
+            result[fullKey] = String(value);
+        }
+        else if (Array.isArray(value)) {
+            result[fullKey] = value.map((v) => String(v)).join(', ');
+        }
+        else if (typeof value === 'object' && value !== null) {
+            Object.assign(result, flatJSON(value, fullKey));
+        }
+    }
+    return result;
+}
+/* ------------------------------------------------------------------ */
+/*  File scanning                                                     */
+/* ------------------------------------------------------------------ */
+function scanLanguageFiles(dirPath) {
+    const files = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dirPath);
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries.sort()) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const name = entry.slice(0, -'.json'.length);
+        const fullPath = path.resolve(dirPath, entry);
+        try {
+            const raw = fs.readFileSync(fullPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            files.push({ name, keys: flatJSON(parsed) });
+        }
+        catch {
+            process.stderr.write(`[ink-cartridge] Warning: failed to parse "${entry}" — skipped\n`);
+        }
+    }
+    return files;
+}
+/* ------------------------------------------------------------------ */
+/*  Key analysis                                                      */
+/* ------------------------------------------------------------------ */
+/** Keys present in EVERY language file. */
+export function findCommonKeys(files) {
+    if (files.length === 0)
+        return [];
+    const keySets = files.map((f) => new Set(Object.keys(f.keys)));
+    const common = new Set(keySets[0]);
+    for (let i = 1; i < keySets.length; i++) {
+        for (const key of common) {
+            if (!keySets[i].has(key))
+                common.delete(key);
+        }
+    }
+    return [...common].sort();
+}
+/** Keys that exist in at least one file but not in all. */
+export function findPartialKeys(files) {
+    if (files.length === 0)
+        return new Map();
+    const allKeys = new Set();
+    for (const f of files)
+        for (const k of Object.keys(f.keys))
+            allKeys.add(k);
+    const partial = new Map();
+    for (const key of allKeys) {
+        const missing = files.filter((f) => !(key in f.keys)).map((f) => f.name);
+        if (missing.length > 0)
+            partial.set(key, missing);
+    }
+    return partial;
+}
+/** Extract {param} names from a template string. */
+export function extractParams(template) {
+    const params = new Set();
+    const re = /\{(\w+)\}/g;
+    let match;
+    while ((match = re.exec(template)) !== null) {
+        params.add(match[1]);
+    }
+    return [...params].sort();
+}
+/** Build an array of template strings for a given key across all files. */
+export function paramSetsForKey(key, files) {
+    return files.map((f) => {
+        const template = f.keys[key];
+        return template ? extractParams(template) : [];
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  Code generation                                                   */
+/* ------------------------------------------------------------------ */
+/** @internal Exported for testing only. */
+export function generateTypesContent(commonKeys, keyParams) {
+    const lines = [
+        '// Auto-generated by ink-cartridge makeLanguageType.',
+        '// Do not edit manually.',
+        '',
+        'export type TranslationKey =',
+    ];
+    if (commonKeys.length === 0) {
+        lines.push('  never;');
+    }
+    else {
+        for (let i = 0; i < commonKeys.length; i++) {
+            const delim = i < commonKeys.length - 1 ? '' : ';';
+            lines.push(`  | '${escapeSingleQuote(commonKeys[i])}'${delim}`);
+        }
+    }
+    lines.push('');
+    if (commonKeys.length === 0) {
+        lines.push('export type TranslationParams = Record<string, never>;');
+    }
+    else {
+        lines.push('export type TranslationParams = {');
+        for (const key of commonKeys) {
+            const params = keyParams[key];
+            if (!params || params.length === 0) {
+                lines.push(`  '${escapeSingleQuote(key)}': undefined;`);
+            }
+            else {
+                const members = params.map((p) => `    ${p}: string | number;`).join('\n');
+                lines.push(`  '${escapeSingleQuote(key)}': {\n${members}\n  };`);
+            }
+        }
+        lines.push('};');
+    }
+    return lines.join('\n') + '\n';
+}
+/** @internal Exported for testing only. */
+export function generateRuntimeContent(packageName) {
+    return (`// Auto-generated by ink-cartridge makeLanguageType.\n` +
+        `// Do not edit manually.\n` +
+        `\n` +
+        `import { t as rawT, useI18n as rawUseI18n } from '${escapeSingleQuote(packageName)}';\n` +
+        `import type { TranslationKey, TranslationParams } from './i18n-types.js';\n` +
+        `\n` +
+        `/**\n` +
+        ` * Typed translation function. Drop-in replacement for the original \`t\`.\n` +
+        ` *\n` +
+        ` * @param key - A translation key shared by all language files.\n` +
+        ` * @param options - Optional params and/or context.\n` +
+        ` */\n` +
+        `export function t<K extends TranslationKey>(\n` +
+        `  key: K,\n` +
+        `  options?: { params?: TranslationParams[K]; context?: string },\n` +
+        `): string {\n` +
+        `  return rawT(key, options as any);\n` +
+        `}\n` +
+        `\n` +
+        `/**\n` +
+        ` * Typed \`useI18n\` hook. Returns the same API as the original hook but\n` +
+        ` * with a type-safe \`t\` function.\n` +
+        ` */\n` +
+        `export function useI18n(): Omit<ReturnType<typeof rawUseI18n>, 't'> & { t: typeof t } {\n` +
+        `  const ctx = rawUseI18n();\n` +
+        `  return { ...ctx, t: (key: any, options?: any) => ctx.t(key, options) };\n` +
+        `}\n`);
+}
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+/** @internal Exported for testing only. */
+export function escapeSingleQuote(s) {
+    return s.replace(/'/g, "\\'");
+}
+function writeOutput(outputDir, typesContent, runtimeContent) {
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(path.join(outputDir, 'i18n-types.d.ts'), typesContent, 'utf-8');
+    fs.writeFileSync(path.join(outputDir, 'i18n.ts'), runtimeContent, 'utf-8');
+}
+/* ------------------------------------------------------------------ */
+/*  Public API                                                         */
+/* ------------------------------------------------------------------ */
+/**
+ * Generate type-safe i18n bindings from a directory of {locale}.json files.
+ *
+ * Produces two files in {@link MakeLanguageTypeOptions.outputDir}:
+ * - `i18n-types.d.ts` — type declarations (TranslationKey, TranslationParams)
+ * - `i18n.ts` — typed `t()` function and `useI18n()` hook
+ *
+ * In watch mode it re-generates whenever a .json file in sourceDir changes,
+ * debounced to avoid rapid rebuilds.
+ */
+export function makeLanguageType(options) {
+    const { sourceDir, outputDir, debounceMs } = options;
+    if (!fs.existsSync(sourceDir)) {
+        process.stderr.write(`[ink-cartridge] Error: source directory not found — "${sourceDir}"\n`);
+        process.exit(1);
+    }
+    generate(sourceDir, outputDir, options);
+    if (options.watch) {
+        let timer;
+        try {
+            fs.watch(sourceDir, (_eventType, filename) => {
+                if (!filename || !filename.endsWith('.json'))
+                    return;
+                if (timer)
+                    clearTimeout(timer);
+                timer = setTimeout(() => {
+                    process.stderr.write(`[ink-cartridge] Change detected in "${filename}", regenerating…\n`);
+                    generate(sourceDir, outputDir, options);
+                }, debounceMs);
+            });
+            process.stderr.write(`[ink-cartridge] Watching "${sourceDir}" for changes (debounce: ${debounceMs}ms)…\n`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[ink-cartridge] Error: watch mode failed — ${msg}\n`);
+            process.exit(1);
+        }
+    }
+}
+/* ------------------------------------------------------------------ */
+/*  Core generate function                                            */
+/* ------------------------------------------------------------------ */
+function generate(sourceDir, outputDir, options) {
+    const files = scanLanguageFiles(sourceDir);
+    if (files.length === 0) {
+        process.stderr.write(`[ink-cartridge] Warning: no .json files found in "${sourceDir}"\n`);
+        const typesContent = generateTypesContent([], {});
+        const runtimeContent = generateRuntimeContent(options.packageName);
+        writeOutput(outputDir, typesContent, runtimeContent);
+        return;
+    }
+    // Find partial keys first, emit warnings
+    const partialKeys = findPartialKeys(files);
+    if (partialKeys.size > 0) {
+        for (const [key, missingIn] of partialKeys) {
+            process.stderr.write(`[ink-cartridge] Warning: key "${key}" is missing in [${missingIn.join(', ')}] — excluded from type\n`);
+        }
+    }
+    const commonKeys = findCommonKeys(files);
+    // Collect params for each common key (union across all files)
+    const keyParams = {};
+    for (const key of commonKeys) {
+        const allParams = new Set();
+        for (const paramsOfFile of paramSetsForKey(key, files)) {
+            for (const p of paramsOfFile)
+                allParams.add(p);
+        }
+        const sorted = [...allParams].sort();
+        if (sorted.length > 0)
+            keyParams[key] = sorted;
+    }
+    const typesContent = generateTypesContent(commonKeys, keyParams);
+    const runtimeContent = generateRuntimeContent(options.packageName);
+    writeOutput(outputDir, typesContent, runtimeContent);
+    process.stderr.write(`[ink-cartridge] Generated ${commonKeys.length} shared keys → ${path.resolve(outputDir)}\n`);
+}