@auraindustry/aurajs 0.0.1

package/src/bundler.mjs

@@ -0,0 +1,698 @@
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+  readdirSync,
+  watch,
+} from 'node:fs';
+import { dirname, join, normalize, relative, resolve, sep } from 'node:path';
+
+export const BUNDLE_ERROR_CODES = {
+  MISSING_ENTRY: 'AURA_MOD_001',
+  MODULE_NOT_FOUND: 'AURA_MOD_002',
+  UNSUPPORTED_SPECIFIER: 'AURA_MOD_003',
+  PATH_ESCAPE: 'AURA_MOD_004',
+  SYNTAX_ERROR: 'AURA_MOD_005',
+  CIRCULAR_DEP: 'AURA_MOD_006',
+  DYNAMIC_IMPORT: 'AURA_MOD_007',
+};
+
+class BundleError extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = 'BundleError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+export function isBundleError(error) {
+  return error instanceof BundleError;
+}
+
+export function formatBundleError(error, projectRoot = process.cwd()) {
+  if (!isBundleError(error)) {
+    return String(error?.message || error || 'Unknown error');
+  }
+
+  const parts = [`${error.code}: ${error.message}`];
+  const details = error.details || {};
+
+  if (details.file) {
+    const rel = relPath(projectRoot, details.file);
+    if (details.line) {
+      parts.push(`at ${rel}:${details.line}`);
+    } else {
+      parts.push(`at ${rel}`);
+    }
+  }
+
+  if (details.importer || details.specifier) {
+    parts.push(
+      `import: ${details.specifier || '<unknown>'} (from ${
+        details.importer ? relPath(projectRoot, details.importer) : '<unknown>'
+      })`,
+    );
+  }
+
+  if (Array.isArray(details.candidates) && details.candidates.length > 0) {
+    parts.push('candidates:');
+    for (const candidate of details.candidates) {
+      parts.push(`  - ${candidate}`);
+    }
+  }
+
+  if (details.cycle) {
+    const rendered = details.cycle.map((entry) => relPath(projectRoot, entry)).join(' -> ');
+    parts.push(`cycle: ${rendered}`);
+  }
+
+  return parts.join('\n');
+}
+
+export function createIncrementalBundler(options = {}) {
+  const projectRoot = resolve(options.projectRoot || process.cwd());
+  const entryFile = options.entryFile || null;
+  const cache = {
+    files: new Map(),
+    watchers: [],
+    poller: null,
+    pollFingerprint: '',
+  };
+
+  return {
+    build(buildOptions = {}) {
+      return bundleProject({
+        projectRoot,
+        mode: buildOptions.mode || 'dev',
+        cache,
+        outFile: buildOptions.outFile,
+        entryFile: buildOptions.entryFile || entryFile || undefined,
+      });
+    },
+    watch(onChange, onError) {
+      return startSourceWatch(projectRoot, cache, onChange, onError);
+    },
+    dispose() {
+      stopSourceWatch(cache);
+    },
+  };
+}
+
+export function bundleProject(options = {}) {
+  const startedAt = Date.now();
+  const projectRoot = resolve(options.projectRoot || process.cwd());
+  const mode = options.mode || 'build';
+  const cache = options.cache || { files: new Map() };
+
+  const srcDir = resolve(projectRoot, 'src');
+  const entryFile = options.entryFile
+    ? resolve(projectRoot, options.entryFile)
+    : resolve(srcDir, 'main.js');
+
+  if (!existsSync(entryFile)) {
+    const display = options.entryFile ? options.entryFile : 'src/main.js';
+    throw new BundleError(
+      BUNDLE_ERROR_CODES.MISSING_ENTRY,
+      `Missing entrypoint ${display}.`,
+      { file: entryFile },
+    );
+  }
+
+  const entryRel = relative(srcDir, entryFile);
+  if (entryRel.startsWith('..')) {
+    throw new BundleError(
+      BUNDLE_ERROR_CODES.PATH_ESCAPE,
+      'Entrypoint must be inside src/.',
+      { file: entryFile },
+    );
+  }
+
+  const graph = buildModuleGraph({ srcDir, entryFile, cache });
+  const bundleText = emitBundle(graph);
+  const bundleHash = sha1(bundleText);
+
+  const defaultOut =
+    mode === 'dev'
+      ? resolve(projectRoot, '.aura/dev/game.bundle.js')
+      : mode === 'test'
+        ? resolve(projectRoot, '.aura/test/test.bundle.js')
+      : resolve(projectRoot, 'build/js/game.bundle.js');
+
+  const outFile = resolve(options.outFile || defaultOut);
+  mkdirSync(dirname(outFile), { recursive: true });
+  writeFileSync(outFile, bundleText, 'utf8');
+
+  return {
+    mode,
+    outFile,
+    moduleCount: graph.order.length,
+    entryId: graph.entryId,
+    hash: bundleHash,
+    elapsedMs: Date.now() - startedAt,
+    graph,
+  };
+}
+
+function buildModuleGraph(ctx) {
+  const state = new Map();
+  const modules = new Map();
+  const order = [];
+
+  visit(ctx.entryFile, []);
+
+  return {
+    srcDir: ctx.srcDir,
+    entryFile: ctx.entryFile,
+    entryId: moduleId(ctx.srcDir, ctx.entryFile),
+    modules,
+    order,
+  };
+
+  function visit(filePath, stack) {
+    const currentState = state.get(filePath) || 0;
+    if (currentState === 2) return;
+
+    if (currentState === 1) {
+      const cycleStart = stack.indexOf(filePath);
+      const cycle = cycleStart >= 0 ? [...stack.slice(cycleStart), filePath] : [...stack, filePath];
+      throw new BundleError(BUNDLE_ERROR_CODES.CIRCULAR_DEP, 'Circular dependency detected.', {
+        file: filePath,
+        cycle,
+      });
+    }
+
+    state.set(filePath, 1);
+
+    const parsed = readParsedModule(ctx, filePath);
+    const dependencies = [];
+
+    for (const entry of parsed.imports) {
+      const resolved = resolveSpecifier(ctx.srcDir, filePath, entry);
+      dependencies.push({ ...entry, resolved });
+      visit(resolved, [...stack, filePath]);
+    }
+
+    modules.set(filePath, {
+      id: moduleId(ctx.srcDir, filePath),
+      filePath,
+      code: parsed.code,
+      imports: dependencies,
+    });
+
+    state.set(filePath, 2);
+    order.push(filePath);
+  }
+}
+
+function emitBundle(graph) {
+  const lines = [];
+  lines.push('// AuraJS bundle v1');
+  lines.push('// Generated by AuraJS bundler (AS-043 semantics, AS-004 module rules)');
+  lines.push('(function(){');
+  lines.push('  const __auraModules = Object.create(null);');
+  lines.push('  const __auraCache = Object.create(null);');
+  lines.push('');
+
+  for (const filePath of graph.order) {
+    const moduleMeta = graph.modules.get(filePath);
+    const transformed = transformModule(moduleMeta, graph.srcDir);
+
+    lines.push(`  __auraModules[${JSON.stringify(moduleMeta.id)}] = function(__module, __exports, __require){`);
+    for (const line of transformed.split('\n')) {
+      lines.push(`    ${line}`);
+    }
+    lines.push('  };');
+    lines.push('');
+  }
+
+  lines.push('  function __require(id){');
+  lines.push('    if (__auraCache[id]) return __auraCache[id].exports;');
+  lines.push('    const factory = __auraModules[id];');
+  lines.push('    if (!factory) throw new Error(`AURA_RUNTIME_MISSING_MODULE: ${id}`);');
+  lines.push('    const module = { exports: Object.create(null) };');
+  lines.push('    __auraCache[id] = module;');
+  lines.push('    factory(module, module.exports, __require);');
+  lines.push('    return module.exports;');
+  lines.push('  }');
+  lines.push('');
+  lines.push(`  __require(${JSON.stringify(graph.entryId)});`);
+  lines.push('})();');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+function transformModule(moduleMeta, srcDir) {
+  const importByLine = new Map();
+  for (const item of moduleMeta.imports) {
+    importByLine.set(item.line, item);
+  }
+
+  const out = [];
+  const exportAssignments = [];
+  const sourceLines = moduleMeta.code.split(/\r?\n/);
+  let importCounter = 0;
+
+  for (let idx = 0; idx < sourceLines.length; idx += 1) {
+    const source = sourceLines[idx];
+    const lineNo = idx + 1;
+
+    if (importByLine.has(lineNo)) {
+      const item = importByLine.get(lineNo);
+      const depId = moduleId(srcDir, item.resolved);
+      const transformedImport = renderImportReplacement(item.clause, depId, importCounter);
+      importCounter += 1;
+      out.push(...transformedImport);
+      continue;
+    }
+
+    const transformedExport = transformExportLine(source, lineNo, moduleMeta.filePath, exportAssignments);
+    out.push(...transformedExport);
+  }
+
+  if (exportAssignments.length > 0) {
+    out.push('');
+    out.push('// exports');
+    for (const line of exportAssignments) {
+      out.push(line);
+    }
+  }
+
+  return out.join('\n');
+}
+
+function transformExportLine(sourceLine, lineNo, filePath, exportAssignments) {
+  const trimmed = sourceLine.trim();
+  if (!trimmed.startsWith('export ')) {
+    return [sourceLine];
+  }
+
+  const leading = sourceLine.slice(0, sourceLine.indexOf('export'));
+
+  const defaultExpr = trimmed.match(/^export\s+default\s+(.+);?$/);
+  if (defaultExpr) {
+    return [`${leading}__exports.default = ${defaultExpr[1]};`];
+  }
+
+  const varExport = trimmed.match(/^export\s+(const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\b(.*)$/);
+  if (varExport) {
+    const declaration = `${leading}${varExport[1]} ${varExport[2]}${varExport[3]}`;
+    exportAssignments.push(`${leading}__exports.${varExport[2]} = ${varExport[2]};`);
+    return [declaration];
+  }
+
+  const fnExport = trimmed.match(/^export\s+function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/);
+  if (fnExport) {
+    const rewritten = sourceLine.replace('export ', '');
+    exportAssignments.push(`${leading}__exports.${fnExport[1]} = ${fnExport[1]};`);
+    return [rewritten];
+  }
+
+  const classExport = trimmed.match(/^export\s+class\s+([A-Za-z_$][A-Za-z0-9_$]*)\b/);
+  if (classExport) {
+    const rewritten = sourceLine.replace('export ', '');
+    exportAssignments.push(`${leading}__exports.${classExport[1]} = ${classExport[1]};`);
+    return [rewritten];
+  }
+
+  const namedExport = trimmed.match(/^export\s*\{([^}]+)\}\s*;?$/);
+  if (namedExport) {
+    const specifiers = namedExport[1]
+      .split(',')
+      .map((entry) => entry.trim())
+      .filter(Boolean);
+
+    const emitted = [];
+    for (const spec of specifiers) {
+      const alias = spec.match(/^([A-Za-z_$][A-Za-z0-9_$]*)\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)$/);
+      if (alias) {
+        emitted.push(`${leading}__exports.${alias[2]} = ${alias[1]};`);
+      } else {
+        emitted.push(`${leading}__exports.${spec} = ${spec};`);
+      }
+    }
+    return emitted;
+  }
+
+  if (trimmed.startsWith('export *')) {
+    throw new BundleError(
+      BUNDLE_ERROR_CODES.SYNTAX_ERROR,
+      'Unsupported export syntax. export * forms are not supported in v1.',
+      { file: filePath, line: lineNo },
+    );
+  }
+
+  throw new BundleError(
+    BUNDLE_ERROR_CODES.SYNTAX_ERROR,
+    'Unsupported export syntax. Use named exports or export default expressions.',
+    { file: filePath, line: lineNo },
+  );
+}
+
+function renderImportReplacement(clause, depId, importCounter) {
+  if (!clause) {
+    return [`__require(${JSON.stringify(depId)});`];
+  }
+
+  const normalized = clause.trim();
+  if (!normalized) {
+    return [`__require(${JSON.stringify(depId)});`];
+  }
+
+  if (normalized.startsWith('{')) {
+    return [
+      `const ${rewriteNamedImports(normalized)} = __require(${JSON.stringify(depId)});`,
+    ];
+  }
+
+  if (normalized.startsWith('* as ')) {
+    const ns = normalized.slice(5).trim();
+    return [`const ${ns} = __require(${JSON.stringify(depId)});`];
+  }
+
+  if (normalized.includes(',')) {
+    const [head, tail] = normalized.split(',', 2);
+    const defaultName = head.trim();
+    const rest = tail.trim();
+    const tmp = `__import_${importCounter}`;
+    const lines = [`const ${tmp} = __require(${JSON.stringify(depId)});`];
+
+    if (defaultName) {
+      lines.push(`const { default: ${defaultName} } = ${tmp};`);
+    }
+
+    if (rest.startsWith('{')) {
+      lines.push(`const ${rewriteNamedImports(rest)} = ${tmp};`);
+    } else if (rest.startsWith('* as ')) {
+      lines.push(`const ${rest.slice(5).trim()} = ${tmp};`);
+    } else {
+      throw new BundleError(
+        BUNDLE_ERROR_CODES.SYNTAX_ERROR,
+        'Unsupported mixed import syntax.',
+        {},
+      );
+    }
+
+    return lines;
+  }
+
+  return [`const { default: ${normalized} } = __require(${JSON.stringify(depId)});`];
+}
+
+function rewriteNamedImports(namedClause) {
+  const inner = namedClause.trim().replace(/^\{/, '').replace(/\}$/, '');
+  const specifiers = inner
+    .split(',')
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .map((part) => {
+      const alias = part.match(/^([A-Za-z_$][A-Za-z0-9_$]*)\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)$/);
+      if (alias) {
+        return `${alias[1]}: ${alias[2]}`;
+      }
+      return part;
+    });
+
+  return `{ ${specifiers.join(', ')} }`;
+}
+
+function readParsedModule(ctx, filePath) {
+  const content = readFileSync(filePath, 'utf8');
+  const hash = sha1(content);
+  const cached = ctx.cache.files.get(filePath);
+
+  if (cached && cached.hash === hash) {
+    return cached;
+  }
+
+  validateSyntax(content, filePath);
+
+  const imports = scanImports(content, filePath);
+  const parsed = { hash, code: content, imports };
+  ctx.cache.files.set(filePath, parsed);
+  return parsed;
+}
+
+function scanImports(code, filePath) {
+  if (hasDynamicImport(code)) {
+    const info = locateToken(code, 'import(');
+    throw new BundleError(
+      BUNDLE_ERROR_CODES.DYNAMIC_IMPORT,
+      'Dynamic import() is not supported in AuraJS v1.',
+      {
+        file: filePath,
+        line: info.line,
+        column: info.column,
+      },
+    );
+  }
+
+  const imports = [];
+  const lines = code.split(/\r?\n/);
+
+  for (let idx = 0; idx < lines.length; idx += 1) {
+    const line = lines[idx];
+    const trimmed = line.trim();
+
+    if (!trimmed.startsWith('import ')) {
+      continue;
+    }
+
+    const lineNo = idx + 1;
+    const sideEffect = trimmed.match(/^import\s+['"]([^'"\n]+)['"]\s*;?$/);
+    if (sideEffect) {
+      imports.push({
+        line: lineNo,
+        column: line.indexOf('import') + 1,
+        clause: null,
+        specifier: sideEffect[1],
+      });
+      continue;
+    }
+
+    const fromImport = trimmed.match(/^import\s+(.+)\s+from\s+['"]([^'"\n]+)['"]\s*;?$/);
+    if (fromImport) {
+      imports.push({
+        line: lineNo,
+        column: line.indexOf('import') + 1,
+        clause: fromImport[1].trim(),
+        specifier: fromImport[2],
+      });
+      continue;
+    }
+
+    throw new BundleError(
+      BUNDLE_ERROR_CODES.SYNTAX_ERROR,
+      'Unsupported import syntax. Use single-line static imports.',
+      { file: filePath, line: lineNo },
+    );
+  }
+
+  return imports;
+}
+
+function resolveSpecifier(srcDir, importer, importEntry) {
+  const specifier = importEntry.specifier;
+
+  if (!(specifier.startsWith('./') || specifier.startsWith('../'))) {
+    throw new BundleError(
+      BUNDLE_ERROR_CODES.UNSUPPORTED_SPECIFIER,
+      `Unsupported module specifier "${specifier}". Use relative imports only.`,
+      {
+        file: importer,
+        importer,
+        specifier,
+        line: importEntry.line,
+      },
+    );
+  }
+
+  const base = resolve(dirname(importer), specifier);
+  const candidates = [
+    normalize(base),
+    normalize(`${base}.js`),
+    normalize(`${base}.mjs`),
+    normalize(join(base, 'index.js')),
+    normalize(join(base, 'index.mjs')),
+  ];
+
+  for (const candidate of candidates) {
+    ensureWithinSource(srcDir, candidate, importer, importEntry);
+    if (existsSync(candidate) && statSync(candidate).isFile()) {
+      return candidate;
+    }
+  }
+
+  throw new BundleError(
+    BUNDLE_ERROR_CODES.MODULE_NOT_FOUND,
+    `Module not found for specifier "${specifier}".`,
+    {
+      file: importer,
+      importer,
+      specifier,
+      line: importEntry.line,
+      candidates: candidates.map((item) => relPath(srcDir, item)),
+    },
+  );
+}
+
+function ensureWithinSource(srcDir, candidate, importer, importEntry) {
+  const rel = relative(srcDir, candidate);
+  if (rel.startsWith('..') || rel === '' && candidate !== srcDir) {
+    if (rel.startsWith('..')) {
+      throw new BundleError(
+        BUNDLE_ERROR_CODES.PATH_ESCAPE,
+        `Import "${importEntry.specifier}" escapes the src/ directory boundary.`,
+        {
+          file: importer,
+          importer,
+          specifier: importEntry.specifier,
+          line: importEntry.line,
+        },
+      );
+    }
+  }
+}
+
+function moduleId(srcDir, filePath) {
+  const rel = relative(srcDir, filePath);
+  return rel.split(sep).join('/');
+}
+
+function validateSyntax(code, filePath) {
+  const check = spawnSync(process.execPath, ['--check', '--input-type=module'], {
+    input: code,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024,
+  });
+
+  if (check.status === 0) {
+    return;
+  }
+
+  const stderr = String(check.stderr || '').trim();
+  const lineMatch = stderr.match(/\[stdin\]:(\d+)/);
+  const line = lineMatch ? Number(lineMatch[1]) : undefined;
+
+  const summary = stderr
+    .split('\n')
+    .map((lineText) => lineText.trim())
+    .filter(Boolean)
+    .find((lineText) => lineText.startsWith('SyntaxError:'));
+
+  throw new BundleError(BUNDLE_ERROR_CODES.SYNTAX_ERROR, summary || 'Syntax error in module.', {
+    file: filePath,
+    line,
+  });
+}
+
+function hasDynamicImport(code) {
+  return /(^|[^\w$.])import\s*\(/m.test(code);
+}
+
+function locateToken(code, token) {
+  const index = code.indexOf(token);
+  if (index < 0) {
+    return { line: undefined, column: undefined };
+  }
+  return lineColumnFromIndex(code, index);
+}
+
+function lineColumnFromIndex(code, index) {
+  const slice = code.slice(0, index);
+  const lines = slice.split(/\r?\n/);
+  const line = lines.length;
+  const column = lines[lines.length - 1].length + 1;
+  return { line, column };
+}
+
+function sha1(value) {
+  return createHash('sha1').update(value).digest('hex');
+}
+
+function relPath(from, to) {
+  const rel = relative(from, to);
+  return rel.split(sep).join('/');
+}
+
+function stopSourceWatch(cache) {
+  for (const watcher of cache.watchers) {
+    watcher.close();
+  }
+  cache.watchers = [];
+  if (cache.poller) {
+    clearInterval(cache.poller);
+    cache.poller = null;
+  }
+}
+
+function startSourceWatch(projectRoot, cache, onChange, onError) {
+  stopSourceWatch(cache);
+
+  const srcDir = resolve(projectRoot, 'src');
+  let closed = false;
+
+  if (!existsSync(srcDir)) {
+    throw new BundleError(BUNDLE_ERROR_CODES.MISSING_ENTRY, 'Missing src/ directory for dev watch.', {
+      file: srcDir,
+    });
+  }
+
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    stopSourceWatch(cache);
+  };
+
+  try {
+    const watcher = watch(srcDir, { recursive: true }, (_eventType, filename) => {
+      if (!filename) return;
+      if (!String(filename).endsWith('.js') && !String(filename).endsWith('.mjs')) return;
+      onChange(filename);
+    });
+    cache.watchers.push(watcher);
+    return close;
+  } catch (_err) {
+    // Fallback for platforms that do not support recursive fs.watch.
+    cache.pollFingerprint = fingerprintSourceTree(srcDir);
+    cache.poller = setInterval(() => {
+      try {
+        const next = fingerprintSourceTree(srcDir);
+        if (next !== cache.pollFingerprint) {
+          cache.pollFingerprint = next;
+          onChange('poll');
+        }
+      } catch (pollError) {
+        onError(pollError);
+      }
+    }, 250);
+    return close;
+  }
+}
+
+function fingerprintSourceTree(rootDir) {
+  const files = [];
+  walk(rootDir, files);
+  files.sort();
+  return sha1(files.join('\n'));
+}
+
+function walk(dir, output) {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const stat = statSync(full);
+    if (stat.isDirectory()) {
+      walk(full, output);
+      continue;
+    }
+    if (!(entry.endsWith('.js') || entry.endsWith('.mjs'))) {
+      continue;
+    }
+    output.push(`${full}:${stat.mtimeMs}:${stat.size}`);
+  }
+}