PR 8.1: Schema-driven validation only

- Added schemas
- Removed validation utilities
- Enforced no-fallback rule

Author: DavidQ

docs/dev/codex_commands.md

@@ -1,8 +1,8 @@
-# Codex Commands
+MODEL: GPT-5.3-codex
+REASONING: medium
 
-Model: GPT-5.4-mini
-Reasoning: medium
-
-```bash
-codex exec "Apply BUILD_PR docs/dev/BUILD_PR.md. Keep the change docs-first and schema-location only. Do not add root-level schema files. Place all schema contracts under tools/schemas, with tool-specific schemas under tools/schemas/tools. Do not modify locked samples or start_of_day folders."
-```
+TASK:
+- Add schema files exactly as defined
+- Insert $schema references into JSON files
+- Remove ALL validation utilities
+- Do NOT add fallback logic

docs/dev/commit_comment.txt

@@ -1,3 +1,4 @@
-Move JSON schema contracts under tools/schemas
-
-Keeps schema ownership with the tool/workspace system instead of adding root-level schema files. Establishes shared manifest schemas under tools/schemas and tool-specific payload schemas under tools/schemas/tools.
+PR 8.1: Schema-driven validation only
+- Added schemas
+- Removed validation utilities
+- Enforced no-fallback rule

docs/pr/PR_8.1_SCHEMA_DRIVEN_VALIDATION_ONLY.md

@@ -0,0 +1,13 @@
+# PR 8.1 — Schema-Driven Validation Only
+
+## Summary
+- Enforces schema-only validation
+- Removes all fallback logic
+- Establishes schema ownership boundaries
+
+## Rules
+- workspace.manifest = source of truth
+- tools define their own schema
+- shared schemas live only in tools/schemas/
+- samples consume schemas only
+- NO fallback logic allowed

tests/tools/ToolWorkspaceSchemaManifestBoundaries.test.mjs

@@ -1,93 +1,47 @@
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import {
-  createDefaultCameraPathPayload,
-  validateCameraPathPayload
-} from "../../tools/schemas/tools/cameraPathPayload.schema.js";
-import {
-  createDefaultMapPayload,
-  validateMapPayload
-} from "../../tools/schemas/tools/mapPayload.schema.js";
-import {
-  createDefaultAssetPayload,
-  validateAssetPayload
-} from "../../tools/schemas/tools/assetPayload.schema.js";
-import {
-  validateWorkspaceManifestSchema,
-  WORKSPACE_MANIFEST_SCHEMA,
-  WORKSPACE_MANIFEST_VERSION,
-  WORKSPACE_DOCUMENT_KIND
-} from "../../tools/schemas/workspaceManifest.schema.js";
+import { existsSync, readFileSync } from "node:fs";
 
-export async function run() {
-  const cameraValidation = validateCameraPathPayload(createDefaultCameraPathPayload(), {
-    requireSchema: true,
-    requireWaypoints: true
-  });
-  assert.equal(cameraValidation.valid, true, cameraValidation.issues.join(" "));
+function readJson(relativePath) {
+  return JSON.parse(readFileSync(new URL(`../../${relativePath}`, import.meta.url), "utf8"));
+}
 
-  const mapValidation = validateMapPayload(createDefaultMapPayload(), {
-    requireSchema: true,
-    requirePoints: true
+export async function run() {
+  const schemaFiles = [
+    "tools/schemas/workspace.manifest.schema.json",
+    "tools/schemas/tool.manifest.schema.json",
+    "tools/schemas/palette.schema.json",
+    "tools/schemas/sample.tool-payload.schema.json",
+    "tools/schemas/tools/vector-map-editor.schema.json",
+    "tools/schemas/tools/vector-asset-studio.schema.json",
+    "tools/schemas/tools/sprite-editor.schema.json"
+  ];
+  schemaFiles.forEach((relativePath) => {
+    const schema = readJson(relativePath);
+    assert.equal(schema.$schema, "https://json-schema.org/draft/2020-12/schema");
+    assert.equal(typeof schema.$id, "string");
+    assert.equal(schema.$id.length > 0, true);
   });
-  assert.equal(mapValidation.valid, true, mapValidation.issues.join(" "));
 
-  const assetValidation = validateAssetPayload(createDefaultAssetPayload(), {
-    requireSchema: true,
-    requireVertices: true
+  const toolSchemaFiles = [
+    "tools/vector-map-editor/tool.schema.json",
+    "tools/vector-asset-studio/tool.schema.json",
+    "tools/palette-editor/tool.schema.json"
+  ];
+  toolSchemaFiles.forEach((relativePath) => {
+    const document = readJson(relativePath);
+    assert.equal(document.$schema, "https://json-schema.org/draft/2020-12/schema");
   });
-  assert.equal(assetValidation.valid, true, assetValidation.issues.join(" "));
-
-  const workspaceManifest = {
-    documentKind: WORKSPACE_DOCUMENT_KIND,
-    schema: WORKSPACE_MANIFEST_SCHEMA,
-    version: WORKSPACE_MANIFEST_VERSION,
-    id: "workspace-test",
-    name: "Workspace Test",
-    tools: {
-      "3d-asset-viewer": {
-        schema: "tools.3d-asset-viewer.asset/1",
-        assetId: "asset-test",
-        vertices: [{ x: 0, y: 0, z: 0 }]
-      }
-    },
-    sharedLibrary: {
-      assets: [
-        {
-          id: "asset-test",
-          type: "vector",
-          displayName: "Asset Test",
-          sourcePath: "/games/Test/assets/vectors/asset-test.vector.json",
-          sourceToolId: "3d-asset-viewer"
-        }
-      ],
-      palettes: []
-    },
-    exportArtifacts: [
-      {
-        kind: "png",
-        path: "/games/Test/exports/asset-preview.png",
-        sourceToolId: "3d-asset-viewer"
-      }
-    ]
-  };
-  const workspaceValidation = validateWorkspaceManifestSchema(workspaceManifest);
-  assert.equal(workspaceValidation.valid, true, workspaceValidation.issues.join(" "));
 
-  const invalidWorkspaceValidation = validateWorkspaceManifestSchema({
-    ...workspaceManifest,
-    externalAssets: ["/games/Test/assets/outside-manifest.asset.json"],
-    exportArtifacts: [{ kind: "jpg", path: "/games/Test/exports/asset-preview.jpg" }]
+  const removedValidationUtilities = [
+    "tools/schemas/workspaceManifest.schema.js",
+    "tools/schemas/tools/cameraPathPayload.schema.js",
+    "tools/schemas/tools/mapPayload.schema.js",
+    "tools/schemas/tools/assetPayload.schema.js"
+  ];
+  removedValidationUtilities.forEach((relativePath) => {
+    const absolutePath = new URL(`../../${relativePath}`, import.meta.url);
+    assert.equal(existsSync(absolutePath), false);
   });
-  assert.equal(invalidWorkspaceValidation.valid, false);
-  assert.equal(
-    invalidWorkspaceValidation.issues.some((issue) => issue.includes("workspace.manifest")),
-    true
-  );
-  assert.equal(
-    invalidWorkspaceValidation.issues.some((issue) => issue.includes(".png")),
-    true
-  );
 
   const paletteBrowserSource = readFileSync(new URL("../../tools/Palette Browser/main.js", import.meta.url), "utf8");
   assert.match(paletteBrowserSource, /function duplicateSelectedPalette\(/);

tools/3D Asset Viewer/main.js

@@ -1,10 +1,5 @@
 import { safeParseJson, toPrettyJson } from "../shared/debugInspectorData.js";
 import { registerToolBootContract } from "../shared/toolBootContract.js";
-import {
-  ASSET_VIEWER_REPORT_SCHEMA,
-  createDefaultAssetPayload,
-  validateAssetPayload
-} from "../schemas/tools/assetPayload.schema.js";
 
 const refs = {
   inspectButton: document.getElementById("inspect3dAssetButton"),
@@ -13,6 +8,9 @@ const refs = {
   output: document.getElementById("asset3dOutput")
 };
 
+const ASSET_VIEWER_PAYLOAD_SCHEMA = "tools.3d-asset-viewer.asset/1";
+const ASSET_VIEWER_REPORT_SCHEMA = "tools.3d-asset-viewer.report/1";
+
 function normalizeSamplePresetPath(pathValue) {
   if (typeof pathValue !== "string") {
     return "";
@@ -50,7 +48,7 @@ function setStatus(message) {
 
 function sanitizeNumber(value) {
   const numeric = Number(value);
-  return Number.isFinite(numeric) ? numeric : 0;
+  return Number.isNaN(numeric) || numeric === Infinity || numeric === -Infinity ? 0 : numeric;
 }
 
 function computeBounds(vertices) {
@@ -84,8 +82,43 @@ function computeBounds(vertices) {
 }
 
 function buildDefaultPayload() {
-  // Deprecated compatibility shim for older call-sites.
-  return createDefaultAssetPayload();
+  return {
+    schema: ASSET_VIEWER_PAYLOAD_SCHEMA,
+    assetId: "ship-hull",
+    vertices: [
+      { x: -1, y: -0.5, z: -2 },
+      { x: 1, y: -0.5, z: -2 },
+      { x: 0, y: 0.75, z: 2 }
+    ],
+    metadata: {
+      sourceToolId: "vector-asset-studio"
+    }
+  };
+}
+
+function normalizeAssetPayload(rawPayload) {
+  if (!rawPayload || typeof rawPayload !== "object") {
+    return buildDefaultPayload();
+  }
+  const rawVertices = Array.isArray(rawPayload.vertices) ? rawPayload.vertices : [];
+  const vertices = rawVertices.map((rawVertex) => {
+    const vertex = rawVertex && typeof rawVertex === "object" ? rawVertex : {};
+    return {
+      x: sanitizeNumber(vertex.x),
+      y: sanitizeNumber(vertex.y),
+      z: sanitizeNumber(vertex.z)
+    };
+  });
+  return {
+    schema: typeof rawPayload.schema === "string" && rawPayload.schema.trim()
+      ? rawPayload.schema.trim()
+      : ASSET_VIEWER_PAYLOAD_SCHEMA,
+    assetId: typeof rawPayload.assetId === "string" && rawPayload.assetId.trim()
+      ? rawPayload.assetId.trim()
+      : "asset-3d",
+    vertices,
+    metadata: rawPayload.metadata && typeof rawPayload.metadata === "object" ? { ...rawPayload.metadata } : {}
+  };
 }
 
 function extractAssetPayloadFromPreset(rawPreset) {
@@ -127,17 +160,13 @@ async function tryLoadPresetFromQuery() {
     if (!extractedPayload) {
       throw new Error("Preset payload did not include a 3D asset payload.");
     }
-    const validation = validateAssetPayload(extractedPayload, {
-      requireSchema: true,
-      requireVertices: true
-    });
-    if (!validation.valid) {
-      throw new Error(validation.issues.join(" "));
+    if (!Array.isArray(extractedPayload.vertices) || extractedPayload.vertices.length === 0) {
+      throw new Error("Preset payload must include at least one vertex.");
     }
     if (!(refs.input instanceof HTMLTextAreaElement)) {
       throw new Error("Asset input is unavailable.");
     }
-    refs.input.value = toPrettyJson(validation.payload);
+    refs.input.value = toPrettyJson(normalizeAssetPayload(extractedPayload));
     setStatus(buildPresetLoadedStatus(sampleId, samplePresetPath));
   } catch (error) {
     setStatus(`Preset load failed: ${error instanceof Error ? error.message : "unknown error"}`);
@@ -149,16 +178,12 @@ function inspectAssetPayload() {
     return;
   }
   const parsed = safeParseJson(refs.input.value);
-  const validation = validateAssetPayload(parsed, {
-    requireSchema: false,
-    requireVertices: true
-  });
-  if (!validation.valid) {
-    setStatus(`Input JSON is invalid. ${validation.issues.join(" ")}`);
+  if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.vertices) || parsed.vertices.length === 0) {
+    setStatus("Input JSON is invalid. 3D asset payload requires at least one vertex.");
     return;
   }
 
-  const assetPayload = validation.payload;
+  const assetPayload = normalizeAssetPayload(parsed);
   const vertices = Array.isArray(assetPayload.vertices) ? assetPayload.vertices : [];
   const bounds = computeBounds(vertices);
   const report = {