@bash0816/claude-code 2.1.241 → 2.1.248

package/lib/bunfs-extract.test.js

@@ -0,0 +1,265 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const {
+  discoverModuleGraph,
+  extractToProcessOwnedDir,
+  cleanupStaleOwnedDirs,
+  prepareProcessOwnedDir,
+  readEntryContentPrefix,
+} = require('./bunfs-extract.js');
+
+const TRAILER = '\n---- Bun! ----\n';
+
+// StandaloneModuleGraphの最小合成バイナリを構築する。
+// レイアウト: [preamble padding][module contents][module table][Offsets(32byte)][trailer]
+function buildSyntheticBinary({ modules, entryPointId, corruptTrailer = false, preamblePadding = 64 }) {
+  const nameBuffers = modules.map((m) => Buffer.from(m.name, 'utf8'));
+  const contentBuffers = modules.map((m) => Buffer.from(m.content ?? '', 'utf8'));
+
+  const dataParts = [];
+  const nameOffsets = [];
+  const contOffsets = [];
+  let cursor = 0;
+  for (let i = 0; i < modules.length; i += 1) {
+    nameOffsets.push(cursor);
+    dataParts.push(nameBuffers[i]);
+    cursor += nameBuffers[i].length;
+  }
+  for (let i = 0; i < modules.length; i += 1) {
+    contOffsets.push(cursor);
+    dataParts.push(contentBuffers[i]);
+    cursor += contentBuffers[i].length;
+  }
+  const byteCountBeforeTable = cursor;
+
+  const MODULE_TABLE_ENTRY_SIZE = 52;
+  const modTable = Buffer.alloc(MODULE_TABLE_ENTRY_SIZE * modules.length);
+  for (let i = 0; i < modules.length; i += 1) {
+    const base = i * MODULE_TABLE_ENTRY_SIZE;
+    modTable.writeUInt32LE(nameOffsets[i], base);
+    modTable.writeUInt32LE(nameBuffers[i].length, base + 4);
+    modTable.writeUInt32LE(contOffsets[i], base + 8);
+    modTable.writeUInt32LE(contentBuffers[i].length, base + 12);
+    modTable[base + 49] = modules[i].loader ?? 1; // 1 = js
+  }
+  const modulesOffset = byteCountBeforeTable;
+  const modulesLength = modTable.length;
+  const byteCount = byteCountBeforeTable + modulesLength;
+
+  const offsetsBuf = Buffer.alloc(32);
+  offsetsBuf.writeBigUInt64LE(BigInt(byteCount), 0);
+  offsetsBuf.writeUInt32LE(modulesOffset, 8);
+  offsetsBuf.writeUInt32LE(modulesLength, 12);
+  offsetsBuf.writeUInt32LE(entryPointId, 16);
+
+  const trailerBuf = Buffer.from(corruptTrailer ? '\n---- NOT BUN ----\n' : TRAILER, 'utf8');
+
+  return Buffer.concat([
+    Buffer.alloc(preamblePadding),
+    ...dataParts,
+    modTable,
+    offsetsBuf,
+    trailerBuf,
+  ]);
+}
+
+function writeTempBinary(buf) {
+  const file = path.join(os.tmpdir(), `bunfs-extract-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.bin`);
+  fs.writeFileSync(file, buf);
+  return file;
+}
+
+test('discoverModuleGraph parses a well-formed synthetic StandaloneModuleGraph', () => {
+  const buf = buildSyntheticBinary({
+    modules: [
+      { name: '/$bunfs/root/cli', content: 'console.log("entry")' },
+      { name: '/$bunfs/root/chunk-a.js', content: 'export const a = 1;' },
+    ],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  try {
+    const graph = discoverModuleGraph(file);
+    try {
+      assert.equal(graph.numModules, 2);
+      assert.equal(graph.entryName, '/$bunfs/root/cli');
+      assert.equal(graph.modules.length, 2);
+      const prefix = readEntryContentPrefix(graph.fd, graph.entryModule, 256).toString('utf8');
+      assert.equal(prefix, 'console.log("entry")');
+    } finally {
+      fs.closeSync(graph.fd);
+    }
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('discoverModuleGraph rejects a binary with a corrupted trailer', () => {
+  const buf = buildSyntheticBinary({
+    modules: [{ name: '/$bunfs/root/cli', content: 'x' }],
+    entryPointId: 0,
+    corruptTrailer: true,
+  });
+  const file = writeTempBinary(buf);
+  try {
+    assert.throws(() => discoverModuleGraph(file), /trailer not found/);
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('discoverModuleGraph rejects entry_point_id out of range', () => {
+  const buf = buildSyntheticBinary({
+    modules: [{ name: '/$bunfs/root/cli', content: 'x' }],
+    entryPointId: 5, // 存在しないインデックス
+  });
+  const file = writeTempBinary(buf);
+  try {
+    assert.throws(() => discoverModuleGraph(file), /entry_point_id.*out of range/);
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('discoverModuleGraph rejects duplicate module names', () => {
+  const buf = buildSyntheticBinary({
+    modules: [
+      { name: '/$bunfs/root/cli', content: 'a' },
+      { name: '/$bunfs/root/cli', content: 'b' },
+    ],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  try {
+    assert.throws(() => discoverModuleGraph(file), /duplicate module name/);
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('discoverModuleGraph skips NAPI loader modules from extraction list', () => {
+  const buf = buildSyntheticBinary({
+    modules: [
+      { name: '/$bunfs/root/cli', content: 'x' },
+      { name: '/$bunfs/root/native.node', content: 'BINARY', loader: 10 },
+    ],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  try {
+    const graph = discoverModuleGraph(file);
+    try {
+      assert.equal(graph.modules.length, 1);
+      assert.equal(graph.modules[0].name, '/$bunfs/root/cli');
+    } finally {
+      fs.closeSync(graph.fd);
+    }
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('extractToProcessOwnedDir rejects path traversal via module name', () => {
+  const buf = buildSyntheticBinary({
+    modules: [{ name: '/$bunfs/root/../../etc/passwd', content: 'evil' }],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  const ownedDir = path.join(os.tmpdir(), `bunfs-extract-owned-${process.pid}-${Date.now()}`);
+  try {
+    assert.throws(() => extractToProcessOwnedDir(file, ownedDir), /rejected unsafe module name|escapes owned dir/);
+  } finally {
+    fs.rmSync(file, { force: true });
+    fs.rmSync(ownedDir, { recursive: true, force: true });
+  }
+});
+
+test('extractToProcessOwnedDir writes module contents to the owned directory', () => {
+  const buf = buildSyntheticBinary({
+    modules: [
+      { name: '/$bunfs/root/cli', content: 'entry-content' },
+      { name: '/$bunfs/root/chunk-a.js', content: 'chunk-content' },
+    ],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  const ownedDir = path.join(os.tmpdir(), `bunfs-extract-owned-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  try {
+    const { entryRelPath } = extractToProcessOwnedDir(file, ownedDir);
+    assert.equal(entryRelPath, 'cli');
+    assert.equal(fs.readFileSync(path.join(ownedDir, 'cli'), 'utf8'), 'entry-content');
+    assert.equal(fs.readFileSync(path.join(ownedDir, 'chunk-a.js'), 'utf8'), 'chunk-content');
+  } finally {
+    fs.rmSync(file, { force: true });
+    fs.rmSync(ownedDir, { recursive: true, force: true });
+  }
+});
+
+test('cleanupStaleOwnedDirs keeps directories whose PID is still alive', () => {
+  const workdir = path.join(os.tmpdir(), `bunfs-cleanup-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(workdir, { recursive: true });
+  const aliveDir = path.join(workdir, `esm.${process.pid}.old.marker.bare-dir`);
+  fs.mkdirSync(aliveDir);
+  const oldTime = new Date(Date.now() - 48 * 60 * 60 * 1000);
+  fs.utimesSync(aliveDir, oldTime, oldTime);
+  try {
+    cleanupStaleOwnedDirs(workdir, 'esm.');
+    assert.ok(fs.existsSync(aliveDir), 'directory owned by a live PID must not be removed even if old');
+  } finally {
+    fs.rmSync(workdir, { recursive: true, force: true });
+  }
+});
+
+test('cleanupStaleOwnedDirs removes old directories whose PID is dead', () => {
+  const workdir = path.join(os.tmpdir(), `bunfs-cleanup-test-${process.pid}-${Date.now()}-dead`);
+  fs.mkdirSync(workdir, { recursive: true });
+  // 実在しない可能性が極めて高い巨大なPID番号を使う
+  const deadDir = path.join(workdir, `esm.999999999.old.marker.bare-dir`);
+  fs.mkdirSync(deadDir);
+  const oldTime = new Date(Date.now() - 48 * 60 * 60 * 1000);
+  fs.utimesSync(deadDir, oldTime, oldTime);
+  try {
+    cleanupStaleOwnedDirs(workdir, 'esm.');
+    assert.ok(!fs.existsSync(deadDir), 'stale directory owned by a dead PID should be removed');
+  } finally {
+    fs.rmSync(workdir, { recursive: true, force: true });
+  }
+});
+
+test('cleanupStaleOwnedDirs keeps recently modified directories regardless of PID', () => {
+  const workdir = path.join(os.tmpdir(), `bunfs-cleanup-test-${process.pid}-${Date.now()}-recent`);
+  fs.mkdirSync(workdir, { recursive: true });
+  const recentDir = path.join(workdir, `esm.999999998.recent.marker.bare-dir`);
+  fs.mkdirSync(recentDir);
+  try {
+    cleanupStaleOwnedDirs(workdir, 'esm.');
+    assert.ok(fs.existsSync(recentDir), 'recently created directory must not be removed regardless of PID liveness');
+  } finally {
+    fs.rmSync(workdir, { recursive: true, force: true });
+  }
+});
+
+test('prepareProcessOwnedDir extracts into a unique directory and returns entry path', () => {
+  const buf = buildSyntheticBinary({
+    modules: [{ name: '/$bunfs/root/cli', content: 'hello' }],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  const workdir = path.join(os.tmpdir(), `bunfs-prepare-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(workdir, { recursive: true });
+  try {
+    const { ownedDir, entryRelPath } = prepareProcessOwnedDir(file, workdir);
+    assert.ok(ownedDir.startsWith(workdir));
+    assert.equal(entryRelPath, 'cli');
+    assert.equal(fs.readFileSync(path.join(ownedDir, 'cli'), 'utf8'), 'hello');
+  } finally {
+    fs.rmSync(file, { force: true });
+    fs.rmSync(workdir, { recursive: true, force: true });
+  }
+});

package/lib/bunfs-vm-guard.mjs

@@ -0,0 +1,116 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const realVm = require('node:vm');
+
+function injectBunIntoContext(context) {
+  if (!context || typeof context !== 'object') return context;
+  try {
+    if (!Object.prototype.hasOwnProperty.call(context, '__claudeYaml')) {
+      Object.defineProperty(context, '__claudeYaml', {
+        value: globalThis.__claudeYaml,
+        configurable: true,
+        writable: true,
+      });
+    }
+    if (!Object.prototype.hasOwnProperty.call(context, '__claudeBunShim')) {
+      Object.defineProperty(context, '__claudeBunShim', {
+        value: globalThis.__claudeBunShim,
+        configurable: true,
+        writable: true,
+      });
+    }
+    if (!Object.prototype.hasOwnProperty.call(context, '__claudeBun')) {
+      Object.defineProperty(context, '__claudeBun', {
+        value: globalThis.__claudeBunShim,
+        configurable: true,
+        writable: true,
+      });
+    }
+    if (Object.prototype.hasOwnProperty.call(context, 'Bun')) {
+      if (context.Bun && typeof context.Bun === 'object' && context.Bun !== globalThis.Bun) {
+        try {
+          context.Bun = globalThis.Bun;
+        } catch {
+          Object.defineProperty(context, 'Bun', {
+            value: globalThis.Bun,
+            configurable: true,
+            writable: true,
+          });
+        }
+      }
+      if (!context.Bun || typeof context.Bun !== 'object') {
+        Object.defineProperty(context, 'Bun', {
+          value: globalThis.Bun,
+          configurable: true,
+          writable: true,
+        });
+      }
+    } else {
+      Object.defineProperty(context, 'Bun', {
+        value: globalThis.Bun,
+        configurable: true,
+        writable: true,
+      });
+    }
+    if (context.Bun && globalThis.__claudeYaml) {
+      context.Bun.YAML = globalThis.__claudeYaml;
+    }
+  } catch {}
+  return context;
+}
+
+if (!realVm.__claudeBunShimPatched) {
+  const originalCreateContext = realVm.createContext.bind(realVm);
+  const originalRunInNewContext = realVm.runInNewContext.bind(realVm);
+  const originalRunInContext = realVm.runInContext.bind(realVm);
+  const originalRunInThisContext = realVm.runInThisContext && realVm.runInThisContext.bind(realVm);
+  const scriptProto = realVm.Script && realVm.Script.prototype;
+
+  realVm.createContext = (contextObject, ...rest) =>
+    originalCreateContext(injectBunIntoContext(contextObject), ...rest);
+  realVm.runInNewContext = (code, contextObject, ...rest) =>
+    originalRunInNewContext(code, injectBunIntoContext(contextObject), ...rest);
+  realVm.runInContext = (code, contextObject, ...rest) =>
+    originalRunInContext(code, injectBunIntoContext(contextObject), ...rest);
+  if (originalRunInThisContext) {
+    realVm.runInThisContext = (code, ...rest) => originalRunInThisContext(code, ...rest);
+  }
+
+  if (scriptProto && !scriptProto.__claudeBunShimPatched) {
+    const originalScriptRunInContext = scriptProto.runInContext;
+    const originalScriptRunInNewContext = scriptProto.runInNewContext;
+    const originalScriptRunInThisContext = scriptProto.runInThisContext;
+
+    scriptProto.runInContext = function (contextObject, ...rest) {
+      return originalScriptRunInContext.call(this, injectBunIntoContext(contextObject), ...rest);
+    };
+    scriptProto.runInNewContext = function (contextObject, ...rest) {
+      return originalScriptRunInNewContext.call(this, injectBunIntoContext(contextObject), ...rest);
+    };
+    if (originalScriptRunInThisContext) {
+      scriptProto.runInThisContext = function (...rest) {
+        return originalScriptRunInThisContext.call(this, ...rest);
+      };
+    }
+
+    Object.defineProperty(scriptProto, '__claudeBunShimPatched', { value: true });
+  }
+
+  Object.defineProperty(realVm, '__claudeBunShimPatched', { value: true });
+}
+
+export const createContext = realVm.createContext;
+export const isContext = realVm.isContext;
+export const runInContext = realVm.runInContext;
+export const runInNewContext = realVm.runInNewContext;
+export const runInThisContext = realVm.runInThisContext;
+export const createScript = realVm.createScript;
+export const compileFunction = realVm.compileFunction;
+export const measureMemory = realVm.measureMemory;
+export const Script = realVm.Script;
+export const SourceTextModule = realVm.SourceTextModule;
+export const SyntheticModule = realVm.SyntheticModule;
+export const constants = realVm.constants;
+
+export default realVm;

package/lib/bunfs-vm-guard.test.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+test('bunfs-vm-guard exports all vm module methods', async () => {
+  const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+  assert.equal(typeof vmGuard.createContext, 'function');
+  assert.equal(typeof vmGuard.isContext, 'function');
+  assert.equal(typeof vmGuard.runInContext, 'function');
+  assert.equal(typeof vmGuard.runInNewContext, 'function');
+  assert.equal(typeof vmGuard.runInThisContext, 'function');
+  assert.equal(typeof vmGuard.createScript, 'function');
+  assert.equal(typeof vmGuard.compileFunction, 'function');
+  assert.equal(typeof vmGuard.measureMemory, 'function');
+  assert.equal(typeof vmGuard.Script, 'function');
+  // SourceTextModule and SyntheticModule only exist with --experimental-vm-modules flag
+  assert.ok('SourceTextModule' in vmGuard);
+  assert.ok('SyntheticModule' in vmGuard);
+  assert.ok(vmGuard.constants);
+});
+
+test('bunfs-vm-guard provides default export with vm module API', async () => {
+  const vmGuard = await import('./bunfs-vm-guard.mjs');
+  const defaultExport = vmGuard.default;
+
+  assert.ok(defaultExport);
+  assert.equal(typeof defaultExport, 'object');
+  assert.equal(typeof defaultExport.createContext, 'function');
+  assert.equal(typeof defaultExport.isContext, 'function');
+  assert.equal(typeof defaultExport.runInContext, 'function');
+  assert.equal(typeof defaultExport.runInNewContext, 'function');
+  assert.equal(typeof defaultExport.runInThisContext, 'function');
+  assert.equal(typeof defaultExport.createScript, 'function');
+  assert.equal(typeof defaultExport.compileFunction, 'function');
+  assert.equal(typeof defaultExport.measureMemory, 'function');
+  assert.equal(typeof defaultExport.Script, 'function');
+  // SourceTextModule and SyntheticModule may not exist in default export without --experimental-vm-modules
+  // They are exported as named exports if they exist
+  assert.ok(defaultExport.constants);
+});
+
+test('bunfs-vm-guard injects Bun into context in createContext', async () => {
+  globalThis.Bun = { __dummy: true };
+  try {
+    const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+    const context = vmGuard.createContext({});
+    // Check that Bun property exists in context
+    assert.ok(Object.prototype.hasOwnProperty.call(context, 'Bun'));
+
+    // Verify Bun is defined when we run code in context
+    const result = vmGuard.runInContext('typeof Bun', context);
+    assert.equal(result, 'object');
+  } finally {
+    delete globalThis.Bun;
+  }
+});
+
+test('bunfs-vm-guard injects Bun into context in runInNewContext', async () => {
+  globalThis.Bun = { __dummy: true };
+  try {
+    const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+    const code = 'typeof Bun';
+    const result = vmGuard.runInNewContext(code, {});
+    assert.equal(result, 'object');
+  } finally {
+    delete globalThis.Bun;
+  }
+});
+
+test('bunfs-vm-guard injects __claudeYaml into context', async () => {
+  const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+  const context = vmGuard.createContext({});
+  // Check that __claudeYaml property exists
+  assert.ok(Object.prototype.hasOwnProperty.call(context, '__claudeYaml'));
+});
+
+test('bunfs-vm-guard injects __claudeBun and __claudeBunShim into context', async () => {
+  const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+  const context = vmGuard.createContext({});
+  // Check that shim properties exist
+  assert.ok(Object.prototype.hasOwnProperty.call(context, '__claudeBun'));
+  assert.ok(Object.prototype.hasOwnProperty.call(context, '__claudeBunShim'));
+});
+
+test('bunfs-vm-guard Script class works with context injection', async () => {
+  globalThis.Bun = { __dummy: true };
+  try {
+    const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+    const code = 'typeof Bun';
+    const script = new vmGuard.Script(code);
+    const context = vmGuard.createContext({});
+    const result = script.runInContext(context);
+    assert.equal(result, 'object');
+  } finally {
+    delete globalThis.Bun;
+  }
+});
+
+test('bunfs-vm-guard handles context with existing Bun property', async () => {
+  globalThis.Bun = { __dummy: true };
+  try {
+    const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+    // Create context with pre-existing Bun property
+    const context = vmGuard.createContext({ Bun: { custom: true } });
+    // The guard should have replaced/overwritten it with globalThis.Bun
+    const result = vmGuard.runInContext('typeof Bun', context);
+    assert.equal(result, 'object');
+  } finally {
+    delete globalThis.Bun;
+  }
+});
+
+test('bunfs-vm-guard does not break normal vm functionality', async () => {
+  const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+  // Test that normal code execution still works
+  const code = '2 + 2';
+  const result = vmGuard.runInNewContext(code);
+  assert.equal(result, 4);
+});
+
+test('bunfs-vm-guard Script.runInNewContext works with injections', async () => {
+  globalThis.Bun = { __dummy: true };
+  try {
+    const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+    const code = 'typeof Bun';
+    const script = new vmGuard.Script(code);
+    const result = script.runInNewContext({});
+    assert.equal(result, 'object');
+  } finally {
+    delete globalThis.Bun;
+  }
+});

package/lib/bunfs-ws-stub.mjs

@@ -0,0 +1,11 @@
+class WS {
+  on() {}
+  once() {}
+  addEventListener() {}
+  close() {}
+  send() {}
+  ping() {}
+}
+
+export default WS;
+export { WS as WebSocket };

package/lib/bunfs-yaml-shim.mjs

@@ -0,0 +1,91 @@
+function parseScalar(value) {
+  const text = String(value ?? '').trim();
+  if (text === '') return '';
+  if (text === 'true') return true;
+  if (text === 'false') return false;
+  if (text === 'null' || text === '~') return null;
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(text)) return Number(text);
+  if (
+    (text.startsWith('"') && text.endsWith('"')) ||
+    (text.startsWith("'") && text.endsWith("'"))
+  ) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+
+function parseInlineArray(value) {
+  const inner = String(value ?? '').trim().slice(1, -1).trim();
+  if (inner === '') return [];
+  const items = [];
+  let current = '';
+  let quote = null;
+
+  for (let i = 0; i < inner.length; i += 1) {
+    const ch = inner[i];
+    if (quote) {
+      if (ch === quote && inner[i - 1] !== '\\') quote = null;
+      current += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === ',') {
+      items.push(parseScalar(current));
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+
+  if (current !== '') items.push(parseScalar(current));
+  return items;
+}
+
+export function yamlParse(text) {
+  const source = String(text ?? '');
+  const result = {};
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const idx = line.indexOf(':');
+    if (idx < 0) continue;
+    const key = line.slice(0, idx).trim();
+    const rawValue = line.slice(idx + 1).trim();
+    if (!key) continue;
+    result[key] = rawValue.startsWith('[') && rawValue.endsWith(']')
+      ? parseInlineArray(rawValue)
+      : parseScalar(rawValue);
+  }
+  return result;
+}
+
+export function yamlStringify(value) {
+  if (!value || typeof value !== 'object') return String(value ?? '');
+  const lines = [];
+  for (const [key, raw] of Object.entries(value)) {
+    if (Array.isArray(raw)) {
+      lines.push(`${key}: [${raw.map(item => JSON.stringify(String(item))).join(', ')}]`);
+    } else if (raw === null) {
+      lines.push(`${key}: null`);
+    } else if (typeof raw === 'string') {
+      lines.push(`${key}: ${JSON.stringify(raw)}`);
+    } else {
+      lines.push(`${key}: ${String(raw)}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+export function createYamlShim() {
+  const yaml = {
+    parse: yamlParse,
+    stringify: yamlStringify,
+  };
+  yaml.YAML = yaml;
+  yaml.default = yaml;
+  return yaml;
+}