@@ -35,4 +46,21 @@ const title = 'Astro inset shadow stripe regression';
[data-case="Thick Fill Edge"] { box-shadow: inset 14px 0 0 var(--brand-accent); }
[data-case="Blurred Edge"] { box-shadow: inset 3px 0 5px var(--brand-accent); }
[data-case="Narrow Artwork"] { width: 24px; box-shadow: inset 3px 0 0 var(--brand-accent); }
+
+ /* Literal colors: authored CSS spells neutrals as hex and keywords, not as
+ the computed rgb()/oklch() forms a browser emits. */
+ [data-case="Chromatic Hex Edge"] { box-shadow: inset 4px 0 0 #6366f1; }
+ [data-case="Named Red Edge"] { box-shadow: inset 4px 0 0 red; }
+ [data-case="Chromatic Rgb Edge"] { box-shadow: inset 4px 0 0 rgb(99, 102, 241); }
+ [data-case="Chromatic Oklch Edge"] { box-shadow: inset 4px 0 0 oklch(65% 0.18 250); }
+ [data-case="Black Hex Edge"] { box-shadow: inset 4px 0 0 #000; }
+ [data-case="Black Named Edge"] { box-shadow: inset 4px 0 0 black; }
+ [data-case="Gray Hex Edge"] { box-shadow: inset 4px 0 0 #e5e7eb; }
+ [data-case="Dimgray Named Edge"] { box-shadow: inset 4px 0 0 dimgray; }
+ [data-case="Black Rgb Edge"] { box-shadow: inset 4px 0 0 rgb(0, 0, 0); }
+ [data-case="Shorthand Neutral Hex Edge"] { box-shadow: inset 4px 0 0 #1118; }
+
+ /* Commented-out rules are not live CSS.
+ [data-case="Commented Out Edge"] { box-shadow: inset 4px 0 0 var(--brand-accent); }
+ */
diff --git a/tests/live-accept.test.mjs b/tests/live-accept.test.mjs
index 81f6098a2..82df1e730 100644
--- a/tests/live-accept.test.mjs
+++ b/tests/live-accept.test.mjs
@@ -9,7 +9,7 @@ import { existsSync, mkdtempSync, writeFileSync, readFileSync, rmSync } from 'no
import { dirname, join, resolve } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
import { scaffoldSourceArtifactSession } from '../skill/scripts/live/source-artifact.mjs';
const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -30,6 +30,60 @@ function runAccept(cwd, args) {
}
}
+describe('live-accept — session id validation', () => {
+ let tmp;
+ beforeEach(() => { tmp = mkdtempSync(join(tmpdir(), 'impeccable-accept-id-')); });
+ afterEach(() => rmSync(tmp, { recursive: true, force: true }));
+
+ // --id becomes a path segment for the accept receipt. Traversal here wrote
+ // JSON to arbitrary absolute paths (e.g. `--id ../../../../etc/evil`).
+ for (const id of ['../../../../etc/evil', 'a/b', '..', 'a\\b', '']) {
+ it(`refuses --id ${JSON.stringify(id)} without writing a receipt`, () => {
+ const res = spawnSync('node', [ACCEPT, '--id', id, '--discard'], {
+ cwd: tmp,
+ encoding: 'utf-8',
+ });
+ assert.equal(res.status, 1, 'must exit non-zero');
+ assert.match(res.stderr, /Invalid --id|Missing --id/);
+ assert.equal(existsSync(join(tmp, '.impeccable', 'live', 'accept-receipts')), false);
+ });
+ }
+
+ it('still accepts a well-formed id', () => {
+ const res = spawnSync('node', [ACCEPT, '--id', 'ab12cd34', '--discard'], {
+ cwd: tmp,
+ encoding: 'utf-8',
+ });
+ assert.doesNotMatch(res.stderr || '', /Invalid --id/);
+ });
+
+ // --variant is interpolated into a RegExp and into the markup written back to
+ // source. `.*` matched the `original` block first, so the CLI reported a
+ // successful accept while actually restoring the original.
+ for (const variant of ['.*', '[12]', 'original', '1e2', '']) {
+ it(`refuses --variant ${JSON.stringify(variant)} rather than matching by regex`, () => {
+ writeFileSync(join(tmp, 'page.html'), [
+ '',
+ '
ORIGINAL CONTENT
',
+ '
VARIANT ONE
',
+ '',
+ '',
+ ].join('\n'));
+ const res = spawnSync('node', [ACCEPT, '--id', 'ab12cd34', '--variant', variant], {
+ cwd: tmp,
+ encoding: 'utf-8',
+ });
+ assert.equal(res.status, 1);
+ assert.match(res.stderr, /Invalid --variant|Need --discard/);
+ assert.match(
+ readFileSync(join(tmp, 'page.html'), 'utf-8'),
+ /impeccable-variants-start/,
+ 'a rejected variant must leave the wrapper untouched',
+ );
+ });
+ }
+});
+
describe('live-accept — isolated source artifacts', () => {
let tmp;
beforeEach(() => { tmp = mkdtempSync(join(tmpdir(), 'impeccable-accept-isolated-')); });
diff --git a/tests/live-generation-preflight.test.mjs b/tests/live-generation-preflight.test.mjs
index 76be7aead..6e614d5ba 100644
--- a/tests/live-generation-preflight.test.mjs
+++ b/tests/live-generation-preflight.test.mjs
@@ -64,9 +64,9 @@ test('builds an insert preflight from the anchor locator', () => {
]);
});
-test('returns scaffold metadata without exposing child-process details', () => {
+test('returns scaffold metadata without exposing child-process details', async () => {
const calls = [];
- const result = runGenerationPreflight({
+ const result = await runGenerationPreflight({
type: 'generate',
id: 'session-3',
count: 1,
@@ -74,9 +74,9 @@ test('returns scaffold metadata without exposing child-process details', () => {
}, {
scriptsDir: SCRIPTS_DIR,
cwd: '/tmp/example',
- execFileSyncImpl(file, args, options) {
+ async execFileImpl(file, args, options) {
calls.push({ file, args, options });
- return '{"file":"src/App.jsx","insertLine":12}\n';
+ return { stdout: '{"file":"src/App.jsx","insertLine":12}\n', stderr: '' };
},
});
@@ -86,8 +86,8 @@ test('returns scaffold metadata without exposing child-process details', () => {
assert.equal(calls[0].options.cwd, '/tmp/example');
});
-test('skips preflight when the picker has no source locator', () => {
- const result = runGenerationPreflight({
+test('skips preflight when the picker has no source locator', async () => {
+ const result = await runGenerationPreflight({
type: 'generate',
id: 'session-4',
count: 3,
@@ -96,3 +96,42 @@ test('skips preflight when the picker has no source locator', () => {
assert.deepEqual(result, { ok: false, skipped: true, reason: 'insufficient_locator' });
});
+
+test('yields to the event loop instead of blocking on the child process', async () => {
+ // The server is single-threaded and leases polls through this call. A
+ // synchronous spawn froze every other request (Accept, Discard, SSE) for the
+ // scaffold's full duration — measured at ~7.6s on a large repo.
+ let tickedDuringPreflight = false;
+ const pending = runGenerationPreflight({
+ type: 'generate',
+ id: 'session-async',
+ count: 1,
+ element: { classes: ['hero'] },
+ }, {
+ scriptsDir: SCRIPTS_DIR,
+ execFileImpl: () => new Promise((resolve) => {
+ setTimeout(() => resolve({ stdout: '{"file":"src/App.jsx"}\n', stderr: '' }), 25);
+ }),
+ });
+ setTimeout(() => { tickedDuringPreflight = true; }, 5);
+ const result = await pending;
+ assert.equal(result.ok, true);
+ assert.equal(tickedDuringPreflight, true, 'the event loop must stay responsive during preflight');
+});
+
+test('reports a child-process failure without leaking internals or throwing', async () => {
+ const error = new Error('spawn failed');
+ error.stderr = 'live-wrap.mjs: element not found\n';
+ const result = await runGenerationPreflight({
+ type: 'generate',
+ id: 'session-fail',
+ count: 1,
+ element: { classes: ['hero'] },
+ }, {
+ scriptsDir: SCRIPTS_DIR,
+ execFileImpl: () => Promise.reject(error),
+ });
+ assert.equal(result.ok, false);
+ assert.equal(result.error, 'live-wrap.mjs: element not found');
+ assert.ok(typeof result.durationMs === 'number');
+});
diff --git a/tests/live-server.test.mjs b/tests/live-server.test.mjs
index eafd886dc..77491f5cf 100644
--- a/tests/live-server.test.mjs
+++ b/tests/live-server.test.mjs
@@ -3084,4 +3084,75 @@ colors: {}
const data = await postRes.json();
assert.match(data.error, /freeformPrompt or annotations/i);
});
+
+ // A stale generate worker's `error` reply used to acknowledge *any* pending
+ // event for its id, because inferSourceEventType returned undefined and
+ // acknowledgePendingEvent treats that as a wildcard. It ate the user's queued
+ // Accept, which was then never handed to an agent: the browser sat in SAVING
+ // forever and a restart could not requeue it.
+ it('a stale generate error reply does not consume a queued accept', async () => {
+ await drainPolls(server);
+ const id = 'ee55ff66';
+
+ await fetch(`http://localhost:${server.port}/events`, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ token: server.token,
+ type: 'generate',
+ id,
+ action: 'impeccable',
+ count: 1,
+ pageUrl: '/',
+ element: { outerHTML: '' },
+ }),
+ });
+
+ // Agent leases the generate.
+ const leased = await (await fetch(
+ `http://localhost:${server.port}/poll?token=${server.token}&timeout=200&leaseMs=60000`,
+ )).json();
+ assert.equal(leased.id, id);
+ assert.equal(leased.type, 'generate');
+
+ // User accepts. This retires the pending generate and queues the accept.
+ await fetch(`http://localhost:${server.port}/events`, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ token: server.token, type: 'accept', id, variantId: '1' }),
+ });
+
+ // The stale generate worker now fails, using live.md's documented reply.
+ const errRes = await fetch(`http://localhost:${server.port}/poll`, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ token: server.token, id, type: 'error', message: 'late failure' }),
+ });
+ assert.equal(errRes.status, 200);
+
+ const status = await (await fetch(
+ `http://localhost:${server.port}/status?token=${server.token}`,
+ )).json();
+ assert.equal(
+ status.pendingEvents.some((e) => e.id === id && e.type === 'accept'),
+ true,
+ 'the queued accept must survive a stale generate error',
+ );
+
+ // And it must still be deliverable to the next agent that polls.
+ const next = await (await fetch(
+ `http://localhost:${server.port}/poll?token=${server.token}&timeout=500&leaseMs=30000`,
+ )).json();
+ assert.equal(next.id, id);
+ assert.equal(next.type, 'accept', 'the accept must reach an agent');
+
+ // Acknowledge the accept explicitly. drainPolls replies `done`, which maps
+ // to `generate`, so it can never retire an accept and would re-lease it in
+ // a loop forever.
+ await fetch(`http://localhost:${server.port}/poll`, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ token: server.token, id, type: 'complete', sourceEventType: 'accept' }),
+ });
+ });
});
diff --git a/tests/live-source-lock.test.mjs b/tests/live-source-lock.test.mjs
new file mode 100644
index 000000000..44ef68f56
--- /dev/null
+++ b/tests/live-source-lock.test.mjs
@@ -0,0 +1,109 @@
+/**
+ * Tests for live/source-lock.mjs — the per-source-file mutex guarding the
+ * accept/publish critical sections.
+ * Run with: node --test tests/live-source-lock.test.mjs
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readFileSync, rmSync, utimesSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { sourceLockPath, withSourceLockSync } from '../skill/scripts/live/source-lock.mjs';
+
+const TARGET = 'src/page.html';
+
+describe('live source-lock', () => {
+ let tmp;
+
+ beforeEach(() => {
+ tmp = mkdtempSync(join(tmpdir(), 'impeccable-source-lock-'));
+ mkdirSync(join(tmp, 'src'), { recursive: true });
+ writeFileSync(join(tmp, TARGET), '
original
\n');
+ });
+ afterEach(() => rmSync(tmp, { recursive: true, force: true }));
+
+ const writeLock = (body) => {
+ const lockPath = sourceLockPath(TARGET, tmp);
+ mkdirSync(dirname(lockPath), { recursive: true });
+ writeFileSync(lockPath, JSON.stringify(body) + '\n');
+ return lockPath;
+ };
+
+ it('runs the critical section and releases the lock', () => {
+ const lockPath = sourceLockPath(TARGET, tmp);
+ const result = withSourceLockSync(TARGET, 'accept:a', () => {
+ assert.equal(existsSync(lockPath), true, 'lock must exist while held');
+ return 'done';
+ }, { cwd: tmp });
+ assert.equal(result, 'done');
+ assert.equal(existsSync(lockPath), false, 'lock must be released');
+ });
+
+ it('throws SOURCE_LOCKED when a live owner holds the lock', () => {
+ // process.pid is this very process, so the recorded owner is alive.
+ writeLock({ owner: 'publish:x', token: 'other', pid: process.pid, at: Date.now() });
+ assert.throws(
+ () => withSourceLockSync(TARGET, 'accept:a', () => 'should not run', { cwd: tmp }),
+ (err) => err.code === 'SOURCE_LOCKED',
+ );
+ });
+
+ it('does not sweep a live owner’s lock no matter how old it is', () => {
+ // Age alone must not make a lock stale: a holder suspended mid-write would
+ // otherwise have a second writer admitted to the same source file.
+ const lockPath = writeLock({ owner: 'publish:x', token: 'other', pid: process.pid, at: 0 });
+ const ancient = new Date(Date.now() - 10 * 60_000);
+ utimesSync(lockPath, ancient, ancient);
+ assert.throws(
+ () => withSourceLockSync(TARGET, 'accept:a', () => 'should not run', { cwd: tmp }),
+ (err) => err.code === 'SOURCE_LOCKED',
+ 'an old but live lock was stolen',
+ );
+ });
+
+ it('reclaims a lock whose owner process is gone, without waiting out a timeout', () => {
+ // PID 2^22 is above the platform maximum, so it can never be running.
+ writeLock({ owner: 'publish:crashed', token: 'other', pid: 4194304, at: Date.now() });
+ const result = withSourceLockSync(TARGET, 'accept:a', () => 'acquired', { cwd: tmp });
+ assert.equal(result, 'acquired', 'a crashed holder must not block the next writer');
+ });
+
+ it('leaves a replacement lock alone when its own was swept', () => {
+ // Simulates: our lock got reclaimed and another writer now owns the file.
+ // Releasing must not unlink the replacement and admit a third writer.
+ const lockPath = sourceLockPath(TARGET, tmp);
+ withSourceLockSync(TARGET, 'accept:a', () => {
+ writeFileSync(lockPath, JSON.stringify({
+ owner: 'publish:other', token: 'a-different-token', pid: process.pid, at: Date.now(),
+ }) + '\n');
+ }, { cwd: tmp });
+ assert.equal(existsSync(lockPath), true, 'another owner’s lock must survive our release');
+ assert.match(readFileSync(lockPath, 'utf-8'), /a-different-token/);
+ });
+
+ it('retires an unreadable lock only once it is older than the fallback window', () => {
+ const lockPath = writeLock('');
+ assert.throws(
+ () => withSourceLockSync(TARGET, 'accept:a', () => 'x', { cwd: tmp }),
+ (err) => err.code === 'SOURCE_LOCKED',
+ 'a fresh unreadable lock is an in-flight acquisition, not garbage',
+ );
+ const ancient = new Date(Date.now() - 120_000);
+ utimesSync(lockPath, ancient, ancient);
+ assert.equal(
+ withSourceLockSync(TARGET, 'accept:a', () => 'acquired', { cwd: tmp }),
+ 'acquired',
+ 'a stale unreadable lock must be retired',
+ );
+ });
+
+ it('releases the lock even when the critical section throws', () => {
+ const lockPath = sourceLockPath(TARGET, tmp);
+ assert.throws(() => withSourceLockSync(TARGET, 'accept:a', () => {
+ throw new Error('boom');
+ }, { cwd: tmp }), /boom/);
+ assert.equal(existsSync(lockPath), false, 'a thrown critical section must not leak the lock');
+ });
+});
diff --git a/tests/live-vue-component.test.mjs b/tests/live-vue-component.test.mjs
index 5aec55cfb..b552fadf0 100644
--- a/tests/live-vue-component.test.mjs
+++ b/tests/live-vue-component.test.mjs
@@ -129,6 +129,72 @@ describe('Nuxt Vue component preview', () => {
assert.equal(existsSync(join(tmp, result.componentDir, 'v1.vue')), true, 'imported SFC remains until Live shutdown');
});
+ it('preserves original root directives and valueless attrs a variant omits', () => {
+ const originalRoot = ' ';
+ writeFileSync(source, [
+ '',
+ ' ',
+ originalRoot,
+ ' ',
+ '',
+ '',
+ ].join('\n'));
+ const result = scaffoldVueComponentSession({
+ id: 'vue12345',
+ count: 1,
+ sourceFile: 'app/pages/index.vue',
+ sourceStartLine: 3,
+ sourceEndLine: 3,
+ originalLines: [originalRoot],
+ cwd: tmp,
+ });
+ // A restyle variant that keeps only class: every behavior attribute must survive Accept.
+ writeFileSync(join(tmp, result.componentDir, 'v1.vue'), [
+ '',
+ ' ',
+ '',
+ '',
+ '',
+ ].join('\n'));
+
+ assert.equal(inlineVueComponentAccept(result.manifest, 1, tmp).handled, true);
+ const next = readFileSync(source, 'utf-8');
+ assert.match(next, /@click="submit"/, 'v-on shorthand must not degrade to a literal click attribute');
+ assert.doesNotMatch(next, /\sclick="submit"/, 'sigil-stripped event handler leaked into source');
+ assert.match(next, /:aria-label="label"/);
+ assert.match(next, /v-bind:title="tip"/);
+ assert.match(next, /\bdisabled\b/, 'valueless boolean attr dropped');
+ assert.match(next, /\bv-cloak\b/, 'valueless directive dropped');
+ assert.match(next, /class="cta cta--bold"|class="cta--bold cta"/);
+ });
+
+ it('does not duplicate an attribute the variant wrote in the other shorthand form', () => {
+ const originalRoot = ' ';
+ writeFileSync(source, ['', ' ', originalRoot, ' ', '', ''].join('\n'));
+ const result = scaffoldVueComponentSession({
+ id: 'vue12345',
+ count: 1,
+ sourceFile: 'app/pages/index.vue',
+ sourceStartLine: 3,
+ sourceEndLine: 3,
+ originalLines: [originalRoot],
+ cwd: tmp,
+ });
+ writeFileSync(join(tmp, result.componentDir, 'v1.vue'), [
+ '',
+ ' ',
+ '',
+ '',
+ ].join('\n'));
+
+ assert.equal(inlineVueComponentAccept(result.manifest, 1, tmp).handled, true);
+ const next = readFileSync(source, 'utf-8');
+ assert.doesNotMatch(next, /:aria-label="label"[^>]*v-bind:aria-label|v-bind:aria-label="label"[^>]*:aria-label/,
+ 'shorthand and longhand of one attr both emitted, which is a Vue compile error');
+ });
+
it('removes deferred SFCs, the shared runtime, and the generated root on Live shutdown', () => {
const result = scaffoldVueComponentSession({
id: 'vue12345',
@@ -194,6 +260,10 @@ describe('Nuxt Vue component preview', () => {
assert.equal(JSON.parse(readFileSync(join(tmp, result.manifestFile), 'utf-8')).arrivedVariants, 1);
const late = prepareGenerationArtifact({ id: 'vue12345', sourceFile: result.manifestFile, cwd: tmp });
+ const lateManifest = JSON.parse(readFileSync(join(tmp, late.artifactFile), 'utf-8'));
+ lateManifest.arrivedVariants = 2;
+ writeFileSync(join(tmp, late.artifactFile), JSON.stringify(lateManifest, null, 2) + '\n');
+ writeFileSync(join(tmp, late.componentDir, 'v2.vue'), '
Second
\n');
store.appendEvent({ type: 'accept', id: 'vue12345', variantId: '1' });
const rejected = publishGenerationArtifact({
id: 'vue12345',
@@ -208,5 +278,13 @@ describe('Nuxt Vue component preview', () => {
assert.equal(rejected.ok, false);
assert.equal(rejected.error, 'stale_generation_epoch');
assert.equal(readFileSync(source, 'utf-8'), routeBefore);
+ assert.equal(JSON.parse(readFileSync(join(tmp, result.manifestFile), 'utf-8')).arrivedVariants, 1,
+ 'the manifest must still advertise only the variant published before Accept');
+ // A rejected publish must not have touched the session dir at all: v2 still
+ // holds its untouched scaffold stub rather than the late variant's markup.
+ const v2AfterReject = readFileSync(join(tmp, result.componentDir, 'v2.vue'), 'utf-8');
+ assert.doesNotMatch(v2AfterReject, /Second/,
+ 'a rejected late publish must not write variant files into the session dir');
+ assert.match(v2AfterReject, /Variant 2: add scoped CSS here/, 'v2 must still be the scaffold stub');
});
});