tandem-editor 0.16.0 → 0.17.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tandem",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Edit and iterate on documents with any MCP-capable AI. Claude is the default and best-supported client today.",
   "author": {
     "name": "Tandem"
@@ -11,14 +11,14 @@
   "mcpServers": {
     "tandem": {
       "command": "npx",
-      "args": ["-y", "tandem-editor@0.16.0", "mcp-stdio"],
+      "args": ["-y", "tandem-editor@0.17.0", "mcp-stdio"],
       "env": {
         "TANDEM_URL": "http://127.0.0.1:3479"
       }
     },
     "tandem-channel": {
       "command": "npx",
-      "args": ["-y", "tandem-editor@0.16.0", "channel"],
+      "args": ["-y", "tandem-editor@0.17.0", "channel"],
       "env": {
         "TANDEM_URL": "http://127.0.0.1:3479"
       }

package/CHANGELOG.md

@@ -5,7 +5,30 @@ All notable changes to Tandem will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),\
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.17.0] - 2026-07-17
+
+### Changed
+
+- **New-tab search is now fuzzy and ranked by match quality (#1186).** The new-tab menu's file search converges on the same fuzzy-match stack the command palette uses: results rank by match quality rather than pure recency (equal scores keep recency order), name matches outrank directory matches, and subsequence matches are now included (`chp` finds `chapter.md`). A directory-only match keeps its row but leaves the filename unhighlighted.
+
+### Fixed
+
+- **The editor no longer throws an unhandled error when focus leaves the document (#1195).** Four surfaces — the status pill's word count, the formatting toolbar, the formatting bar, and find/replace's match count — kept themselves in sync with the editor by writing Svelte state directly from a Tiptap event callback. Tiptap emits those callbacks synchronously from ProseMirror's dispatch, and a native `blur` can arrive while the UI is mid-render, so the write landed inside an active Svelte reaction and threw. Despite the error text naming only `$derived`/`$inspect`/template expressions, an ordinary `{#if}` block is enough to trigger it, and the throw is not dev-only — it escapes through ProseMirror's dispatch in packaged builds too. All four now bridge through a shared microtask hop, which also collapses a burst of transactions into a single update instead of recomputing on every cursor move.
+
+- **Settings controls no longer lie about being editable when the store is read-only (#1186).** When the on-disk settings `schemaVersion` is newer than the running build, Tandem opens settings read-only and silently drops writes — but the toggles and radios still flipped visually and then went stale, so the UI disagreed with what was saved. Every settings control across all tabs and the popover now shows a genuine disabled state, with a surface-wide banner explaining why, instead of accepting input it can't persist. (Display-name and actions that don't write settings stay live.)
+
+- **Keyboard activation works again in the Cowork "admin declined" dialog (#1186).** The dialog sits inside its backdrop, whose unguarded keydown handler called `preventDefault()` on Enter/Space as they bubbled up from the dialog's own buttons and the Learn-more link — so every control in that dialog was dead to the keyboard, and pressing a key dismissed the dialog out from under you. The backdrop now only acts on events that originate on itself.
+
+- **The text selection popup no longer paints a stray frosted-glass rectangle behind itself (#1189).** Selecting text in the desktop app drew a blurred rectangle spanning the popup's whole bounding box — including the empty space beside the narrower Annotate row, where no chrome is actually visible. The shared `.tandem-floating-pill` recipe carried a `backdrop-filter: blur(8px)` that every other pill hides behind its opaque background; the selection popup's shell is deliberately transparent (the two-capsule design), so there the blur had nothing to hide behind. The blur is now gone from the recipe, where it was invisible dead weight on every other surface anyway. The popup's capsules keep their background, border, shadow, and the gap the editor shows through — unchanged.
+
+- **The text selection popup no longer paints a stray frosted-glass rectangle behind itself (#1189).** Selecting text in the desktop app drew a blurred rectangle spanning the popup's whole bounding box — including the empty space beside the narrower Annotate row, where no chrome is actually visible. The shared `.tandem-floating-pill` recipe carried a `backdrop-filter: blur(8px)` that every other pill hides behind its opaque background; the selection popup's shell is deliberately transparent (the two-capsule design), so there the blur had nothing to hide behind. The blur is now gone from the recipe, where it was invisible dead weight on every other surface anyway. The popup's capsules keep their background, border, shadow, and the gap the editor shows through — unchanged.
+
+  Only production builds were affected, which is why it survived since the two-capsule popup landed in #798: that redesign shipped with a `backdrop-filter: none` reset on the shell meant to cancel the recipe's blur, and the reset never survived minification. lightningcss (Vite's default CSS minifier) collapses a `backdrop-filter` + `-webkit-backdrop-filter` pair into the `-webkit-` form alone, and Chromium does not honour the prefixed form, so the reset silently evaporated in the packaged app while working fine in dev. That minifier hazard is tracked separately in #1188; a regression test now forbids both the blur on the recipe and the prefixed-pair pattern that hid it.
+
+### Internal
+
+- **`tandem doctor` gains two dev-checkout diagnostics (#1192).** A staleness check compares `package.json` / `package-lock.json` against the tree npm actually installed and warns (fix: `npm install`) when they disagree — but only reports PASS after a comparison that compared something, recording an explicit "skipped" result for lockfile shapes it can't compare (v1/v2 lockfiles, root-only maps) rather than an unearned green. An orphaned-Vite check warns when :5173 is serving while both backend ports are down — the "editor loads but nothing works" state a crashed `dev:standalone` leaves behind — after confirming the port really is Vite. Both self-gate to the `tandem-editor` checkout and never appear for an end user running `tandem doctor` in their own project.
+- **A `release` skill codifies the six-surface version bump (#1191).** `.claude/skills/release/SKILL.md` records the full cut sequence: the six version surfaces (four CI-guarded, the two lockfiles not), the changelog and tag steps, and the draft-then-publish GitHub Release flow. The `dev-server` skill gains an orphaned-Vite recovery step, and three Windows/cross-platform gotchas were promoted into `CLAUDE.md`.
 
 ## [0.16.0] - 2026-07-13
 

package/dist/cli/index.js

@@ -290,7 +290,7 @@ function resolveChannelDist(env = process.env, exists = existsSync) {
   return resolve2(PACKAGE_ROOT, "dist/channel/index.js");
 }
 function resolveCliVersion() {
-  if (true) return "0.16.0";
+  if (true) return "0.17.0";
   if (typeof __APP_VERSION__ !== "undefined") return __APP_VERSION__;
   for (const rel of ["../../package.json", "../../../package.json"]) {
     try {
@@ -2447,8 +2447,12 @@ var init_lockfile = __esm({
 // src/cli/doctor.ts
 var doctor_exports = {};
 __export(doctor_exports, {
+  evaluateNpmStaleness: () => evaluateNpmStaleness,
+  evaluateOrphanedVite: () => evaluateOrphanedVite,
   evaluateStaleGlobal: () => evaluateStaleGlobal,
   globalTandemEditorVersion: () => globalTandemEditorVersion,
+  isTandemEditorRepo: () => isTandemEditorRepo,
+  probeTandemEditorRepo: () => probeTandemEditorRepo,
   runDoctor: () => runDoctor,
   runDoctorCli: () => runDoctorCli,
   summarizeDoctorResults: () => summarizeDoctorResults
@@ -2459,6 +2463,10 @@ import { request } from "http";
 import { createConnection as createConnection2 } from "net";
 import { homedir as homedir3, platform } from "os";
 import { join as join5 } from "path";
+function errorClass(err) {
+  if (err instanceof Error) return err.name;
+  return typeof err;
+}
 function checkNodeVersion(r) {
   const version2 = process.version;
   const major = Number.parseInt(version2.slice(1), 10);
@@ -2478,6 +2486,204 @@ function checkNodeModules(r) {
     r.fail("node_modules/ not found", "npm install");
   }
 }
+function recordEvaluation(r, result) {
+  if (!result) return;
+  if (result.status === "warn") {
+    r.warn(result.message, result.fix, result.data);
+    return;
+  }
+  if (result.status === "skip") {
+    r.pass(`skipped \u2014 ${result.message}`, result.fix, { ...result.data, skipped: true });
+    return;
+  }
+  r.pass(result.message, result.fix, result.data);
+}
+function probeTandemEditorRepo(dir) {
+  const read = readJson(join5(dir, "package.json"));
+  if (read.kind === "absent") return "no";
+  if (read.kind === "unreadable") return "unreadable";
+  const parsed = read.value;
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return "unreadable";
+  }
+  return parsed.name === "tandem-editor" ? "yes" : "no";
+}
+function isTandemEditorRepo(dir) {
+  return probeTandemEditorRepo(dir) === "yes";
+}
+function readJson(path8) {
+  let raw;
+  try {
+    raw = readFileSync3(path8, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return { kind: "absent" };
+    return { kind: "unreadable", reason: code ?? errorClass(err) };
+  }
+  try {
+    return { kind: "ok", value: JSON.parse(raw) };
+  } catch {
+    return { kind: "unreadable", reason: "not valid JSON" };
+  }
+}
+function parseLockfileEntry(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const entry = value;
+  if (entry.version !== void 0 && typeof entry.version !== "string") return null;
+  if (entry.optional !== void 0 && typeof entry.optional !== "boolean") return null;
+  return {
+    version: entry.version,
+    optional: entry.optional
+  };
+}
+function parseLockfileJson(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const obj = value;
+  if (obj.version !== void 0 && typeof obj.version !== "string") return null;
+  const version2 = obj.version;
+  if (obj.packages === void 0) return { version: version2 };
+  if (typeof obj.packages !== "object" || obj.packages === null || Array.isArray(obj.packages)) {
+    return null;
+  }
+  const packages = {};
+  for (const [path8, raw] of Object.entries(obj.packages)) {
+    const entry = parseLockfileEntry(raw);
+    if (!entry) return null;
+    packages[path8] = entry;
+  }
+  return { version: version2, packages };
+}
+function evaluateNpmStaleness(pkgInput, lockInput, hiddenLockInput) {
+  if (!pkgInput || !lockInput || !hiddenLockInput) return null;
+  const lock = parseLockfileJson(lockInput);
+  if (!lock) {
+    return {
+      status: "skip",
+      message: "cannot compare (package-lock.json has an unexpected structure)",
+      fix: "Restore it from git: git checkout package-lock.json",
+      data: { reason: "malformed-lock" }
+    };
+  }
+  const hiddenLock = parseLockfileJson(hiddenLockInput);
+  if (!hiddenLock) {
+    return {
+      status: "skip",
+      message: "cannot compare (node_modules/.package-lock.json has an unexpected structure)",
+      fix: "npm install",
+      data: { reason: "malformed-hidden-lock" }
+    };
+  }
+  const pkg = typeof pkgInput === "object" && !Array.isArray(pkgInput) ? pkgInput : {};
+  const pkgVersion = typeof pkg.version === "string" ? pkg.version : void 0;
+  if (pkgVersion && lock.version && pkgVersion !== lock.version) {
+    return {
+      status: "warn",
+      message: `package-lock.json (v${lock.version}) is out of date with package.json (v${pkgVersion})`,
+      fix: "npm install",
+      data: { packageVersion: pkgVersion, lockVersion: lock.version }
+    };
+  }
+  if (lock.version && hiddenLock.version && lock.version !== hiddenLock.version) {
+    return {
+      status: "warn",
+      message: `node_modules was installed from a different lockfile (v${hiddenLock.version} installed, v${lock.version} expected)`,
+      fix: "npm install",
+      data: { lockVersion: lock.version, installedVersion: hiddenLock.version }
+    };
+  }
+  const wanted = lock.packages ?? {};
+  const installed = hiddenLock.packages ?? {};
+  const wantedCount = Object.keys(wanted).filter((path8) => path8 !== "").length;
+  if (wantedCount === 0) {
+    return {
+      status: "skip",
+      message: "cannot compare (package-lock.json lists no packages \u2014 a lockfileVersion 1 file, or one written by something other than npm)",
+      fix: "npm install",
+      // No inferred `lockfileVersion` here: we did not read that field, and
+      // guessing it from the presence of `packages` would put a fabricated
+      // value under a real npm field name.
+      data: { reason: "no-comparable-packages" }
+    };
+  }
+  const drifted = [];
+  for (const [path8, entry] of Object.entries(wanted)) {
+    if (path8 === "") continue;
+    const got = installed[path8];
+    if (!got) {
+      if (!entry.optional) drifted.push(path8);
+    } else if (entry.version !== got.version) {
+      drifted.push(path8);
+    }
+  }
+  for (const path8 of Object.keys(installed)) {
+    if (path8 !== "" && !(path8 in wanted)) drifted.push(path8);
+  }
+  if (drifted.length > 0) {
+    return {
+      status: "warn",
+      message: `node_modules is stale \u2014 ${drifted.length} package(s) differ from package-lock.json (e.g. after a pull or branch switch)`,
+      fix: "npm install",
+      data: { driftCount: drifted.length, sample: drifted.slice(0, 5) }
+    };
+  }
+  const missingVersions = [];
+  if (!pkgVersion) missingVersions.push("package.json");
+  if (!lock.version) missingVersions.push("package-lock.json");
+  if (!hiddenLock.version) missingVersions.push("node_modules/.package-lock.json");
+  if (missingVersions.length > 0) {
+    return {
+      status: "skip",
+      message: `node_modules matches package-lock.json, but the version check could not run \u2014 no "version" field in ${missingVersions.join(", ")}`,
+      data: { reason: "no-comparable-version", missingVersions }
+    };
+  }
+  return {
+    status: "pass",
+    message: "node_modules matches package-lock.json",
+    data: { packageCount: Object.keys(installed).length }
+  };
+}
+function readLockfileOrReport(r, path8, label) {
+  const read = readJson(path8);
+  if (read.kind === "absent") {
+    r.pass(`skipped \u2014 cannot compare (${label} not found)`, void 0, {
+      skipped: true,
+      reason: "absent",
+      path: label
+    });
+    return { ok: false };
+  }
+  if (read.kind === "ok") {
+    if (typeof read.value === "object" && read.value !== null && !Array.isArray(read.value)) {
+      return { ok: true, value: read.value };
+    }
+    r.warn(
+      `${label} is not a JSON object \u2014 npm install staleness cannot be checked`,
+      "Check for a truncated or hand-edited file, then: npm install",
+      { reason: "not-an-object", path: label }
+    );
+    return { ok: false };
+  }
+  r.warn(
+    `${label} could not be read (${read.reason}) \u2014 npm install staleness cannot be checked`,
+    "Check for merge-conflict markers or a truncated file, then: npm install",
+    { reason: read.reason, path: label }
+  );
+  return { ok: false };
+}
+function checkNpmStaleness(r, repoDir) {
+  const pkgRead = readJson(join5(repoDir, "package.json"));
+  const pkg = pkgRead.kind === "ok" ? pkgRead.value : null;
+  const lock = readLockfileOrReport(r, join5(repoDir, "package-lock.json"), "package-lock.json");
+  if (!lock.ok) return;
+  const hiddenLock = readLockfileOrReport(
+    r,
+    join5(repoDir, "node_modules", ".package-lock.json"),
+    "node_modules/.package-lock.json"
+  );
+  if (!hiddenLock.ok) return;
+  recordEvaluation(r, evaluateNpmStaleness(pkg, lock.value, hiddenLock.value));
+}
 function checkMcpJson(r) {
   const mcpPath = join5(process.cwd(), ".mcp.json");
   if (!existsSync3(mcpPath)) {
@@ -2603,14 +2809,64 @@ async function checkPorts(r, wsPort, mcpPort) {
   }
   return { ws, mcp };
 }
+function evaluateOrphanedVite(input) {
+  const { viteUp, viteConfirmed, wsUp, mcpUp, wsPort, mcpPort, vitePort } = input;
+  if (!viteUp) return null;
+  if (!viteConfirmed) {
+    return {
+      status: "skip",
+      message: `cannot identify the process on :${vitePort} \u2014 it is listening but did not answer /@vite/client, so it is probably not a Vite dev server`,
+      data: { vite: false, ws: wsUp, mcp: mcpUp, reason: "unconfirmed-vite" }
+    };
+  }
+  if (!wsUp && !mcpUp) {
+    return {
+      status: "warn",
+      message: `Vite dev server on :${vitePort} is running but the backend (:${wsPort} + :${mcpPort}) is down \u2014 likely orphaned by a crashed dev session`,
+      fix: `If you meant to run the client alone (npm run dev:client), this is expected. Otherwise kill the process on :${vitePort} and restart: npm run dev:standalone`,
+      data: { vite: true, ws: wsUp, mcp: mcpUp }
+    };
+  }
+  if (wsUp !== mcpUp) {
+    return {
+      status: "skip",
+      message: `cannot tell whether the Vite dev server on :${vitePort} is orphaned \u2014 the backend is only partially up (:${wsPort} ${wsUp ? "up" : "down"}, :${mcpPort} ${mcpUp ? "up" : "down"}); see the ports check`,
+      data: { vite: true, ws: wsUp, mcp: mcpUp, reason: "partial-backend" }
+    };
+  }
+  return {
+    status: "pass",
+    message: `Vite dev server (:${vitePort}) running alongside the backend`,
+    data: { vite: true, ws: wsUp, mcp: mcpUp }
+  };
+}
+async function checkOrphanedVite(r, wsUp, mcpUp, wsPort, mcpPort, vitePort) {
+  const viteUp = await probePort(vitePort);
+  const viteConfirmed = viteUp ? await isViteDevServer(vitePort) : false;
+  recordEvaluation(
+    r,
+    evaluateOrphanedVite({ viteUp, viteConfirmed, wsUp, mcpUp, wsPort, mcpPort, vitePort })
+  );
+}
 function httpGet(url, timeoutMs = 3e3) {
   return new Promise((resolve4) => {
     const req = request(url, { timeout: timeoutMs }, (res) => {
       let body = "";
+      let bytes = 0;
+      let truncated = false;
       res.on("data", (chunk) => {
+        if (truncated) return;
+        bytes += Buffer.byteLength(chunk);
+        if (bytes > HTTP_MAX_BYTES) {
+          truncated = true;
+          res.destroy();
+          resolve4({ status: res.statusCode, data: null });
+          return;
+        }
         body += chunk;
       });
       res.on("end", () => {
+        if (truncated) return;
         try {
           resolve4({ status: res.statusCode, data: JSON.parse(body) });
         } catch {
@@ -2626,6 +2882,10 @@ function httpGet(url, timeoutMs = 3e3) {
     req.end();
   });
 }
+async function isViteDevServer(port) {
+  const result = await httpGet(`http://127.0.0.1:${port}/@vite/client`, 2e3);
+  return result?.status === 200;
+}
 async function checkHealth(r, mcpPort) {
   const result = await httpGet(`http://127.0.0.1:${mcpPort}/health`);
   if (!result) {
@@ -2865,7 +3125,7 @@ function evaluateStaleGlobal(bundled, globalVersion) {
   };
 }
 async function checkStaleGlobal(r) {
-  const bundled = true ? "0.16.0" : null;
+  const bundled = true ? "0.17.0" : null;
   if (!bundled) return;
   let globalVersion;
   try {
@@ -2884,16 +3144,37 @@ async function checkStaleGlobal(r) {
 async function runDoctor(opts = {}) {
   const wsPort = opts.wsPort ?? DEFAULT_WS_PORT;
   const mcpPort = opts.mcpPort ?? DEFAULT_MCP_PORT;
+  const vitePort = opts.vitePort ?? VITE_DEV_PORT;
   const r = new Recorder();
+  const cwd = process.cwd();
+  const repo = probeTandemEditorRepo(cwd);
+  const devRepo = repo === "yes";
   await r.check("node-version", () => checkNodeVersion(r));
   await r.check("node-modules", () => checkNodeModules(r));
+  if (repo === "unreadable") {
+    await r.check(
+      "dev-repo",
+      () => r.warn(
+        "package.json in the current directory could not be read \u2014 if this is the tandem-editor checkout, the npm-staleness and orphaned-Vite checks are being skipped",
+        "Check for merge-conflict markers or a truncated file: git checkout package.json"
+      )
+    );
+  }
+  if (devRepo) {
+    await r.check("npm-staleness", () => checkNpmStaleness(r, cwd));
+  }
   await r.check("mcp-json", () => checkMcpJson(r));
   await r.check("user-mcp-config", () => checkUserMcpConfig(r));
   await r.check("annotation-store", () => checkAnnotationStore(r));
   await r.check("stale-global", () => checkStaleGlobal(r));
-  const { mcp } = await r.check("ports", () => checkPorts(r, wsPort, mcpPort));
+  const ports = await r.check("ports", () => checkPorts(r, wsPort, mcpPort));
+  const ws = ports?.ws ?? false;
+  const mcp = ports?.mcp ?? false;
+  if (devRepo) {
+    await r.check("orphaned-vite", () => checkOrphanedVite(r, ws, mcp, wsPort, mcpPort, vitePort));
+  }
   if (mcp) {
-    const healthy = await r.check("health", () => checkHealth(r, mcpPort));
+    const healthy = await r.check("health", () => checkHealth(r, mcpPort)) ?? false;
     if (healthy) {
       await r.check("sse", () => checkSseEndpoint(r, mcpPort));
     }
@@ -2976,7 +3257,7 @@ async function runDoctorCli(opts = {}) {
   out("");
   return exitCode;
 }
-var Recorder;
+var Recorder, VITE_DEV_PORT, HTTP_MAX_BYTES;
 var init_doctor = __esm({
   "src/cli/doctor.ts"() {
     "use strict";
@@ -2987,11 +3268,29 @@ var init_doctor = __esm({
       warnings = 0;
       results = [];
       currentCheck = "";
+      /**
+       * Run one check under `name`. A throwing check is contained here and
+       * recorded as a `fail` rather than taking the whole report down.
+       *
+       * Returns `T | undefined` — NOT `T`. The `undefined` is load-bearing and
+       * must not be cast away: a crashed check produced no value, and the two
+       * callers that consume one (`ports` destructures `{ws, mcp}`; `health`
+       * gates the `sse` check) have to say what they want instead. Returning
+       * `undefined as T` would satisfy the compiler and then throw a TypeError
+       * on the destructure — converting a clear crash into a confusing one on
+       * the exact path this containment exists to protect.
+       */
       async check(name, fn) {
         const prev = this.currentCheck;
         this.currentCheck = name;
         try {
           return await fn();
+        } catch (err) {
+          this.fail(
+            `${name} check crashed (${errorClass(err)}) \u2014 the rest of the report is still valid`,
+            "Please report this at https://github.com/bloknayrb/tandem/issues"
+          );
+          return void 0;
         } finally {
           this.currentCheck = prev;
         }
@@ -3014,6 +3313,8 @@ var init_doctor = __esm({
         this.record("fail", msg, fix, fields);
       }
     };
+    VITE_DEV_PORT = 5173;
+    HTTP_MAX_BYTES = 256 * 1024;
   }
 });
 
@@ -3696,7 +3997,7 @@ import fs4 from "fs";
 function knownVersion(v) {
   return typeof v === "string" && KNOWN_VERSION_MAJORS.has(v.split(".")[0]);
 }
-function readJson(filePath) {
+function readJson2(filePath) {
   try {
     return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
   } catch {
@@ -3709,7 +4010,7 @@ function resolveLicenseState(deps) {
     return { gateActive: false };
   }
   const nowMs = now();
-  const lf = readJson(licenseFilePath(appDataDir));
+  const lf = readJson2(licenseFilePath(appDataDir));
   if (lf?.blob) {
     try {
       const meta = verify(lf.blob);
@@ -3726,7 +4027,7 @@ function resolveLicenseState(deps) {
     } catch {
     }
   }
-  const tf = readJson(trialFilePath(appDataDir));
+  const tf = readJson2(trialFilePath(appDataDir));
   const firstRunAt = tf?.firstRunAt ? new Date(tf.firstRunAt).getTime() : nowMs;
   const expiresAt = firstRunAt + TRIAL_MS;
   if (nowMs < expiresAt) {
@@ -3917,7 +4218,7 @@ process.once("unhandledRejection", (reason) => {
 `);
   process.exit(1);
 });
-var version = true ? "0.16.0" : "0.0.0-dev";
+var version = true ? "0.17.0" : "0.0.0-dev";
 var args = process.argv.slice(2);
 if (args.includes("--help") || args.includes("-h")) {
   console.log(`tandem v${version}