@openvcs/sdk 0.4.0 → 0.4.1-beta.102

package/test/cli-direct.test.js

@@ -0,0 +1,57 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { runCli } = require("../lib/cli");
+
+async function captureCli(args) {
+  const stdout = [];
+  const stderr = [];
+  const originalStdoutWrite = process.stdout.write;
+  const originalStderrWrite = process.stderr.write;
+  const originalExitCode = process.exitCode;
+  process.exitCode = undefined;
+  process.stdout.write = (chunk) => { stdout.push(String(chunk)); return true; };
+  process.stderr.write = (chunk) => { stderr.push(String(chunk)); return true; };
+  try {
+    await runCli(args);
+    return { stdout: stdout.join(""), stderr: stderr.join(""), exitCode: process.exitCode };
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+    process.exitCode = originalExitCode;
+  }
+}
+
+test("runCli writes usage to stderr for empty args", async () => {
+  const result = await captureCli([]);
+
+  assert.match(result.stderr, /Usage: openvcs/);
+  assert.equal(result.exitCode, 1);
+});
+
+test("runCli writes root help to stdout", async () => {
+  const result = await captureCli(["help"]);
+
+  assert.match(result.stdout, /Commands:/);
+  assert.equal(result.exitCode, undefined);
+});
+
+test("runCli passes through build parser errors", async () => {
+  await assert.rejects(() => runCli(["build", "--plugin-dir"]), /missing value for --plugin-dir/);
+});
+
+test("runCli rejects invalid init arguments", async () => {
+  await assert.rejects(() => runCli(["init", "--bad"]), /unknown argument for init/);
+});
+
+test("runCli direct help branches write subcommand usage", async () => {
+  const buildHelp = await captureCli(["build", "--help"]);
+  const initHelp = await captureCli(["init", "--help"]);
+
+  assert.match(buildHelp.stdout, /openvcs build \[args\]/);
+  assert.match(initHelp.stdout, /Usage: openvcs init/);
+});
+
+test("runCli direct unknown command branch rejects", async () => {
+  await assert.rejects(() => runCli(["wat"]), /unknown command: wat/);
+});

package/test/dispatcher.test.js

@@ -0,0 +1,104 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { createDefaultPluginDelegates, createHost, createRuntimeDispatcher, isPluginFailure, pluginError } = require("../lib/runtime");
+const { PROTOCOL_VERSION } = require("../lib/types");
+
+function writer() {
+  const messages = [];
+  return {
+    messages,
+    sendResult(id, result) {
+      messages.push({ id, result });
+    },
+    sendError(id, code, message, data) {
+      messages.push({ id, error: { code, message, data } });
+    },
+  };
+}
+
+test("default plugin delegates return protocol-safe defaults", async () => {
+  const delegates = createDefaultPluginDelegates();
+
+  assert.equal(await delegates["plugin.init"]({}, {}), null);
+  assert.equal(await delegates["plugin.deinit"]({}, {}), null);
+  assert.deepEqual(await delegates["plugin.get_menus"]({}, {}), []);
+  assert.equal(await delegates["plugin.handle_action"]({}, {}), null);
+  assert.deepEqual(await delegates["plugin.settings.defaults"]({}, {}), []);
+  assert.deepEqual(await delegates["plugin.settings.on_load"]({ values: [1] }, {}), [1]);
+  assert.deepEqual(await delegates["plugin.settings.on_load"]({}, {}), []);
+  assert.equal(await delegates["plugin.settings.on_apply"]({}, {}), null);
+  assert.deepEqual(await delegates["plugin.settings.on_save"]({ values: [2] }, {}), [2]);
+  assert.deepEqual(await delegates["plugin.settings.on_save"]({}, {}), []);
+  assert.equal(await delegates["plugin.settings.on_reset"]({}, {}), null);
+});
+
+test("dispatcher rejects protocol version mismatch", async () => {
+  const out = writer();
+  const dispatcher = createRuntimeDispatcher({}, createHost(() => {}), out);
+
+  await dispatcher(1, "plugin.initialize", { expected_protocol_version: PROTOCOL_VERSION + 1 });
+
+  assert.equal(out.messages[0].id, 1);
+  assert.equal(out.messages[0].error.data.code, "protocol-version-mismatch");
+});
+
+test("dispatcher merges initialize override with inferred implements", async () => {
+  const out = writer();
+  const dispatcher = createRuntimeDispatcher(
+    {
+      implements: { plugin: { menus: true } },
+      vcs: { "vcs.status": async () => ({ files: [] }) },
+      plugin: {
+        "plugin.initialize": async () => ({ implements: { custom: true } }),
+      },
+    },
+    createHost(() => {}),
+    out,
+  );
+
+  await dispatcher("init", "plugin.initialize", { expected_protocol_version: PROTOCOL_VERSION });
+
+  assert.equal(out.messages[0].result.protocol_version, PROTOCOL_VERSION);
+  assert.equal(out.messages[0].result.implements.custom, true);
+  assert.equal(out.messages[0].result.implements.vcs, true);
+});
+
+test("dispatcher reports plugin failures separately from generic failures", async () => {
+  const pluginOut = writer();
+  await createRuntimeDispatcher(
+    { plugin: { "plugin.init": async () => { throw pluginError("bad-input", "Bad input", { field: "x" }); } } },
+    createHost(() => {}),
+    pluginOut,
+  )(2, "plugin.init", {});
+
+  const genericOut = writer();
+  await createRuntimeDispatcher(
+    { plugin: { "plugin.init": async () => { throw new Error("Boom"); } } },
+    createHost(() => {}),
+    genericOut,
+  )(3, "plugin.init", {});
+
+  assert.equal(pluginOut.messages[0].error.data.code, "bad-input");
+  assert.equal(genericOut.messages[0].error.data.code, "plugin-internal-error");
+});
+
+test("isPluginFailure rejects non-objects", () => {
+  assert.equal(isPluginFailure(null), false);
+  assert.equal(isPluginFailure("bad"), false);
+  assert.equal(isPluginFailure({ code: "x", message: "y" }), false);
+});
+
+test("dispatcher times out slow handlers", async () => {
+  const out = writer();
+  const dispatcher = createRuntimeDispatcher(
+    { timeout: 1, plugin: { "plugin.init": async () => new Promise(() => {}) } },
+    createHost(() => {}),
+    out,
+  );
+
+  await dispatcher(4, "plugin.init", {});
+
+  assert.equal(out.messages[0].error.data.code, "request-timeout");
+  assert.match(out.messages[0].error.message, /timed out/);
+});

package/test/fs-utils.test.js

@@ -55,6 +55,20 @@ test("copyFileStrict rejects non-files", () => {
   cleanupTempDir(root);
 });
 
+test("copyFileStrict rejects file symlinks", () => {
+  if (process.platform === "win32") {
+    return;
+  }
+  const root = makeTempDir("openvcs-sdk-test");
+  const target = path.join(root, "target.txt");
+  const link = path.join(root, "link.txt");
+  writeText(target, "target");
+  fs.symlinkSync(target, link);
+
+  assert.throws(() => copyFileStrict(link, path.join(root, "out.txt")), /symlink/);
+  cleanupTempDir(root);
+});
+
 test("copyDirectoryRecursiveStrict copies nested trees", () => {
   const root = makeTempDir("openvcs-sdk-test");
   const src = path.join(root, "src");
@@ -87,6 +101,49 @@ test("copyDirectoryRecursiveStrict errors when source is file", () => {
   cleanupTempDir(root);
 });
 
+test("copyDirectoryRecursiveStrict rejects source directory symlink", () => {
+  if (process.platform === "win32") {
+    return;
+  }
+  const root = makeTempDir("openvcs-sdk-test");
+  const targetDir = path.join(root, "target");
+  const link = path.join(root, "link");
+  fs.mkdirSync(targetDir, { recursive: true });
+  fs.symlinkSync(targetDir, link);
+
+  assert.throws(() => copyDirectoryRecursiveStrict(link, path.join(root, "dst")), /symlink/);
+  cleanupTempDir(root);
+});
+
+test("copyDirectoryRecursiveStrict skips special non-file entries", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const src = path.join(root, "src");
+  const dst = path.join(root, "dst");
+  fs.mkdirSync(path.join(src, "fifo-like"), { recursive: true });
+  writeText(path.join(src, "file.txt"), "ok");
+
+  copyDirectoryRecursiveStrict(src, dst);
+
+  assert.equal(fs.readFileSync(path.join(dst, "file.txt"), "utf8"), "ok");
+  cleanupTempDir(root);
+});
+
+test("copyDirectoryRecursiveStrict rejects symlink entries inside trees", () => {
+  if (process.platform === "win32") {
+    return;
+  }
+  const root = makeTempDir("openvcs-sdk-test");
+  const src = path.join(root, "src");
+  const dst = path.join(root, "dst");
+  const target = path.join(root, "target.txt");
+  writeText(target, "target");
+  fs.mkdirSync(src, { recursive: true });
+  fs.symlinkSync(target, path.join(src, "linked.txt"));
+
+  assert.throws(() => copyDirectoryRecursiveStrict(src, dst), /symlink/);
+  cleanupTempDir(root);
+});
+
 test("rejectSymlinksRecursive allows regular trees", () => {
   const root = makeTempDir("openvcs-sdk-test");
   writeText(path.join(root, "a.txt"), "a");

package/test/host.test.js

@@ -0,0 +1,39 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { createHost } = require("../lib/runtime");
+
+test("createHost maps log helpers to host.log notifications", () => {
+  const sent = [];
+  const host = createHost((method, params) => sent.push({ method, params }), { logTarget: "test.plugin" });
+
+  host.log("warn", "careful");
+  host.info("ready");
+  host.error("failed");
+
+  assert.deepEqual(sent, [
+    { method: "host.log", params: { level: "warn", target: "test.plugin", message: "careful" } },
+    { method: "host.log", params: { level: "info", target: "test.plugin", message: "ready" } },
+    { method: "host.log", params: { level: "error", target: "test.plugin", message: "failed" } },
+  ]);
+});
+
+test("createHost maps UI/status/event helpers to protocol notifications", () => {
+  const sent = [];
+  const host = createHost((method, params) => sent.push({ method, params }));
+
+  host.uiNotify({ level: "info", message: "Saved" });
+  host.statusSet({ message: "Working" });
+  host.emitEvent({ name: "custom", payload: { value: 1 } });
+  host.emitVcsEvent("session-1", 42, { type: "progress", message: "Fetch" });
+
+  assert.deepEqual(sent, [
+    { method: "host.ui_notify", params: { level: "info", message: "Saved" } },
+    { method: "host.status_set", params: { message: "Working" } },
+    { method: "host.event_emit", params: { name: "custom", payload: { value: 1 } } },
+    {
+      method: "vcs.event",
+      params: { session_id: "session-1", request_id: 42, event: { type: "progress", message: "Fetch" } },
+    },
+  ]);
+});

package/test/init.test.js

@@ -1,11 +1,42 @@
 const assert = require("node:assert/strict");
+const childProcess = require("node:child_process");
 const fs = require("node:fs");
+const readline = require("node:readline/promises");
 const test = require("node:test");
 const path = require("node:path");
 
-const { __private } = require("../lib/init");
+const { __private, initUsage, isUsageError, runInitCommand } = require("../lib/init");
 const { cleanupTempDir, makeTempDir } = require("./helpers");
 
+async function withMockReadline(answers, run) {
+  const originalCreateInterface = readline.createInterface;
+  const prompts = [];
+  readline.createInterface = () => ({
+    async question(prompt) {
+      prompts.push(prompt);
+      return answers.shift() ?? "";
+    },
+    close() {},
+  });
+
+  try {
+    return await run(prompts);
+  } finally {
+    readline.createInterface = originalCreateInterface;
+  }
+}
+
+async function withMockSpawnSync(result, run) {
+  const originalSpawnSync = childProcess.spawnSync;
+  childProcess.spawnSync = () => result;
+
+  try {
+    return await run();
+  } finally {
+    childProcess.spawnSync = originalSpawnSync;
+  }
+}
+
 test("validatePluginId accepts regular ids", () => {
   assert.equal(__private.validatePluginId("my.plugin"), undefined);
   assert.equal(__private.validatePluginId("my-plugin_1"), undefined);
@@ -25,6 +56,97 @@ test("validatePluginId rejects path separators", () => {
   assert.match(__private.validatePluginId("bad\\id"), /path separators/);
 });
 
+test("init helpers derive stable defaults", () => {
+  assert.equal(__private.sanitizeIdToken(" My Plugin!! "), "my-plugin");
+  assert.equal(__private.defaultPluginIdFromDir(path.join("tmp", "My Plugin")), "my-plugin");
+  assert.equal(__private.defaultPluginIdFromDir(path.join("tmp", "!!!")), "openvcs.plugin");
+  assert.equal(__private.defaultPluginNameFromId("my-plugin.name"), "My Plugin Name");
+  assert.equal(__private.defaultPluginNameFromId("---"), "OpenVCS Plugin");
+  assert.match(initUsage("sdk"), /sdk init/);
+});
+
+test("runInitCommand validates args before prompting", async () => {
+  await assert.rejects(() => runInitCommand(["--bad"]), /unknown argument for init/);
+  await assert.rejects(() => runInitCommand(["one", "two"]), /at most one target directory/);
+
+  let usageError;
+  try {
+    await runInitCommand(["--help"]);
+  } catch (error) {
+    usageError = error;
+  }
+  assert.equal(isUsageError(usageError), true);
+});
+
+test("runInitCommand rejects when target path is a file", async () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const targetPath = path.join(root, "plugin");
+  fs.writeFileSync(targetPath, "not a directory", "utf8");
+
+  await assert.rejects(
+    () =>
+      withMockReadline([
+        "",
+        "module",
+        "",
+        "",
+        "",
+        "",
+        "n",
+      ], () => runInitCommand([targetPath])),
+    /target path exists but is not a directory/
+  );
+
+  cleanupTempDir(root);
+});
+
+test("runInitCommand writes a module template after confirming overwrite", async () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const targetDir = path.join(root, "plugin");
+  fs.mkdirSync(targetDir, { recursive: true });
+  fs.writeFileSync(path.join(targetDir, "README.md"), "keep", "utf8");
+
+  const created = await withMockReadline([
+    "",
+    "module",
+    "",
+    "",
+    "",
+    "",
+    "n",
+    "y",
+  ], () => runInitCommand([targetDir]));
+
+  assert.equal(created, targetDir);
+  assert.equal(fs.existsSync(path.join(targetDir, "package.json")), true);
+  assert.equal(fs.existsSync(path.join(targetDir, "src", "plugin.ts")), true);
+  assert.equal(fs.existsSync(path.join(targetDir, ".gitignore")), true);
+
+  cleanupTempDir(root);
+});
+
+test("runInitCommand spawns npm install when requested", async () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const targetDir = path.join(root, "fresh-plugin");
+
+  await withMockSpawnSync({ status: 0 }, async () => {
+    const created = await withMockReadline([
+      targetDir,
+      "module",
+      "fresh.plugin",
+      "Fresh Plugin",
+      "0.1.0",
+      "y",
+      "y",
+    ], () => runInitCommand([]));
+
+    assert.equal(created, path.resolve(targetDir));
+    assert.equal(fs.existsSync(path.join(targetDir, "package.json")), true);
+  });
+
+  cleanupTempDir(root);
+});
+
 test("collectAnswers re-prompts invalid plugin id", async () => {
   const prompts = [
     "plugin-dir",
@@ -66,6 +188,67 @@ test("collectAnswers re-prompts invalid plugin id", async () => {
   assert.equal(messages.some((message) => message.includes("must not contain path separators")), true);
 });
 
+test("collectAnswers handles theme mode, invalid kind, blank defaults, and boolean retries", async () => {
+  const prompts = [
+    "",
+    "bad-kind",
+    "t",
+    "",
+    "",
+    "",
+  ];
+  const booleans = [false, true];
+  const messages = [];
+  const promptDriver = {
+    async promptText(_label, defaultValue) {
+      const value = prompts.shift();
+      return value === "" ? defaultValue : value;
+    },
+    async promptBoolean() {
+      return booleans.shift();
+    },
+    close() {
+      messages.push("closed");
+    },
+  };
+  const output = { write(message) { messages.push(message); } };
+
+  const answers = await __private.collectAnswers(
+    { forceTheme: false, targetHint: "theme-dir" },
+    promptDriver,
+    output,
+  );
+
+  assert.equal(answers.kind, "theme");
+  assert.equal(answers.pluginId, "theme-dir");
+  assert.equal(answers.pluginName, "Theme Dir");
+  assert.equal(answers.pluginVersion, "0.1.0");
+  assert.equal(answers.defaultEnabled, false);
+  assert.equal(answers.runNpmInstall, true);
+  assert.equal(messages.some((message) => String(message).includes("Please choose")), true);
+  assert.equal(messages.includes("closed"), true);
+});
+
+test("collectAnswers skips kind prompt when theme is forced", async () => {
+  const prompts = ["forced-dir", "forced.theme", "Forced Theme", "1.0.0"];
+  const labels = [];
+  const promptDriver = {
+    async promptText(label) {
+      labels.push(label);
+      return prompts.shift();
+    },
+    async promptBoolean() {
+      return false;
+    },
+    close() {},
+  };
+
+  const answers = await __private.collectAnswers({ forceTheme: true }, promptDriver, { write() {} });
+
+  assert.equal(answers.kind, "theme");
+  assert.equal(labels.includes("Template type (module/theme)"), false);
+});
+
 test("writeModuleTemplate scaffolds SDK runtime entrypoint", () => {
   const root = makeTempDir("openvcs-sdk-test");
   const targetDir = path.join(root, "plugin");
@@ -92,3 +275,28 @@ test("writeModuleTemplate scaffolds SDK runtime entrypoint", () => {
 
   cleanupTempDir(root);
 });
+
+test("writeThemeTemplate scaffolds theme package without module runtime", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const targetDir = path.join(root, "theme-plugin");
+
+  __private.writeThemeTemplate({
+    targetDir,
+    kind: "theme",
+    pluginId: "example.theme",
+    pluginName: "Example Theme",
+    pluginVersion: "0.3.0",
+    defaultEnabled: false,
+    runNpmInstall: false,
+  });
+
+  const packageJson = JSON.parse(fs.readFileSync(path.join(targetDir, "package.json"), "utf8"));
+  const themeJson = JSON.parse(fs.readFileSync(path.join(targetDir, "themes", "default", "theme.json"), "utf8"));
+
+  assert.equal(packageJson.openvcs.module, undefined);
+  assert.equal(packageJson.openvcs.default_enabled, false);
+  assert.equal(themeJson.name, "Example Theme");
+  assert.equal(themeJson.tokens.accent, "#2a7fff");
+
+  cleanupTempDir(root);
+});

package/test/menu.test.js

@@ -0,0 +1,147 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const {
+  addMenuItem,
+  createMenu,
+  getMenu,
+  hasRegisteredAction,
+  hideMenu,
+  invoke,
+  notify,
+  registerAction,
+  removeMenu,
+  resetMenuRegistry,
+  runRegisteredAction,
+  showMenu,
+} = require("../lib/runtime/menu");
+const { createRegisteredPluginRuntime } = require("../lib/runtime");
+const { EventEmitter } = require("node:events");
+const { parseFramedMessages, serializeFramedMessage } = require("../lib/runtime/transport");
+
+function menuResult() {
+  const stdin = new EventEmitter();
+  const chunks = [];
+  const stdout = {
+    write(chunk) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      return true;
+    },
+  };
+  createRegisteredPluginRuntime({}).start({ stdin, stdout });
+  stdin.emit("data", serializeFramedMessage({ jsonrpc: "2.0", id: 1, method: "plugin.get_menus", params: {} }));
+  return new Promise((resolve) => setImmediate(() => resolve(parseFramedMessages(Buffer.concat(chunks)).messages[0].result)));
+}
+
+test("menu ordering supports before and after placement", async () => {
+  resetMenuRegistry();
+  createMenu("middle", "Middle", { surface: "menubar" });
+  createMenu("after", "After", { surface: "settings", after: "middle" });
+  createMenu("before", "Before", { surface: "menubar", before: "middle" });
+
+  const menus = await menuResult();
+
+  assert.deepEqual(menus.map((menu) => menu.id), ["before", "middle", "after"]);
+  assert.deepEqual(menus.map((menu) => menu.surface), ["menubar", "menubar", "settings"]);
+});
+
+test("menu ordering falls back when requested anchors are missing", async () => {
+  resetMenuRegistry();
+  createMenu("first", "First", { surface: "menubar", after: "missing" });
+  createMenu("second", "Second", { surface: "menubar", before: "missing" });
+  createMenu("first", "First Updated", { surface: "settings" });
+
+  const menus = await menuResult();
+
+  assert.deepEqual(menus.map((menu) => menu.id), ["second", "first"]);
+  assert.equal(menus[1].label, "First Updated");
+  assert.equal(menus[1].surface, "settings");
+});
+
+test("menu item insertion supports before anchors and ignores invalid items", async () => {
+  resetMenuRegistry();
+  const menu = createMenu("insert", "Insert", { surface: "menubar" });
+  menu.addItem({ label: "Last", action: "last" });
+  menu.addItem({ label: "First", action: "first", before: "last" });
+  menu.addItem({ label: "", action: "ignored" });
+  menu.addItem({ label: "Ignored", action: "" });
+
+  const menus = await menuResult();
+
+  assert.deepEqual(menus[0].elements, [
+    { type: "button", id: "first", label: "First" },
+    { type: "button", id: "last", label: "Last" },
+  ]);
+});
+
+test("menu handle can remove, hide, and show individual items", async () => {
+  resetMenuRegistry();
+  const menu = createMenu("tools", "Tools", { surface: "menubar" });
+  menu.addItem({ label: "A", action: "a" });
+  menu.addItem({ label: "B", action: "b" });
+  menu.hideItem("a");
+
+  let menus = await menuResult();
+  assert.deepEqual(menus[0].elements, [{ type: "button", id: "b", label: "B" }]);
+
+  menu.showItem("a");
+  menu.removeItem("b");
+  menus = await menuResult();
+
+  assert.deepEqual(menus[0].elements, [{ type: "button", id: "a", label: "A" }]);
+});
+
+test("registered actions report presence and ignore blank ids", async () => {
+  resetMenuRegistry();
+  registerAction(" save ", () => "saved");
+
+  assert.equal(hasRegisteredAction("save"), true);
+  assert.equal(hasRegisteredAction(""), false);
+  assert.equal(await runRegisteredAction("save"), "saved");
+  assert.equal(await runRegisteredAction("missing"), null);
+  assert.equal(await runRegisteredAction(""), null);
+});
+
+test("removeMenu deletes menu and order entry", async () => {
+  resetMenuRegistry();
+  createMenu("gone", "Gone", { surface: "menubar" });
+  createMenu("stay", "Stay", { surface: "menubar" });
+  removeMenu("gone");
+  hideMenu("missing");
+  showMenu("missing");
+
+  assert.equal(getMenu("gone"), null);
+  assert.deepEqual((await menuResult()).map((menu) => menu.id), ["stay"]);
+});
+
+test("invoke and notify use OpenVCS host helper when available", async () => {
+  const previous = globalThis.OpenVCS;
+  const calls = [];
+  globalThis.OpenVCS = {
+    async invoke(cmd, args) {
+      calls.push({ cmd, args });
+      return "ok";
+    },
+    notify(msg) {
+      calls.push({ msg });
+    },
+  };
+  try {
+    assert.equal(await invoke("repo.open", { path: "/tmp" }), "ok");
+    notify("done");
+    assert.deepEqual(calls, [{ cmd: "repo.open", args: { path: "/tmp" } }, { msg: "done" }]);
+  } finally {
+    globalThis.OpenVCS = previous;
+  }
+});
+
+test("invoke and notify fail when OpenVCS host helper is missing", async () => {
+  const previous = globalThis.OpenVCS;
+  delete globalThis.OpenVCS;
+  try {
+    await assert.rejects(() => invoke("missing"), /host is not available/);
+    assert.throws(() => notify("missing"), /host is not available/);
+  } finally {
+    globalThis.OpenVCS = previous;
+  }
+});