synthos 0.10.1 → 0.11.1

package/tests/sharedTableSchema.spec.ts

@@ -0,0 +1,242 @@
+import assert from 'assert';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import path from 'path';
+import {
+    deleteSchema,
+    isValidSchemaPayload,
+    listTables,
+    loadSchema,
+    mergeSchema,
+    newSchemaWrapper,
+    saveSchema,
+    schemaFile,
+    updateSchemaWrapper,
+} from '../src/service/sharedTableSchema';
+import { SynthOSConfig } from '../src/init';
+import { FsStorageProvider } from '../src/storage';
+
+function makeConfig(pagesFolder: string): SynthOSConfig {
+    return {
+        localFolder: '.synthos',
+        pagesFolder,
+        requiredPagesFolders: [],
+        defaultPagesFolders: [],
+        defaultScriptsFolders: [],
+        defaultThemesFolders: [],
+        staticFilesFolders: [],
+        serviceConnectorsFolders: [],
+        requiredPages: [],
+        storageProvider: new FsStorageProvider(),
+        debug: false,
+        debugPageUpdates: false,
+    };
+}
+
+const SAMPLE_SCHEMA: Record<string, unknown> = {
+    type: 'object',
+    properties: {
+        first_name: { type: 'string' },
+        last_name: { type: 'string' },
+    },
+    required: ['first_name'],
+};
+
+describe('sharedTableSchema — pure helpers', () => {
+    describe('schemaFile', () => {
+        it('returns <parent>/<table>.schema.json', () => {
+            assert.strictEqual(schemaFile('/p/shared', 'employees'), path.join('/p/shared', 'employees.schema.json'));
+        });
+    });
+
+    describe('isValidSchemaPayload', () => {
+        it('accepts plain objects', () => {
+            assert.strictEqual(isValidSchemaPayload({ type: 'object' }), true);
+        });
+        it('rejects arrays, null, primitives', () => {
+            assert.strictEqual(isValidSchemaPayload([]), false);
+            assert.strictEqual(isValidSchemaPayload(null), false);
+            assert.strictEqual(isValidSchemaPayload('schema'), false);
+            assert.strictEqual(isValidSchemaPayload(42), false);
+        });
+    });
+
+    describe('newSchemaWrapper', () => {
+        it('initializes version, timestamps, schema, definedBy', () => {
+            const w = newSchemaWrapper(SAMPLE_SCHEMA, '2026-04-25T00:00:00.000Z', 'builder');
+            assert.strictEqual(w.version, 1);
+            assert.strictEqual(w.createdAt, '2026-04-25T00:00:00.000Z');
+            assert.strictEqual(w.updatedAt, '2026-04-25T00:00:00.000Z');
+            assert.strictEqual(w.definedBy, 'builder');
+            assert.deepStrictEqual(w.schema, SAMPLE_SCHEMA);
+        });
+        it('omits definedBy when not provided', () => {
+            const w = newSchemaWrapper(SAMPLE_SCHEMA, '2026-04-25T00:00:00.000Z');
+            assert.strictEqual(w.definedBy, undefined);
+        });
+    });
+
+    describe('updateSchemaWrapper', () => {
+        it('preserves createdAt, advances updatedAt', () => {
+            const orig = newSchemaWrapper(SAMPLE_SCHEMA, '2026-04-25T00:00:00.000Z', 'page-a');
+            const updated = updateSchemaWrapper(orig, { type: 'object' }, '2026-04-26T00:00:00.000Z', 'page-b');
+            assert.strictEqual(updated.createdAt, '2026-04-25T00:00:00.000Z');
+            assert.strictEqual(updated.updatedAt, '2026-04-26T00:00:00.000Z');
+            assert.strictEqual(updated.definedBy, 'page-b');
+        });
+        it('keeps existing definedBy when no override given', () => {
+            const orig = newSchemaWrapper(SAMPLE_SCHEMA, '2026-04-25T00:00:00.000Z', 'page-a');
+            const updated = updateSchemaWrapper(orig, { type: 'object' }, '2026-04-26T00:00:00.000Z');
+            assert.strictEqual(updated.definedBy, 'page-a');
+        });
+    });
+
+    describe('mergeSchema', () => {
+        it('replace mode wins outright', () => {
+            const { merged, conflicts } = mergeSchema(SAMPLE_SCHEMA, { type: 'object', properties: { name: { type: 'string' } } }, 'replace');
+            assert.deepStrictEqual(conflicts, []);
+            assert.deepStrictEqual(merged, { type: 'object', properties: { name: { type: 'string' } } });
+        });
+        it('additive: adds new fields, keeps existing', () => {
+            const incoming: Record<string, unknown> = {
+                type: 'object',
+                properties: {
+                    phone: { type: 'string' },
+                },
+                required: ['phone'],
+            };
+            const { merged, conflicts } = mergeSchema(SAMPLE_SCHEMA, incoming, 'additive');
+            assert.deepStrictEqual(conflicts, []);
+            const props = (merged.properties as Record<string, unknown>);
+            assert.ok(props.first_name);
+            assert.ok(props.last_name);
+            assert.ok(props.phone);
+            assert.deepStrictEqual(merged.required, ['first_name', 'phone']);
+        });
+        it('additive: existing wins on overlap when types match', () => {
+            const incoming: Record<string, unknown> = {
+                type: 'object',
+                properties: {
+                    first_name: { type: 'string', description: 'changed' },
+                },
+            };
+            const { merged, conflicts } = mergeSchema(SAMPLE_SCHEMA, incoming, 'additive');
+            assert.deepStrictEqual(conflicts, []);
+            const fn = (merged.properties as Record<string, any>).first_name;
+            assert.strictEqual(fn.description, undefined, 'existing definition should be preserved');
+        });
+        it('additive: type conflicts produce 409-style result with merged === existing', () => {
+            const incoming: Record<string, unknown> = {
+                type: 'object',
+                properties: {
+                    first_name: { type: 'number' },
+                },
+            };
+            const { merged, conflicts } = mergeSchema(SAMPLE_SCHEMA, incoming, 'additive');
+            assert.strictEqual(conflicts.length, 1);
+            assert.strictEqual(conflicts[0].field, 'first_name');
+            assert.strictEqual(merged, SAMPLE_SCHEMA);
+        });
+        it('additive: undefined existing returns incoming as-is', () => {
+            const incoming: Record<string, unknown> = { type: 'object', properties: { x: { type: 'string' } } };
+            const { merged, conflicts } = mergeSchema(undefined, incoming, 'additive');
+            assert.deepStrictEqual(conflicts, []);
+            assert.deepStrictEqual(merged, incoming);
+        });
+    });
+});
+
+describe('sharedTableSchema — IO + listing', () => {
+    let tmpDir: string;
+    let config: SynthOSConfig;
+    let parent: string;
+
+    beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'synthos-schema-test-'));
+        parent = path.join(tmpDir, 'shared');
+        config = makeConfig(tmpDir);
+        await fs.mkdir(parent, { recursive: true });
+    });
+
+    afterEach(async () => {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+
+    it('saveSchema + loadSchema roundtrip', async () => {
+        const wrapper = newSchemaWrapper(SAMPLE_SCHEMA, '2026-04-25T00:00:00.000Z', 'builder');
+        await saveSchema(config, parent, 'employees', wrapper);
+        const loaded = await loadSchema(config, parent, 'employees');
+        assert.deepStrictEqual(loaded, wrapper);
+    });
+
+    it('loadSchema returns undefined for missing sidecar', async () => {
+        const loaded = await loadSchema(config, parent, 'ghost');
+        assert.strictEqual(loaded, undefined);
+    });
+
+    it('loadSchema returns undefined for malformed sidecar', async () => {
+        await fs.writeFile(path.join(parent, 'bad.schema.json'), 'not-json');
+        const loaded = await loadSchema(config, parent, 'bad');
+        assert.strictEqual(loaded, undefined);
+    });
+
+    it('deleteSchema removes the sidecar; idempotent on missing', async () => {
+        const wrapper = newSchemaWrapper(SAMPLE_SCHEMA, '2026-04-25T00:00:00.000Z');
+        await saveSchema(config, parent, 'employees', wrapper);
+        await deleteSchema(config, parent, 'employees');
+        assert.strictEqual(await loadSchema(config, parent, 'employees'), undefined);
+        // Second delete should not throw
+        await deleteSchema(config, parent, 'employees');
+    });
+
+    describe('listTables', () => {
+        it('lists subfolder tables with record count', async () => {
+            const empFolder = path.join(parent, 'employees');
+            await fs.mkdir(empFolder, { recursive: true });
+            await fs.writeFile(path.join(empFolder, 'a.json'), '{}');
+            await fs.writeFile(path.join(empFolder, 'b.json'), '{}');
+
+            const tables = await listTables(config, parent);
+            assert.deepStrictEqual(tables, [
+                { name: 'employees', hasSchema: false, recordCount: 2 },
+            ]);
+        });
+
+        it('lists schema-only tables (no records yet)', async () => {
+            const wrapper = newSchemaWrapper(SAMPLE_SCHEMA, '2026-04-25T00:00:00.000Z');
+            await saveSchema(config, parent, 'locations', wrapper);
+            const tables = await listTables(config, parent);
+            assert.deepStrictEqual(tables, [
+                { name: 'locations', hasSchema: true, recordCount: 0 },
+            ]);
+        });
+
+        it('combines records + schema entries', async () => {
+            const empFolder = path.join(parent, 'employees');
+            await fs.mkdir(empFolder, { recursive: true });
+            await fs.writeFile(path.join(empFolder, 'a.json'), '{}');
+            const wrapper = newSchemaWrapper(SAMPLE_SCHEMA, '2026-04-25T00:00:00.000Z');
+            await saveSchema(config, parent, 'employees', wrapper);
+            const tables = await listTables(config, parent);
+            assert.deepStrictEqual(tables, [
+                { name: 'employees', hasSchema: true, recordCount: 1 },
+            ]);
+        });
+
+        it('respects reserved set', async () => {
+            const filesFolder = path.join(parent, 'files');
+            await fs.mkdir(filesFolder, { recursive: true });
+            const empFolder = path.join(parent, 'employees');
+            await fs.mkdir(empFolder, { recursive: true });
+
+            const tables = await listTables(config, parent, new Set(['files']));
+            assert.strictEqual(tables.length, 1);
+            assert.strictEqual(tables[0].name, 'employees');
+        });
+
+        it('returns [] for missing namespace', async () => {
+            const tables = await listTables(config, path.join(tmpDir, 'doesnotexist'));
+            assert.deepStrictEqual(tables, []);
+        });
+    });
+});

package/tests/transformPage.spec.ts

@@ -7,7 +7,6 @@ import {
     stripNodeIds,
     applyChangeList,
     parseChangeList,
-    injectError,
     deduplicateInlineScripts,
     normalizedIndexOf,
     transformPage,
@@ -21,13 +20,13 @@ import { Builder, BuilderResult, ContextSection } from '../src/builders/types';
 // ---------------------------------------------------------------------------
 
 describe('assignNodeIds', () => {
-    it('assigns sequential data-node-id to every element', () => {
+    it('assigns sequential data-nid to every element', () => {
         const html = '<html><head></head><body><div><p>Hello</p></div></body></html>';
         const { html: result, nodeCount } = assignNodeIds(html);
-        assert.ok(result.includes('data-node-id="0"'));
+        assert.ok(result.includes('data-nid="0"'));
         assert.ok(nodeCount > 0);
         // Every tag should have an id — count occurrences
-        const ids = result.match(/data-node-id="/g);
+        const ids = result.match(/data-nid="/g);
         assert.strictEqual(ids?.length, nodeCount);
     });
 
@@ -38,16 +37,16 @@ describe('assignNodeIds', () => {
         assert.ok(nodeCount >= 4); // html, head, body, div, span, span = 6
     });
 
-    it('assigns data-node-id to script and style elements', () => {
+    it('assigns data-nid to script and style elements', () => {
         const html = '<html><head><style>.a{color:red}</style><script>var x=1;</script></head><body><script src="/app.js"></script></body></html>';
         const { html: result, nodeCount } = assignNodeIds(html);
         // All 6 elements should have ids: html, head, style, script(inline), body, script(src)
-        const ids = result.match(/data-node-id="/g);
+        const ids = result.match(/data-nid="/g);
         assert.strictEqual(ids?.length, nodeCount);
         assert.strictEqual(nodeCount, 6);
         // Verify the style and script tags specifically got ids
-        assert.ok(result.match(/<style[^>]+data-node-id="/), 'style element should have data-node-id');
-        assert.ok(result.match(/<script[^>]+data-node-id="/), 'script element should have data-node-id');
+        assert.ok(result.match(/<style[^>]+data-nid="/), 'style element should have data-nid');
+        assert.ok(result.match(/<script[^>]+data-nid="/), 'script element should have data-nid');
     });
 });
 
@@ -56,10 +55,10 @@ describe('assignNodeIds', () => {
 // ---------------------------------------------------------------------------
 
 describe('stripNodeIds', () => {
-    it('removes all data-node-id attributes', () => {
-        const html = '<div data-node-id="0"><p data-node-id="1">Hi</p></div>';
+    it('removes all data-nid attributes', () => {
+        const html = '<div data-nid="0"><p data-nid="1">Hi</p></div>';
         const result = stripNodeIds(html);
-        assert.ok(!result.includes('data-node-id'));
+        assert.ok(!result.includes('data-nid'));
         assert.ok(result.includes('<p>Hi</p>'));
     });
 });
@@ -69,12 +68,12 @@ describe('stripNodeIds', () => {
 // ---------------------------------------------------------------------------
 
 describe('assignNodeIds -> stripNodeIds roundtrip', () => {
-    it('produces HTML without data-node-id attributes', () => {
+    it('produces HTML without data-nid attributes', () => {
         const original = '<html><head></head><body><div><p>Hello</p></div></body></html>';
         const { html: annotated } = assignNodeIds(original);
-        assert.ok(annotated.includes('data-node-id'));
+        assert.ok(annotated.includes('data-nid'));
         const stripped = stripNodeIds(annotated);
-        assert.ok(!stripped.includes('data-node-id'));
+        assert.ok(!stripped.includes('data-nid'));
         assert.ok(stripped.includes('<p>Hello</p>'));
     });
 });
@@ -86,7 +85,7 @@ describe('assignNodeIds -> stripNodeIds roundtrip', () => {
 describe('applyChangeList', () => {
     // Helper: wrap content in a minimal annotated structure
     const annotated = '<html><head></head><body>' +
-        '<div data-node-id="10"><p data-node-id="11">Old text</p></div>' +
+        '<div data-nid="10"><p data-nid="11">Old text</p></div>' +
         '</body></html>';
 
     it('applies "update" — replaces innerHTML', () => {
@@ -94,7 +93,7 @@ describe('applyChangeList', () => {
             { op: 'update', nodeId: '11', html: 'New text' },
         ];
         const result = applyChangeList(annotated, changes);
-        assert.ok(result.includes('<p data-node-id="11">New text</p>'));
+        assert.ok(result.includes('<p data-nid="11">New text</p>'));
     });
 
     it('applies "replace" — replaces outerHTML', () => {
@@ -103,7 +102,7 @@ describe('applyChangeList', () => {
         ];
         const result = applyChangeList(annotated, changes);
         assert.ok(result.includes('<span>Replaced</span>'));
-        assert.ok(!result.includes('data-node-id="11"'));
+        assert.ok(!result.includes('data-nid="11"'));
     });
 
     it('applies "delete" — removes element', () => {
@@ -111,7 +110,7 @@ describe('applyChangeList', () => {
             { op: 'delete', nodeId: '11' },
         ];
         const result = applyChangeList(annotated, changes);
-        assert.ok(!result.includes('data-node-id="11"'));
+        assert.ok(!result.includes('data-nid="11"'));
         assert.ok(!result.includes('Old text'));
     });
 
@@ -130,7 +129,7 @@ describe('applyChangeList', () => {
         const result = applyChangeList(annotated, changes);
         // Prepended element should appear before the <p>
         const prependIdx = result.indexOf('<em>Prepended</em>');
-        const pIdx = result.indexOf('<p data-node-id="11">');
+        const pIdx = result.indexOf('<p data-nid="11">');
         assert.ok(prependIdx < pIdx);
     });
 
@@ -140,7 +139,7 @@ describe('applyChangeList', () => {
         ];
         const result = applyChangeList(annotated, changes);
         const beforeIdx = result.indexOf('<em>Before</em>');
-        const pIdx = result.indexOf('<p data-node-id="11">');
+        const pIdx = result.indexOf('<p data-nid="11">');
         assert.ok(beforeIdx < pIdx);
     });
 
@@ -150,7 +149,7 @@ describe('applyChangeList', () => {
         ];
         const result = applyChangeList(annotated, changes);
         const afterIdx = result.indexOf('<em>After</em>');
-        const pIdx = result.indexOf('<p data-node-id="11">');
+        const pIdx = result.indexOf('<p data-nid="11">');
         assert.ok(afterIdx > pIdx);
     });
 
@@ -163,11 +162,14 @@ describe('applyChangeList', () => {
         assert.ok(!result.includes('Ghost'));
     });
 
-    it('throws on missing parent for insert', () => {
+    it('warns but does not throw on missing parent for insert', () => {
         const changes: ChangeList = [
             { op: 'insert', parentId: '999', position: 'append', html: '<em>Fail</em>' },
         ];
-        assert.throws(() => applyChangeList(annotated, changes), /not found/);
+        // Should not throw — warns and skips
+        const result = applyChangeList(annotated, changes);
+        assert.ok(!result.includes('Fail'));
+        assert.ok(result.includes('Old text')); // original content preserved
     });
 
     it('applies "style-element" — sets style attribute on unlocked element', () => {
@@ -176,12 +178,12 @@ describe('applyChangeList', () => {
         ];
         const result = applyChangeList(annotated, changes);
         assert.ok(result.includes('style="color: red; font-size: 16px"'));
-        assert.ok(result.includes('data-node-id="11"'));
+        assert.ok(result.includes('data-nid="11"'));
     });
 
     it('skips "style-element" on a data-locked element', () => {
         const lockedHtml = '<html><head></head><body>' +
-            '<div data-node-id="10"><p data-node-id="11" data-locked>Locked text</p></div>' +
+            '<div data-nid="10"><p data-nid="11" data-locked>Locked text</p></div>' +
             '</body></html>';
         const changes: ChangeList = [
             { op: 'style-element', nodeId: '11', style: 'color: red' },
@@ -200,9 +202,9 @@ describe('applyChangeList', () => {
 
     it('allows delete of unlocked child inside a data-locked parent', () => {
         const lockedParentHtml = '<html><head></head><body>' +
-            '<div data-node-id="10" data-locked="true">' +
-            '<p data-node-id="11">Child message</p>' +
-            '<p data-node-id="12">Another child</p>' +
+            '<div data-nid="10" data-locked="true">' +
+            '<p data-nid="11">Child message</p>' +
+            '<p data-nid="12">Another child</p>' +
             '</div></body></html>';
         const changes: ChangeList = [
             { op: 'delete', nodeId: '11' },
@@ -214,7 +216,7 @@ describe('applyChangeList', () => {
 
     it('blocks delete of element that itself has data-locked', () => {
         const lockedHtml = '<html><head></head><body>' +
-            '<div data-node-id="10"><p data-node-id="11" data-locked="true">Locked</p></div>' +
+            '<div data-nid="10"><p data-nid="11" data-locked="true">Locked</p></div>' +
             '</body></html>';
         const changes: ChangeList = [
             { op: 'delete', nodeId: '11' },
@@ -225,8 +227,8 @@ describe('applyChangeList', () => {
 
     it('allows replace of unlocked child inside a data-locked parent', () => {
         const lockedParentHtml = '<html><head></head><body>' +
-            '<div data-node-id="10" data-locked="true">' +
-            '<p data-node-id="11">Old child</p>' +
+            '<div data-nid="10" data-locked="true">' +
+            '<p data-nid="11">Old child</p>' +
             '</div></body></html>';
         const changes: ChangeList = [
             { op: 'replace', nodeId: '11', html: '<span>New child</span>' },
@@ -246,7 +248,7 @@ describe('applyChangeList', () => {
 
     it('skips replace on a data-locked element', () => {
         const lockedHtml = '<html><head></head><body>' +
-            '<div data-node-id="10"><p data-node-id="11" data-locked>Locked</p></div>' +
+            '<div data-nid="10"><p data-nid="11" data-locked>Locked</p></div>' +
             '</body></html>';
         const changes: ChangeList = [
             { op: 'replace', nodeId: '11', html: '<span>Replaced</span>' },
@@ -265,11 +267,14 @@ describe('applyChangeList', () => {
         assert.ok(result.includes('Old text'));
     });
 
-    it('throws on unknown insert position', () => {
+    it('warns but does not throw on unknown insert position', () => {
         const changes = [
             { op: 'insert', parentId: '10', position: 'sideways', html: '<em>Oops</em>' },
         ] as unknown as ChangeList;
-        assert.throws(() => applyChangeList(annotated, changes), /unknown position/);
+        // Should not throw — warns and skips
+        const result = applyChangeList(annotated, changes);
+        assert.ok(!result.includes('Oops'));
+        assert.ok(result.includes('Old text')); // original content preserved
     });
 
     it('throws on unknown op', () => {
@@ -313,34 +318,9 @@ describe('parseChangeList', () => {
 });
 
 // ---------------------------------------------------------------------------
-// injectError
+// injectError — REMOVED (iframe model: errors reported via shell postMessage)
 // ---------------------------------------------------------------------------
 
-describe('injectError', () => {
-    it('injects error script block into body', () => {
-        const html = '<html><head></head><body><p>Page</p></body></html>';
-        const result = injectError(html, 'Oops', 'details here');
-        assert.ok(result.includes('<script id="error" type="application/json">'));
-        assert.ok(result.includes('"message":"Oops"'));
-        assert.ok(result.includes('"details":"details here"'));
-    });
-
-    it('replaces existing error block', () => {
-        const html = '<html><head></head><body><script id="error" type="application/json">{"message":"old"}</script></body></html>';
-        const result = injectError(html, 'New', 'new detail');
-        // Should have exactly one error script
-        const matches = result.match(/<script id="error"/g);
-        assert.strictEqual(matches?.length, 1);
-        assert.ok(result.includes('"message":"New"'));
-    });
-
-    it('appends to end if no body tag', () => {
-        const html = '<div>No body</div>';
-        const result = injectError(html, 'Err', 'det');
-        assert.ok(result.includes('<script id="error"'));
-    });
-});
-
 // ---------------------------------------------------------------------------
 // deduplicateInlineScripts
 // ---------------------------------------------------------------------------
@@ -497,7 +477,7 @@ describe('normalizedIndexOf', () => {
 
 describe('applyChangeList — search-replace / search-insert ops', () => {
     const scriptHtml = '<html><head></head><body>' +
-        '<script data-node-id="5">let a = 1;\nlet b = 2;\nlet c = 3;\nlet d = 4;\nlet e = 5;</script>' +
+        '<script data-nid="5">let a = 1;\nlet b = 2;\nlet c = 3;\nlet d = 4;\nlet e = 5;</script>' +
         '</body></html>';
 
     it('search-replace replaces exact text match', () => {
@@ -524,7 +504,7 @@ describe('applyChangeList — search-replace / search-insert ops', () => {
     it('search-replace falls back to normalized match', () => {
         // Script has single spaces, search has different whitespace
         const html = '<html><head></head><body>' +
-            '<script data-node-id="5">function  foo()  {\n  return  1;\n}</script>' +
+            '<script data-nid="5">function  foo()  {\n  return  1;\n}</script>' +
             '</body></html>';
         const changes: ChangeList = [
             { op: 'search-replace', nodeId: '5', search: 'function foo() { return 1; }', replace: 'function foo() { return 2; }' },
@@ -545,7 +525,7 @@ describe('applyChangeList — search-replace / search-insert ops', () => {
     });
 
     it('search-replace works on style blocks', () => {
-        const styleHtml = '<html><head><style data-node-id="3">.a { color: red; }\n.b { color: blue; }\n.c { color: green; }</style></head><body></body></html>';
+        const styleHtml = '<html><head><style data-nid="3">.a { color: red; }\n.b { color: blue; }\n.c { color: green; }</style></head><body></body></html>';
         const changes: ChangeList = [
             { op: 'search-replace', nodeId: '3', search: '.b { color: blue; }', replace: '.b { color: purple; }' },
         ];
@@ -602,11 +582,11 @@ describe('transformPage', () => {
         <div id="thoughts" style="display: none;"></div>
     </body></html>`;
 
-    /** Extract the data-node-id for an element identified by a CSS-style attribute (e.g. id="content") from annotated HTML. */
+    /** Extract the data-nid for an element identified by a CSS-style attribute (e.g. id="content") from annotated HTML. */
     function findNodeId(annotatedHtml: string, idAttr: string): string {
-        // Match a tag that contains both data-node-id="X" and the target id, in either order
-        const pattern1 = new RegExp(`data-node-id="(\\d+)"[^>]*${idAttr}`);
-        const pattern2 = new RegExp(`${idAttr}[^>]*data-node-id="(\\d+)"`);
+        // Match a tag that contains both data-nid="X" and the target id, in either order
+        const pattern1 = new RegExp(`data-nid="(\\d+)"[^>]*${idAttr}`);
+        const pattern2 = new RegExp(`${idAttr}[^>]*data-nid="(\\d+)"`);
         const m = annotatedHtml.match(pattern1) || annotatedHtml.match(pattern2);
         return m ? m[1] : '99999';
     }
@@ -639,11 +619,11 @@ describe('transformPage', () => {
         assert.ok(result.value);
         assert.ok(result.value.html.includes('Updated content'));
         assert.strictEqual(result.value.changeCount, 1);
-        // Should not contain data-node-id attributes
-        assert.ok(!result.value.html.includes('data-node-id'));
+        // Should not contain data-nid attributes
+        assert.ok(!result.value.html.includes('data-nid'));
     });
 
-    it('returns error HTML when builder returns error', async () => {
+    it('returns errorText when builder returns error (shell displays it)', async () => {
         const builder = makeBuilder(async () => ({
             kind: 'error',
             error: new Error('API quota exceeded'),
@@ -652,11 +632,12 @@ describe('transformPage', () => {
         const result = await transformPage(makeArgs(builder));
         assert.strictEqual(result.completed, true);
         assert.ok(result.value);
-        assert.ok(result.value.html.includes('id="error"'));
-        assert.strictEqual(result.value.changeCount, 0);
+        assert.strictEqual(result.value.errorText, 'API quota exceeded');
+        assert.ok(!result.value.html.includes('id="error"'), 'error should not be injected into HTML');
+        assert.strictEqual(result.value.changeCount, -1);
     });
 
-    it('handles reply result by appending chat messages', async () => {
+    it('returns replyText when builder returns reply (shell displays it)', async () => {
         const builder = makeBuilder(async () => ({
             kind: 'reply',
             text: 'I cannot help with that.',
@@ -668,10 +649,9 @@ describe('transformPage', () => {
         });
         assert.strictEqual(result.completed, true);
         assert.ok(result.value);
-        assert.ok(result.value.html.includes('User:'));
-        assert.ok(result.value.html.includes('SynthOS:'));
-        assert.ok(result.value.html.includes('I cannot help with that.'));
-        assert.strictEqual(result.value.changeCount, 0);
+        assert.strictEqual(result.value.replyText, 'I cannot help with that.');
+        assert.ok(!result.value.html.includes('User:'), 'chat messages should not be injected into HTML');
+        assert.strictEqual(result.value.changeCount, -1);
     });
 
     it('handles missing nodes gracefully (no repair pass)', async () => {
@@ -783,7 +763,7 @@ describe('transformPage', () => {
         assert.ok(!result.value!.html.includes('color: red'));
     });
 
-    it('catches exceptions from builder and injects error', async () => {
+    it('catches exceptions from builder and returns errorText (shell displays it)', async () => {
         const builder = makeBuilder(async () => {
             throw new Error('Unexpected builder crash');
         });
@@ -791,8 +771,9 @@ describe('transformPage', () => {
         const result = await transformPage(makeArgs(builder));
         assert.strictEqual(result.completed, true);
         assert.ok(result.value);
-        assert.ok(result.value.html.includes('id="error"'));
-        assert.strictEqual(result.value.changeCount, 0);
+        assert.strictEqual(result.value.errorText, 'Unexpected builder crash');
+        assert.ok(!result.value.html.includes('id="error"'), 'error should not be injected into HTML');
+        assert.strictEqual(result.value.changeCount, -1);
     });
 
     it('detects newBuild when isBuilder is true and only one chat message', async () => {
@@ -864,7 +845,7 @@ describe('transformPage', () => {
         // Edit should be applied
         assert.ok(result.value.html.includes('let count = 42;'));
         // Node ids should be stripped
-        assert.ok(!result.value.html.includes('data-node-id'));
+        assert.ok(!result.value.html.includes('data-nid'));
         assert.strictEqual(result.value.changeCount, 1);
     });
 });

package/default-pages/application/page.json

@@ -1,10 +0,0 @@
-{
-    "title": "Application",
-    "categories": [
-        "Starters"
-    ],
-    "pinned": false,
-    "showInAll": false,
-    "pageVersion": 3,
-    "mode": "unlocked"
-}

package/default-pages/retro_game_starter/page.json

@@ -1,12 +0,0 @@
-{
-    "title": "Retro Game Starter",
-    "categories": [
-        "Starters"
-    ],
-    "pinned": false,
-    "showInAll": true,
-    "createdDate": "2026-03-02T12:00:00.000Z",
-    "lastModified": "2026-03-02T12:00:00.000Z",
-    "pageVersion": 3,
-    "mode": "unlocked"
-}