@a2ui/web_core 0.9.2 → 0.10.0

package/src/v0_8/data/model-processor.test.js

@@ -13,139 +13,143 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import assert from "node:assert";
-import { describe, it, beforeEach } from "node:test";
-import { A2uiMessageProcessor } from "./model-processor.js";
-describe("A2uiMessageProcessor", () => {
+import assert from 'node:assert';
+import { describe, it, beforeEach } from 'node:test';
+import { A2uiMessageProcessor } from './model-processor.js';
+describe('A2uiMessageProcessor', () => {
     let processor;
     beforeEach(() => {
         processor = new A2uiMessageProcessor();
     });
-    it("handles beginRendering", () => {
+    it('handles beginRendering', () => {
         processor.processMessages([
             {
                 beginRendering: {
-                    surfaceId: "s1",
-                    root: "root",
-                    styles: { font: "Arial" },
+                    surfaceId: 's1',
+                    root: 'root',
+                    styles: { font: 'Arial' },
                 },
             },
         ]);
         const surfaces = processor.getSurfaces();
-        const surface = surfaces.get("s1");
+        const surface = surfaces.get('s1');
         assert.ok(surface);
-        assert.strictEqual(surface.rootComponentId, "root");
-        assert.deepStrictEqual(surface.styles, { font: "Arial" });
+        assert.strictEqual(surface.rootComponentId, 'root');
+        assert.deepStrictEqual(surface.styles, { font: 'Arial' });
         // The component tree remains null until components are added via surfaceUpdate.
         assert.strictEqual(surface.componentTree, null);
     });
-    it("handles surfaceUpdate", () => {
+    it('handles surfaceUpdate', () => {
         processor.processMessages([
             {
-                beginRendering: { surfaceId: "s1", root: "root" },
+                beginRendering: { surfaceId: 's1', root: 'root' },
             },
         ]);
         processor.processMessages([
             {
                 surfaceUpdate: {
-                    surfaceId: "s1",
+                    surfaceId: 's1',
                     components: [
                         {
-                            id: "root",
+                            id: 'root',
                             component: {
-                                Text: { text: { literal: "Hello" }, usageHint: "body" },
+                                Text: { text: { literal: 'Hello' }, usageHint: 'body' },
                             },
                         },
                     ],
                 },
             },
         ]);
-        const surface = processor.getSurfaces().get("s1");
+        const surface = processor.getSurfaces().get('s1');
         assert.ok(surface);
         assert.ok(surface.componentTree);
         const root = surface.componentTree;
-        assert.strictEqual(root.id, "root");
-        assert.strictEqual(root.type, "Text");
+        assert.strictEqual(root.id, 'root');
+        assert.strictEqual(root.type, 'Text');
         // The property preserves the literal wrapper
-        assert.deepStrictEqual(root.properties.text, { literal: "Hello" });
+        assert.deepStrictEqual(root.properties.text, { literal: 'Hello' });
     });
-    it("handles dataModelUpdate", () => {
+    it('handles dataModelUpdate', () => {
         processor.processMessages([
             {
-                beginRendering: { surfaceId: "s1", root: "root" },
+                beginRendering: { surfaceId: 's1', root: 'root' },
             },
             {
                 dataModelUpdate: {
-                    surfaceId: "s1",
-                    contents: [{ key: "message", valueString: "World" }],
+                    surfaceId: 's1',
+                    contents: [{ key: 'message', valueString: 'World' }],
                 },
             },
         ]);
-        const surface = processor.getSurfaces().get("s1");
-        assert.strictEqual(surface?.dataModel.get("message"), "World");
+        const surface = processor.getSurfaces().get('s1');
+        assert.strictEqual(surface?.dataModel.get('message'), 'World');
     });
-    it("handles deleteSurface", () => {
+    it('handles deleteSurface', () => {
         processor.processMessages([
             {
-                beginRendering: { surfaceId: "s1", root: "root" },
+                beginRendering: { surfaceId: 's1', root: 'root' },
             },
         ]);
-        assert.ok(processor.getSurfaces().has("s1"));
+        assert.ok(processor.getSurfaces().has('s1'));
         processor.processMessages([
             {
-                deleteSurface: { surfaceId: "s1" },
+                deleteSurface: { surfaceId: 's1' },
             },
         ]);
-        assert.ok(!processor.getSurfaces().has("s1"));
+        assert.ok(!processor.getSurfaces().has('s1'));
     });
-    it("resolves component references (children)", () => {
+    it('resolves component references (children)', () => {
         processor.processMessages([
-            { beginRendering: { surfaceId: "s1", root: "row" } },
+            { beginRendering: { surfaceId: 's1', root: 'row' } },
             {
                 surfaceUpdate: {
-                    surfaceId: "s1",
+                    surfaceId: 's1',
                     components: [
                         {
-                            id: "row",
+                            id: 'row',
                             component: {
-                                Row: { children: { explicitList: ["t1", "t2"] } },
+                                Row: { children: { explicitList: ['t1', 't2'] } },
                             },
                         },
                         {
-                            id: "t1",
+                            id: 't1',
                             component: {
-                                Text: { text: { literal: "One" }, usageHint: "body" },
+                                Text: { text: { literal: 'One' }, usageHint: 'body' },
                             },
                         },
                         {
-                            id: "t2",
+                            id: 't2',
                             component: {
-                                Text: { text: { literal: "Two" }, usageHint: "body" },
+                                Text: { text: { literal: 'Two' }, usageHint: 'body' },
                             },
                         },
                     ],
                 },
             },
         ]);
-        const surface = processor.getSurfaces().get("s1");
+        const surface = processor.getSurfaces().get('s1');
         const root = surface?.componentTree;
-        assert.strictEqual(root.type, "Row");
+        assert.strictEqual(root.type, 'Row');
         assert.strictEqual(root.properties.children.length, 2);
-        assert.deepStrictEqual(root.properties.children[0].properties.text, { literal: "One" });
-        assert.deepStrictEqual(root.properties.children[1].properties.text, { literal: "Two" });
+        assert.deepStrictEqual(root.properties.children[0].properties.text, {
+            literal: 'One',
+        });
+        assert.deepStrictEqual(root.properties.children[1].properties.text, {
+            literal: 'Two',
+        });
     });
-    it("resolves templates", () => {
+    it('resolves templates', () => {
         processor.processMessages([
-            { beginRendering: { surfaceId: "s1", root: "row" } },
+            { beginRendering: { surfaceId: 's1', root: 'row' } },
             {
                 dataModelUpdate: {
-                    surfaceId: "s1",
+                    surfaceId: 's1',
                     contents: [
                         {
-                            key: "items",
+                            key: 'items',
                             valueMap: [
-                                { key: "0", valueString: "Item A" },
-                                { key: "1", valueString: "Item B" },
+                                { key: '0', valueString: 'Item A' },
+                                { key: '1', valueString: 'Item B' },
                             ],
                         },
                     ],
@@ -153,40 +157,40 @@ describe("A2uiMessageProcessor", () => {
             },
             {
                 surfaceUpdate: {
-                    surfaceId: "s1",
+                    surfaceId: 's1',
                     components: [
                         {
-                            id: "row",
+                            id: 'row',
                             component: {
                                 Row: {
                                     children: {
                                         template: {
-                                            componentId: "item",
-                                            dataBinding: "/items",
+                                            componentId: 'item',
+                                            dataBinding: '/items',
                                         },
                                     },
                                 },
                             },
                         },
                         {
-                            id: "item",
+                            id: 'item',
                             component: {
-                                Text: { text: { path: "." }, usageHint: "body" },
+                                Text: { text: { path: '.' }, usageHint: 'body' },
                             },
                         },
                     ],
                 },
             },
         ]);
-        const surface = processor.getSurfaces().get("s1");
+        const surface = processor.getSurfaces().get('s1');
         const root = surface?.componentTree;
-        assert.strictEqual(root.type, "Row");
+        assert.strictEqual(root.type, 'Row');
         assert.strictEqual(root.properties.children.length, 2);
         // Verify template expansion
         const child0 = root.properties.children[0];
         const child1 = root.properties.children[1];
         // Check that binding paths are correct (processor does NOT resolve the value, just the binding path context)
-        assert.deepStrictEqual(child0.properties.text, { path: "." });
+        assert.deepStrictEqual(child0.properties.text, { path: '.' });
         // Now verify we can resolve the data using the node's context
         const textProp0 = child0.properties.text;
         const resolvedValue0 = processor.getData(child0, textProp0.path, 's1');
@@ -195,178 +199,162 @@ describe("A2uiMessageProcessor", () => {
         const resolvedValue1 = processor.getData(child1, textProp1.path, 's1');
         assert.strictEqual(resolvedValue1, 'Item B');
     });
-    it("getData resolves paths relative to node context", () => {
+    it('getData resolves paths relative to node context', () => {
         processor.processMessages([
-            { beginRendering: { surfaceId: "s1", root: "root" } },
+            { beginRendering: { surfaceId: 's1', root: 'root' } },
             {
                 dataModelUpdate: {
-                    surfaceId: "s1",
-                    contents: [
-                        { key: "user", valueMap: [{ key: "name", valueString: "Alice" }] },
-                    ],
+                    surfaceId: 's1',
+                    contents: [{ key: 'user', valueMap: [{ key: 'name', valueString: 'Alice' }] }],
                 },
             },
         ]);
-        processor.getSurfaces().get("s1");
-        const node = { id: "test", dataContextPath: "/user" };
-        const name = processor.getData(node, "name", "s1");
-        assert.strictEqual(name, "Alice");
-        const self = processor.getData(node, ".", "s1");
+        processor.getSurfaces().get('s1');
+        const node = { id: 'test', dataContextPath: '/user' };
+        const name = processor.getData(node, 'name', 's1');
+        assert.strictEqual(name, 'Alice');
+        const self = processor.getData(node, '.', 's1');
         assert.ok(self instanceof Map);
-        assert.strictEqual(self.get("name"), "Alice");
-        const rootData = processor.getData(node, "/user/name", "s1");
-        assert.strictEqual(rootData, "Alice");
+        assert.strictEqual(self.get('name'), 'Alice');
+        const rootData = processor.getData(node, '/user/name', 's1');
+        assert.strictEqual(rootData, 'Alice');
     });
-    it("setData updates data model", () => {
-        processor.processMessages([
-            { beginRendering: { surfaceId: "s1", root: "root" } },
-        ]);
-        const surface = processor.getSurfaces().get("s1");
-        const node = { id: "test", dataContextPath: "/" };
-        processor.setData(node, "count", 42, "s1");
-        assert.strictEqual(surface?.dataModel.get("count"), 42);
-        processor.setData(node, "/nested/value", "foo", "s1");
-        const nested = surface?.dataModel.get("nested");
-        assert.strictEqual(nested.get("value"), "foo");
+    it('setData updates data model', () => {
+        processor.processMessages([{ beginRendering: { surfaceId: 's1', root: 'root' } }]);
+        const surface = processor.getSurfaces().get('s1');
+        const node = { id: 'test', dataContextPath: '/' };
+        processor.setData(node, 'count', 42, 's1');
+        assert.strictEqual(surface?.dataModel.get('count'), 42);
+        processor.setData(node, '/nested/value', 'foo', 's1');
+        const nested = surface?.dataModel.get('nested');
+        assert.strictEqual(nested.get('value'), 'foo');
     });
-    it("normalizes paths correctly", () => {
-        const p = processor.normalizePath("users[0].name");
-        assert.strictEqual(p, "/users/0/name");
+    it('normalizes paths correctly', () => {
+        const p = processor.normalizePath('users[0].name');
+        assert.strictEqual(p, '/users/0/name');
     });
-    it("parses JSON strings in data", () => {
-        processor.processMessages([
-            { beginRendering: { surfaceId: "s1", root: "root" } },
-        ]);
+    it('parses JSON strings in data', () => {
+        processor.processMessages([{ beginRendering: { surfaceId: 's1', root: 'root' } }]);
         // Explicitly testing private/internal parsing logic via public update
         processor.processMessages([
             {
                 dataModelUpdate: {
-                    surfaceId: "s1",
-                    contents: [{ key: "config", valueString: '{"theme":"dark"}' }],
+                    surfaceId: 's1',
+                    contents: [{ key: 'config', valueString: '{"theme":"dark"}' }],
                 },
             },
         ]);
-        const surface = processor.getSurfaces().get("s1");
-        const config = surface?.dataModel.get("config");
-        assert.deepStrictEqual(config, { theme: "dark" });
+        const surface = processor.getSurfaces().get('s1');
+        const config = surface?.dataModel.get('config');
+        assert.deepStrictEqual(config, { theme: 'dark' });
     });
-    it("test basic edge cases and internal fallbacks", () => {
+    it('test basic edge cases and internal fallbacks', () => {
         // 1. clearSurfaces
-        processor.processMessages([
-            { beginRendering: { surfaceId: "s1", root: "root" } },
-        ]);
+        processor.processMessages([{ beginRendering: { surfaceId: 's1', root: 'root' } }]);
         assert.strictEqual(processor.getSurfaces().size, 1);
         processor.clearSurfaces();
         assert.strictEqual(processor.getSurfaces().size, 0);
         // 2. setData with null node
-        processor.processMessages([
-            { beginRendering: { surfaceId: "s1", root: "root" } },
-        ]);
+        processor.processMessages([{ beginRendering: { surfaceId: 's1', root: 'root' } }]);
         // Shouldn't throw
-        processor.setData(null, "foo", "bar");
+        processor.setData(null, 'foo', 'bar');
         // 3. setData with default data context (default to /)
-        const node = { id: "test", dataContextPath: undefined };
-        processor.setData(node, ".", "value");
-        const surface = processor.getSurfaces().get("s1");
-        assert.strictEqual(surface.dataModel.get("."), undefined); // Normal setDataByPath logic when root=/
+        const node = { id: 'test', dataContextPath: undefined };
+        processor.setData(node, '.', 'value');
+        const surface = processor.getSurfaces().get('s1');
+        assert.strictEqual(surface.dataModel.get('.'), undefined); // Normal setDataByPath logic when root=/
         // 4. parseIfJsonString with invalid JSON layout
         processor.processMessages([
             {
                 dataModelUpdate: {
-                    surfaceId: "s1",
-                    contents: [{ key: "badJson", valueString: '{bad" }' }],
+                    surfaceId: 's1',
+                    contents: [{ key: 'badJson', valueString: '{bad" }' }],
                 },
             },
         ]);
-        assert.strictEqual(surface.dataModel.get("badJson"), '{bad" }'); // Returns original
+        assert.strictEqual(surface.dataModel.get('badJson'), '{bad" }'); // Returns original
         // 5. convertKeyValueArrayToMap with missing valueKey
         // Explicit array pass directly to internal mapping simulation
-        processor.setDataByPath(surface.dataModel, "malformed", [
-            { key: "foo", unknownKey: "bar" }, // missing value map/string etc
+        processor.setDataByPath(surface.dataModel, 'malformed', [
+            { key: 'foo', unknownKey: 'bar' }, // missing value map/string etc
         ]);
-        const malformed = surface.dataModel.get("malformed");
-        assert.strictEqual(malformed.has("foo"), false); // Skips processing
+        const malformed = surface.dataModel.get('malformed');
+        assert.strictEqual(malformed.has('foo'), false); // Skips processing
         // 6. object normalization at root
-        processor.setDataByPath(surface.dataModel, "/", {
-            plain: "object",
+        processor.setDataByPath(surface.dataModel, '/', {
+            plain: 'object',
         });
-        assert.strictEqual(surface.dataModel.get("plain"), "object");
+        assert.strictEqual(surface.dataModel.get('plain'), 'object');
         // 7. non-map/object root fails gracefully
-        processor.setDataByPath(surface.dataModel, "/", "stringroot");
+        processor.setDataByPath(surface.dataModel, '/', 'stringroot');
         // Doesn't explode, just prints error internally
     });
-    it("test array set operations and invalid primitive traversal", () => {
-        processor.processMessages([
-            { beginRendering: { surfaceId: "s1", root: "root" } },
-        ]);
-        const surface = processor.getSurfaces().get("s1");
+    it('test array set operations and invalid primitive traversal', () => {
+        processor.processMessages([{ beginRendering: { surfaceId: 's1', root: 'root' } }]);
+        const surface = processor.getSurfaces().get('s1');
         // Manually set an array to avoid empty array being converted to Map
-        surface.dataModel.set("list", ["dummy"]);
+        surface.dataModel.set('list', ['dummy']);
         // Now it's an array at /list, set something deep inside it
-        processor.setDataByPath(surface.dataModel, "/list/0/name", "Alice");
+        processor.setDataByPath(surface.dataModel, '/list/0/name', 'Alice');
         // Also test setting a value directly on an array index
-        processor.setDataByPath(surface.dataModel, "/list/1", "Bob");
-        const list = surface.dataModel.get("list");
-        assert.strictEqual(list[0].get("name"), "Alice"); // It creates a Map for `name`
-        assert.strictEqual(list[1], "Bob");
+        processor.setDataByPath(surface.dataModel, '/list/1', 'Bob');
+        const list = surface.dataModel.get('list');
+        assert.strictEqual(list[0].get('name'), 'Alice'); // It creates a Map for `name`
+        assert.strictEqual(list[1], 'Bob');
         // Test getDataByPath failing traversal over a primitive
-        processor.setDataByPath(surface.dataModel, "/primitive", "hello");
-        const result = processor.getDataByPath(surface.dataModel, "/primitive/invalid");
+        processor.setDataByPath(surface.dataModel, '/primitive', 'hello');
+        const result = processor.getDataByPath(surface.dataModel, '/primitive/invalid');
         assert.strictEqual(result, null);
     });
-    it("test tree rebuilding edge cases", () => {
-        processor.processMessages([
-            { beginRendering: { surfaceId: "s_tree", root: "root" } },
-        ]);
-        const surface = processor.getSurfaces().get("s_tree");
+    it('test tree rebuilding edge cases', () => {
+        processor.processMessages([{ beginRendering: { surfaceId: 's_tree', root: 'root' } }]);
+        const surface = processor.getSurfaces().get('s_tree');
         // 1. rebuildComponentTree without rootComponentId
         surface.rootComponentId = null;
         processor.rebuildComponentTree(surface);
         assert.strictEqual(surface.componentTree, null);
         // 2. Circular dependency
-        surface.rootComponentId = "circleA";
-        surface.components.set("circleA", {
-            id: "circleA",
-            component: { Row: { children: ["circleB"] } },
+        surface.rootComponentId = 'circleA';
+        surface.components.set('circleA', {
+            id: 'circleA',
+            component: { Row: { children: ['circleB'] } },
         });
-        surface.components.set("circleB", {
-            id: "circleB",
-            component: { Row: { children: ["circleA"] } },
+        surface.components.set('circleB', {
+            id: 'circleB',
+            component: { Row: { children: ['circleA'] } },
         });
         assert.throws(() => {
             processor.rebuildComponentTree(surface);
         }, /Circular dependency/);
     });
-    it("throws A2uiValidationError for malformed components", () => {
-        processor.processMessages([
-            { beginRendering: { surfaceId: `s_bad_comp`, root: "bad" } },
-        ]);
-        const surface = processor.getSurfaces().get("s_bad_comp");
-        surface.rootComponentId = "bad";
+    it('throws A2uiValidationError for malformed components', () => {
+        processor.processMessages([{ beginRendering: { surfaceId: `s_bad_comp`, root: 'bad' } }]);
+        const surface = processor.getSurfaces().get('s_bad_comp');
+        surface.rootComponentId = 'bad';
         // Divider is omitted here because it has no required fields, so `{}` is valid.
         const types = [
-            "Text",
-            "Image",
-            "Icon",
-            "Video",
-            "AudioPlayer",
-            "Row",
-            "Column",
-            "List",
-            "Card",
-            "Tabs",
-            "Modal",
-            "Button",
-            "CheckBox",
-            "TextField",
-            "DateTimeInput",
-            "MultipleChoice",
-            "Slider",
+            'Text',
+            'Image',
+            'Icon',
+            'Video',
+            'AudioPlayer',
+            'Row',
+            'Column',
+            'List',
+            'Card',
+            'Tabs',
+            'Modal',
+            'Button',
+            'CheckBox',
+            'TextField',
+            'DateTimeInput',
+            'MultipleChoice',
+            'Slider',
         ];
         for (const type of types) {
             assert.throws(() => {
-                surface.components.set("bad", {
-                    id: "bad",
+                surface.components.set('bad', {
+                    id: 'bad',
                     component: {
                         [type]: {
                         /* missing required fields */
@@ -377,334 +365,311 @@ describe("A2uiMessageProcessor", () => {
             }, /Invalid data; expected/);
         }
         // Default catch-all (doesn't throw, just passes it through)
-        surface.components.set("bad", {
-            id: "bad",
-            component: { CustomWidget: { foo: "bar" } },
+        surface.components.set('bad', {
+            id: 'bad',
+            component: { CustomWidget: { foo: 'bar' } },
         });
         processor.rebuildComponentTree(surface);
-        assert.strictEqual(surface.componentTree.type, "CustomWidget");
+        assert.strictEqual(surface.componentTree.type, 'CustomWidget');
     });
-    it("resolves Template with Array data", () => {
+    it('resolves Template with Array data', () => {
         processor.processMessages([
-            { beginRendering: { surfaceId: "s3_arr", root: "list" } },
+            { beginRendering: { surfaceId: 's3_arr', root: 'list' } },
             {
                 dataModelUpdate: {
-                    surfaceId: "s3_arr",
-                    path: "/items",
+                    surfaceId: 's3_arr',
+                    path: '/items',
                     contents: [
-                        { key: "0", valueString: "a" },
-                        { key: "1", valueString: "b" },
+                        { key: '0', valueString: 'a' },
+                        { key: '1', valueString: 'b' },
                     ],
                 },
             },
         ]);
-        const surface = processor.getSurfaces().get("s3_arr");
-        surface.components.set("list", {
-            id: "list",
+        const surface = processor.getSurfaces().get('s3_arr');
+        surface.components.set('list', {
+            id: 'list',
             component: {
                 List: {
                     children: {
-                        template: { dataBinding: "/items", componentId: "item" },
+                        template: { dataBinding: '/items', componentId: 'item' },
                     },
                 },
             },
         });
-        surface.components.set("item", {
-            id: "item",
+        surface.components.set('item', {
+            id: 'item',
             component: {
-                Text: { text: { literalString: "hello" }, usageHint: "body" },
+                Text: { text: { literalString: 'hello' }, usageHint: 'body' },
             },
         });
         processor.rebuildComponentTree(surface);
         const root = surface.componentTree;
         assert.strictEqual(root.properties.children.length, 2);
-        assert.strictEqual(root.properties.children[0].id, "item:0");
-        assert.strictEqual(root.properties.children[0].dataContextPath, "/items/0");
-        assert.strictEqual(root.properties.children[1].id, "item:1");
-        assert.strictEqual(root.properties.children[1].dataContextPath, "/items/1");
+        assert.strictEqual(root.properties.children[0].id, 'item:0');
+        assert.strictEqual(root.properties.children[0].dataContextPath, '/items/0');
+        assert.strictEqual(root.properties.children[1].id, 'item:1');
+        assert.strictEqual(root.properties.children[1].dataContextPath, '/items/1');
     });
-    it("resolves Template with undefined/null data as empty array", () => {
-        processor.processMessages([
-            { beginRendering: { surfaceId: "s3_null", root: "list" } },
-        ]);
-        const surface = processor.getSurfaces().get("s3_null");
-        surface.components.set("list", {
-            id: "list",
+    it('resolves Template with undefined/null data as empty array', () => {
+        processor.processMessages([{ beginRendering: { surfaceId: 's3_null', root: 'list' } }]);
+        const surface = processor.getSurfaces().get('s3_null');
+        surface.components.set('list', {
+            id: 'list',
             component: {
                 List: {
                     children: {
-                        template: { dataBinding: "/missingItems", componentId: "item" },
+                        template: { dataBinding: '/missingItems', componentId: 'item' },
                     },
                 },
             },
         });
-        surface.components.set("item", {
-            id: "item",
+        surface.components.set('item', {
+            id: 'item',
             component: {
-                Text: { text: { literalString: "hello" }, usageHint: "body" },
+                Text: { text: { literalString: 'hello' }, usageHint: 'body' },
             },
         });
         processor.rebuildComponentTree(surface);
         const root = surface.componentTree;
         assert.deepStrictEqual(root.properties.children, []);
     });
-    it("sets primitive at path via single array element with dot key", () => {
+    it('sets primitive at path via single array element with dot key', () => {
         processor.processMessages([
-            { beginRendering: { surfaceId: "s1_prim", root: "list" } },
+            { beginRendering: { surfaceId: 's1_prim', root: 'list' } },
             {
                 dataModelUpdate: {
-                    surfaceId: "s1_prim",
-                    path: "/nested/item",
-                    contents: [{ key: ".", valueString: "hello" }],
+                    surfaceId: 's1_prim',
+                    path: '/nested/item',
+                    contents: [{ key: '.', valueString: 'hello' }],
                 },
             },
         ]);
-        const surface = processor.getSurfaces().get("s1_prim");
-        surface.components.set("list", {
-            id: "list",
+        const surface = processor.getSurfaces().get('s1_prim');
+        surface.components.set('list', {
+            id: 'list',
             component: { Row: { children: { explicitList: [] } } },
         });
         processor.rebuildComponentTree(surface);
         const root = surface.componentTree;
-        assert.strictEqual(processor.getData(root, "/nested/item", "s1_prim"), "hello");
+        assert.strictEqual(processor.getData(root, '/nested/item', 's1_prim'), 'hello');
         // Test the fallback where valueString is absent but we pass something anyway
         assert.throws(() => {
             processor.processMessages([
                 {
                     dataModelUpdate: {
-                        surfaceId: "s1_prim",
-                        path: "/nested/malformed",
-                        contents: [{ key: "." }],
+                        surfaceId: 's1_prim',
+                        path: '/nested/malformed',
+                        contents: [{ key: '.' }],
                     },
                 },
             ]);
         }, /Value must have exactly one value property/);
     });
-    it("path resolves through primitive objects and arrays", () => {
-        processor.processMessages([
-            { beginRendering: { surfaceId: "s1_path", root: "list" } },
-        ]);
-        const surface = processor.getSurfaces().get("s1_path");
-        surface.dataModel.set("obj", {
-            nestedMap: new Map([["index", [1, 2, { val: "hi" }]]]),
+    it('path resolves through primitive objects and arrays', () => {
+        processor.processMessages([{ beginRendering: { surfaceId: 's1_path', root: 'list' } }]);
+        const surface = processor.getSurfaces().get('s1_path');
+        surface.dataModel.set('obj', {
+            nestedMap: new Map([['index', [1, 2, { val: 'hi' }]]]),
         });
-        surface.components.set("list", {
-            id: "list",
+        surface.components.set('list', {
+            id: 'list',
             component: { Row: { children: { explicitList: [] } } },
         });
         processor.rebuildComponentTree(surface);
         const root = surface.componentTree;
-        assert.strictEqual(processor.getData(root, "/obj/nestedMap/index/2/val", "s1_path"), "hi");
-        assert.strictEqual(processor.getData(root, "/obj/nestedMap/index/2/val/deeper", "s1_path"), null);
+        assert.strictEqual(processor.getData(root, '/obj/nestedMap/index/2/val', 's1_path'), 'hi');
+        assert.strictEqual(processor.getData(root, '/obj/nestedMap/index/2/val/deeper', 's1_path'), null);
     });
-    it("builds all component types correctly", () => {
-        const surfaceId = "s_all";
-        processor.processMessages([{ beginRendering: { surfaceId, root: "col" } }]);
+    it('builds all component types correctly', () => {
+        const surfaceId = 's_all';
+        processor.processMessages([{ beginRendering: { surfaceId, root: 'col' } }]);
         const surface = processor.getSurfaces().get(surfaceId);
         const components = {
-            col: { Column: { children: ["row"] } },
-            row: { Row: { children: ["card"] } },
-            card: { Card: { child: "tabs" } },
+            col: { Column: { children: ['row'] } },
+            row: { Row: { children: ['card'] } },
+            card: { Card: { child: 'tabs' } },
             tabs: {
                 Tabs: {
-                    tabItems: [{ title: { literalString: "T1" }, child: "modal" }],
+                    tabItems: [{ title: { literalString: 'T1' }, child: 'modal' }],
                 },
             },
-            modal: { Modal: { entryPointChild: "list", contentChild: "div" } },
-            list: { List: { children: ["btn"] } },
-            btn: { Button: { child: "btn_txt", action: "act" } },
-            btn_txt: { Text: { text: { literalString: "Click" } } },
+            modal: { Modal: { entryPointChild: 'list', contentChild: 'div' } },
+            list: { List: { children: ['btn'] } },
+            btn: { Button: { child: 'btn_txt', action: 'act' } },
+            btn_txt: { Text: { text: { literalString: 'Click' } } },
             div: { Divider: {} },
             chk: {
                 CheckBox: {
-                    label: { literalString: "Chk" },
+                    label: { literalString: 'Chk' },
                     value: { literalBoolean: true },
                 },
             },
-            txt: { TextField: { label: { literalString: "Txt" } } },
-            dt: { DateTimeInput: { value: { literalString: "2022-01-01" } } },
-            mc: { MultipleChoice: { selections: { literal: ["a"] } } },
+            txt: { TextField: { label: { literalString: 'Txt' } } },
+            dt: { DateTimeInput: { value: { literalString: '2022-01-01' } } },
+            mc: { MultipleChoice: { selections: { literal: ['a'] } } },
             sl: { Slider: { value: { literalNumber: 50 } } },
-            img: { Image: { url: { literalString: "http://img" } } },
-            icon: { Icon: { name: { literalString: "home" } } },
-            vid: { Video: { url: { literalString: "http://vid" } } },
-            aud: { AudioPlayer: { url: { literalString: "http://aud" } } },
+            img: { Image: { url: { literalString: 'http://img' } } },
+            icon: { Icon: { name: { literalString: 'home' } } },
+            vid: { Video: { url: { literalString: 'http://vid' } } },
+            aud: { AudioPlayer: { url: { literalString: 'http://aud' } } },
         };
         for (const [id, comp] of Object.entries(components)) {
             surface.components.set(id, { id, component: comp });
         }
-        surface.components.set("root_all", {
-            id: "root_all",
+        surface.components.set('root_all', {
+            id: 'root_all',
             component: {
                 Column: {
-                    children: [
-                        "col",
-                        "chk",
-                        "txt",
-                        "dt",
-                        "mc",
-                        "sl",
-                        "img",
-                        "icon",
-                        "vid",
-                        "aud",
-                    ],
+                    children: ['col', 'chk', 'txt', 'dt', 'mc', 'sl', 'img', 'icon', 'vid', 'aud'],
                 },
             },
         });
-        surface.rootComponentId = "root_all";
+        surface.rootComponentId = 'root_all';
         processor.rebuildComponentTree(surface);
         const root = surface.componentTree;
-        assert.strictEqual(root.type, "Column");
+        assert.strictEqual(root.type, 'Column');
         assert.strictEqual(root.properties.children.length, 10);
     });
-    it("handles recursive valueMap in convertKeyValueArrayToMap", () => {
+    it('handles recursive valueMap in convertKeyValueArrayToMap', () => {
         // We need to bypass private check or use a method that calls it.
         // setData calls setDataByPath which calls convertKeyValueArrayToMap.
         const update = {
-            surfaceId: "s_rec",
+            surfaceId: 's_rec',
             contents: [
                 {
-                    key: "nested",
-                    valueMap: [{ key: "inner", valueString: "val" }],
+                    key: 'nested',
+                    valueMap: [{ key: 'inner', valueString: 'val' }],
                 },
             ], // Recursive generic type difficult to construct in TS literal
         };
         // We can use processMessages with dataModelUpdate.
-        processor.processMessages([
-            { beginRendering: { surfaceId: "s_rec", root: "root" } },
-        ]);
+        processor.processMessages([{ beginRendering: { surfaceId: 's_rec', root: 'root' } }]);
         // Set root to Map first
-        const surface = processor.getSurfaces().get("s_rec");
-        surface.dataModel.set("junk", "ignored");
+        const surface = processor.getSurfaces().get('s_rec');
+        surface.dataModel.set('junk', 'ignored');
         processor.processMessages([{ dataModelUpdate: update }]);
         // Verify data
-        const nested = surface.dataModel.get("nested");
+        const nested = surface.dataModel.get('nested');
         assert.strictEqual(nested instanceof Map, true);
-        assert.strictEqual(nested.get("inner"), "val");
+        assert.strictEqual(nested.get('inner'), 'val');
     });
-    it("resolves Template with Map data", () => {
+    it('resolves Template with Map data', () => {
         processor.processMessages([
-            { beginRendering: { surfaceId: "s3_map", root: "list" } },
+            { beginRendering: { surfaceId: 's3_map', root: 'list' } },
             {
                 dataModelUpdate: {
-                    surfaceId: "s3_map",
+                    surfaceId: 's3_map',
                     contents: [
                         {
-                            key: "items",
+                            key: 'items',
                             valueMap: [
-                                { key: "a", valueString: "valA" },
-                                { key: "b", valueString: "valB" },
+                                { key: 'a', valueString: 'valA' },
+                                { key: 'b', valueString: 'valB' },
                             ],
                         },
                     ],
                 },
             },
         ]);
-        const surface = processor.getSurfaces().get("s3_map");
+        const surface = processor.getSurfaces().get('s3_map');
         // Define components
-        surface.components.set("list", {
-            id: "list",
+        surface.components.set('list', {
+            id: 'list',
             component: {
                 List: {
                     children: {
                         template: {
-                            dataBinding: "/items",
-                            componentId: "item",
+                            dataBinding: '/items',
+                            componentId: 'item',
                         },
                     },
                 },
             },
         });
-        surface.components.set("item", {
-            id: "item",
+        surface.components.set('item', {
+            id: 'item',
             component: {
-                Text: { text: { path: "." } },
+                Text: { text: { path: '.' } },
             },
         });
         processor.rebuildComponentTree(surface);
         const root = surface.componentTree;
-        assert.strictEqual(root.type, "List");
+        assert.strictEqual(root.type, 'List');
         // Map entries should be processed.
         assert.strictEqual(root.properties.children.length, 2);
     });
-    it("handles Object-to-Map normalization in handleDataModelUpdate (direct call)", () => {
-        const surfaceId = "s_norm";
-        processor.processMessages([
-            { beginRendering: { surfaceId, root: "root" } },
-        ]);
+    it('handles Object-to-Map normalization in handleDataModelUpdate (direct call)', () => {
+        const surfaceId = 's_norm';
+        processor.processMessages([{ beginRendering: { surfaceId, root: 'root' } }]);
         const surface = processor.getSurfaces().get(surfaceId);
         // Direct call to bypass Zod validation in processMessages
         processor.handleDataModelUpdate({
             surfaceId,
-            contents: { normalized: "value" },
+            contents: { normalized: 'value' },
         }, surfaceId);
-        assert.strictEqual(surface.dataModel.get("normalized"), "value");
+        assert.strictEqual(surface.dataModel.get('normalized'), 'value');
     });
-    it("throws validation error for invalid List", () => {
-        const surfaceId = "s_bad_list";
-        processor.processMessages([
-            { beginRendering: { surfaceId, root: "badList" } },
-        ]);
+    it('throws validation error for invalid List', () => {
+        const surfaceId = 's_bad_list';
+        processor.processMessages([{ beginRendering: { surfaceId, root: 'badList' } }]);
         const surface = processor.getSurfaces().get(surfaceId);
-        surface.components.set("badList", {
-            id: "badList",
-            component: { List: { children: "not-array" } },
+        surface.components.set('badList', {
+            id: 'badList',
+            component: { List: { children: 'not-array' } },
         });
         assert.throws(() => {
             processor.rebuildComponentTree(surface);
         }, /Invalid data; expected List/);
     });
-    it("handles recursive valueMap in convertKeyValueArrayToMap with dot key", () => {
-        const surfaceId = "s_dot_rec";
+    it('handles recursive valueMap in convertKeyValueArrayToMap with dot key', () => {
+        const surfaceId = 's_dot_rec';
         const surface = processor.getOrCreateSurface(surfaceId);
         const value = [
             {
-                key: ".",
-                valueMap: [{ key: "inner", valueString: "val" }],
+                key: '.',
+                valueMap: [{ key: 'inner', valueString: 'val' }],
             },
         ];
         // Calling setDataByPath directly (private)
-        processor.setDataByPath(surface.dataModel, "/target", value);
-        const target = surface.dataModel.get("target");
+        processor.setDataByPath(surface.dataModel, '/target', value);
+        const target = surface.dataModel.get('target');
         assert.strictEqual(target instanceof Map, true);
-        assert.strictEqual(target.get("inner"), "val");
+        assert.strictEqual(target.get('inner'), 'val');
     });
-    it("resolves Template with Array data (via direct setData)", () => {
-        const surfaceId = "s_direct_arr";
-        processor.processMessages([
-            { beginRendering: { surfaceId, root: "list" } },
-        ]);
+    it('resolves Template with Array data (via direct setData)', () => {
+        const surfaceId = 's_direct_arr';
+        processor.processMessages([{ beginRendering: { surfaceId, root: 'list' } }]);
         const surface = processor.getSurfaces().get(surfaceId);
         // Setup components
-        surface.components.set("list", {
-            id: "list",
+        surface.components.set('list', {
+            id: 'list',
             component: {
                 List: {
                     children: {
                         template: {
-                            dataBinding: "/items",
-                            componentId: "item",
+                            dataBinding: '/items',
+                            componentId: 'item',
                         },
                     },
                 },
             },
         });
-        surface.components.set("item", {
-            id: "item",
+        surface.components.set('item', {
+            id: 'item',
             component: {
-                Text: { text: { path: "." } },
+                Text: { text: { path: '.' } },
             },
         });
         // Direct set array to bypass normalization/schema
-        const itemsArray = ["A", "B"];
-        surface.dataModel.set("items", itemsArray);
+        const itemsArray = ['A', 'B'];
+        surface.dataModel.set('items', itemsArray);
         processor.rebuildComponentTree(surface);
         const root = surface.componentTree;
-        assert.strictEqual(root.type, "List");
+        assert.strictEqual(root.type, 'List');
         assert.strictEqual(root.properties.children.length, 2);
     });
-    it("ignores non-strings when trying to parse JSON", () => {
+    it('ignores non-strings when trying to parse JSON', () => {
         const result = processor.parseIfJsonString(123);
         assert.strictEqual(result, 123);
     });