@marsx-dev/launcher 0.0.1 → 0.0.4

package/src/cli/index.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { initProject } from './init';
+import { migrateV3ToV4 } from './migrate';
+import { start } from './start';
+
+export class CliError extends Error {}
+
+async function main() {
+  try {
+    const program = new Command();
+
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const version = require('../../package.json').version;
+    program.name('marsx').description('CLI for MarsX launcher').version(version);
+
+    program.command('start', { isDefault: true }).description('Start MarsX server').action(start);
+    program
+      .command('init <project_name>')
+      .description('Initialize a new MarsX project named <project_name> in a directory of the same name')
+      .action(initProject);
+    program.command('migrate').description('Migrate MarsX V3 project to V4').action(migrateV3ToV4);
+
+    await program.parseAsync();
+  } catch (e) {
+    if (e instanceof CliError) {
+      console.error(chalk.red(e.message));
+    } else {
+      console.error(chalk.red(e));
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/src/cli/init.ts

@@ -0,0 +1,141 @@
+import chalk from 'chalk';
+import { spawnSync } from 'child_process';
+import { randomBytes } from 'crypto';
+import path from 'path';
+import { Configuration } from '../configuration';
+import { assert, isDirectory, writeFileMakeDir } from '../utils/utils';
+import { CliError } from './index';
+
+const FASTIFY_DEPS = [
+  '@fastify/session',
+  'fastify',
+  'fastify-accepts',
+  'fastify-compress',
+  'fastify-cookie',
+  'fastify-cors',
+  'fastify-csrf',
+  'fastify-flash',
+  'fastify-formbody',
+  'fastify-helmet',
+  'fastify-multipart',
+  'fastify-request-context',
+  'fastify-static',
+  'fastify-websocket',
+];
+
+const COMMON_DEPS = [
+  '@marsx-dev/launcher',
+  'aws-sdk',
+  'axios',
+  'azure-storage',
+  'base-x',
+  'bcrypt',
+  'chokidar',
+  'lodash',
+  'mongodb4@npm:mongodb@4',
+  'mongodb3@npm:mongodb@3',
+  'typescript',
+  'uuid',
+  'xxhash',
+];
+
+const V3_DEPS = [
+  'babel-core',
+  'babel-plugin-transform-react-jsx',
+  'config',
+  'crypto-js',
+  'jsonwebtoken',
+  'mobile-detect',
+  'moment-timezone',
+  'route-pattern',
+  'route-sort',
+];
+
+const DEFAULT_DEPS = [...FASTIFY_DEPS, ...COMMON_DEPS, ...V3_DEPS];
+
+const DEMO_BOOTER = `<json id='metadata'>
+{"version": 4, "restartOnChange": true}
+</json>
+
+
+<script id='BlockFunction' lang='tsx'>
+export default async () => {
+    console.log('MarsX loaded!')
+};
+</script>`;
+
+export async function initProject(projectName: string) {
+  if (!projectName.match(/^\w+$/) || projectName !== projectName.toLowerCase()) {
+    throw new CliError(
+      `Project name "${projectName}" may contain only lower case alphanumeric characters and underscores (eg. my_project_name)`,
+    );
+  }
+
+  const projectDir = path.resolve(projectName);
+
+  if (await isDirectory(projectDir)) {
+    throw new CliError(`Project dir "${projectName}" already exist. Delete it or choose a different name.`);
+  }
+
+  console.log(`Creating a new MarsX project in ${chalk.green(projectDir)}`);
+
+  const packageJson = {
+    name: projectName,
+    version: '0.0.0',
+    private: true,
+    scripts: {
+      start: 'marsx start',
+    },
+    dependencies: {},
+  };
+  const packageJsonStr = JSON.stringify(packageJson, null, 2);
+  await writeFileMakeDir(path.join(projectDir, 'package.json'), packageJsonStr);
+
+  const config: Configuration = {
+    production: false,
+    port: 3000,
+    blocksDir: 'blocks',
+    cacheDir: '.cache',
+    mongoConn: '<CONN_STR>',
+    mongoDbName: projectName,
+    azureStorageConnection: '<CONN_STR>',
+    azureStorageAccountName: projectName,
+    azureStorageUrl: `https://${projectName}.blob.core.windows.net`,
+    webFilesTable: 'webFiles',
+    webRecentFilesTable: 'webRecentFiles',
+    webFilesBlob: 'web-files',
+    secret: (await randomBytes(48)).toString('hex'),
+    importProjects: [
+      {
+        name: 'mars-ide',
+        url: 'https://ide.marscloud.dev',
+        api_key: '<API_KEY>',
+        git_commit_ish: 'main',
+      },
+    ],
+  };
+
+  await writeFileMakeDir(path.join(projectDir, 'config', 'default.json'), JSON.stringify(config, null, 2));
+  await writeFileMakeDir(path.join(projectDir, '.gitignore'), 'node_modules\ndist\n.cache\n');
+
+  await writeFileMakeDir(path.join(projectDir, 'blocks', 'Booter.service.vue'), DEMO_BOOTER);
+
+  function run(...args: string[]) {
+    const cmd = args[0];
+    assert(cmd);
+    spawnSync(cmd, args.slice(1), { cwd: projectDir, stdio: 'inherit' });
+  }
+  console.log('Installing dependencies. This might take a couple of minutes.');
+  run('npm', 'i', ...DEFAULT_DEPS);
+
+  run('git', 'init');
+  run('git', 'add', '.gitignore');
+  run('git', 'add', '-A');
+  run('git', 'commit', '-m', 'Initial commit');
+  console.log('Initialized git repository and created initial commit.');
+
+  console.log(chalk.yellow(`\nMake sure to update parameters in config/default.json`));
+
+  console.log(`${chalk.green('Success!')} Created ${projectName} at ${projectDir}`);
+  console.log(chalk.dim(`\nInside that directory, you can start MarsX with\n\n    cd ${projectName}\n    npm run start\n`));
+}

package/src/cli/migrate.ts

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { MongoClient } from 'mongodb';
+import path from 'path';
+import { config } from '../configuration';
+import { serializeSfc } from '../utils/sfc';
+import { writeFileMakeDir } from '../utils/utils';
+import { convertV3ToSfc, V3MongoBlock } from '../utils/v3';
+
+export async function migrateV3ToV4() {
+  console.log('Connecting to MongoDB...');
+  const mongoConn = await new MongoClient(config.mongoConn).connect();
+  const db = mongoConn.db(config.mongoDbName);
+  const allBlocks = await db.collection<V3MongoBlock>('blocks').find().toArray();
+  console.log(`Downloaded ${allBlocks.length} block(s)`);
+
+  for (const block of allBlocks) {
+    const serialized = serializeSfc(convertV3ToSfc(block));
+    await writeFileMakeDir(path.join(config.blocksDir, serialized.filePath), serialized.content);
+    console.log(`Saved ${serialized.filePath}`);
+  }
+
+  console.log(chalk.green('\nMigration complete successfully!'));
+}

package/src/cli/start.ts

@@ -0,0 +1,34 @@
+import child_process from 'child_process';
+import { config } from '../configuration';
+import { launchBooter } from '../launcher';
+import { assert } from '../utils/utils';
+
+export const RESTART_EXIT_CODe = 9;
+
+export const start = async () => {
+  if (config.production || process.env['MARSX_NO_SPAWN']) {
+    console.log(`MarsX process ${process.pid} starting...`);
+    await launchBooter();
+    console.log(`MarsX process ${process.pid} started`);
+  } else {
+    const spawnChildProc = () => {
+      assert(process.argv[0]);
+      const child = child_process.spawn(process.argv[0], ['--inspect', '--enable-source-maps', ...process.argv.slice(1)], {
+        cwd: process.cwd(),
+        env: { ...process.env, MARSX_NO_SPAWN: 'true' },
+        stdio: 'inherit',
+      });
+
+      child.on('close', (code: number) => {
+        console.log(`MarsX process ${child.pid} terminated with ${code}`);
+        if (code === RESTART_EXIT_CODe) {
+          setTimeout(spawnChildProc, 100);
+        } else {
+          process.exit(code);
+        }
+      });
+    };
+
+    spawnChildProc();
+  }
+};

package/src/configuration.ts

@@ -0,0 +1,53 @@
+process.env['SUPPRESS_NO_CONFIG_WARNING'] = 'true';
+import configModule from 'config';
+import path from 'path';
+import { assert } from './utils/utils';
+
+export interface ImportProjectConfig {
+  name: string;
+  url: string;
+  api_key: string;
+  git_commit_ish?: string | undefined;
+}
+
+const ensureType =
+  <T>(typeName: string) =>
+  (configName: string): T => {
+    const value = configModule.get(configName);
+    assert(typeof value === typeName);
+    return value as T;
+  };
+
+const ensureString = ensureType<string>('string');
+const ensureBoolean = ensureType<boolean>('boolean');
+const ensureNumber = ensureType<number>('number');
+
+function validatedConfig() {
+  if (configModule.util.getConfigSources().length === 0) {
+    return new Proxy({} as never, {
+      get() {
+        throw new Error('Config file not found, ensure you have "config/default.json" file.');
+      },
+    });
+  }
+
+  return {
+    production: ensureBoolean('production'),
+    port: ensureNumber('port'),
+    blocksDir: path.resolve(ensureString('blocksDir')),
+    cacheDir: path.resolve(ensureString('cacheDir')),
+    mongoConn: ensureString('mongoConn'),
+    mongoDbName: ensureString('mongoDbName'),
+    azureStorageConnection: ensureString('azureStorageConnection'),
+    azureStorageAccountName: ensureString('azureStorageAccountName'),
+    azureStorageUrl: ensureString('azureStorageUrl'),
+    secret: ensureString('secret'),
+    webFilesTable: ensureString('webFilesTable'),
+    webRecentFilesTable: ensureString('webRecentFilesTable'),
+    webFilesBlob: ensureString('webFilesBlob'),
+    importProjects: configModule.get<ImportProjectConfig[]>('importProjects'),
+  };
+}
+
+export const config = validatedConfig();
+export type Configuration = typeof config;

package/src/index.ts

@@ -0,0 +1,5 @@
+export { config, ImportProjectConfig, Configuration } from './configuration';
+export { compileSfcSource, transpileTypescript } from './utils/compile';
+export { parseSFC, serializeSfc, SfcBlock, SfcIdentity, SfcSource, parseSfcIdentity, serializeSfcIdentity } from './utils/sfc';
+export * as utils from './utils/utils';
+export { convertSfcToV3, convertV3ToSfc, V3MongoBlock } from './utils/v3';

package/src/launcher.ts

@@ -0,0 +1,38 @@
+import { config } from './configuration';
+import { loadAllBlocks } from './loader';
+import { compileSfcSource, transpileTypescript } from './utils/compile';
+import { parseSFC, serializeSfc } from './utils/sfc';
+import { assert, writeFileMakeDir } from './utils/utils';
+import { convertSfcToV3, convertV3ToSfc } from './utils/v3';
+
+const LAUNCHER_UTILS = {
+  config,
+  parseSFC,
+  serializeSfc,
+  convertV3ToSfc,
+  convertSfcToV3,
+  transpileTypescript,
+  compileSfcSource,
+  writeFileMakeDir,
+};
+
+export async function launchBooter(booterBlockName = 'Booter') {
+  const allBlocks = await loadAllBlocks();
+
+  const booterBlocks = allBlocks.filter(b => b.identity.name === booterBlockName);
+  if (booterBlocks.length === 0)
+    throw new Error(`Booter block ${booterBlockName} not found. Ensure you have it locally or it is imported.`);
+
+  // Take last because order of imports matter and local blocks always override imported.
+  const booterBlock = booterBlocks[booterBlocks.length - 1];
+  assert(booterBlock);
+
+  const compiledBooterPath = await compileSfcSource(booterBlock, 'BlockFunction');
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    await require(compiledBooterPath).default(allBlocks, LAUNCHER_UTILS);
+  } catch (e) {
+    console.error('Booter failed with:', e);
+    process.exit(1);
+  }
+}

package/src/loader.ts

@@ -0,0 +1,65 @@
+import axios from 'axios';
+import crypto from 'crypto';
+import { promises as fs } from 'fs';
+import stringify from 'json-stable-stringify';
+import _ from 'lodash';
+import path from 'path';
+import { config, ImportProjectConfig } from './configuration';
+import { parseSFC, SfcBlock } from './utils/sfc';
+import { isFile, listFilesRecursive, writeFileMakeDir } from './utils/utils';
+import { convertV3ToSfc, V3MongoBlock } from './utils/v3';
+
+async function downloadFromExternal(externalImport: ImportProjectConfig): Promise<SfcBlock[]> {
+  const params = { api_key: externalImport.api_key, git_commit_ish: externalImport.git_commit_ish || '' };
+
+  console.log(`Downloading blocks from ${externalImport.url}`);
+  try {
+    const v4Resp = await axios.get<SfcBlock[]>(`${externalImport.url}/api/GetExportedAppBlocksV4`, { params });
+    return v4Resp.data;
+  } catch (e) {
+    console.log(`${externalImport.url} does not support V4, fallback to V3`);
+  }
+
+  const v3Resp = await axios.get<V3MongoBlock[]>(`${externalImport.url}/api/GetExportedAppBlocks`, { params });
+  return v3Resp.data.map(b => convertV3ToSfc(b));
+}
+
+async function loadCachedOrDownload(externalImport: ImportProjectConfig): Promise<SfcBlock[]> {
+  const hash = crypto.createHash('md5').update(stringify(externalImport)).digest('hex');
+  const cacheFileName = `${externalImport.name}_${externalImport.git_commit_ish}_${hash}.json`.replace(/[^\w.]+/g, '_');
+  const cacheFilePath = path.join(config.cacheDir, 'imports', cacheFileName);
+
+  if (await isFile(cacheFilePath)) {
+    const content = await fs.readFile(cacheFilePath);
+    console.log(`Loading cached blocks from ${externalImport.url}`);
+    return JSON.parse(content.toString('utf-8'));
+  }
+
+  const data = await downloadFromExternal(externalImport);
+  console.log(`Downloaded ${data.length} blocks from ${externalImport.url}`);
+
+  await writeFileMakeDir(cacheFilePath, JSON.stringify(data, null, 2), 'utf-8');
+  return data;
+}
+
+async function downloadAll(externalImports: ImportProjectConfig[]) {
+  const responses = await Promise.all(externalImports.map(loadCachedOrDownload));
+  return _.flatten(responses);
+}
+
+async function readBlockFile(blocksDir: string, filePath: string): Promise<SfcBlock> {
+  const content = await fs.readFile(filePath);
+  const relPath = path.relative(blocksDir, filePath);
+  return parseSFC(relPath, content);
+}
+
+async function readBlockFiles(blocksDir: string) {
+  const files = await listFilesRecursive(blocksDir);
+  return await Promise.all(files.filter(f => !path.basename(f).startsWith('.')).map(f => readBlockFile(blocksDir, f)));
+}
+
+export async function loadAllBlocks(): Promise<SfcBlock[]> {
+  const externalBlocks = await downloadAll(config.importProjects);
+  const localBlocks = await readBlockFiles(config.blocksDir);
+  return [...externalBlocks, ...localBlocks];
+}

package/src/utils/compile.ts

@@ -0,0 +1,58 @@
+import { SourceMapPayload } from 'module';
+import path from 'path';
+import ts from 'typescript';
+import { config } from '../configuration';
+import { SfcBlock } from './sfc';
+import { assert, writeFileMakeDir } from './utils';
+
+function genSourceMapComment(sourceMap: SourceMapPayload): string {
+  return `\n//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(sourceMap)).toString('base64')}`;
+}
+
+export function transpileTypescript(
+  sourceCode: string,
+  options?: {
+    sourceRoot?: string;
+    originalFilePath?: string;
+    compiledFilePath?: string;
+    lineOffset?: number | undefined;
+  },
+): string {
+  const compiledFilePath = options?.compiledFilePath || '<UNKNOWN>.js';
+  const originalFilePath = options?.originalFilePath || '<UNKNOWN>.ts';
+
+  if (options?.lineOffset) {
+    sourceCode = '\n'.repeat(options.lineOffset) + sourceCode;
+  }
+
+  const transpiled = ts.transpileModule(sourceCode, {
+    compilerOptions: {
+      module: ts.ModuleKind.CommonJS,
+      target: ts.ScriptTarget.Latest,
+      esModuleInterop: true,
+      sourceMap: true,
+      // inlineSources: true,
+      // inlineSourceMap: true,
+    },
+  });
+  assert(transpiled.sourceMapText);
+
+  const sourceMap: SourceMapPayload = JSON.parse(transpiled.sourceMapText);
+  sourceMap.sourceRoot = options?.sourceRoot || '';
+  sourceMap.file = compiledFilePath;
+  sourceMap.sources = [originalFilePath];
+  const sourceMapComment = genSourceMapComment(sourceMap);
+  return transpiled.outputText.replace(/\n\/\/# sourceMappingURL=.+/, '') + sourceMapComment;
+}
+
+export async function compileSfcSource(sfcBlock: SfcBlock, sourceId: string): Promise<string> {
+  const sourceCode = sfcBlock.sources[sourceId];
+  if (!sourceCode) throw new Error(`Source code block ${sourceId} not found in ${sfcBlock.identity.filePath}`);
+
+  const compiledFilePath = path.join(config.cacheDir, 'compiled', `${sfcBlock.identity.filePath}.${sourceId}.js`);
+  const originalFilePath = path.join(config.blocksDir, sfcBlock.identity.filePath);
+  const code = transpileTypescript(sourceCode.source, { compiledFilePath, originalFilePath, lineOffset: sourceCode.lineOffset });
+
+  await writeFileMakeDir(compiledFilePath, code, 'utf-8');
+  return compiledFilePath;
+}

package/src/utils/sfc.ts

@@ -0,0 +1,178 @@
+import { CompilerError, TextModes } from '@vue/compiler-core';
+import * as CompilerDOM from '@vue/compiler-dom';
+import { NodeTypes } from '@vue/compiler-dom';
+import stringify from 'json-stable-stringify';
+import JSON5 from 'json5';
+import _ from 'lodash';
+import path from 'path';
+import prettier, { Options } from 'prettier';
+import { escapeCloseTag, escapeHtmlAttr, unescapeCloseTag } from './utils';
+
+export const METADATA = 'metadata';
+export const SFC_EXT = 'vue';
+const SAVE_EMPTY_SOURCES = true;
+
+export type SfcIdentity = {
+  folder: string;
+  name: string;
+  blockTypeName: string;
+  ext: string;
+  // Derived
+  fullName: string;
+  filePath: string;
+};
+
+export function parseSfcIdentity(filePath: string): SfcIdentity {
+  // Blog/BlogPost.page.vue => {id: "BlogPost.page", folder:"Blog", name: "BlogPost", blockTypeName: "page", ext: "vue", fullName: "Blog.BlogPost"}
+  const originalParsed = path.parse(filePath);
+  const withoutExt = originalParsed.name;
+  const ext = originalParsed.ext.slice(1);
+
+  const parsed = path.parse(withoutExt);
+  if (!parsed.name || !parsed.ext) throw new Error(`Invalid block file path: ${filePath}`);
+  const blockTypeName = parsed.ext.slice(1);
+
+  const namespace = originalParsed.dir.replace(/\//g, '.');
+  const fullName = namespace.length > 0 ? `${namespace}.${parsed.name}` : parsed.name;
+  return {
+    folder: originalParsed.dir,
+    name: parsed.name,
+    blockTypeName,
+    ext,
+    fullName,
+    filePath,
+  };
+}
+
+export function serializeSfcIdentity(identity: SfcIdentity): string {
+  return path.join(identity.folder, `${identity.name}.${identity.blockTypeName}.${identity.ext}`);
+}
+
+type EmptyObject = {
+  [K in string]: never;
+};
+
+const LANG_TAG_MAP = {
+  html: 'html',
+  pug: 'template',
+  js: 'script',
+  jsx: 'script',
+  ts: 'script',
+  tsx: 'script',
+  css: 'style',
+  scss: 'style',
+  less: 'style',
+  sass: 'style',
+  stylus: 'style',
+  text: 'text',
+};
+
+export type SfcSource = { source: string; lang: keyof typeof LANG_TAG_MAP | string | undefined; lineOffset?: number };
+
+export type SfcBlock = { identity: SfcIdentity } & (
+  | { metadata: Record<string, unknown>; jsons: Record<string, unknown>; sources: Record<string, SfcSource>; rawContent: null }
+  | { metadata: EmptyObject; jsons: EmptyObject; sources: EmptyObject; rawContent: Buffer }
+);
+
+function getNodeAttr(node: CompilerDOM.ElementNode, attr: string) {
+  return node.props.map(p => (p.name == attr && p.type === NodeTypes.ATTRIBUTE ? p.value?.content : undefined)).find(p => !!p);
+}
+
+export function parseSFC(filePath: string, content: Buffer): SfcBlock {
+  const identity = parseSfcIdentity(filePath);
+  if (identity.ext !== SFC_EXT) {
+    return { identity, metadata: {}, jsons: {}, sources: {}, rawContent: content };
+  }
+
+  const errors: (CompilerError | SyntaxError)[] = [];
+
+  const ast = CompilerDOM.parse(content.toString('utf-8'), {
+    // there are no components at SFC parsing level
+    isNativeTag: () => true,
+    // preserve all whitespaces
+    isPreTag: () => true,
+    getTextMode: () => TextModes.RAWTEXT,
+    onError: e => errors.push(e),
+  });
+
+  const block: SfcBlock = {
+    identity: parseSfcIdentity(filePath),
+    metadata: {},
+    jsons: {},
+    sources: {},
+    rawContent: null,
+  };
+  const seenIds = new Set<string>();
+
+  ast.children.forEach(node => {
+    if (node.type === NodeTypes.ELEMENT) {
+      const child = node.children.length === 1 ? node.children[0] : null;
+      const content = child && child.type === NodeTypes.TEXT ? child.content : null;
+
+      if (content) {
+        const sectionId = getNodeAttr(node, 'id');
+
+        if (!sectionId) {
+          errors.push({ name: `missing-id`, message: `Id property is missing`, code: 0, loc: node.loc });
+          return;
+        }
+        if (seenIds.has(sectionId)) {
+          errors.push({ name: `duplicate-id`, message: `Duplicate section id: ${sectionId}`, code: 0, loc: node.loc });
+          return;
+        }
+        seenIds.add(sectionId);
+
+        if (node.tag === 'json') {
+          try {
+            const jsonData = JSON5.parse(content);
+            if (sectionId === METADATA) {
+              block.metadata = jsonData;
+            } else {
+              block.jsons[sectionId] = jsonData;
+            }
+          } catch (e) {
+            errors.push({ name: 'invalid-json', message: `${e}`, code: 0, loc: node.loc });
+          }
+        } else {
+          const source = unescapeCloseTag(content.slice(1, -1), node.tag);
+          const lang = getNodeAttr(node, 'lang');
+          const lineOffset = node.loc.start.line;
+          block.sources[sectionId] = { source, lang, lineOffset };
+        }
+      }
+    }
+  });
+
+  if (errors.length) {
+    throw new Error(`Parsing SFC ${filePath} failed with ${JSON.stringify(errors)}`);
+  }
+
+  return block;
+}
+
+const PRETTIER_JSON_CONFIG: Options = { parser: 'json5', printWidth: 120, trailingComma: 'all' };
+
+export function serializeSfc(block: SfcBlock): { filePath: string; content: Buffer } {
+  const filePath = serializeSfcIdentity(block.identity);
+  if (block.identity.ext !== SFC_EXT) {
+    if (block.rawContent === null) throw new Error(`SfcBlock must have rawContent if ext!="${SFC_EXT}"`);
+    return { filePath, content: block.rawContent };
+  }
+
+  if (block.rawContent !== null) throw new Error(`SfcBlock cannot have rawContent if ext=="${SFC_EXT}"`);
+
+  let content = '';
+
+  for (const [name, source] of [[METADATA, block.metadata] as const, ..._.sortBy(Object.entries(block.jsons), e => e[0])]) {
+    const jsonStr = prettier.format('(' + stringify(source) + ')', PRETTIER_JSON_CONFIG);
+    content += `<json id="${escapeHtmlAttr(name)}">\n${jsonStr}</json>\n\n`;
+  }
+
+  for (const [name, source] of _.sortBy(Object.entries(block.sources), e => e[0])) {
+    if (!SAVE_EMPTY_SOURCES && !source.source.trim()) continue;
+    const tag = (LANG_TAG_MAP as Record<string, string>)[source.lang || ''] || 'script';
+    content += `<${tag} id="${escapeHtmlAttr(name)}" lang="${source.lang}">\n${escapeCloseTag(source.source, tag)}\n</${tag}>\n\n`;
+  }
+
+  return { filePath, content: Buffer.from(content, 'utf-8') };
+}