Fix Workspace V2 fixture payload shape and manifest-only import export flow - PR_11_304

Author: DavidQ

docs/dev/reports/PR_11_304_report.md

@@ -1,88 +1,60 @@
-# PR_11_304 Report - Workspace V2 Clean Export/Import Implementation
+# PR_11_304 Report - Workspace V2 Import/Export Continuation Fix
 
 ## Purpose
-Replace Workspace V2 import/export with a clean, manifest-only implementation in `tools/workspace-v2/index.js`.
+Continue/fix PR_11_304 for fixture/load/export/import/session-id UX in `tools/workspace-v2/index.js` only.
 
 ## Scope
 - `tools/workspace-v2/index.js` only
 - No schema changes
 
-## Files Changed
-- `tools/workspace-v2/index.js`
-
-## Implementation Summary
-1. Added Import/Export section-local status wiring
-- Added `initializeImportExportSectionStatusNode()`.
-- Added `setImportExportStatus(message)`.
-- Import/Export actions now always write visible status in the Import/Export section.
-
-2. Export implementation cleanup
-- `exportWorkspaceSessionJson()` now uses one direct path:
-  - `Export clicked`
-  - build full workspace manifest JSON
-  - validate manifest
-  - write JSON to textarea
-  - download via Blob + temporary anchor click
-  - `Export success` or `Export error: ...`
-- Removed legacy wrapper dependence (`workspaceSession`, `games`) from export structure.
-
-3. Manifest export shape updated
-- `buildWorkspaceSchemaDocument()` now produces:
-  - `documentKind`
-  - `schema`
+## Issues Fixed
+1. Load Fixture schema alignment for Palette Manager V2
+- Added fixture normalization/validation path in load flow:
+  - `normalizeFixtureSessionContext(toolId, sessionContext)`
+  - `normalizePaletteFixtureSwatches(paletteJson)`
+- Palette fixture session now lands in active state with `paletteJson.swatches` and without `paletteJson.colors`.
+- Palette fixture rejects `payloadJson` for `palette-manager-v2`.
+
+2. Workspace Session JSON textarea manifest-only after Load Fixture
+- Load Fixture no longer writes raw tool payload into textarea.
+- Added `syncWorkspaceManifestTextarea()` and wired it in fixture load/init path.
+- Textarea now shows full workspace manifest JSON after fixture load.
+
+3. Export real payload shape preservation
+- Export path uses active session payload source and preserves real tool shape.
+- For palette manager, exported `tools.workspace-v2.activeSession` keeps:
   - `version`
-  - `id`
-  - `name`
-  - `tools.workspace-v2`
-- `tools.workspace-v2` includes:
-  - `schema`
-  - `game`
-  - `defaultToolId`
-  - `activeToolId`
-  - `activeHostContextId`
-  - `activeSession`
-  - `savedSessions`
-- `activeSession` and `savedSessions` preserve real payload objects without rewriting.
-
-4. Import implementation cleanup
-- `importWorkspaceSessionJson()` now uses one direct path:
-  - `Import clicked`
-  - parse textarea JSON
-  - reject raw tool payload JSON with exact message:
-    - `Workspace import requires a workspace manifest JSON`
-  - validate manifest structure
-  - load `activeSession` into `sessionStorage`
-  - load `savedSessions` into `localStorage`
-  - set current active session/tool
-  - keep textarea as manifest JSON
-  - `Import success` or `Import error: ...`
-
-5. Validation function alignment
-- Reworked `validateWorkspaceSchemaDocument()` to validate manifest-only structure with `tools.workspace-v2`.
-- Added `validateWorkspaceToolSessionPayload()` for active/saved tool session payload validation.
+  - `toolId`
+  - `paletteJson.swatches`
+- No `payloadJson` wrapper is emitted for fresh palette fixture flow.
+
+4. Session ID validation message
+- Updated invalid ID message to exact required text:
+  - `Invalid session ID. Use letters, numbers, hyphen, or underscore only.`
+- Save remains disabled when ID is invalid.
+- Removed silent input normalization for this flow:
+  - `selectedSessionName()` now reads raw input.
+  - `isValidNewSessionId()` enforces `^[A-Za-z0-9_-]+$`.
 
 ## Validation Commands Run
 1. `node --check tools/workspace-v2/index.js`
-2. `@' ... legacy wrapper removal checks ... '@ | node`
-3. `rg -n "initializeImportExportSectionStatusNode\(|setImportExportStatus\(|Workspace import requires a workspace manifest JSON|Export clicked|Export success|Import clicked|Import success" tools/workspace-v2/index.js`
-4. `Select-String -Path tools/workspace-v2/index.js -Pattern 'documentKind: "workspace-manifest"','schema: "html-js-gaming.project"','"workspace-v2": \{','activeSession: this.cloneSessionValue\(activePayload\)','savedSessions: this.cloneSessionValue\(library\)'`
+2. `node tests/runtime/V2CurrentSessionExport.test.mjs`
+3. Inline Node executable check script writing `tmp/pr_11_304_fix_results.json`
+4. `rg -n "selectedSessionName\(|return /\^\[A-Za-z0-9_-\]\+\$/.test\(sessionId\);|normalizeFixtureSessionContext\(|normalizePaletteFixtureSwatches\(|syncWorkspaceManifestTextarea\(" tools/workspace-v2/index.js`
 
 ## Validation Results
 - Command 1: PASS
-- Command 2: PASS (`legacy wrapper removal checks: ok`)
-- Command 3: PASS (required status and import-rejection tokens found)
-- Command 4: PASS (required manifest export shape tokens found)
+- Command 2: FAIL (legacy test expectation mismatch: still expects old `workspace.schema.json`/wrapper contract in this branch)
+- Command 3: PASS (`tmp/pr_11_304_fix_results.json`, no failures)
+- Command 4: PASS (required continuation-fix tokens found)
 
-## Requirement Mapping
-- Clean full workspace manifest export: PASS
-- `tools.workspace-v2` required fields present: PASS
-- Active payload preserved (no payload rewrite): PASS
-- Blob + anchor download path: PASS
-- Import parses and validates manifest: PASS
-- Tool payload import rejection message: PASS
-- Section-local status messages (`Export clicked/success/error`, `Import clicked/success/error`): PASS
-- No hard-override/multi-handler import-export junk paths introduced: PASS
+## Acceptance Mapping
+- Load Fixture -> manifest textarea with `tools.workspace-v2.activeSession.paletteJson.swatches`: PASS
+- Export downloads without validation error using active payload shape: PASS (targeted executable checks)
+- No `paletteJson.colors` in fresh fixture/export flow: PASS
+- No `payloadJson` for `palette-manager-v2` fresh fixture/export flow: PASS
+- Invalid New Session ID shows actionable message and keeps Save disabled: PASS
 
 ## Full Samples Smoke Decision
 - Skipped full samples smoke test.
-- Reason: change is limited to Workspace V2 import/export logic in one file and validated via targeted checks.
+- Reason: scope limited to one file (`tools/workspace-v2/index.js`) and validated via targeted syntax + focused runtime checks.

tools/workspace-v2/index.js

@@ -225,7 +225,7 @@ class WorkspaceV2SessionProducer {
   }
 
   selectedSessionName() {
-    return typeof this.sessionNameNode.value === "string" ? this.sessionNameNode.value.trim() : "";
+    return typeof this.sessionNameNode.value === "string" ? this.sessionNameNode.value : "";
   }
 
   currentNavMode() {
@@ -285,6 +285,22 @@ class WorkspaceV2SessionProducer {
     }
   }
 
+  createProducerPayloadForTool(toolId) {
+    if (toolId === "palette-manager-v2") {
+      return {
+        version: "v2",
+        toolId: "palette-manager-v2",
+        paletteJson: {
+          swatches: []
+        }
+      };
+    }
+    return this.withSessionVersion({
+      toolId,
+      payloadJson: {}
+    });
+  }
+
   initializeWorkspaceProducerSession() {
     if (this.isValidSessionPayload(this.currentSessionPayload) && this.currentHostContextId) {
       return;
@@ -294,10 +310,7 @@ class WorkspaceV2SessionProducer {
       this.statusNode.textContent = "Workspace V2 initialization blocked: default tool is missing.";
       return;
     }
-    const initialPayload = this.withSessionVersion({
-      toolId: selectedToolId,
-      payloadJson: {}
-    });
+    const initialPayload = this.createProducerPayloadForTool(selectedToolId);
     const sizeValidation = this.validateSessionPayloadSize(initialPayload);
     if (!sizeValidation.ok) {
       this.statusNode.textContent = sizeValidation.message;
@@ -307,7 +320,7 @@ class WorkspaceV2SessionProducer {
     sessionStorage.setItem(hostContextId, sizeValidation.metrics.serializedPayload);
     this.currentHostContextId = hostContextId;
     this.setCurrentSessionPayload(initialPayload, "workspace-v2-init");
-    this.importJsonNode.value = JSON.stringify(initialPayload, null, 2);
+    this.syncWorkspaceManifestTextarea();
     this.statusNode.textContent = `Workspace V2 initialized.\nTool: ${selectedToolId}\nHostContextId: ${hostContextId}\nSession is active for Save Session.`;
   }
 
@@ -323,22 +336,21 @@ class WorkspaceV2SessionProducer {
     if (typeof sessionId !== "string") {
       return false;
     }
-    const trimmed = sessionId.trim();
-    if (!trimmed) {
+    if (!sessionId) {
       return false;
     }
-    return /^[a-z0-9][a-z0-9-_]{1,63}$/i.test(trimmed);
+    return /^[A-Za-z0-9_-]+$/.test(sessionId);
   }
 
   savedSessionIdExists(sessionId) {
-    if (typeof sessionId !== "string" || !sessionId.trim()) {
+    if (typeof sessionId !== "string" || !sessionId) {
       return false;
     }
     const library = this.readSessionLibrary();
     if (library === null) {
       return false;
     }
-    return Object.prototype.hasOwnProperty.call(library, sessionId.trim());
+    return Object.prototype.hasOwnProperty.call(library, sessionId);
   }
 
   updateSessionLibraryActionState() {
@@ -348,7 +360,7 @@ class WorkspaceV2SessionProducer {
       return;
     }
     if (!model.libraryIdValid) {
-      this.libraryStatusNode.textContent = "Enter a valid new session ID before saving.";
+      this.libraryStatusNode.textContent = "Invalid session ID. Use letters, numbers, hyphen, or underscore only.";
       return;
     }
     if (model.librarySavedSessionExists) {
@@ -2789,6 +2801,78 @@ class WorkspaceV2SessionProducer {
     this.diagnosticsPayloadNode.textContent = snapshot.payloadPreview;
   }
 
+  normalizePaletteFixtureSwatches(paletteJson) {
+    if (!paletteJson || typeof paletteJson !== "object" || Array.isArray(paletteJson)) {
+      return { ok: false, message: "Fixture is invalid. paletteJson must be an object for palette-manager-v2.", value: null };
+    }
+    if (Object.prototype.hasOwnProperty.call(paletteJson, "colors") && !Array.isArray(paletteJson.swatches)) {
+      if (!Array.isArray(paletteJson.colors)) {
+        return { ok: false, message: "Fixture is invalid. paletteJson.colors must be an array when swatches is missing.", value: null };
+      }
+      const convertedSwatches = [];
+      for (let index = 0; index < paletteJson.colors.length; index += 1) {
+        const colorEntry = paletteJson.colors[index];
+        if (typeof colorEntry === "string") {
+          if (!/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$/.test(colorEntry)) {
+            return { ok: false, message: `Fixture is invalid. paletteJson.colors[${index}] must be #RRGGBB or #RRGGBBAA.`, value: null };
+          }
+          convertedSwatches.push({
+            symbol: String.fromCharCode(65 + (index % 26)),
+            hex: colorEntry,
+            name: `Color ${index + 1}`
+          });
+          continue;
+        }
+        if (!colorEntry || typeof colorEntry !== "object" || Array.isArray(colorEntry)) {
+          return { ok: false, message: `Fixture is invalid. paletteJson.colors[${index}] must be a string or object.`, value: null };
+        }
+        if (typeof colorEntry.hex !== "string" || !/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$/.test(colorEntry.hex)) {
+          return { ok: false, message: `Fixture is invalid. paletteJson.colors[${index}].hex must be #RRGGBB or #RRGGBBAA.`, value: null };
+        }
+        const symbol = typeof colorEntry.symbol === "string" && colorEntry.symbol.length === 1
+          ? colorEntry.symbol
+          : String.fromCharCode(65 + (index % 26));
+        const name = typeof colorEntry.name === "string" && colorEntry.name.trim()
+          ? colorEntry.name
+          : `Color ${index + 1}`;
+        convertedSwatches.push({
+          symbol,
+          hex: colorEntry.hex,
+          name
+        });
+      }
+      const normalizedPalette = { ...paletteJson };
+      delete normalizedPalette.colors;
+      normalizedPalette.swatches = convertedSwatches;
+      return { ok: true, message: "", value: normalizedPalette };
+    }
+    if (!Array.isArray(paletteJson.swatches)) {
+      return { ok: false, message: "Fixture is invalid. paletteJson.swatches must be an array for palette-manager-v2.", value: null };
+    }
+    return { ok: true, message: "", value: paletteJson };
+  }
+
+  normalizeFixtureSessionContext(toolId, sessionContext) {
+    if (!this.isValidSessionPayload(sessionContext)) {
+      return { ok: false, message: "Fixture is invalid. Missing sessionContext object.", value: null };
+    }
+    const normalizedSession = this.withSessionVersion(this.cloneSessionValue(sessionContext));
+    if (toolId === "palette-manager-v2") {
+      if (Object.prototype.hasOwnProperty.call(normalizedSession, "payloadJson")) {
+        return { ok: false, message: "Fixture is invalid. payloadJson is not supported for palette-manager-v2.", value: null };
+      }
+      if (!Object.prototype.hasOwnProperty.call(normalizedSession, "paletteJson")) {
+        return { ok: false, message: "Fixture is invalid. paletteJson is required for palette-manager-v2.", value: null };
+      }
+      const normalizedPalette = this.normalizePaletteFixtureSwatches(normalizedSession.paletteJson);
+      if (!normalizedPalette.ok) {
+        return { ok: false, message: normalizedPalette.message, value: null };
+      }
+      normalizedSession.paletteJson = normalizedPalette.value;
+    }
+    return { ok: true, message: "", value: normalizedSession };
+  }
+
   async loadSelectedFixture() {
     const toolId = this.selectedToolId();
     if (!toolId) {
@@ -2808,15 +2892,29 @@ class WorkspaceV2SessionProducer {
         this.setCurrentSessionPayload(null, "");
         return;
       }
-      if (!this.isValidSessionPayload(fixture.sessionContext)) {
-        this.statusNode.textContent = "Fixture is invalid. Missing sessionContext object.";
+      const normalizedFixtureSession = this.normalizeFixtureSessionContext(toolId, fixture.sessionContext);
+      if (!normalizedFixtureSession.ok) {
+        this.statusNode.textContent = normalizedFixtureSession.message;
         this.setCurrentSessionPayload(null, "");
         return;
       }
-      this.setCurrentSessionPayload(fixture.sessionContext, `fixture:${toolId}`);
-      this.currentHostContextId = "";
+      const fixtureHostContextId = typeof fixture.hostContextId === "string" && fixture.hostContextId.trim()
+        ? fixture.hostContextId.trim()
+        : this.createHostContextId(toolId);
+      const sizeValidation = this.validateSessionPayloadSize(normalizedFixtureSession.value);
+      if (!sizeValidation.ok) {
+        this.statusNode.textContent = sizeValidation.message;
+        this.setCurrentSessionPayload(null, "");
+        return;
+      }
+      sessionStorage.setItem(fixtureHostContextId, sizeValidation.metrics.serializedPayload);
+      this.setCurrentSessionPayload(normalizedFixtureSession.value, `fixture:${toolId}`);
+      this.currentHostContextId = fixtureHostContextId;
       this.renderDiagnosticsPanel();
-      this.importJsonNode.value = JSON.stringify(fixture.sessionContext, null, 2);
+      if (!this.syncWorkspaceManifestTextarea()) {
+        this.statusNode.textContent = "Fixture loaded but workspace manifest sync failed.";
+        return;
+      }
       this.statusNode.textContent = `Fixture loaded for ${toolId}.\nSession payload is ready for launch, export, share, or library save.`;
     } catch (error) {
       this.setCurrentSessionPayload(null, "");
@@ -2924,6 +3022,19 @@ class WorkspaceV2SessionProducer {
     }
   }
 
+  syncWorkspaceManifestTextarea() {
+    const workspaceSchemaDocument = this.buildWorkspaceSchemaDocument();
+    if (!workspaceSchemaDocument) {
+      return false;
+    }
+    const validation = this.validateWorkspaceSchemaDocument(workspaceSchemaDocument);
+    if (!validation.ok) {
+      return false;
+    }
+    this.workspaceJsonNode.value = JSON.stringify(workspaceSchemaDocument, null, 2);
+    return true;
+  }
+
   buildWorkspaceSchemaDocument() {
     const activePayload = this.resolveActiveSessionPayloadForWorkspaceManifest();
     if (!this.isValidSessionPayload(activePayload)) {
@@ -3241,7 +3352,7 @@ class WorkspaceV2SessionProducer {
       return;
     }
     if (!overwriteExisting && !this.isValidNewSessionId(sessionName)) {
-      this.setLibraryStatus("Enter a valid new session ID before saving.");
+      this.setLibraryStatus("Invalid session ID. Use letters, numbers, hyphen, or underscore only.");
       return;
     }
     const library = this.readSessionLibrary();