kustom-mc 0.1.0

package/dist/compiler/rhino-plugin.js

@@ -0,0 +1,324 @@
+/**
+ * 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
+ */
+export function rhinoCompatPlugin() {
+    return {
+        name: 'rhino-compat',
+        setup(build) {
+            build.onEnd(async (result) => {
+                if (result.errors.length > 0)
+                    return;
+                if (!result.outputFiles)
+                    return;
+                for (const file of result.outputFiles) {
+                    if (file.path.endsWith('.js')) {
+                        const transformed = transformForRhino(file.text);
+                        file.contents = new TextEncoder().encode(transformed);
+                    }
+                }
+            });
+        }
+    };
+}
+/**
+ * Transform JavaScript code for Rhino compatibility.
+ */
+export function transformForRhino(code) {
+    let result = code;
+    // 1. Transform relative script imports to __kustom_import() calls
+    // This must happen BEFORE removing other imports
+    result = transformScriptImports(result);
+    // 2. Remove kustom-mc imports (resolved to Java-injected globals)
+    result = result.replace(/^import\s+.*?from\s+['"]kustom-mc['"];?\s*$/gm, '');
+    result = result.replace(/^import\s+['"]kustom-mc['"];?\s*$/gm, '');
+    // 3. Remove any remaining import statements (shouldn't be any, but just in case)
+    result = result.replace(/^import\s+.*?from\s+['"][^'"]+['"];?\s*$/gm, '');
+    result = result.replace(/^import\s+['"][^'"]+['"];?\s*$/gm, '');
+    // 4. Transform defineScript/defineBlock/defineItem calls
+    // Pattern: var xxx = defineScript({ ... });
+    // Result:  var xxx = { __type: "script", ... };
+    result = transformDefineCall(result, 'defineScript', 'script');
+    result = transformDefineCall(result, 'defineBlock', 'block');
+    result = transformDefineCall(result, 'defineItem', 'item');
+    // 5. Handle ESM export: export { xxx as default };
+    result = result.replace(/export\s*\{\s*(\w+)\s+as\s+default\s*\}\s*;?/g, 'exports.default = $1;');
+    // 6. Handle other ESM exports: export { foo, bar };
+    result = result.replace(/export\s*\{\s*([^}]+)\s*\}\s*;?/g, (match, exports) => {
+        const exportList = exports.split(',').map((e) => e.trim());
+        return exportList
+            .map((e) => {
+            const parts = e.split(/\s+as\s+/);
+            const localName = parts[0].trim();
+            const exportName = parts[1]?.trim() || localName;
+            return `exports.${exportName} = ${localName};`;
+        })
+            .join('\n');
+    });
+    // 7. Transform destructuring in function params (including shorthand methods)
+    result = transformDestructuringParams(result);
+    // 8. Transform shorthand methods: onClick(event) { -> onClick: function(event) {
+    result = transformShorthandMethods(result);
+    // 9. Convert optional chaining ?. to regular access
+    result = result.replace(/\?\./g, '.');
+    // 10. Convert nullish coalescing ?? to ||
+    result = result.replace(/\?\?/g, '||');
+    // 11. Convert const/let to var
+    result = result.replace(/\bconst\s+/g, 'var ');
+    result = result.replace(/\blet\s+/g, 'var ');
+    // 12. Ensure exports object exists at the top
+    if (!result.includes('var exports =') && !result.startsWith('var exports')) {
+        result = 'var exports = exports || {};\n' + result;
+    }
+    // 13. Clean up empty lines and multiple semicolons
+    result = result.replace(/^\s*\n/gm, '');
+    result = result.replace(/;;+/g, ';');
+    return result;
+}
+/**
+ * Transform a define call (defineScript, defineBlock, defineItem) to inject __type.
+ *
+ * Input:  var xxx = defineScript({ props: {}, run() {} });
+ * Output: var xxx = { __type: "script", props: {}, run() {} };
+ */
+function transformDefineCall(code, funcName, typeName) {
+    // Match: var xxx = defineScript(
+    const pattern = new RegExp(`(var\\s+\\w+\\s*=\\s*)${funcName}\\s*\\(\\s*\\{`, 'g');
+    let result = code.replace(pattern, `$1{ __type: "${typeName}",`);
+    // Now we need to remove the extra closing ) from defineScript({...});
+    // This is tricky because we need to find the matching closing brace
+    // Simple approach: find defineScript pattern and track braces
+    // After the above replacement, we have patterns like:
+    // var xxx = { __type: "script", ... });
+    // We need to change }); to };
+    // Look for the pattern where we have __type followed eventually by });
+    // This is a simplified approach - find }); that follows __type declaration
+    if (result.includes(`__type: "${typeName}"`)) {
+        // Find all occurrences and fix the closing
+        result = fixClosingParens(result, typeName);
+    }
+    return result;
+}
+/**
+ * Fix the closing parenthesis after transforming defineX calls.
+ * Changes }); to }; for objects that have __type property.
+ */
+function fixClosingParens(code, typeName) {
+    // Find positions where __type: "typeName" appears
+    const typePattern = new RegExp(`__type:\\s*"${typeName}"`, 'g');
+    let match;
+    let result = code;
+    // Process one at a time, recalculating position each time
+    while ((match = typePattern.exec(result)) !== null) {
+        const pos = match.index;
+        // Find the opening brace before __type
+        let braceStart = result.lastIndexOf('{', pos);
+        if (braceStart === -1)
+            continue;
+        // Find matching closing brace
+        let depth = 1;
+        let i = braceStart + 1;
+        // Track if we're inside a string to avoid matching braces in strings
+        let inString = false;
+        let stringChar = '';
+        while (i < result.length && depth > 0) {
+            const char = result[i];
+            const prevChar = result[i - 1];
+            // Handle string detection (skip escaped quotes)
+            if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
+                if (!inString) {
+                    inString = true;
+                    stringChar = char;
+                }
+                else if (char === stringChar) {
+                    inString = false;
+                }
+            }
+            if (!inString) {
+                if (char === '{')
+                    depth++;
+                else if (char === '}')
+                    depth--;
+            }
+            i++;
+        }
+        // i now points to just after the closing }
+        // Check if followed by ); 
+        const after = result.substring(i).match(/^\s*\)\s*;/);
+        if (after) {
+            // Replace }); with };
+            result = result.substring(0, i) + ';' + result.substring(i + after[0].length);
+            // Reset the regex lastIndex since we modified the string
+            typePattern.lastIndex = 0;
+        }
+    }
+    return result;
+}
+/**
+ * Transform destructuring in function parameters.
+ *
+ * Input:  run({ executor, props }) { ... }
+ * Output: run: function(ctx) { var executor = ctx.executor; var props = ctx.props; ... }
+ *
+ * Also handles generator functions from Babel's async/await transform:
+ * Input:  function* ({ process, props }) { ... }
+ * Output: function* (_ctx) { var process = _ctx.process; var props = _ctx.props; ... }
+ */
+function transformDestructuringParams(code) {
+    let result = code;
+    // First, handle generator functions with destructuring (from Babel async transform)
+    // Match: function* ({ param1, param2 }) {
+    result = result.replace(/function\*\s*\(\s*\{\s*([^}]+)\s*\}\s*\)\s*\{/g, (match, params) => {
+        const paramList = params.split(',').map((p) => p.trim()).filter((p) => p);
+        const assignments = paramList
+            .map((p) => {
+            const [name] = p.split('=').map(s => s.trim());
+            return `var ${name} = _ctx.${name};`;
+        })
+            .join(' ');
+        return `function* (_ctx) { ${assignments}`;
+    });
+    // Handle regular function keyword with destructuring
+    // Match: function ({ param1, param2 }) {
+    result = result.replace(/function\s*\(\s*\{\s*([^}]+)\s*\}\s*\)\s*\{/g, (match, params) => {
+        const paramList = params.split(',').map((p) => p.trim()).filter((p) => p);
+        const assignments = paramList
+            .map((p) => {
+            const [name] = p.split('=').map(s => s.trim());
+            return `var ${name} = _ctx.${name};`;
+        })
+            .join(' ');
+        return `function(_ctx) { ${assignments}`;
+    });
+    // Handle methods with destructuring
+    // Match: methodName({ param1, param2 }) {
+    result = result.replace(/(\w+)\s*\(\s*\{\s*([^}]+)\s*\}\s*\)\s*\{/g, (match, methodName, params) => {
+        // Skip keywords that we've already handled or shouldn't transform
+        const keywords = ['function', 'if', 'while', 'for', 'switch', 'catch', 'with'];
+        if (keywords.includes(methodName)) {
+            return match; // Already handled above
+        }
+        // For methods, convert to function syntax and transform params
+        const paramList = params.split(',').map((p) => p.trim()).filter((p) => p);
+        const assignments = paramList
+            .map((p) => {
+            const [name] = p.split('=').map(s => s.trim());
+            return `var ${name} = _ctx.${name};`;
+        })
+            .join(' ');
+        return `${methodName}: function(_ctx) { ${assignments}`;
+    });
+    return result;
+}
+/**
+ * Transform shorthand methods to function syntax.
+ *
+ * Input:  onClick(event) { ... }
+ * Output: onClick: function(event) { ... }
+ *
+ * Only transforms methods inside object literals (preceded by { or ,)
+ */
+function transformShorthandMethods(code) {
+    // Match: methodName(params) { preceded by { or , (indicating object literal method)
+    // We need to be careful to only transform actual shorthand methods, not function declarations
+    return code.replace(/([{,]\s*)(\w+)\s*\(([^)]*)\)\s*\{/g, (match, prefix, methodName, params) => {
+        // Skip keywords (shouldn't happen but just in case)
+        const keywords = ['function', 'if', 'while', 'for', 'switch', 'catch', 'with', 'return'];
+        if (keywords.includes(methodName)) {
+            return match;
+        }
+        // Skip if params contain destructuring (already handled by transformDestructuringParams)
+        if (params.includes('{')) {
+            return match;
+        }
+        return `${prefix}${methodName}: function(${params}) {`;
+    });
+}
+/**
+ * Transform script imports to __kustom_import() or __kustom_cross_import() calls.
+ *
+ * Handles:
+ * - Relative imports: import foo from "./foo" → var foo = __kustom_import("./foo");
+ * - Cross-pack imports: import foo from "otherpack:scripts/foo" → var foo = __kustom_cross_import("otherpack", "scripts/foo");
+ * - Named imports: import { run } from "./foo" → var { run } = __kustom_import("./foo");
+ * - Namespace imports: import * as foo from "./foo" → var foo = __kustom_import("./foo");
+ *
+ * Cross-pack import format: packId:path (e.g., "core-pack:scripts/utils")
+ */
+function transformScriptImports(code) {
+    let result = code;
+    // Pattern 1a: Default import from cross-pack - import foo from "packId:path"
+    // Transform to: var foo = __kustom_cross_import("packId", "path");
+    result = result.replace(/^import\s+(\w+)\s+from\s+['"]([a-z0-9-]+):([^'"]+)['"];?\s*$/gm, (match, varName, packId, importPath) => {
+        const normalizedPath = normalizeImportPath(importPath);
+        return `var ${varName} = __kustom_cross_import("${packId}", "${normalizedPath}");`;
+    });
+    // Pattern 1b: Default import from relative path - import foo from "./path"
+    // Transform to: var foo = __kustom_import("./path");
+    result = result.replace(/^import\s+(\w+)\s+from\s+['"](\.[^'"]+)['"];?\s*$/gm, (match, varName, importPath) => {
+        // Normalize path: remove .ts/.js extension if present
+        const normalizedPath = normalizeImportPath(importPath);
+        return `var ${varName} = __kustom_import("${normalizedPath}");`;
+    });
+    // Pattern 2a: Named imports from cross-pack - import { foo, bar } from "packId:path"
+    // Transform to: var __import = __kustom_cross_import("packId", "path"); var foo = __import.foo; var bar = __import.bar;
+    result = result.replace(/^import\s+\{\s*([^}]+)\s*\}\s+from\s+['"]([a-z0-9-]+):([^'"]+)['"];?\s*$/gm, (match, imports, packId, importPath) => {
+        const normalizedPath = normalizeImportPath(importPath);
+        const importList = imports.split(',').map((i) => i.trim()).filter((i) => i);
+        // Generate a unique variable name for the module
+        const moduleVar = `__crossimport_${packId}_${normalizedPath.replace(/[^a-zA-Z0-9]/g, '_')}`;
+        const lines = [`var ${moduleVar} = __kustom_cross_import("${packId}", "${normalizedPath}");`];
+        for (const imp of importList) {
+            // Handle "foo as bar" syntax
+            const parts = imp.split(/\s+as\s+/);
+            const originalName = parts[0].trim();
+            const localName = parts[1]?.trim() || originalName;
+            lines.push(`var ${localName} = ${moduleVar}.${originalName};`);
+        }
+        return lines.join('\n');
+    });
+    // Pattern 2b: Named imports from relative path - import { foo, bar } from "./path"
+    // Transform to: var __import_path = __kustom_import("./path"); var foo = __import_path.foo; var bar = __import_path.bar;
+    result = result.replace(/^import\s+\{\s*([^}]+)\s*\}\s+from\s+['"](\.[^'"]+)['"];?\s*$/gm, (match, imports, importPath) => {
+        const normalizedPath = normalizeImportPath(importPath);
+        const importList = imports.split(',').map((i) => i.trim()).filter((i) => i);
+        // Generate a unique variable name for the module
+        const moduleVar = `__import_${normalizedPath.replace(/[^a-zA-Z0-9]/g, '_')}`;
+        const lines = [`var ${moduleVar} = __kustom_import("${normalizedPath}");`];
+        for (const imp of importList) {
+            // Handle "foo as bar" syntax
+            const parts = imp.split(/\s+as\s+/);
+            const originalName = parts[0].trim();
+            const localName = parts[1]?.trim() || originalName;
+            lines.push(`var ${localName} = ${moduleVar}.${originalName};`);
+        }
+        return lines.join('\n');
+    });
+    // Pattern 3a: Namespace import from cross-pack - import * as foo from "packId:path"
+    // Transform to: var foo = __kustom_cross_import("packId", "path");
+    result = result.replace(/^import\s+\*\s+as\s+(\w+)\s+from\s+['"]([a-z0-9-]+):([^'"]+)['"];?\s*$/gm, (match, varName, packId, importPath) => {
+        const normalizedPath = normalizeImportPath(importPath);
+        return `var ${varName} = __kustom_cross_import("${packId}", "${normalizedPath}");`;
+    });
+    // Pattern 3b: Namespace import from relative path - import * as foo from "./path"
+    // Transform to: var foo = __kustom_import("./path");
+    result = result.replace(/^import\s+\*\s+as\s+(\w+)\s+from\s+['"](\.[^'"]+)['"];?\s*$/gm, (match, varName, importPath) => {
+        const normalizedPath = normalizeImportPath(importPath);
+        return `var ${varName} = __kustom_import("${normalizedPath}");`;
+    });
+    return result;
+}
+/**
+ * Normalize import path by removing .ts or .js extension.
+ * The Java runtime will handle extension resolution.
+ */
+function normalizeImportPath(path) {
+    return path.replace(/\.(ts|js)$/, '');
+}

package/dist/compiler/transform.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Transform pipeline for TypeScript to Rhino-compatible JavaScript.
+ */
+export interface TransformOptions {
+    /** Whether to inline imports from local files */
+    inlineImports?: boolean;
+    /** Directories containing library files to inline */
+    libDirs?: string[];
+}
+export interface TransformResult {
+    code: string;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Transform TypeScript source code to Rhino-compatible JavaScript.
+ */
+export declare function transformScript(sourcePath: string, options?: TransformOptions): Promise<TransformResult>;

package/dist/compiler/transform.js

@@ -0,0 +1,59 @@
+/**
+ * Transform pipeline for TypeScript to Rhino-compatible JavaScript.
+ */
+import * as esbuild from 'esbuild';
+import { postProcessForRhino } from './postprocess.js';
+import { transformAsyncAwait } from './async-transform.js';
+/**
+ * Transform TypeScript source code to Rhino-compatible JavaScript.
+ */
+export async function transformScript(sourcePath, options = {}) {
+    const errors = [];
+    const warnings = [];
+    try {
+        // Use esbuild to bundle the script with its local imports
+        const result = await esbuild.build({
+            entryPoints: [sourcePath],
+            bundle: true,
+            write: false,
+            format: 'esm',
+            target: 'es2020',
+            platform: 'neutral',
+            external: ['kustom-mc'], // Don't bundle the SDK
+            loader: { '.ts': 'ts' },
+            logLevel: 'silent',
+        });
+        // Collect errors and warnings
+        for (const error of result.errors) {
+            errors.push(formatEsbuildMessage(error));
+        }
+        for (const warning of result.warnings) {
+            warnings.push(formatEsbuildMessage(warning));
+        }
+        if (result.outputFiles.length === 0) {
+            errors.push('No output generated from esbuild');
+            return { code: '', errors, warnings };
+        }
+        const bundledCode = result.outputFiles[0].text;
+        // Transform async/await to generators
+        const asyncTransformed = await transformAsyncAwait(bundledCode);
+        // Post-process for Rhino compatibility
+        const rhinoCode = postProcessForRhino(asyncTransformed);
+        return { code: rhinoCode, errors, warnings };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            errors.push(error.message);
+        }
+        else {
+            errors.push(String(error));
+        }
+        return { code: '', errors, warnings };
+    }
+}
+function formatEsbuildMessage(msg) {
+    if (msg.location) {
+        return `${msg.location.file}:${msg.location.line}:${msg.location.column}: ${msg.text}`;
+    }
+    return msg.text;
+}

package/dist/config.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Pack manifest configuration (embedded in kustom.config.json)
+ */
+export interface ManifestConfig {
+    /** Unique pack identifier (required) */
+    id: string;
+    /** Human-readable pack name */
+    name?: string;
+    /** Pack version (semver) */
+    version?: string;
+    /** Pack description */
+    description?: string;
+    /** Pack author */
+    author?: string;
+    /** Pack scope: "global", "world", or "player" */
+    scope?: 'global' | 'world' | 'player';
+    /** Worlds this pack applies to (for scope: "world") */
+    worlds?: string[];
+    /** Pack priority (higher = loaded later, can override) */
+    priority?: number;
+}
+/**
+ * Server connection configuration
+ */
+export interface ServerConfig {
+    /** Server URL for registry API */
+    url?: string;
+}
+export interface KustomConfig {
+    include?: string[];
+    exclude?: string[];
+    outDir?: string;
+    lib?: string[];
+    /** Pack manifest configuration */
+    manifest?: ManifestConfig;
+    /** Pack dependencies (e.g., ["core-pack@^1.0.0"]) */
+    dependencies?: string[];
+    /** Server connection settings */
+    server?: ServerConfig;
+    deploy?: {
+        target?: string;
+        reloadCommand?: string;
+    };
+    bundle?: {
+        output?: string;
+        include?: string[];
+    };
+}
+export declare function loadConfig(cwd: string): KustomConfig;
+/**
+ * Generate the kustompack.json manifest content from config
+ */
+export declare function generateManifest(config: KustomConfig): string;
+/**
+ * Validate the manifest configuration
+ */
+export declare function validateManifest(config: KustomConfig): string[];
+/**
+ * Parse a namespaced ID string.
+ * Format: packId:type/name (e.g., "mypack:item/sword")
+ */
+export declare function parseNamespacedId(fullId: string): {
+    packId: string;
+    type: string;
+    name: string;
+} | null;
+/**
+ * Check if a string is a fully qualified namespaced ID.
+ */
+export declare function isNamespacedId(id: string): boolean;
+/**
+ * Check if a string is a cross-pack import (packId:path format).
+ */
+export declare function isCrossPackImport(importPath: string): boolean;
+/**
+ * Parse a cross-pack import path.
+ * Format: packId:scripts/path or packId:type/name
+ */
+export declare function parseCrossPackImport(importPath: string): {
+    packId: string;
+    path: string;
+} | null;
+/**
+ * Create a fully qualified namespaced ID.
+ */
+export declare function createNamespacedId(packId: string, type: string, name: string): string;

package/dist/config.js

@@ -0,0 +1,166 @@
+import * as fs from 'fs';
+import * as path from 'path';
+const defaultConfig = {
+    include: ['scripts/**/*.ts', 'blocks/**/*.ts', 'items/**/*.ts'],
+    exclude: ['**/*.test.ts', '**/*.spec.ts'],
+    outDir: '.',
+    lib: ['scripts/lib'],
+    manifest: {
+        id: 'my-pack',
+        version: '1.0.0',
+        scope: 'global',
+        priority: 0
+    },
+    dependencies: [],
+    server: {
+        url: 'http://localhost:8765'
+    },
+    deploy: {
+        target: '../run/plugins/kustom-plugin/packs',
+        reloadCommand: '/kustom pack reload'
+    },
+    bundle: {
+        output: 'dist/kustompack.zip',
+        include: ['**/*.js', 'textures/**/*', 'gui/**/*', 'models/**/*', 'sounds/**/*']
+    }
+};
+export function loadConfig(cwd) {
+    const configPath = path.join(cwd, 'kustom.config.json');
+    if (fs.existsSync(configPath)) {
+        try {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            const userConfig = JSON.parse(content);
+            // Deep merge for nested objects
+            const merged = {
+                ...defaultConfig,
+                ...userConfig,
+                manifest: {
+                    ...defaultConfig.manifest,
+                    ...userConfig.manifest,
+                    // Ensure id is always present
+                    id: userConfig.manifest?.id || defaultConfig.manifest?.id || 'my-pack'
+                },
+                server: { ...defaultConfig.server, ...userConfig.server },
+                deploy: { ...defaultConfig.deploy, ...userConfig.deploy },
+                bundle: { ...defaultConfig.bundle, ...userConfig.bundle }
+            };
+            return merged;
+        }
+        catch (error) {
+            console.warn(`Warning: Could not parse kustom.config.json: ${error}`);
+        }
+    }
+    return defaultConfig;
+}
+/**
+ * Generate the kustompack.json manifest content from config
+ */
+export function generateManifest(config) {
+    const manifest = config.manifest;
+    if (!manifest?.id) {
+        throw new Error('manifest.id is required in kustom.config.json');
+    }
+    const output = {
+        id: manifest.id,
+        name: manifest.name || manifest.id,
+        version: manifest.version || '1.0.0',
+        description: manifest.description || '',
+        author: manifest.author || '',
+        dependencies: config.dependencies || [],
+        scope: {
+            type: manifest.scope || 'global',
+            worlds: manifest.worlds || [],
+            priority: manifest.priority || 0
+        },
+        resources: {
+            merge: true,
+            priority: manifest.priority || 0
+        }
+    };
+    return JSON.stringify(output, null, 2);
+}
+/**
+ * Validate the manifest configuration
+ */
+export function validateManifest(config) {
+    const errors = [];
+    if (!config.manifest?.id) {
+        errors.push('manifest.id is required');
+    }
+    else {
+        // Validate pack ID format (lowercase, alphanumeric, hyphens)
+        if (!/^[a-z0-9-]+$/.test(config.manifest.id)) {
+            errors.push('manifest.id must be lowercase alphanumeric with hyphens only');
+        }
+        // Check for reserved IDs
+        const reservedIds = ['default', 'minecraft', 'kustom', 'global'];
+        if (reservedIds.includes(config.manifest.id)) {
+            errors.push(`manifest.id cannot be a reserved name: ${reservedIds.join(', ')}`);
+        }
+    }
+    if (config.manifest?.version) {
+        // Basic semver validation
+        if (!/^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/.test(config.manifest.version)) {
+            errors.push('manifest.version must be valid semver (e.g., 1.0.0)');
+        }
+    }
+    if (config.manifest?.scope && !['global', 'world', 'player'].includes(config.manifest.scope)) {
+        errors.push('manifest.scope must be "global", "world", or "player"');
+    }
+    // Validate dependencies format
+    if (config.dependencies) {
+        for (const dep of config.dependencies) {
+            if (!/^[a-z0-9-]+@.+$/.test(dep)) {
+                errors.push(`Invalid dependency format: ${dep}. Expected: pack-id@version-range`);
+            }
+        }
+    }
+    // Validate server URL if provided
+    if (config.server?.url) {
+        try {
+            new URL(config.server.url);
+        }
+        catch {
+            errors.push(`Invalid server URL: ${config.server.url}`);
+        }
+    }
+    return errors;
+}
+/**
+ * Parse a namespaced ID string.
+ * Format: packId:type/name (e.g., "mypack:item/sword")
+ */
+export function parseNamespacedId(fullId) {
+    const match = fullId.match(/^([a-z0-9-]+):([a-z]+)\/(.+)$/);
+    if (!match)
+        return null;
+    return { packId: match[1], type: match[2], name: match[3] };
+}
+/**
+ * Check if a string is a fully qualified namespaced ID.
+ */
+export function isNamespacedId(id) {
+    return /^[a-z0-9-]+:[a-z]+\/.+$/.test(id);
+}
+/**
+ * Check if a string is a cross-pack import (packId:path format).
+ */
+export function isCrossPackImport(importPath) {
+    return /^[a-z0-9-]+:/.test(importPath) && !importPath.startsWith('./') && !importPath.startsWith('../');
+}
+/**
+ * Parse a cross-pack import path.
+ * Format: packId:scripts/path or packId:type/name
+ */
+export function parseCrossPackImport(importPath) {
+    const match = importPath.match(/^([a-z0-9-]+):(.+)$/);
+    if (!match)
+        return null;
+    return { packId: match[1], path: match[2] };
+}
+/**
+ * Create a fully qualified namespaced ID.
+ */
+export function createNamespacedId(packId, type, name) {
+    return `${packId}:${type}/${name}`;
+}