@webship.co/workspace 1.0.0-rc1 → 1.0.0

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

@@ -3,38 +3,54 @@ Feature: The checks a project already declares
 
   # One quality menu, not two. On a packages workspace there is no browser suite at all, and on a
   # site there was no checks control — a separate button would have been the only one present in
-  # each case. They live together under Tests, with the checks nested inside it.
+  # each case. They live together under Tests, with the checks nested inside it. The menu's items
+  # arrive when it opens (/fragments/row-menu/tests/…), so each scenario that reads one opens the
+  # first row's menu first; the caption under the button is on the page before that.
   Scenario: A package row offers its checks inside the Tests menu
     Given I am on "/products"
      Then the element ".project-row .act-menu-tests" should be displayed
-      And ".act-menu-tests .act-menu-checks" should be attached
       And I should see "Tests"
+     When I click on the element ".project-row >> nth=0 >> .act-menu-tests button"
+     Then ".uk-dropdown.uk-open" should be visible
+      And ".act-menu-tests .act-menu-checks" should be attached
 
   Scenario: The button says what the package covers without running anything
     Given I am on "/products"
      Then the element ".act-menu-tests + .act-status" should be displayed
-      And "[hx-post='/actions/checks-plan']" should be attached
+     When I click on the element ".project-row >> nth=0 >> .act-menu-tests button"
+     Then "[hx-post='/actions/checks-plan']" should be attached
 
   # The pair is the point: the canonical name is what you type (--only js), the code beside it is
   # the script the package itself declared. Listing them together is how the mapping is checkable.
+  # Opened on a row whose caption says the package declares checks, since a package that declares
+  # none lists none.
   Scenario: The nested menu lists each alias against the script it runs
     Given I am on "/products"
-     Then ".checks-sub" should be attached
+     When I click on the element ".project-row:has(.act-menu-tests + .act-status:has-text('declared')), .project-row:has(.act-menu-tests + .act-status:has-text('deps missing')), .project-row:has(.act-menu-tests + .act-status:has-text('passed')), .project-row:has(.act-menu-tests + .act-status:has-text('failed')) >> nth=0 >> .act-menu-tests button"
+     Then ".uk-dropdown.uk-open" should be visible
+      And ".checks-sub" should be attached
       And ".checks-sub .checks-alias" should be attached
       And ".checks-sub .checks-script" should be attached
 
+  # Opened on a row whose caption says its checks are declared with their dependencies there — the
+  # alias control renders only for an alias that is READY, and "deps missing" says none is.
   @needs-check-aliases
   Scenario: Each alias can be run on its own, and so can all of them
     Given I am on "/products"
-     Then "[hx-post='/actions/checks']" should be attached
+     When I click on the element ".project-row:has(.act-menu-tests + .act-status:has-text('declared')), .project-row:has(.act-menu-tests + .act-status:has-text('passed')), .project-row:has(.act-menu-tests + .act-status:has-text('failed')) >> nth=0 >> .act-menu-tests button"
+     Then ".uk-dropdown.uk-open" should be visible
+      And "[hx-post='/actions/checks']" should be attached
       And "[hx-vals*='only']" should be attached
 
   # 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.
+  # ddev-dev-tools add-on adds the PHP and Twig checks on top. Opened on a row whose caption says a
+  # stack is there, since "Run the tests" is only offered where there is a suite to run.
   @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
+     When I click on the element ".project-row:has(.act-menu-tests + .act-status:text-is('ready to test')), .project-row:has(.act-menu-tests + .act-status:text-is('not ready')), .project-row:has(.act-menu-tests + .act-status:text-is('running now')) >> nth=0 >> .act-menu-tests button"
+     Then ".uk-dropdown.uk-open" should be visible
       And "[hx-post='/actions/testing-configure']" should be attached
       And "[hx-post='/actions/testing-run']" should be attached
       And ".act-menu-tests .act-menu-checks" should be attached

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

@@ -4,6 +4,7 @@ Feature: Cloning a project
 
   Scenario: The DDEV menu offers the clone
     Given I am on "/dev"
+     When I click on the element ".project-row >> nth=0 >> .act-menu-ddev button"
      Then "[hx-get^='/fragments/projects/clone-form/dev/']" should be attached
 
   Scenario: The form arrives prefilled, with the live check wired

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

@@ -2,9 +2,10 @@ Feature: What a project row can actually do
   The verbs on a row, asserted where they are rather than by opening every menu.
 
   # Each menu carries the name of the verb it opens (act-menu-ddev, act-menu-tests, …). A page of
-  # thirteen projects has thirteen of each, so these assert that the control and its items EXIST
-  # rather than clicking one — a test that has to say "the third one" breaks the moment a project
-  # is built. The one click test lives on /rag, which holds exactly one row.
+  # thirteen projects has thirteen of each, so these assert that the control EXISTS rather than
+  # clicking one — a test that has to say "the third one" breaks the moment a project is built. A
+  # menu's items are not on the page until it opens (its body comes from /fragments/row-menu/…), so
+  # a scenario that needs an item opens one menu first, by `nth=0` or on /rag, which holds one row.
 
   Scenario: A row carries a menu for each thing it can do
     Given I am on "/dev"
@@ -14,11 +15,16 @@ Feature: What a project row can actually do
       And the element ".project-row .act-menu-more" should be displayed
 
   # 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.
+  # environment up, the other runs the suite. Both post to their own action. The menu's items arrive
+  # when it opens (/fragments/row-menu/tests/…), so the menu is opened first — on a row whose caption
+  # says a stack is there (ready to test, not ready, running now), since "Run the tests" is only
+  # offered where there is a suite to run.
   @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
+     When I click on the element ".project-row:has(.act-menu-tests + .act-status:text-is('ready to test')), .project-row:has(.act-menu-tests + .act-status:text-is('not ready')), .project-row:has(.act-menu-tests + .act-status:text-is('running now')) >> nth=0 >> .act-menu-tests button"
+     Then ".uk-dropdown.uk-open" should be visible
+      And "[hx-post='/actions/testing-configure']" should be attached
       And "[hx-post='/actions/testing-run']" should be attached
 
   # The state under the button is the answer to "is there anything to look at yet" — it says

package/core/workspace-app/tests/unit/claude-code-here.test.js

@@ -6,7 +6,7 @@ const path = require('path');
 const server = fs.readFileSync(path.join(__dirname, '..', '..', 'server.js'), 'utf8');
 
 test('the SCREENS menu offers Claude Code in the same folder, beside New screen here', () => {
-  assert.match(server, /screen-new-form\?workspace=\$\{encodeURIComponent\(sm\[1\]\)\}&project=\$\{encodeURIComponent\(sm\[2\]\)\}&kind=claude/);
+  assert.match(server, /screen-new-form\?workspace=\$\{encodeURIComponent\(ws\)\}&project=\$\{encodeURIComponent\(project\)\}&kind=claude/);
   assert.match(server, /Claude Code here…/);
 });
 

package/core/workspace-app/tests/unit/plugin-system.test.js

@@ -61,11 +61,14 @@ function tree() {
   fs.writeFileSync(path.join(dir, 'index.js'), `
     module.exports.register = (api) => {
       api.addRowMenu('x-cloud', { label: 'X CLOUD', row: 0 }, ({ key, project, allowed }) => allowed.has('x-cloud') ? '<div class="act-menu-x-cloud">' + key + '/' + project + '</div>' : null);
+      // The lazy form: the button and the URL of the body, which the fragment below answers.
+      api.addRowMenu('x-lazy', { label: 'X LAZY', row: 0 }, ({ key, project, allowed }) => allowed.has('x-cloud')
+        ? { html: '<button class="x-lazy-button">X LAZY</button>', body: '/fragments/p/x-cloud/menu/' + key + '/' + project, caption: 'not linked', classes: 'act-menu-hosting x-family' } : null);
       api.addPage(/^\\/x-cloud\\/([a-z]+)$/, ({ send, match }) => send('page:' + match[1]));
       api.addProjectChip(({ project }) => '<span class="x-chip">' + project + '</span>');
       api.addFolderSetup({ html: () => '<div class="x-setup"></div>', steps: (ws, name, form) => form.x === '1' ? ['echo x ' + name] : [], prompt: () => ['x prompt'], problem: (ws, form) => form.x === 'bad' ? 'bad x' : '' });
       api.addAction('ping', ({ send }) => send('pong'));
-      api.addFragment(({ send, rest }) => send('frag:' + rest));
+      api.addFragment(({ send, rest }) => send(rest.startsWith('menu/') ? '<ul class="uk-nav uk-dropdown-nav"><li class="uk-nav-header">Menu for ' + rest.slice(5) + '</li><li><a href="#" class="x-lazy-item">Deploy</a></li></ul>' : 'frag:' + rest));
       api.addLabels({ region: { label: 'Region' } });
       api.addForge('forge.test', { label: 'X Forge', env: () => ({ X_TOKEN: 'secret' }), auth: () => ({ username: 'me', how: 'token' }) });
       api.addWorkspaceView('x-store', { listHtml: (state) => '<div class="x-list">' + (state.q || '') + '</div>', count: () => 7, noNewForm: true });
@@ -128,6 +131,40 @@ test('a plugin reaches every hook, and what it registers is what the dashboard d
   assert.strictEqual(r.noView, null);
 });
 
+test('a row menu that answers { html, body } is drawn as its button and an empty shell; the body is fetched, through the core, when it opens', async () => {
+  const t = tree();
+  const out = node(`
+    const l = require('./plugin-loader');
+    const vals = () => '';
+    const menus = l.pluginRowMenus({ key: 'dev', project: 'site1', dir: '${t.root}/dev', meta: {}, allowed: new Set(['x-cloud']), vals });
+    const none = l.pluginRowMenus({ key: 'modules', project: 'm', dir: '${t.root}/modules', meta: {}, allowed: new Set(), vals });
+    const bad = l.rowMenuHtml('x-lazy', { html: '<button>x</button>', body: 'https://elsewhere.test/menu' }, { key: 'dev', project: 'site1' });
+    const noCaption = l.rowMenuHtml('x-lazy', { html: '<button>x</button>', body: '/fragments/p/x-cloud/menu/dev/site1' }, { key: 'dev', project: 'site1' });
+    Promise.all([
+      l.pluginRowMenuBody('/fragments/p/x-cloud/menu/dev/site1', { headers: {} }),
+      l.pluginRowMenuBody('/fragments/p/nobody/menu/dev/site1', { headers: {} }),
+    ]).then(([body, missing]) => {
+      console.log(JSON.stringify({ lazy: menus['x-lazy'], inline: menus['x-cloud'], none: none['x-lazy'], bad, noCaption, body, missing,
+        slot: l.pluginRowMenuSlot('x-lazy'), noSlot: l.pluginRowMenuSlot('x-other'), capability: l.loadedPlugins.length > 0 }));
+    });`, env(t));
+  const r = JSON.parse(out);
+  const lazy = r.lazy;
+  assert.ok(lazy.startsWith('<span class="act-with-status"><div class="uk-inline act-menu act-menu-x-lazy act-menu-hosting x-family">'), 'the wrapper the row layout expects, with the slot and the plugin\'s classes');
+  assert.ok(lazy.includes('<button class="x-lazy-button">X LAZY</button>'), 'the button as the plugin drew it');
+  assert.ok(lazy.includes('hx-get="/fragments/row-menu/x-lazy/dev/site1?body=%2Ffragments%2Fp%2Fx-cloud%2Fmenu%2Fdev%2Fsite1"'), 'the shell asks the core for the body, naming the plugin\'s URL');
+  assert.ok(lazy.includes('hx-trigger="menu-opened" hx-target="this" hx-swap="innerHTML"'), 'fetched when the menu opens, into the dropdown');
+  assert.ok(lazy.includes('<div uk-dropdown="mode: click; pos: bottom-right" class="act-menu-lazy"'), 'an ordinary UIkit dropdown shell');
+  assert.ok(lazy.endsWith('<span class="act-status uk-text-meta">not linked</span></span>'), 'the caption beside the button');
+  assert.ok(!lazy.includes('Menu for') && !lazy.includes('x-lazy-item'), 'the page carries no menu body');
+  assert.strictEqual(r.inline, '<div class="act-menu-x-cloud">dev/site1</div>', 'a string return is drawn inline, as before');
+  assert.strictEqual(r.none, '', 'null is an empty slot, in either form');
+  assert.strictEqual(r.bad, '', 'a body outside /fragments/p/<plugin>/ is not a menu');
+  assert.ok(!r.noCaption.includes('act-status'), 'no caption, no caption span');
+  assert.deepStrictEqual(r.body, { status: 200, html: '<ul class="uk-nav uk-dropdown-nav"><li class="uk-nav-header">Menu for dev/site1</li><li><a href="#" class="x-lazy-item">Deploy</a></li></ul>' }, 'the body is the plugin\'s fragment, answered as a value');
+  assert.strictEqual(r.missing.status, 404, 'a URL no plugin serves is 404');
+  assert.ok(r.slot && !r.noSlot, 'the core knows which slots are plugin menus');
+});
+
 test('a dotted legacy key names a nested settings.yml block, for the reader and the installer', () => {
   const t = tree();
   const dir = path.join(t.plugins, 'x-forge');

package/core/workspace-app/tests/unit/row-layout.test.js

@@ -514,7 +514,10 @@ test('the row, the SCREENS fragment and the Commands page are wired to rows mana
   assert.match(src, /const extraRows = rowLines\.extra\.filter\(Boolean\);/);
   assert.match(src, /\$\{extraRows\.join\(''\)\}/);
   assert.match(src, /const ddevItems = rowLayout\.arrangeNavInner\('ddev', ddevMenuItems, rowCtx\);/);
-  assert.match(src, /return res\.end\(rowLayout\.arrangeNavInner\('screens', screensNav,/);
+  // The SCREENS body is arranged where it is served: the legacy fragment, and the row-menu route every
+  // core menu (DDEV, COMPOSER, Tests, SCREENS) loads its body through when it opens — arranged, then columns.
+  assert.match(src, /return res\.end\(rowLayout\.arrangeNavInner\('screens', nav,/);
+  assert.match(src, /rowLayout\.columnizeButtonHtml\(slot, rowLayout\.arrangeButtonHtml\(slot, html, ctx\), layout\)/);
   assert.match(src, /'\/settings\/buttons'[\s\S]{0,400}settingsPage\('buttons'/);
   assert.match(src, /\.\.\.require\('\.\/actions\/row-actions'\)/);
   const ui = fs.readFileSync(path.join(__dirname, '..', '..', 'public', 'ui.js'), 'utf8');

package/core/workspace-app/tests/unit/row-menu-fragments.test.js

@@ -0,0 +1,229 @@
+/**
+ * The core's row menus load their bodies when they open (#109).
+ *
+ * A page of fifty project rows carried fifty copies of the DDEV, COMPOSER, Tests and SCREENS menus —
+ * about 1.2 MB of dropdowns nobody had opened. Now each row carries the button, its caption and an
+ * empty shell (plugin-loader's menuShellHtml, the one the plugins' lazy menus use), and the body comes
+ * from /fragments/row-menu/<slot>/<ws>/<project> when the menu opens, computed for that one project.
+ *
+ * Against a real server over a temp workspace tree: a sites workspace with a DDEV project that has a
+ * composer.json and the testing scripts, and a packages workspace with a package that declares checks.
+ */
+
+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 net = require('net');
+const { spawn } = require('child_process');
+
+const APP = path.join(__dirname, '../..');
+const REPO = path.join(APP, '../..');
+const { copyConfig } = require('./_isolated-config');
+
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-row-menus-'));
+let proc;
+let base;
+
+const free = () => new Promise((resolve) => {
+  const s = net.createServer();
+  s.listen(0, '127.0.0.1', () => { const { port } = s.address(); s.close(() => resolve(port)); });
+});
+
+before(async () => {
+  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'));
+  // The layout the rows and the fragments arrange by, blank: a machine's own row-actions.yml must not
+  // decide what this test sees.
+  for (const f of ['row-actions.yml', 'row-actions.seen.json']) fs.rmSync(path.join(root, 'core/config', f), { force: true });
+  // A site: DDEV-configured, with a composer.json and the scripts that gate Tests, test users and checks.
+  const site = path.join(root, 'dev/site-one');
+  fs.mkdirSync(path.join(site, '.ddev'), { recursive: true });
+  fs.writeFileSync(path.join(site, '.ddev/config.yaml'), 'name: site-one\ntype: drupal\ndocroot: web\n');
+  fs.writeFileSync(path.join(site, 'composer.json'), JSON.stringify({ name: 'acme/site-one', require: { 'drupal/core': '^11' }, scripts: { 'post-install-cmd': ['echo hi'], 'site:check': 'echo check' } }));
+  fs.writeFileSync(path.join(site, 'composer.lock'), '{}');
+  fs.writeFileSync(path.join(site, 'package.json'), JSON.stringify({ name: 'site-one', scripts: { 'lint:js': 'eslint .' } }));
+  fs.mkdirSync(path.join(root, 'dev/plain-folder'), { recursive: true });
+  for (const f of ['cmd-tools-testing.sh', 'cmd-tools-checks.sh', 'cmd-tools-add-users.sh']) fs.writeFileSync(path.join(root, 'dev', f), '#!/usr/bin/env bash\n');
+  // A package: no DDEV, a package.json that declares checks.
+  const pkg = path.join(root, 'products/pkg-one');
+  fs.mkdirSync(pkg, { recursive: true });
+  fs.writeFileSync(path.join(pkg, 'package.json'), JSON.stringify({ name: 'pkg-one', scripts: { 'lint:js': 'eslint .', 'lint:css': 'stylelint "**/*.css"' } }));
+  fs.writeFileSync(path.join(pkg, 'composer.json'), JSON.stringify({ name: 'acme/pkg-one', type: 'drupal-module' }));
+  fs.writeFileSync(path.join(root, 'products', 'cmd-tools-checks.sh'), '#!/usr/bin/env bash\n');
+  const port = await free();
+  base = `http://127.0.0.1:${port}`;
+  proc = spawn(process.execPath, ['server.js'], { cwd: APP, env: { ...process.env, PORT: String(port), WORKSPACE_ROOT: root, WORKSPACE_PLUGINS_NO_RESTART: '1' }, stdio: ['ignore', 'pipe', 'pipe'] });
+  await new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error('server did not start')), 20000);
+    proc.stdout.on('data', (d) => { if (/listening/.test(String(d))) { clearTimeout(t); resolve(); } });
+    proc.on('exit', (c) => { clearTimeout(t); reject(new Error(`server exited ${c}`)); });
+  });
+});
+
+after(() => {
+  if (proc) proc.kill();
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+const get = (p) => fetch(base + p);
+const text = async (p) => { const r = await get(p); return { status: r.status, html: await r.text() }; };
+/** One row's HTML out of a workspace page. */
+const rowOf = (html, name, anchor = `"projectName":"${name}"`) => {
+  const at = html.indexOf(anchor);
+  assert.ok(at > 0, `no row for ${name}`);
+  // A row is a card: `<div class="uk-card … project-row pcard">` opens it, the next card ends it.
+  const start = html.lastIndexOf('project-row pcard', at);
+  const end = html.indexOf('project-row pcard', at);
+  return html.slice(start, end < 0 ? undefined : end);
+};
+/** The menu wrapper of one slot inside a row: the shell and what follows it up to the caption. */
+const menuOf = (row, slot) => {
+  const m = new RegExp(`<span class="act-with-status"><div class="uk-inline act-menu act-menu-${slot}[^"]*">[\\s\\S]*?</div></div>(<span class="act-status uk-text-meta">[^<]*</span>)?</span>`).exec(row);
+  return m ? m[0] : '';
+};
+
+test('a project row carries the button, the caption and an empty shell for each core menu, and no menu body', async () => {
+  const { status, html } = await text('/dev');
+  assert.strictEqual(status, 200);
+  const row = rowOf(html, 'site-one');
+  for (const slot of ['ddev', 'composer', 'tests', 'screens']) {
+    const menu = menuOf(row, slot);
+    assert.ok(menu, `${slot}: the row has the menu`);
+    assert.match(menu, new RegExp(`hx-get="/fragments/row-menu/${slot}/dev/site-one"`), `${slot}: the shell asks the core route for its body`);
+    assert.match(menu, /class="act-menu-lazy[^"]*" hx-get=/, `${slot}: the dropdown is the lazy shell`);
+    assert.match(menu, /hx-trigger="menu-opened/, `${slot}: fetched when the menu opens`);
+    assert.match(menu, /hx-target="this" hx-swap="innerHTML"/, `${slot}: into the dropdown itself`);
+    assert.match(menu, /<ul class="uk-nav uk-dropdown-nav"><li class="uk-nav-header">…<\/li><\/ul>/, `${slot}: a placeholder, not the menu`);
+  }
+  // The state words stay on the row: DDEV counts its commands, COMPOSER says locked, Tests says what it can do.
+  assert.match(menuOf(row, 'ddev'), /<span class="act-status uk-text-meta">\d+ commands<\/span>/, 'the DDEV caption counts the commands the body will hold');
+  assert.match(menuOf(row, 'ddev'), /class="act-menu-lazy ddev-dropdown-wide"/, 'the DDEV width class rides on the shell');
+  assert.match(menuOf(row, 'composer'), /<span class="act-status uk-text-meta">locked<\/span>/);
+  assert.match(menuOf(row, 'composer'), /class="act-menu-lazy composer-dropdown composer-dropdown-wide"/, 'a site workspace installs: the wide, two-column menu');
+  assert.match(menuOf(row, 'tests'), /<span class="act-status uk-text-meta">not set up<\/span>/);
+  assert.match(menuOf(row, 'tests'), /uk-button-secondary/, 'the Tests button as it was');
+  assert.match(menuOf(row, 'screens'), /hx-trigger="menu-opened, load, every 30s, screens-changed from:body"/, 'SCREENS still polls: the hand and the agent badge ride on its answer');
+  assert.match(menuOf(row, 'screens'), /<span class="act-status uk-text-meta">none<\/span>/);
+  // Nothing of the bodies is on the page.
+  for (const inner of ['/actions/ddev-restart', '/actions/ddev-describe', '/actions/composer-install', '/actions/testing-configure', '/actions/checks-plan', 'composer-package', 'checks-sub', 'ddev-nav-columns']) {
+    assert.ok(!row.includes(inner), `${inner} is not on the page before a menu opens`);
+  }
+  // A folder with no DDEV config has the Configure DDEV button and no DDEV menu; no composer.json, no COMPOSER.
+  // No DDEV and no backup here, so nothing on the row posts with its name: found by its Configure DDEV link.
+  const plain = rowOf(html, 'plain-folder', '/fragments/projects/ddev-config/dev/plain-folder');
+  assert.match(plain, /act-ddev-config/);
+  assert.ok(!menuOf(plain, 'ddev') && !menuOf(plain, 'composer'));
+});
+
+test('the DDEV body for one project holds the verbs the row used to carry, arranged, in the DDEV list', async () => {
+  const { status, html } = await text('/fragments/row-menu/ddev/dev/site-one');
+  assert.strictEqual(status, 200);
+  assert.match(html, /^<ul class="uk-nav uk-dropdown-nav ddev-nav-columns">/, 'the list the DDEV CSS lays out');
+  assert.match(html, /<li class="uk-nav-header" data-group="project">site-one<\/li>/);
+  for (const verb of ['/actions/ddev-start', '/actions/ddev-restart', '/actions/ddev-describe', '/actions/ddev-logs', '/actions/ddev-mutagen-sync', '/actions/ddev-diagnose', '/fragments/projects/ddev-config/dev/site-one', '/fragments/projects/addons/dev/site-one']) {
+    assert.ok(html.includes(`"${verb}"`), `${verb} is in the body`);
+  }
+  assert.match(html, /hx-vals='\{"workspace":"dev","projectName":"site-one"\}' hx-target="#webship-workspace-output"/, 'the items post for this project into the output');
+  assert.match(html, /class="uk-text-danger arm-step" hx-post="\/actions\/ddev-mutagen-reset"[^>]*hx-trigger="confirmed-remove"/, 'the confirm dialog still arms the destructive items');
+  assert.match(html, /Canonical URL/);
+  // Stopped: the running-only items (xdebug, share, export) are not offered — the state is read for this project.
+  assert.ok(!html.includes('/actions/ddev-xdebug-on') && !html.includes('/actions/ddev-share'), 'a stopped project is not offered the running-only verbs');
+  // The caption on the row counted what the body holds.
+  const page = (await text('/dev')).html;
+  const count = Number(/(\d+) commands/.exec(menuOf(rowOf(page, 'site-one'), 'ddev'))[1]);
+  assert.strictEqual((html.match(/<a /g) || []).length, count, 'the row counts the commands the body holds');
+});
+
+test('the COMPOSER body for a site is the two-column menu with its commands, the package field and the scripts', async () => {
+  const { status, html } = await text('/fragments/row-menu/composer/dev/site-one');
+  assert.strictEqual(status, 200);
+  assert.match(html, /^<div class="composer-columns">/);
+  assert.match(html, /Composer · acme\/site-one/);
+  assert.match(html, /Runs as ddev composer in this project\./);
+  for (const verb of ['/actions/composer-install', '/actions/composer-update', '/actions/composer-validate', '/actions/composer-require']) assert.ok(html.includes(`"${verb}"`), verb);
+  assert.match(html, /hx-include="closest \.composer-package"/);
+  assert.match(html, /Scripts in composer\.json/);
+  assert.match(html, /"script":"site:check"/, 'the custom script from composer.json is offered');
+  assert.ok(!html.includes('post-install-cmd'), 'an event hook is not a script to run');
+});
+
+test('the Tests body for a site offers the test users, the environment and the nested checks', async () => {
+  const { status, html } = await text('/fragments/row-menu/tests/dev/site-one');
+  assert.strictEqual(status, 200);
+  assert.match(html, /^<ul class="uk-nav uk-dropdown-nav" uk-nav="multiple: true">/);
+  assert.match(html, /hx-post="\/actions\/add-users"/);
+  assert.match(html, /hx-post="\/actions\/cancel-users"/);
+  assert.match(html, /<li class="uk-nav-header" data-group="suite">not set up<\/li>/);
+  assert.match(html, /hx-post="\/actions\/testing-configure"[^>]*>[\s\S]*?Set up the testing environment/);
+  assert.ok(!html.includes('/actions/testing-run'), 'no stack, nothing to run');
+  assert.match(html, /<li class="uk-parent act-menu-checks" data-entry="checks">/);
+  assert.match(html, /hx-post="\/actions\/checks-plan"/);
+  assert.match(html, /<ul class="uk-nav-sub checks-sub">/);
+  assert.match(html, /<span class="checks-alias">js<\/span> <code class="checks-script">lint:js<\/code>/, 'each alias against the script it runs');
+});
+
+test('the Tests body for a package is the checks alone, and a plain folder in a site workspace still gets the environment', async () => {
+  const pkg = await text('/fragments/row-menu/tests/products/pkg-one');
+  assert.strictEqual(pkg.status, 200);
+  assert.match(pkg.html, /act-menu-checks/);
+  assert.match(pkg.html, /2 declared/);
+  assert.match(pkg.html, /<span class="checks-alias">css<\/span>/);
+  assert.ok(!pkg.html.includes('/actions/testing-configure') && !pkg.html.includes('/actions/add-users'), 'a packages workspace has no suite and no test users');
+  const page = (await text('/products')).html;
+  assert.match(menuOf(rowOf(page, 'pkg-one'), 'tests'), /<span class="act-status uk-text-meta">(2 declared|deps missing)<\/span>/, 'the caption says what the package declares');
+  const plain = await text('/fragments/row-menu/tests/dev/plain-folder');
+  assert.strictEqual(plain.status, 200);
+  assert.match(plain.html, /hx-post="\/actions\/testing-configure"/);
+});
+
+test('the SCREENS body lists the sessions (none here), the ways to start one, and swaps the row\'s badges out of band', async () => {
+  const { status, html } = await text('/fragments/row-menu/screens/dev/site-one');
+  assert.strictEqual(status, 200);
+  assert.match(html, /^<ul class="uk-nav uk-dropdown-nav">/);
+  assert.match(html, /No screens in this project/);
+  assert.match(html, /New screen here…/);
+  assert.match(html, /Claude Code here…/);
+  assert.match(html, /href="\/screens"/);
+  assert.match(html, /<span class="screens-hand" id="screens-hand-dev-site-one" hx-swap-oob="true">/, 'the hand on the button');
+  assert.match(html, /id="agent-badge-dev-site-one" hx-swap-oob="true"/, 'the agent badge in the title');
+  assert.match(html, /id="plugin-badges-dev-site-one" hx-swap-oob="true"/, 'the plugins\' badges');
+  // The legacy fragment the old rows polled still answers, with the list's inner HTML.
+  const legacy = await text('/fragments/projects/screens/dev/site-one');
+  assert.strictEqual(legacy.status, 200);
+  assert.match(legacy.html, /^\s*<li class="uk-nav-header">No screens in this project<\/li>/);
+});
+
+test('a project that is not there, a menu the row would not draw, and a slot that is not a menu are 404', async () => {
+  for (const [p, why] of [
+    ['/fragments/row-menu/ddev/dev/no-such-project', 'no such project'],
+    ['/fragments/row-menu/ddev/dev/plain-folder', 'not a DDEV project'],
+    ['/fragments/row-menu/composer/dev/plain-folder', 'no composer.json'],
+    ['/fragments/row-menu/ddev/products/pkg-one', 'a packages workspace has no DDEV'],
+    ['/fragments/row-menu/more/dev/site-one', 'More is drawn inline, not served'],
+    ['/fragments/row-menu/ddev/nope/site-one', 'no such workspace'],
+    ['/fragments/row-menu/ddev/dev/site-one?body=/fragments/p/x/menu', 'a core slot takes no plugin body'],
+    ['/fragments/row-menu/x-plugin/dev/site-one', 'a plugin slot nobody registered'],
+  ]) {
+    const { status, html } = await text(p);
+    assert.strictEqual(status, 404, `${p}: ${why}`);
+    assert.match(html, /^<ul class="uk-nav uk-dropdown-nav"><li class="uk-nav-header">/, `${p}: answered as a menu line, so the shell shows why`);
+  }
+});
+
+test('the Buttons settings page learns the lazy menus\' entries without anyone opening one', async () => {
+  const { status, html } = await text('/settings/buttons');
+  assert.strictEqual(status, 200);
+  // Both menus whose bodies load on open are listed with what they hold, learned from the first project
+  // that carries them (learnCoreMenus) — the seen record this tree started with was empty.
+  assert.match(html, /composer/i);
+  // The record is written a moment after it changes (row-layout's flushSeenSoon).
+  await new Promise((r) => setTimeout(r, 2500));
+  const seen = JSON.parse(fs.readFileSync(path.join(root, 'core/config/row-actions.seen.json'), 'utf8'));
+  assert.ok(seen.composer && Object.keys(seen.composer.groups).length > 0, 'COMPOSER has groups on record');
+  assert.ok(seen.tests && Object.keys(seen.tests.groups).length > 0, 'Tests has groups on record');
+  assert.ok(seen.ddev && Object.keys(seen.ddev.groups).length > 0, 'DDEV is on record from the rows themselves');
+});

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

@@ -43,7 +43,12 @@ test('a dropdown that is being typed in or paged stays open', () => {
 });
 
 test('the row polls slowly, and catches up the moment anything happens', () => {
-  const menu = server.match(/hx-get="\/fragments\/projects\/screens\/[^"]+" hx-trigger="([^"]+)"/)[1];
+  // The row's SCREENS is the shared lazy shell (plugin-loader's menuShellHtml): its body is
+  // /fragments/row-menu/screens/<ws>/<project>, fetched on `menu-opened` by the shell itself and, for the
+  // badges that ride on the answer, on the triggers the row adds.
+  const shell = server.match(/menuShellHtml\('screens', \{[\s\S]*?triggers: '([^']+)'/)[1];
+  const loader = fs.readFileSync(path.join(__dirname, '..', '..', 'plugin-loader.js'), 'utf8');
+  const menu = `${loader.match(/const trigger = \['([a-z-]+)'/)[1]}, ${shell}`;
   assert.match(menu, /every 30s/, 'the background poll is the cheap one');
   assert.ok(!/every 15s/.test(menu), 'not twice a minute per row, forever');
   assert.match(menu, /screens-changed from:body/, 'a session starting or stopping reaches it');
@@ -79,6 +84,6 @@ test('a session in the menu says what it is doing', () => {
   assert.match(items, /dead \? '<span class="uk-label">dead<\/span>'/, 'a session whose process is gone opens onto nothing');
   assert.match(items, /isAgent \? iconHtml\('tabler:robot-face'/);
   // The name is `<workspace>--<project>--<what>`, and the first two are the row it is already on.
-  assert.match(items, /s\.session\.startsWith\(`\$\{sm\[1\]\}--\$\{sm\[2\]\}--`\)/);
+  assert.match(items, /s\.session\.startsWith\(`\$\{ws\}--\$\{project\}--`\)/);
   assert.match(items, /title="\$\{esc\(s\.session\)\}/, 'the whole name is still one hover away');
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webship.co/workspace",
-  "version": "1.0.0-rc1",
+  "version": "1.0.0",
   "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": {