@webship.co/workspace 1.0.0-beta2 → 1.0.0-rc1

package/core/workspace-app/PLUGINS.md

@@ -39,7 +39,8 @@ the same shape, which is how one is developed before it gets a repository.
                "machine": ["scripts/upsun-ai.sh"], "hostInstall": "scripts/host-install.sh" },
   "ddev": { "compose": ["ddev/docker-compose.upsun-cli.yaml"], "hostMounts": ["~/.upsun-cli"] },
   "themes": ["config/theme.upsun.yml"],
-  "css": ["public/upsun.css"]
+  "css": ["public/upsun.css"],
+  "features": ["features/upsun.feature"]              // webship-js scenarios, run by the dashboard's own suite
 }
 ```
 
@@ -51,6 +52,13 @@ compose files as `core/workspace-app/.ddev/docker-compose.plugin-<name>-<file>`;
 `host-mounts.txt` that `host-mounts.sh` reads; themes in `core/config/`. `hostInstall` runs with
 `--check` after an install and in full from `install.sh`.
 
+Features land in `core/workspace-app/tests/features/plugins/<name>/`, so `ddev test-dashboard browser`
+runs them with the core's. A scenario that only holds when one of the plugin's settings is set says
+so in a tag: `@needs-setting-<plugin>-<key>` skips it, with the reason, while
+`core/config/plugin.<plugin>.settings.yml` has no value for `<key>` (the Jira feature tags its menu
+scenario `@needs-setting-jira-default_project`). A plugin ships no step definitions: webship-js's
+own steps and the core's are what a feature can use.
+
 Everything stays HTMX + UIKit: a plugin serves server-rendered fragments and wires them with
 `hx-get`/`hx-post`; no client frameworks.
 

package/core/workspace-app/package.json

@@ -1,7 +1,7 @@
 {
   "name": "workspace-dashboard",
-  "version": "1.0.0-beta2",
-  "description": "The Webship Workspace dashboard: a lean core (workspaces, builders, settings, the assistant shell, the plugin system) that every feature joins as a @webship.co/workspace-<name> plugin \u2014 required with npm, then activated, installed and configured.",
+  "version": "1.0.0-rc1",
+  "description": "The Webship Workspace dashboard: a lean core (workspaces, builders, settings, the assistant shell, the plugin system) that every feature joins as a @webship.co/workspace-<name> plugin — required with npm, then activated, installed and configured.",
   "license": "ISC",
   "main": "server.js",
   "scripts": {

package/core/workspace-app/tests/features/assistant-speech.feature

@@ -57,7 +57,7 @@ Feature: Talking to the assistant
   # A browser with no synthesis voices accepts speak(), fires error: synthesis-failed, and is silent.
   # Nothing reported it, so "read replies aloud" looked switched on and did nothing at all — the worst
   # state a setting can be in.
-  Scenario: The settings page says which voices this browser actually has
-    Given I am on "/settings"
+  Scenario: The settings file editor says which voices this browser actually has
+    Given I am on "/settings/settings.yml"
      Then "[data-voice-name]" should be attached
       And the voice list should report what this browser has

package/core/workspace-app/tests/features/checks.feature

@@ -31,6 +31,7 @@ Feature: The checks a project already declares
 
   # A site gets the same nested list: its package.json declares the same vocabulary, and its
   # ddev-dev-tools add-on adds the PHP and Twig checks on top.
+  @needs-testing-stack
   Scenario: A site keeps its testing verbs and gains the checks beside them
     Given I am on "/dev"
      Then the element ".project-row .act-menu-tests" should be displayed

package/core/workspace-app/tests/features/clone-project.feature

@@ -7,14 +7,14 @@ Feature: Cloning a project
      Then "[hx-get^='/fragments/projects/clone-form/dev/']" should be attached
 
   Scenario: The form arrives prefilled, with the live check wired
-    Given I am on "/fragments/projects/clone-form/dev/v11x00b1i18n"
-     Then "input[name='to'][value='v11x00b1i18n-copy']" should be attached
+    When I open the clone form of the first project in "dev"
+     Then the clone form proposes a copy of that project
       And "select[name='toWorkspace']" should be attached
       And "[hx-get='/fragments/projects/clone-check']" should be attached
       And "textarea[name='prompt']" should be attached
 
   Scenario: The live check refuses an existing project
-    Given I am on "/fragments/projects/clone-check?to=v11x00b1i18n&toWorkspace=dev"
+    When I ask the live check about the name of the first project in "dev"
      Then I should see "already exists"
 
   Scenario: The live check blesses a free name
@@ -22,7 +22,7 @@ Feature: Cloning a project
      Then I should see "is free"
 
   Scenario: Cloning over an existing project is refused server-side too
-    When I post "/actions/clone-project" with '{"workspace":"dev","projectName":"v11x00b1i18n","to":"v11x00b1i18n","toWorkspace":"dev"}'
+    When I post a clone of the first project in "dev" over itself
     Then the action response should contain "already exists"
 
   Scenario: A source that does not exist is refused

package/core/workspace-app/tests/features/project-actions.feature

@@ -15,6 +15,7 @@ Feature: What a project row can actually do
 
   # These two are the whole testing feature as far as the interface is concerned: one sets the
   # environment up, the other runs the suite. Both post to their own action.
+  @needs-testing-stack
   Scenario: The Tests menu offers setting the environment up and running the suite
     Given I am on "/dev"
      Then "[hx-post='/actions/testing-configure']" should be attached
@@ -34,7 +35,7 @@ Feature: What a project row can actually do
       And I should see "Describe (URLs, services)"
 
   # Launch belongs with the hostname it opens, not in the row of things you DO to a project.
-  Scenario: A running project offers its own URL beside the Launch button
+  @needs-running-project
+  Scenario: A running project shows its own host on its card
     Given I am on "/dev"
-     Then the element ".proj-launch-line" should be displayed
-      And the element ".proj-launch-line .proj-alias" should be displayed
+     Then ".project-row .pcard-host-name" should be attached

package/core/workspace-app/tests/step-definitions/assistant-speech.steps.js

@@ -39,12 +39,17 @@ Then(/^the assistant should offer voice input$/, async function () {
 });
 
 Then(/^the assistant should read its replies aloud$/, async function () {
-  const cfg = await speechConfig(this.page);
+  // The replies are read by the panel's own narrator, not by deep-chat (whose textToSpeech the panel
+  // sets to false on purpose: it would speak the HTML). What must hold is that the panel was handed
+  // narration that is switched on and resolved: a voice with a rate.
+  const cfg = await this.page.evaluate(() => {
+    const el = document.querySelector('deep-chat');
+    if (!el) return null;
+    try { return JSON.parse(el.dataset.settings || '{}'); } catch (_) { return {}; }
+  });
   assert.ok(cfg, 'there is no deep-chat element on this page');
-  assert.notStrictEqual(cfg.textToSpeech, 'unset', 'deep-chat was never given a textToSpeech config');
-  assert.notStrictEqual(cfg.textToSpeech, false, 'voice output is switched off');
-  // Its presence IS the read-aloud behaviour; there is no separate switch to check.
-  assert.ok(Number.isFinite(cfg.textToSpeech.rate), 'no speech rate, so the config is not the resolved one');
+  assert.notStrictEqual(cfg.voiceOutput, false, 'voice output is switched off');
+  assert.ok(cfg.narration && Number.isFinite(cfg.narration.rate), 'no narration voice with a speech rate, so the config is not the resolved one');
 });
 
 /**

package/core/workspace-app/tests/step-definitions/clone-project.steps.js

@@ -0,0 +1,47 @@
+/**
+ * The clone action, exercised on whatever project the dev workspace holds first, so the scenarios
+ * name no project of one machine (#89). The project is read from the tree the dashboard serves.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+
+const APP = path.join(__dirname, '..', '..');
+const BASE = () => process.env.LAUNCH_URL || 'https://workspace.ddev.site';
+
+function firstProject(wsKey) {
+  const { loadWorkspaces } = require(path.join(APP, 'workspaces'));
+  const dir = loadWorkspaces()[wsKey].dir;
+  const first = fs.readdirSync(dir).filter((p) => !p.startsWith('.') && fs.statSync(path.join(dir, p)).isDirectory()).sort()[0];
+  assert.ok(first, `the ${wsKey} workspace holds no project to clone`);
+  return first;
+}
+
+Given('{string} is the first project of the {string} workspace', function (alias, wsKey) {
+  this.cloneProject = firstProject(wsKey); this.cloneWorkspace = wsKey;
+});
+
+When('I open the clone form of the first project in {string}', async function (wsKey) {
+  this.cloneProject = firstProject(wsKey); this.cloneWorkspace = wsKey;
+  await this.page.goto(`${BASE()}/fragments/projects/clone-form/${wsKey}/${encodeURIComponent(this.cloneProject)}`, { waitUntil: 'domcontentloaded' });
+});
+
+Then('the clone form proposes a copy of that project', async function () {
+  await this.page.locator(`input[name='to'][value='${this.cloneProject}-copy']`).waitFor({ state: 'attached', timeout: 10000 });
+});
+
+When('I ask the live check about the name of the first project in {string}', async function (wsKey) {
+  this.cloneProject = firstProject(wsKey); this.cloneWorkspace = wsKey;
+  await this.page.goto(`${BASE()}/fragments/projects/clone-check?to=${encodeURIComponent(this.cloneProject)}&toWorkspace=${wsKey}`, { waitUntil: 'domcontentloaded' });
+});
+
+When('I post a clone of the first project in {string} over itself', async function (wsKey) {
+  this.cloneProject = firstProject(wsKey); this.cloneWorkspace = wsKey;
+  const form = { workspace: wsKey, projectName: this.cloneProject, to: this.cloneProject, toWorkspace: wsKey };
+  const response = await this.page.request.post(`${BASE()}/actions/clone-project`, { form });
+  this.lastActionResponse = await response.text();
+});

package/core/workspace-app/tests/step-definitions/preconditions.steps.js

@@ -97,4 +97,72 @@ Before({ tags: '@needs-check-aliases' }, function () {
   return undefined;
 });
 
-module.exports = { settingValue, APP };
+Before({ tags: '@needs-testing-stack' }, function () {
+  // A row offers "Run the tests" only when the project has a testing stack (a webship-js project,
+  // or the init-full-automated-testing command); the Tests menu of a bare site has nothing to run.
+  let any = false;
+  try {
+    const { testingStackOf } = require(path.join(APP, 'test-reports'));
+    const { loadWorkspaces } = require(path.join(APP, 'workspaces'));
+    const dir = loadWorkspaces().dev.dir;
+    any = fs.readdirSync(dir).some((p) => {
+      try { return fs.statSync(path.join(dir, p)).isDirectory() && testingStackOf(dir, p) !== 'none'; } catch (_) { return false; }
+    });
+  } catch (_) { any = false; }
+  if (!any) {
+    this.attach('SKIPPED: no project in dev/ has a testing stack (a cucumber.js, tests/step-definitions, '
+      + 'or the init-full-automated-testing command), so no row offers "Run the tests". Set one up and '
+      + 'this becomes a real test again.');
+    return 'skipped';
+  }
+  return undefined;
+});
+
+Before({ tags: '@needs-running-project' }, function () {
+  // The card shows a project's host only while DDEV reports it running.
+  let any = false;
+  try {
+    const { execFileSync } = require('child_process');
+    const { loadWorkspaces } = require(path.join(APP, 'workspaces'));
+    const dir = fs.realpathSync(loadWorkspaces().dev.dir);
+    const out = JSON.parse(execFileSync('ddev', ['list', '--json-output'], { encoding: 'utf8', timeout: 60000 }));
+    any = (out.raw || []).some((p) => p.status === 'running' && String(p.approot || '').startsWith(dir + path.sep));
+  } catch (_) { any = false; }
+  if (!any) {
+    this.attach('SKIPPED: no project in dev/ is running (ddev list), so no card shows a host. Start one '
+      + 'and this becomes a real test again.');
+    return 'skipped';
+  }
+  return undefined;
+});
+
+/** A scalar out of a plugin's own settings file (core/config/plugin.<name>.settings.yml), or ''. */
+function pluginSettingValue(plugin, key) {
+  try {
+    const yml = fs.readFileSync(path.join(ROOT, 'core', 'config', `plugin.${plugin}.settings.yml`), 'utf8');
+    const m = yml.match(new RegExp(`^\\s*${key}:\\s*(.+)$`, 'm'));
+    return m ? m[1].trim().replace(/^["']|["']$/g, '').replace(/\s+#.*$/, '') : '';
+  } catch (_) { return ''; }
+}
+
+// A plugin ships features into this suite but no hooks, so it states a precondition in its tag:
+// `@needs-setting-<plugin>-<key>` skips the scenario, with the reason, while that key has no value in
+// the plugin's settings file. The plugin name ends at the first hyphen that is followed by the key,
+// so a plugin named with hyphens tags `@needs-setting-google-drive-folder_id` and the key is the part
+// after the last plugin-name hyphen: the key itself never contains a hyphen (settings keys are snake_case).
+const NEEDS_SETTING = /^@needs-setting-(.+)-([a-z0-9_]+)$/;
+Before(function (scenario) {
+  for (const t of scenario.pickle.tags || []) {
+    const m = NEEDS_SETTING.exec(t.name);
+    if (!m) continue;
+    const [, plugin, key] = m;
+    if (!pluginSettingValue(plugin, key)) {
+      this.attach(`SKIPPED: core/config/plugin.${plugin}.settings.yml has no ${key} on this machine; `
+        + `set it and this becomes a real test again.`);
+      return 'skipped';
+    }
+  }
+  return undefined;
+});
+
+module.exports = { settingValue, pluginSettingValue, APP };

package/core/workspace-app/tests/unit/changelog.test.js

@@ -8,13 +8,53 @@
 
 'use strict';
 
-const test = require('node:test');
+const { test, before, after } = require('node:test');
 const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { copyConfig } = require('./_isolated-config');
+
+// The walk is tested on a tree built here, not on whatever this checkout holds: a fresh clone has no
+// built site and no changelog in it, and a test that passed only on a full machine said nothing about
+// the code. The module reads its root once, at load, so the root is set before it is required.
+const REPO = path.join(__dirname, '../../../..');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-changelog-root-'));
+process.env.WORKSPACE_ROOT = root;
 
 const {
   parseChangelog, kindOf, looksLikeVersion, listChangelogs, changelogFor, releasesFor, changelogIndex,
 } = require('../../changelog');
 
+const write = (rel, text) => {
+  fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+  fs.writeFileSync(path.join(root, rel), text);
+};
+
+before(() => {
+  fs.mkdirSync(path.join(root, 'core'), { recursive: true });
+  copyConfig(path.join(REPO, 'core/config'), path.join(root, 'core/config'));
+  // A product with a Keep a Changelog file (Unreleased on top, as they are written), a built site in
+  // dev/ with the old Drupal .txt, and a project that keeps none.
+  write('products/starter/CHANGELOG.md', `# Changelog
+
+## [Unreleased]
+### Added
+- Something that is not out yet
+
+## [1.0.3] - 2026-09-14
+### Added
+- Add a Newsletter Canvas page at \`/newsletter\`
+`);
+  write('dev/blog1/CHANGELOG.txt', `Blog 7.x-1.1, 2012-02-22
+------------------------
+- #1 by someone: a fix
+`);
+  write('dev/plain/README.md', 'No changelog here.\n');
+});
+
+after(() => fs.rmSync(root, { recursive: true, force: true }));
+
 /* ---------------- the formats ---------------- */
 
 test('Keep a Changelog: version, date, and the kind from the section', () => {
@@ -138,7 +178,7 @@ test('an empty file, and a file of nothing but prose, are no releases rather tha
   assert.deepEqual(parseChangelog('# Changelog\n\nAll notable changes are documented here.\n'), []);
 });
 
-/* ---------------- against the real tree ---------------- */
+/* ---------------- against the tree built above ---------------- */
 
 test('a changelog anywhere in the tree is found, not only in products/', () => {
   const found = listChangelogs();
@@ -151,7 +191,9 @@ test('a changelog anywhere in the tree is found, not only in products/', () => {
   // The point of the change: it is a walk of every workspace, not a list of one.
   const workspaces = new Set(found.map((c) => c.workspace));
   assert.ok(workspaces.size > 1,
-    `only ${[...workspaces]} was walked — a built site in dev/ keeps one too`);
+    `only ${[...workspaces]} was walked, and a built site in dev/ keeps one too`);
+  assert.deepEqual(found.map((c) => `${c.workspace}/${c.item}`).sort(), ['dev/blog1', 'products/starter'],
+    'both files, and nothing for the project that keeps none');
 });
 
 test('a name that climbs out of its workspace is refused', () => {
@@ -174,4 +216,8 @@ test('the index summarises everything without throwing on any of it', () => {
     // The newest release is the first in the file, never "Unreleased" — a version people can install.
     assert.ok(!/^unreleased$/i.test(r.latest), `${r.label} reports Unreleased as its latest`);
   }
+  const starter = rows.find((r) => r.item === 'starter');
+  assert.equal(starter.latest, '1.0.3', 'the Unreleased block on top is passed over');
+  assert.equal(starter.unreleasedEntries, 1);
+  assert.equal(rows.find((r) => r.item === 'blog1').latest, 'Blog 7.x-1.1');
 });

package/core/workspace-app/tests/unit/ddev-domains.test.js

@@ -9,14 +9,39 @@
 
 'use strict';
 
-const test = require('node:test');
+const { test, before, after } = require('node:test');
 const assert = require('node:assert');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { copyConfig } = require('./_isolated-config');
+
+// The walk over the workspaces runs on a tree built here, not on this checkout: a fresh clone holds no
+// project at all. The workspaces module reads its root once, at load, so it is set before the require.
+const REPO = path.join(__dirname, '../../../..');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-ddev-domains-root-'));
+process.env.WORKSPACE_ROOT = root;
 
 const { ddevHostnames, ddevExtraDomains } = require('../../ddev-domains');
-const { ROOT } = require('../../workspaces');
+const { loadWorkspaces } = require('../../workspaces');
+
+/** A DDEV project inside a workspace of the built tree. */
+function inTree(workspace, name, yaml) {
+  const dir = path.join(root, workspace, name);
+  fs.mkdirSync(path.join(dir, '.ddev'), { recursive: true });
+  if (yaml !== null) fs.writeFileSync(path.join(dir, '.ddev', 'config.yaml'), yaml);
+}
+
+before(() => {
+  fs.mkdirSync(path.join(root, 'core'), { recursive: true });
+  copyConfig(path.join(REPO, 'core/config'), path.join(root, 'core/config'));
+  inTree('dev', 'blog', 'name: blog\nadditional_fqdns:\n  - storybook.blog.ddev.site\n');
+  inTree('dev', 'plain', 'name: plain\nadditional_hostnames:\n  - plain-dev\n');
+  inTree('products', 'shop', 'name: shop\nadditional_fqdns:\n  - mail.shop.ddev.site\n');
+  inTree('products', 'bare', null);
+});
+
+after(() => fs.rmSync(root, { recursive: true, force: true }));
 
 /** A throwaway project directory holding one .ddev/config.yaml. */
 function project(yaml) {
@@ -130,11 +155,10 @@ additional_fqdns:
     'only a host whose FIRST label is storybook is the component library');
 });
 
-/* ---------------- against the real tree ---------------- */
+/* ---------------- against the tree built above ---------------- */
 
 test('the projects in this tree that ship a Storybook are found', () => {
   // The regression in one line: before this parsed additional_fqdns, every one of these was absent.
-  const { loadWorkspaces } = require('../../workspaces');
   const found = [];
   for (const w of Object.values(loadWorkspaces())) {
     if (!w.dir) continue;
@@ -148,6 +172,8 @@ test('the projects in this tree that ship a Storybook are found', () => {
     }
   }
   assert.ok(found.length > 0,
-    'no project in the tree declares a Storybook domain — either the tree changed or the fqdn key stopped being read');
+    'no project in the tree declares a Storybook domain: the fqdn key stopped being read');
   for (const p of found) assert.ok(p.includes('/'), p);
+  assert.deepEqual(found, ['dev/blog'],
+    'the one with a storybook fqdn, and not the label-only, the mail-only or the project with no config');
 });

package/core/workspace-app/tests/unit/preconditions.test.js

@@ -0,0 +1,21 @@
+'use strict';
+// The precondition helpers read the machine's settings files the way the hooks do.
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+test('a plugin setting is read from the plugin\'s own file, and is empty when the file or the key is absent', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-precond-'));
+  fs.mkdirSync(path.join(tmp, 'core', 'config'), { recursive: true });
+  fs.writeFileSync(path.join(tmp, 'core', 'config', 'plugin.jira.settings.yml'), 'site: "https://example.atlassian.net"\ndefault_project: WEBSHIP  # the key folders inherit\nallow_writes: false\n');
+  // The hooks resolve ROOT from their own location; the helper is exercised through the same regex on a copy.
+  const src = fs.readFileSync(path.join(__dirname, '..', 'step-definitions', 'preconditions.steps.js'), 'utf8');
+  const fn = new Function('fs', 'path', 'ROOT', src.match(/function pluginSettingValue[\s\S]*?\n}\n/)[0] + '; return pluginSettingValue;')(fs, path, tmp);
+  assert.strictEqual(fn('jira', 'default_project'), 'WEBSHIP');
+  assert.strictEqual(fn('jira', 'site'), 'https://example.atlassian.net');
+  assert.strictEqual(fn('jira', 'missing_key'), '');
+  assert.strictEqual(fn('nope', 'default_project'), '');
+  fs.rmSync(tmp, { recursive: true, force: true });
+});

package/core/workspace-app/tests/unit/screens.test.js

@@ -5,12 +5,36 @@
  * of `screen`, so they are pinned here rather than left to the browser tests.
  */
 
-const { test } = require('node:test');
+const { test, before, after } = require('node:test');
 const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
 const path = require('path');
+const { copyConfig } = require('./_isolated-config');
+
+// The targets are read from a tree built here, not from this checkout: a fresh clone holds the
+// workspace folders and no project in any of them. The modules read their root once, at load, so
+// it is set before they are required.
+const APP = path.join(__dirname, '../..');
+const REPO = path.join(APP, '../..');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-screens-root-'));
+process.env.WORKSPACE_ROOT = root;
 
 const { screenTargets, screenTargetDir } = require('../../screens');
-const { ROOT } = require('../../workspaces');
+const { ROOT, loadWorkspaces } = require('../../workspaces');
+
+before(() => {
+  fs.mkdirSync(path.join(root, 'core'), { recursive: true });
+  copyConfig(path.join(REPO, 'core/config'), path.join(root, 'core/config'));
+  fs.symlinkSync(path.join(REPO, 'core/scripts'), path.join(root, 'core/scripts'));
+  fs.symlinkSync(APP, path.join(root, 'core/workspace-app'));
+  // Every workspace folder, as a clone has them; one project in dev/; a dot folder, which is not one.
+  for (const w of Object.values(loadWorkspaces())) fs.mkdirSync(w.dir, { recursive: true });
+  fs.mkdirSync(path.join(root, 'dev', 'blog1', '.ddev'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'dev', '.cache'), { recursive: true });
+});
+
+after(() => fs.rmSync(root, { recursive: true, force: true }));
 
 test('the workspace root is always a place to start a session', () => {
   const root = screenTargets().find((t) => t.value === 'root');
@@ -38,6 +62,10 @@ test('workspace folders and projects are offered separately', () => {
   assert.ok(targets.some((t) => t.group === 'Projects'), 'at least one project is offered');
   const dev = targets.find((t) => t.value === 'ws:dev');
   assert.ok(dev && dev.dir === path.join(ROOT, 'dev'));
+  const blog = targets.find((t) => t.value === 'p:dev:blog1');
+  assert.ok(blog && blog.group === 'Projects' && blog.dir === path.join(ROOT, 'dev', 'blog1'),
+    'the project in dev/ is offered under Projects');
+  assert.ok(!targets.some((t) => t.value === 'p:dev:.cache'), 'a dot folder is not a project');
 });
 
 // The name rule is shared by the form, the actions and both /fragments routes:
@@ -55,20 +83,11 @@ test('a session name may not start with a dash, and holds no shell characters',
 // share: the runner republishes its list every two seconds, so a stale file
 // means the runner is gone and nothing new may be started.
 test('a published session list is trusted only while it is fresh', () => {
-  const fs = require('fs');
-  const path = require('path');
-  const os = require('os');
-  const { ROOT } = require('../../workspaces');
   const file = path.join(ROOT, '.screens', 'host-sessions.json');
-  const had = fs.existsSync(file) ? fs.readFileSync(file) : null;
   const { hostSessionsFile } = require('../../jobs');
-  try {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, JSON.stringify({ at: Date.now(), host: os.hostname(), sessions: [{ session: 'a--b--c' }] }));
-    assert.equal(hostSessionsFile().sessions.length, 1, 'a list written now is the truth');
-    fs.writeFileSync(file, JSON.stringify({ at: Date.now() - 60000, sessions: [{ session: 'a--b--c' }] }));
-    assert.equal(hostSessionsFile(), null, 'a minute-old list means the runner stopped');
-  } finally {
-    if (had) fs.writeFileSync(file, had); else fs.rmSync(file, { force: true });
-  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify({ at: Date.now(), host: os.hostname(), sessions: [{ session: 'a--b--c' }] }));
+  assert.equal(hostSessionsFile().sessions.length, 1, 'a list written now is the truth');
+  fs.writeFileSync(file, JSON.stringify({ at: Date.now() - 60000, sessions: [{ session: 'a--b--c' }] }));
+  assert.equal(hostSessionsFile(), null, 'a minute-old list means the runner stopped');
 });

package/core/workspace-app/tests/unit/video-borrow.test.js

@@ -70,7 +70,12 @@ before(async () => {
   fs.copyFileSync(path.join(REPO, 'videos/cmd-tools-video-edit.sh'), path.join(root, 'videos/cmd-tools-video-edit.sh'));
   fs.writeFileSync(path.join(root, 'docs/main-voiceover-script.md'), MAIN_SCRIPT);
   fs.writeFileSync(path.join(root, 'docs/other-voiceover-script.md'), OTHER_SCRIPT);
-  if (!CAN_RUN) return;
+  if (!CAN_RUN) {
+    // No ffmpeg on this machine: the engine tests are skipped, but the form and the fragments read only a
+    // video's name beside its script, so a file by that name is enough for them to run here too.
+    for (const n of ['main.mp4', 'other.mp4']) fs.writeFileSync(V(n), Buffer.alloc(100, 1));
+    return;
+  }
   const make = (name, source, dur, tone) => run('ffmpeg', ['-y', '-loglevel', 'error', '-f', 'lavfi', '-i', `${source}:rate=15:duration=${dur}`,
     '-f', 'lavfi', '-i', `sine=frequency=${tone}:duration=${dur}`, '-c:v', 'libx264', '-preset', 'ultrafast', '-pix_fmt', 'yuv420p', '-c:a', 'aac',
     '-shortest', V(name)], { env: env() });
@@ -78,10 +83,27 @@ before(async () => {
   await make('other.mp4', 'smptebars=size=200x200', 9, 880);
 });
 
-after(() => {
-  for (const s of servers) s.kill();
-  fs.rmSync(root, { recursive: true, force: true });
-});
+/**
+ * Stop the servers this file started, then remove a tree, trying again for a moment. The server runs `ddev list` with
+ * HOME inside the tree, and a ddev still finishing after the server is gone puts `~/.ddev` back while the tree is
+ * being removed: a single rmSync then fails with ENOTEMPTY and the tree is left in /tmp.
+ */
+async function stopAndRemove(dirs) {
+  await Promise.all(servers.map((s) => new Promise((resolve) => {
+    if (s.exitCode !== null || s.signalCode !== null) return resolve();
+    s.once('exit', resolve);
+    s.kill();
+  })));
+  for (const dir of dirs) {
+    for (let i = 0; i < 50; i += 1) {
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_) { /* something was still writing */ }
+      await new Promise((r) => setTimeout(r, 100));
+      if (!fs.existsSync(dir)) break;
+    }
+  }
+}
+
+after(() => stopAndRemove([root]));
 
 const args = (...more) => ['-a', 'edit', '--video', V('main.mp4'), '--script', path.join(root, 'docs/main-voiceover-script.md'), ...more];
 const borrow = (what, after = 'end', script = true) => ['--borrow', [V('other.mp4'), what, after, script ? path.join(root, 'docs/other-voiceover-script.md') : ''].join('|').replace(/\|+$/, '')];

package/core/workspace-app/tests/unit/video-edit.test.js

@@ -79,17 +79,36 @@ before(async () => {
     await run('ffmpeg', ['-y', '-loglevel', 'error', '-f', 'lavfi', '-i', 'testsrc2=size=320x180:rate=15', '-f', 'lavfi', '-i', 'sine=frequency=440',
       '-t', '6', '-c:v', 'libx264', '-preset', 'ultrafast', '-pix_fmt', 'yuv420p', '-c:a', 'aac', path.join(root, 'videos/demo.mp4')], { env });
     await run('ffmpeg', ['-y', '-loglevel', 'error', '-f', 'lavfi', '-i', 'sine=frequency=220:duration=10', '-c:a', 'libmp3lame', path.join(root, 'audio/sounds/bed.mp3')], { env });
-    fs.writeFileSync(path.join(root, 'videos/demo-poster.jpg'), Buffer.alloc(50, 2));
   } else {
+    // No ffmpeg on this machine: the command tests are skipped, and the page tests read only the files' names.
     fs.writeFileSync(path.join(root, 'videos/demo.mp4'), Buffer.alloc(100, 1));
     fs.writeFileSync(path.join(root, 'audio/sounds/bed.mp3'), Buffer.alloc(100, 1));
   }
+  // The poster is the row's thumbnail whichever way the video was made.
+  fs.writeFileSync(path.join(root, 'videos/demo-poster.jpg'), Buffer.alloc(50, 2));
 });
 
-after(() => {
-  for (const s of servers) s.kill();
-  for (const d of [root, home]) fs.rmSync(d, { recursive: true, force: true });
-});
+/**
+ * Stop the servers this file started, then remove a tree, trying again for a moment. The server runs `ddev list` with
+ * HOME inside the tree, and a ddev still finishing after the server is gone puts `~/.ddev` back while the tree is
+ * being removed: a single rmSync then fails with ENOTEMPTY and the tree is left in /tmp.
+ */
+async function stopAndRemove(dirs) {
+  await Promise.all(servers.map((s) => new Promise((resolve) => {
+    if (s.exitCode !== null || s.signalCode !== null) return resolve();
+    s.once('exit', resolve);
+    s.kill();
+  })));
+  for (const dir of dirs) {
+    for (let i = 0; i < 50; i += 1) {
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_) { /* something was still writing */ }
+      await new Promise((r) => setTimeout(r, 100));
+      if (!fs.existsSync(dir)) break;
+    }
+  }
+}
+
+after(() => stopAndRemove([root, home]));
 
 const env = (extra = {}) => ({ PATH: `/usr/bin:/bin:${path.dirname(process.execPath)}:${path.join(home, 'bin')}`, HOME: home, WORKSPACE_ROOT: root, ...extra });
 const cli = (args) => run('bash', [path.join(root, 'videos/cmd-tools-video-edit.sh'), ...args], { env: env() });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webship.co/workspace",
-  "version": "1.0.0-beta2",
+  "version": "1.0.0-rc1",
   "description": "Webship Workspace: a container-based development workspace with a web dashboard. The core ships empty; workspace folders, hosting providers, git forges, container runtimes and features are @webship.co/workspace-<name> plugins you add one at a time.",
   "license": "GPL-2.0-or-later",
   "repository": {