kustom-mc 0.1.0

package/dist/commands/validate.js

@@ -0,0 +1,191 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import * as ts from 'typescript';
+import { loadConfig, validateManifest, isCrossPackImport, parseCrossPackImport } from '../config.js';
+export const validateCommand = new Command('validate')
+    .description('Validate scripts for errors')
+    .option('--strict', 'Fail on warnings')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (options) => {
+    const config = loadConfig(process.cwd());
+    console.log('Validating kustompack...\n');
+    // Validate manifest configuration
+    console.log('Checking manifest...');
+    const manifestErrors = validateManifest(config);
+    if (manifestErrors.length > 0) {
+        console.log('  Manifest errors:');
+        for (const error of manifestErrors) {
+            console.log(`    - ${error}`);
+        }
+    }
+    else {
+        console.log(`  Pack ID: ${config.manifest?.id || 'unknown'}`);
+        console.log(`  Version: ${config.manifest?.version || '1.0.0'}`);
+        if (config.dependencies && config.dependencies.length > 0) {
+            console.log(`  Dependencies: ${config.dependencies.join(', ')}`);
+        }
+        console.log('  Manifest OK\n');
+    }
+    console.log('Validating scripts...');
+    // Find all TypeScript files
+    const patterns = config.include || ['scripts/**/*.ts', 'blocks/**/*.ts', 'items/**/*.ts'];
+    const excludePatterns = config.exclude || [];
+    const files = [];
+    for (const pattern of patterns) {
+        const matches = await glob(pattern, {
+            cwd: process.cwd(),
+            ignore: excludePatterns
+        });
+        files.push(...matches);
+    }
+    if (files.length === 0) {
+        console.log('No TypeScript files found to validate.');
+        return;
+    }
+    console.log(`Found ${files.length} file(s) to validate...\n`);
+    const results = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    // TypeScript validation
+    const tsconfigPath = path.resolve(process.cwd(), 'tsconfig.json');
+    let compilerOptions = {
+        target: ts.ScriptTarget.ES2020,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        strict: true,
+        noEmit: true,
+        isolatedModules: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+    };
+    if (fs.existsSync(tsconfigPath)) {
+        const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+        if (!configFile.error) {
+            const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, process.cwd());
+            compilerOptions = parsed.options;
+        }
+    }
+    const program = ts.createProgram(files.map(f => path.resolve(process.cwd(), f)), compilerOptions);
+    const diagnostics = ts.getPreEmitDiagnostics(program);
+    for (const diagnostic of diagnostics) {
+        if (diagnostic.file && diagnostic.start !== undefined) {
+            const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+            const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+            const relativePath = path.relative(process.cwd(), diagnostic.file.fileName);
+            let result = results.find(r => r.file === relativePath);
+            if (!result) {
+                result = { file: relativePath, errors: [], warnings: [] };
+                results.push(result);
+            }
+            if (diagnostic.category === ts.DiagnosticCategory.Error) {
+                result.errors.push({ line: line + 1, column: character + 1, message });
+                totalErrors++;
+            }
+            else if (diagnostic.category === ts.DiagnosticCategory.Warning) {
+                result.warnings.push({ line: line + 1, column: character + 1, message });
+                totalWarnings++;
+            }
+        }
+    }
+    // Build set of declared dependencies for cross-pack import validation
+    const declaredDependencies = new Set((config.dependencies || []).map(dep => dep.split('@')[0]));
+    const crossPackImportsUsed = new Map();
+    // Resource and cross-pack import validation
+    for (const file of files) {
+        const filePath = path.resolve(process.cwd(), file);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        let result = results.find(r => r.file === file);
+        if (!result) {
+            result = { file, errors: [], warnings: [] };
+            results.push(result);
+        }
+        // Check for resource references (textures, models, gui)
+        const resourcePatterns = [
+            { regex: /["']gui\/([^"']+)["']/g, type: 'GUI texture', dir: 'gui' },
+            { regex: /["']textures\/([^"']+)["']/g, type: 'Texture', dir: 'textures' },
+            { regex: /["']models\/([^"']+)["']/g, type: 'Model', dir: 'models' },
+        ];
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Check resource references
+            for (const { regex, type, dir } of resourcePatterns) {
+                regex.lastIndex = 0;
+                let match;
+                while ((match = regex.exec(line)) !== null) {
+                    const resourcePath = path.join(process.cwd(), dir, match[1]);
+                    if (!fs.existsSync(resourcePath)) {
+                        result.warnings.push({
+                            line: i + 1,
+                            column: match.index + 1,
+                            message: `${type} not found: ${dir}/${match[1]}`
+                        });
+                        totalWarnings++;
+                    }
+                }
+            }
+            // Check for cross-pack imports
+            const importMatch = line.match(/import\s+.*?\s+from\s+['"]([^'"]+)['"]/);
+            if (importMatch) {
+                const importPath = importMatch[1];
+                if (isCrossPackImport(importPath)) {
+                    const parsed = parseCrossPackImport(importPath);
+                    if (parsed) {
+                        // Track cross-pack import usage
+                        if (!crossPackImportsUsed.has(parsed.packId)) {
+                            crossPackImportsUsed.set(parsed.packId, []);
+                        }
+                        crossPackImportsUsed.get(parsed.packId).push({ file, line: i + 1 });
+                        // Warn if importing from undeclared dependency
+                        if (!declaredDependencies.has(parsed.packId)) {
+                            result.warnings.push({
+                                line: i + 1,
+                                column: importMatch.index || 0,
+                                message: `Cross-pack import from "${parsed.packId}" but it's not declared in dependencies`
+                            });
+                            totalWarnings++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Report cross-pack import summary
+    if (crossPackImportsUsed.size > 0) {
+        console.log('\nCross-pack imports:');
+        for (const [packId, usages] of crossPackImportsUsed) {
+            const isDeclared = declaredDependencies.has(packId);
+            const status = isDeclared ? '(declared)' : '(NOT DECLARED)';
+            console.log(`  ${packId} ${status}: ${usages.length} import(s)`);
+            if (options.verbose) {
+                for (const usage of usages) {
+                    console.log(`    - ${usage.file}:${usage.line}`);
+                }
+            }
+        }
+        console.log('');
+    }
+    // Print results
+    for (const result of results) {
+        if (result.errors.length > 0 || result.warnings.length > 0) {
+            console.log(`${result.file}:`);
+            for (const error of result.errors) {
+                console.log(`  ${error.line}:${error.column} - error: ${error.message}`);
+            }
+            for (const warning of result.warnings) {
+                console.log(`  ${warning.line}:${warning.column} - warning: ${warning.message}`);
+            }
+            console.log('');
+        }
+        else if (options.verbose) {
+            console.log(`${result.file}: OK`);
+        }
+    }
+    // Summary
+    console.log(`Validation complete: ${totalErrors} error(s), ${totalWarnings} warning(s)`);
+    if (totalErrors > 0 || (options.strict && totalWarnings > 0)) {
+        process.exit(1);
+    }
+});

package/dist/compiler/async-transform.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Transform async/await to generator-based code for Rhino compatibility.
+ * Uses Babel's @babel/plugin-transform-async-to-generator.
+ *
+ * IMPORTANT: Rhino has a bug where generator.apply(obj, args) fails with
+ * "Cannot find default value for object". We work around this by replacing
+ * Babel's helper with a custom one that uses direct function calls.
+ */
+/**
+ * Transform async functions to generator-based equivalents.
+ * This allows async/await syntax to work in Rhino, which supports generators
+ * but not native async/await.
+ *
+ * @param code JavaScript code potentially containing async/await
+ * @returns Transformed code with async functions converted to generators
+ */
+export declare function transformAsyncAwait(code: string): Promise<string>;
+/**
+ * Check if code contains async functions that need transformation.
+ */
+export declare function needsAsyncTransform(code: string): boolean;

package/dist/compiler/async-transform.js

@@ -0,0 +1,158 @@
+/**
+ * Transform async/await to generator-based code for Rhino compatibility.
+ * Uses Babel's @babel/plugin-transform-async-to-generator.
+ *
+ * IMPORTANT: Rhino has a bug where generator.apply(obj, args) fails with
+ * "Cannot find default value for object". We work around this by replacing
+ * Babel's helper with a custom one that uses direct function calls.
+ */
+import * as babel from '@babel/core';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import * as path from 'path';
+// Get the directory of this module to resolve plugins correctly
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
+// Resolve the plugin path from kustom-mc's node_modules
+const asyncToGeneratorPlugin = require.resolve('@babel/plugin-transform-async-to-generator');
+/**
+ * Custom asyncToGenerator helper that works with Rhino.
+ *
+ * PROBLEM: Rhino's generator functions don't work with .apply() or .call()
+ * when the thisArg is an object. It throws "Cannot find default value for object".
+ *
+ * SOLUTION: We return a wrapper function that, when called, captures arguments
+ * and calls the generator directly without using .apply().
+ *
+ * Babel expects _asyncToGenerator to return a FUNCTION that returns a Promise.
+ * So __rhino_asyncToGen(generatorFn) must return a function.
+ */
+const RHINO_ASYNC_STEP = `function __rhino_asyncStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}`;
+// Returns a FUNCTION that when called returns a Promise
+// This matches Babel's expected interface: _asyncToGenerator(fn)() or _asyncToGenerator(fn).apply(...)
+const RHINO_ASYNC_TO_GEN = `function __rhino_asyncToGen(fn) {
+  return function() {
+    var args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen;
+      if (args && args.length > 0) {
+        switch(args.length) {
+          case 1: gen = fn(args[0]); break;
+          case 2: gen = fn(args[0], args[1]); break;
+          case 3: gen = fn(args[0], args[1], args[2]); break;
+          case 4: gen = fn(args[0], args[1], args[2], args[3]); break;
+          case 5: gen = fn(args[0], args[1], args[2], args[3], args[4]); break;
+          default: gen = fn(args[0], args[1], args[2], args[3], args[4]); break;
+        }
+      } else {
+        gen = fn();
+      }
+      function _next(value) {
+        __rhino_asyncStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        __rhino_asyncStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(undefined);
+    });
+  };
+}`;
+/**
+ * Transform async functions to generator-based equivalents.
+ * This allows async/await syntax to work in Rhino, which supports generators
+ * but not native async/await.
+ *
+ * @param code JavaScript code potentially containing async/await
+ * @returns Transformed code with async functions converted to generators
+ */
+export async function transformAsyncAwait(code) {
+    // Skip transformation if no async functions are present
+    if (!code.includes('async ') && !code.includes('async(')) {
+        return code;
+    }
+    try {
+        const result = await babel.transformAsync(code, {
+            plugins: [
+                asyncToGeneratorPlugin
+            ],
+            // Parse as module since esbuild outputs ESM before rhino-plugin transforms it
+            sourceType: 'module',
+            // Disable other Babel features we don't need
+            presets: [],
+            configFile: false,
+            babelrc: false,
+            // Preserve formatting as much as possible
+            compact: false,
+            retainLines: true,
+        });
+        if (!result?.code) {
+            console.warn('[async-transform] Babel returned no code, using original');
+            return code;
+        }
+        // Post-process: Replace Babel's asyncToGenerator with our Rhino-compatible version
+        let transformed = result.code;
+        transformed = replaceAsyncHelper(transformed);
+        return transformed;
+    }
+    catch (error) {
+        console.error('[async-transform] Babel transformation failed:', error);
+        // Return original code if transformation fails
+        return code;
+    }
+}
+/**
+ * Replace Babel's asyncToGenerator helper with our Rhino-compatible version.
+ *
+ * Strategy:
+ * 1. FIRST remove Babel's helper definitions (before any renaming)
+ * 2. Add our custom helper functions at the top
+ * 3. Replace _asyncToGenerator(fn).apply(this, arguments) with __rhino_asyncToGen(fn, arguments)
+ * 4. Replace standalone _asyncToGenerator calls
+ */
+function replaceAsyncHelper(code) {
+    // Check if Babel's helper was added
+    if (!code.includes('_asyncToGenerator')) {
+        return code;
+    }
+    // Step 1: FIRST remove Babel's helper definitions (before any renaming!)
+    // Babel outputs on a single line (with spaces after commas):
+    // function asyncGeneratorStep(n, t, e, r, o, a, c) {try {var i = n[a](c),u = i.value;} catch (n) {return void e(n);}i.done ? t(u) : Promise.resolve(u).then(r, o);}function _asyncToGenerator(n) {return function () {var t = this,e = arguments;return new Promise(function (r, o) {var a = n.apply(t, e);function _next(n) {asyncGeneratorStep(a, r, o, _next, _throw, "next", n);}function _throw(n) {asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);}_next(void 0);});};} // scripts/...
+    // Use string manipulation instead of complex regex
+    // Find "function asyncGeneratorStep" and remove everything up to (but not including) "// scripts"
+    const asyncGenStart = code.indexOf('function asyncGeneratorStep');
+    if (asyncGenStart !== -1) {
+        // Find the comment that follows the helper block
+        const commentStart = code.indexOf('// scripts/', asyncGenStart);
+        if (commentStart !== -1) {
+            // Remove the helper block (everything from asyncGeneratorStep to the comment)
+            code = code.substring(0, asyncGenStart) + code.substring(commentStart);
+        }
+    }
+    // Step 2: Add our helpers at the top
+    code = RHINO_ASYNC_STEP + '\n' + RHINO_ASYNC_TO_GEN + '\n' + code;
+    // Step 3: Simply replace _asyncToGenerator with __rhino_asyncToGen
+    // Our helper returns a function (just like Babel's), so .apply() on that function is fine.
+    // The key difference is that OUR function doesn't use .apply() internally to call the generator.
+    code = code.replace(/_asyncToGenerator/g, '__rhino_asyncToGen');
+    return code;
+}
+/**
+ * Check if code contains async functions that need transformation.
+ */
+export function needsAsyncTransform(code) {
+    return code.includes('async ') || code.includes('async(');
+}

package/dist/compiler/inline.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Import inlining utilities.
+ *
+ * These are largely handled by esbuild now, but this module provides
+ * utilities for custom import resolution if needed.
+ */
+export interface InlineOptions {
+    /** Base directory for resolving relative imports */
+    baseDir: string;
+    /** Directories to treat as library directories (imports get inlined) */
+    libDirs: string[];
+}
+/**
+ * Check if an import path should be inlined.
+ */
+export declare function shouldInlineImport(importPath: string, options: InlineOptions): boolean;
+/**
+ * Resolve an import path to an absolute file path.
+ */
+export declare function resolveImportPath(importPath: string, fromFile: string, options: InlineOptions): string | null;
+/**
+ * Extract import statements from source code.
+ */
+export interface ImportInfo {
+    statement: string;
+    path: string;
+    names: string[];
+    isTypeOnly: boolean;
+    startIndex: number;
+    endIndex: number;
+}
+export declare function extractImports(code: string): ImportInfo[];

package/dist/compiler/inline.js

@@ -0,0 +1,87 @@
+/**
+ * Import inlining utilities.
+ *
+ * These are largely handled by esbuild now, but this module provides
+ * utilities for custom import resolution if needed.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Check if an import path should be inlined.
+ */
+export function shouldInlineImport(importPath, options) {
+    // External packages (node_modules) should not be inlined
+    if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
+        return false;
+    }
+    // SDK import should not be inlined
+    if (importPath === 'kustom-mc') {
+        return false;
+    }
+    return true;
+}
+/**
+ * Resolve an import path to an absolute file path.
+ */
+export function resolveImportPath(importPath, fromFile, options) {
+    const fromDir = path.dirname(fromFile);
+    // Handle relative imports
+    if (importPath.startsWith('.')) {
+        const resolved = path.resolve(fromDir, importPath);
+        // Try with different extensions
+        const extensions = ['.ts', '.js', '/index.ts', '/index.js'];
+        for (const ext of extensions) {
+            const fullPath = resolved + ext;
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        // Try without extension (might already have it)
+        if (fs.existsSync(resolved)) {
+            return resolved;
+        }
+    }
+    // Handle @lib/* alias
+    if (importPath.startsWith('@lib/')) {
+        const relativePath = importPath.slice('@lib/'.length);
+        for (const libDir of options.libDirs) {
+            const resolved = path.resolve(options.baseDir, libDir, relativePath);
+            const extensions = ['.ts', '.js', '/index.ts', '/index.js'];
+            for (const ext of extensions) {
+                const fullPath = resolved + ext;
+                if (fs.existsSync(fullPath)) {
+                    return fullPath;
+                }
+            }
+        }
+    }
+    return null;
+}
+export function extractImports(code) {
+    const imports = [];
+    // Match import statements
+    const importRegex = /import\s+(type\s+)?(?:{([^}]+)}|(\w+))\s+from\s+['"]([^'"]+)['"];?/g;
+    let match;
+    while ((match = importRegex.exec(code)) !== null) {
+        const isTypeOnly = !!match[1];
+        const namedImports = match[2];
+        const defaultImport = match[3];
+        const importPath = match[4];
+        const names = [];
+        if (namedImports) {
+            names.push(...namedImports.split(',').map(n => n.trim()));
+        }
+        if (defaultImport) {
+            names.push(defaultImport);
+        }
+        imports.push({
+            statement: match[0],
+            path: importPath,
+            names,
+            isTypeOnly,
+            startIndex: match.index,
+            endIndex: match.index + match[0].length
+        });
+    }
+    return imports;
+}

package/dist/compiler/postprocess.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Post-process bundled JavaScript for Rhino compatibility.
+ *
+ * Transforms:
+ * 1. Remove kustom-mc import
+ * 2. Convert export default defineX({...}) to exports.default = { __type: "x", ... }
+ * 3. Convert arrow functions to regular functions (for older Rhino)
+ * 4. Convert destructuring in function params to variable assignments
+ * 5. Convert const/let to var (for older Rhino)
+ * 6. Convert template literals to string concatenation
+ */
+export declare function postProcessForRhino(code: string): string;
+/**
+ * Transform destructuring in function parameters to manual assignments.
+ *
+ * Input:  function({ executor, props }) { ... }
+ * Output: function(ctx) { var executor = ctx.executor; var props = ctx.props; ... }
+ */
+export declare function transformDestructuringParams(code: string): string;

package/dist/compiler/postprocess.js

@@ -0,0 +1,134 @@
+/**
+ * Post-process bundled JavaScript for Rhino compatibility.
+ *
+ * Transforms:
+ * 1. Remove kustom-mc import
+ * 2. Convert export default defineX({...}) to exports.default = { __type: "x", ... }
+ * 3. Convert arrow functions to regular functions (for older Rhino)
+ * 4. Convert destructuring in function params to variable assignments
+ * 5. Convert const/let to var (for older Rhino)
+ * 6. Convert template literals to string concatenation
+ */
+export function postProcessForRhino(code) {
+    let result = code;
+    // Remove import statements for kustom-mc (handle all define functions)
+    result = result.replace(/import\s*{\s*(?:defineScript|defineBlock|defineItem)(?:\s*,\s*(?:defineScript|defineBlock|defineItem))*\s*}\s*from\s*['"]kustom-mc['"];?\s*/g, '');
+    result = result.replace(/import\s+type\s*{[^}]*}\s*from\s*['"]kustom-mc['"];?\s*/g, '');
+    // Convert export default defineScript({...}) to exports.default = { __type: "script", ...}
+    result = result.replace(/export\s+default\s+defineScript\s*\(\s*({[\s\S]*})\s*\)\s*;?/, (match, content) => injectTypeProperty(content, 'script'));
+    // Convert export default defineBlock({...}) to exports.default = { __type: "block", ...}
+    result = result.replace(/export\s+default\s+defineBlock\s*\(\s*({[\s\S]*})\s*\)\s*;?/, (match, content) => injectTypeProperty(content, 'block'));
+    // Convert export default defineItem({...}) to exports.default = { __type: "item", ...}
+    result = result.replace(/export\s+default\s+defineItem\s*\(\s*({[\s\S]*})\s*\)\s*;?/, (match, content) => injectTypeProperty(content, 'item'));
+    // Convert any remaining export default to exports.default
+    result = result.replace(/export\s+default\s+/g, 'exports.default = ');
+    // Convert const/let to var for maximum Rhino compatibility
+    result = result.replace(/\bconst\s+/g, 'var ');
+    result = result.replace(/\blet\s+/g, 'var ');
+    // Convert arrow functions to regular functions
+    // Handle: ({ a, b }) => { ... }
+    result = convertArrowFunctions(result);
+    // Convert template literals to string concatenation
+    result = convertTemplateLiterals(result);
+    // Ensure exports object exists at the top
+    if (!result.includes('var exports =') && !result.includes('exports =')) {
+        result = 'var exports = exports || {};\n' + result;
+    }
+    return result;
+}
+/**
+ * Inject __type property into the definition object.
+ *
+ * Input:  { id: "foo", model: "bar" }
+ * Output: exports.default = { __type: "block", id: "foo", model: "bar" };
+ */
+function injectTypeProperty(objectContent, type) {
+    // objectContent starts with { and ends with }
+    // We need to insert __type as the first property
+    const trimmed = objectContent.trim();
+    if (trimmed.startsWith('{')) {
+        // Insert __type right after the opening brace
+        const inner = trimmed.slice(1).trimStart();
+        if (inner.startsWith('}')) {
+            // Empty object
+            return `exports.default = { __type: "${type}" };`;
+        }
+        return `exports.default = { __type: "${type}", ${inner};`;
+    }
+    // Fallback - shouldn't happen but be safe
+    return `exports.default = ${objectContent};`;
+}
+function convertArrowFunctions(code) {
+    let result = code;
+    // Convert arrow functions with block body: (params) => { ... }
+    // This regex handles various parameter patterns
+    result = result.replace(/(\([^)]*\)|\w+)\s*=>\s*{/g, (match, params) => {
+        // Convert destructuring params if needed
+        if (params.startsWith('(') && params.includes('{')) {
+            // Has destructuring, we'll convert to function with manual destructuring
+            return `function${params} {`;
+        }
+        return `function${params.startsWith('(') ? params : `(${params})`} {`;
+    });
+    // Convert arrow functions with expression body: (params) => expr
+    // This is trickier - we need to wrap in { return expr; }
+    result = result.replace(/(\([^)]*\)|\w+)\s*=>\s*([^{][^,;\n]*)/g, (match, params, body) => {
+        // Skip if this looks like it's already been converted
+        if (body.trim().startsWith('function'))
+            return match;
+        // Skip if body ends with { (block body)
+        if (body.trim().endsWith('{'))
+            return match;
+        const funcParams = params.startsWith('(') ? params : `(${params})`;
+        return `function${funcParams} { return ${body.trim()}; }`;
+    });
+    return result;
+}
+function convertTemplateLiterals(code) {
+    // Convert template literals to string concatenation
+    // Handle: `text ${expr} more text`
+    return code.replace(/`([^`]*)`/g, (match, content) => {
+        // If no interpolation, just use regular string
+        if (!content.includes('${')) {
+            return `"${content.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
+        }
+        // Split by interpolation and join with +
+        const parts = [];
+        let remaining = content;
+        let lastIndex = 0;
+        const regex = /\$\{([^}]+)\}/g;
+        let match2;
+        while ((match2 = regex.exec(content)) !== null) {
+            // Add text before this interpolation
+            const textBefore = content.slice(lastIndex, match2.index);
+            if (textBefore) {
+                parts.push(`"${textBefore.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`);
+            }
+            // Add the expression
+            parts.push(`(${match2[1]})`);
+            lastIndex = regex.lastIndex;
+        }
+        // Add any remaining text
+        const textAfter = content.slice(lastIndex);
+        if (textAfter) {
+            parts.push(`"${textAfter.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`);
+        }
+        return parts.join(' + ');
+    });
+}
+/**
+ * Transform destructuring in function parameters to manual assignments.
+ *
+ * Input:  function({ executor, props }) { ... }
+ * Output: function(ctx) { var executor = ctx.executor; var props = ctx.props; ... }
+ */
+export function transformDestructuringParams(code) {
+    // This is a simplified version - a full implementation would need a proper parser
+    return code.replace(/function\s*\(\s*{\s*([^}]+)\s*}\s*\)\s*{/g, (match, params) => {
+        const paramList = params.split(',').map((p) => p.trim());
+        const assignments = paramList
+            .map((p) => `var ${p} = ctx.${p};`)
+            .join(' ');
+        return `function(ctx) { ${assignments}`;
+    });
+}

package/dist/compiler/rhino-plugin.d.ts

@@ -0,0 +1,17 @@
+/**
+ * esbuild plugin for Rhino compatibility.
+ *
+ * Transforms bundled JavaScript output to be compatible with the Rhino JS engine:
+ * 1. Transforms relative script imports to __kustom_import() calls
+ * 2. Strips kustom-mc imports (resolved to Java-injected globals)
+ * 3. Injects __type property into defineScript/defineBlock/defineItem calls
+ * 4. Converts ESM export syntax to CommonJS exports
+ * 5. Transforms destructuring function parameters
+ * 6. Converts modern JS features to ES5-compatible code
+ */
+import type { Plugin } from 'esbuild';
+export declare function rhinoCompatPlugin(): Plugin;
+/**
+ * Transform JavaScript code for Rhino compatibility.
+ */
+export declare function transformForRhino(code: string): string;