@playcademy/sandbox 0.6.1-beta.7 → 0.6.1-beta.8

package/dist/cli.js

@@ -1084,7 +1084,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.6.1-beta.7",
+    version: "0.6.1-beta.8",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -28293,14 +28293,16 @@ function assertBaselineClaimValid(args2) {
 function validateBaselineClaim(args2) {
   const { claimedTag, evidence, tables, indexes: indexes2, views, lastDeployAt } = args2;
   const claimedIndex = evidence.findIndex((entry) => entry.tag === claimedTag);
+  const expected = replayEvidence(evidence, claimedIndex);
+  const live = { tables, indexes: indexes2, views };
   const verdicts = [];
   const unverified = [];
   evidence.forEach((entry, index2) => {
     if (claimedIndex === -1 || index2 > claimedIndex) {
-      verdicts.push(judgeBeyond(entry, tables, indexes2, views));
+      verdicts.push(judgeBeyond(entry, expected, live));
       return;
     }
-    const judged = judgeClaimed(entry, tables, lastDeployAt);
+    const judged = judgeClaimed(entry, expected, live, lastDeployAt);
     verdicts.push(judged.verdict);
     if (judged.unverifiable) {
       unverified.push(judged.verdict);
@@ -28313,8 +28315,99 @@ function validateBaselineClaim(args2) {
     suggestedTag: suggestTag(evidence, tables)
   };
 }
-function judgeClaimed(entry, tables, lastDeployAt) {
-  if (!hasSignal(entry)) {
+function replayEvidence(evidence, claimedIndex) {
+  const state = { tables: new Map, indexes: new Map, views: new Map };
+  for (let index2 = 0;index2 <= claimedIndex; index2++) {
+    applyEvidenceEntry(state, evidence[index2]);
+  }
+  return state;
+}
+function applyEvidenceEntry(state, entry) {
+  for (const table8 of entry.dropsTables) {
+    state.tables.delete(table8);
+  }
+  for (const dropped of entry.dropsColumns) {
+    state.tables.get(dropped.table)?.columns.delete(dropped.column);
+  }
+  for (const droppedIndex of entry.dropsIndexes) {
+    state.indexes.delete(droppedIndex);
+  }
+  for (const view2 of entry.dropsViews) {
+    state.views.delete(view2);
+  }
+  for (const table8 of entry.createsTables) {
+    state.tables.set(table8.name, {
+      creator: entry.tag,
+      columns: new Map(table8.columns.map((column2) => [column2, entry.tag]))
+    });
+  }
+  for (const added of entry.addsColumns) {
+    state.tables.get(added.table)?.columns.set(added.column, entry.tag);
+  }
+  for (const createdIndex of entry.createsIndexes) {
+    state.indexes.set(createdIndex, entry.tag);
+  }
+  for (const view2 of entry.createsViews) {
+    state.views.set(view2, entry.tag);
+  }
+}
+function judgeClaimed(entry, expected, live, lastDeployAt) {
+  let surviving = 0;
+  for (const table8 of entry.createsTables) {
+    const expectation = expected.tables.get(table8.name);
+    if (expectation?.creator === entry.tag) {
+      surviving++;
+      const columns2 = live.tables.get(table8.name);
+      if (!columns2) {
+        return {
+          verdict: {
+            tag: entry.tag,
+            verdict: "contradicted",
+            detail: `creates table \`${table8.name}\`, which is not in the live database`
+          },
+          unverifiable: false
+        };
+      }
+      const missing = [...expectation.columns.entries()].filter(([, creator]) => creator === entry.tag).map(([column2]) => column2).filter((column2) => !columns2.includes(column2));
+      if (missing.length > 0) {
+        return {
+          verdict: {
+            tag: entry.tag,
+            verdict: "contradicted",
+            detail: `table \`${table8.name}\` exists but is missing column(s) ${missing.map((column2) => `\`${column2}\``).join(", ")} this migration defines`
+          },
+          unverifiable: false
+        };
+      }
+    }
+  }
+  for (const added of entry.addsColumns) {
+    if (expected.tables.get(added.table)?.columns.get(added.column) === entry.tag) {
+      surviving++;
+      const columns2 = live.tables.get(added.table);
+      if (columns2 && !columns2.includes(added.column)) {
+        return {
+          verdict: {
+            tag: entry.tag,
+            verdict: "contradicted",
+            detail: `adds column \`${added.column}\` to \`${added.table}\`, which the live table does not have`
+          },
+          unverifiable: false
+        };
+      }
+    }
+  }
+  for (const name2 of entry.createsIndexes) {
+    if (expected.indexes.get(name2) === entry.tag && live.indexes.has(name2)) {
+      surviving++;
+    }
+  }
+  for (const name2 of entry.createsViews) {
+    if (expected.views.get(name2) === entry.tag && live.views.has(name2)) {
+      surviving++;
+    }
+  }
+  if (surviving === 0) {
     const generated = new Date(entry.generatedAt);
     if (lastDeployAt && generated > lastDeployAt) {
       return {
@@ -28328,48 +28421,11 @@ function judgeClaimed(entry, tables, lastDeployAt) {
     }
     return { verdict: { tag: entry.tag, verdict: "no-signal" }, unverifiable: false };
   }
-  for (const table8 of entry.createsTables) {
-    const columns2 = tables.get(table8.name);
-    if (!columns2) {
-      return {
-        verdict: {
-          tag: entry.tag,
-          verdict: "contradicted",
-          detail: `creates table \`${table8.name}\`, which is not in the live database`
-        },
-        unverifiable: false
-      };
-    }
-    const missing = table8.columns.filter((column2) => !columns2.includes(column2));
-    if (missing.length > 0) {
-      return {
-        verdict: {
-          tag: entry.tag,
-          verdict: "contradicted",
-          detail: `table \`${table8.name}\` exists but is missing column(s) ${missing.map((column2) => `\`${column2}\``).join(", ")} this migration defines`
-        },
-        unverifiable: false
-      };
-    }
-  }
-  for (const added of entry.addsColumns) {
-    const columns2 = tables.get(added.table);
-    if (columns2 && !columns2.includes(added.column)) {
-      return {
-        verdict: {
-          tag: entry.tag,
-          verdict: "contradicted",
-          detail: `adds column \`${added.column}\` to \`${added.table}\`, which the live table does not have`
-        },
-        unverifiable: false
-      };
-    }
-  }
   return { verdict: { tag: entry.tag, verdict: "verified" }, unverifiable: false };
 }
-function judgeBeyond(entry, tables, indexes2, views) {
+function judgeBeyond(entry, expected, live) {
   for (const table8 of entry.createsTables) {
-    if (tables.has(table8.name)) {
+    if (live.tables.has(table8.name) && !expected.tables.has(table8.name)) {
       return {
         tag: entry.tag,
         verdict: "contradicted",
@@ -28378,8 +28434,9 @@ function judgeBeyond(entry, tables, indexes2, views) {
     }
   }
   for (const added of entry.addsColumns) {
-    const columns2 = tables.get(added.table);
-    if (columns2?.includes(added.column)) {
+    const columns2 = live.tables.get(added.table);
+    const explained = expected.tables.get(added.table)?.columns.has(added.column);
+    if (columns2?.includes(added.column) && !explained) {
       return {
         tag: entry.tag,
         verdict: "contradicted",
@@ -28388,7 +28445,7 @@ function judgeBeyond(entry, tables, indexes2, views) {
     }
   }
   for (const index2 of entry.createsIndexes) {
-    if (indexes2.has(index2)) {
+    if (live.indexes.has(index2) && !expected.indexes.has(index2)) {
       return {
         tag: entry.tag,
         verdict: "contradicted",
@@ -28397,7 +28454,7 @@ function judgeBeyond(entry, tables, indexes2, views) {
     }
   }
   for (const view2 of entry.createsViews) {
-    if (views.has(view2)) {
+    if (live.views.has(view2) && !expected.views.has(view2)) {
       return {
         tag: entry.tag,
         verdict: "contradicted",
@@ -28408,19 +28465,20 @@ function judgeBeyond(entry, tables, indexes2, views) {
   return { tag: entry.tag, verdict: "verified" };
 }
 function suggestTag(evidence, tables) {
-  let presentPrefix = 0;
-  while (presentPrefix < evidence.length && evidence[presentPrefix].createsTables.every((table8) => tables.has(table8.name))) {
-    presentPrefix++;
-  }
-  let absentFrom = evidence.length;
-  while (absentFrom > 0 && evidence[absentFrom - 1].createsTables.every((table8) => !tables.has(table8.name))) {
-    absentFrom--;
+  const liveCreated = [
+    ...new Set(evidence.flatMap((entry) => entry.createsTables.map((table8) => table8.name)))
+  ].filter((name2) => tables.has(name2));
+  const state = { tables: new Map, indexes: new Map, views: new Map };
+  let best = null;
+  for (const entry of evidence) {
+    applyEvidenceEntry(state, entry);
+    const allPresent = [...state.tables.keys()].every((name2) => tables.has(name2));
+    const noStray = liveCreated.every((name2) => state.tables.has(name2));
+    if (allPresent && noStray) {
+      best = entry.tag;
+    }
   }
-  const candidate = presentPrefix - 1;
-  return candidate >= 0 && candidate >= absentFrom - 1 ? evidence[candidate].tag : null;
-}
-function hasSignal(entry) {
-  return entry.createsTables.length > 0 || entry.addsColumns.length > 0 || entry.createsIndexes.length > 0 || entry.createsViews.length > 0;
+  return best;
 }
 var init_baseline_validation_util = __esm(() => {
   init_spans();
@@ -33980,7 +34038,14 @@ var init_schemas2 = __esm(() => {
       column: exports_external.string().min(1)
     })),
     createsIndexes: exports_external.array(exports_external.string()),
-    createsViews: exports_external.array(exports_external.string())
+    createsViews: exports_external.array(exports_external.string()),
+    dropsTables: exports_external.array(exports_external.string()),
+    dropsColumns: exports_external.array(exports_external.object({
+      table: exports_external.string().min(1),
+      column: exports_external.string().min(1)
+    })),
+    dropsIndexes: exports_external.array(exports_external.string()),
+    dropsViews: exports_external.array(exports_external.string())
   })).optional();
   DeployBaselineSchema = exports_external.object({
     lastAppliedMigrationTag: exports_external.string().min(1).optional(),

package/dist/server.js

@@ -1083,7 +1083,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.6.1-beta.7",
+    version: "0.6.1-beta.8",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -28292,14 +28292,16 @@ function assertBaselineClaimValid(args2) {
 function validateBaselineClaim(args2) {
   const { claimedTag, evidence, tables, indexes: indexes2, views, lastDeployAt } = args2;
   const claimedIndex = evidence.findIndex((entry) => entry.tag === claimedTag);
+  const expected = replayEvidence(evidence, claimedIndex);
+  const live = { tables, indexes: indexes2, views };
   const verdicts = [];
   const unverified = [];
   evidence.forEach((entry, index2) => {
     if (claimedIndex === -1 || index2 > claimedIndex) {
-      verdicts.push(judgeBeyond(entry, tables, indexes2, views));
+      verdicts.push(judgeBeyond(entry, expected, live));
       return;
     }
-    const judged = judgeClaimed(entry, tables, lastDeployAt);
+    const judged = judgeClaimed(entry, expected, live, lastDeployAt);
     verdicts.push(judged.verdict);
     if (judged.unverifiable) {
       unverified.push(judged.verdict);
@@ -28312,8 +28314,99 @@ function validateBaselineClaim(args2) {
     suggestedTag: suggestTag(evidence, tables)
   };
 }
-function judgeClaimed(entry, tables, lastDeployAt) {
-  if (!hasSignal(entry)) {
+function replayEvidence(evidence, claimedIndex) {
+  const state = { tables: new Map, indexes: new Map, views: new Map };
+  for (let index2 = 0;index2 <= claimedIndex; index2++) {
+    applyEvidenceEntry(state, evidence[index2]);
+  }
+  return state;
+}
+function applyEvidenceEntry(state, entry) {
+  for (const table8 of entry.dropsTables) {
+    state.tables.delete(table8);
+  }
+  for (const dropped of entry.dropsColumns) {
+    state.tables.get(dropped.table)?.columns.delete(dropped.column);
+  }
+  for (const droppedIndex of entry.dropsIndexes) {
+    state.indexes.delete(droppedIndex);
+  }
+  for (const view2 of entry.dropsViews) {
+    state.views.delete(view2);
+  }
+  for (const table8 of entry.createsTables) {
+    state.tables.set(table8.name, {
+      creator: entry.tag,
+      columns: new Map(table8.columns.map((column2) => [column2, entry.tag]))
+    });
+  }
+  for (const added of entry.addsColumns) {
+    state.tables.get(added.table)?.columns.set(added.column, entry.tag);
+  }
+  for (const createdIndex of entry.createsIndexes) {
+    state.indexes.set(createdIndex, entry.tag);
+  }
+  for (const view2 of entry.createsViews) {
+    state.views.set(view2, entry.tag);
+  }
+}
+function judgeClaimed(entry, expected, live, lastDeployAt) {
+  let surviving = 0;
+  for (const table8 of entry.createsTables) {
+    const expectation = expected.tables.get(table8.name);
+    if (expectation?.creator === entry.tag) {
+      surviving++;
+      const columns2 = live.tables.get(table8.name);
+      if (!columns2) {
+        return {
+          verdict: {
+            tag: entry.tag,
+            verdict: "contradicted",
+            detail: `creates table \`${table8.name}\`, which is not in the live database`
+          },
+          unverifiable: false
+        };
+      }
+      const missing = [...expectation.columns.entries()].filter(([, creator]) => creator === entry.tag).map(([column2]) => column2).filter((column2) => !columns2.includes(column2));
+      if (missing.length > 0) {
+        return {
+          verdict: {
+            tag: entry.tag,
+            verdict: "contradicted",
+            detail: `table \`${table8.name}\` exists but is missing column(s) ${missing.map((column2) => `\`${column2}\``).join(", ")} this migration defines`
+          },
+          unverifiable: false
+        };
+      }
+    }
+  }
+  for (const added of entry.addsColumns) {
+    if (expected.tables.get(added.table)?.columns.get(added.column) === entry.tag) {
+      surviving++;
+      const columns2 = live.tables.get(added.table);
+      if (columns2 && !columns2.includes(added.column)) {
+        return {
+          verdict: {
+            tag: entry.tag,
+            verdict: "contradicted",
+            detail: `adds column \`${added.column}\` to \`${added.table}\`, which the live table does not have`
+          },
+          unverifiable: false
+        };
+      }
+    }
+  }
+  for (const name2 of entry.createsIndexes) {
+    if (expected.indexes.get(name2) === entry.tag && live.indexes.has(name2)) {
+      surviving++;
+    }
+  }
+  for (const name2 of entry.createsViews) {
+    if (expected.views.get(name2) === entry.tag && live.views.has(name2)) {
+      surviving++;
+    }
+  }
+  if (surviving === 0) {
     const generated = new Date(entry.generatedAt);
     if (lastDeployAt && generated > lastDeployAt) {
       return {
@@ -28327,48 +28420,11 @@ function judgeClaimed(entry, tables, lastDeployAt) {
     }
     return { verdict: { tag: entry.tag, verdict: "no-signal" }, unverifiable: false };
   }
-  for (const table8 of entry.createsTables) {
-    const columns2 = tables.get(table8.name);
-    if (!columns2) {
-      return {
-        verdict: {
-          tag: entry.tag,
-          verdict: "contradicted",
-          detail: `creates table \`${table8.name}\`, which is not in the live database`
-        },
-        unverifiable: false
-      };
-    }
-    const missing = table8.columns.filter((column2) => !columns2.includes(column2));
-    if (missing.length > 0) {
-      return {
-        verdict: {
-          tag: entry.tag,
-          verdict: "contradicted",
-          detail: `table \`${table8.name}\` exists but is missing column(s) ${missing.map((column2) => `\`${column2}\``).join(", ")} this migration defines`
-        },
-        unverifiable: false
-      };
-    }
-  }
-  for (const added of entry.addsColumns) {
-    const columns2 = tables.get(added.table);
-    if (columns2 && !columns2.includes(added.column)) {
-      return {
-        verdict: {
-          tag: entry.tag,
-          verdict: "contradicted",
-          detail: `adds column \`${added.column}\` to \`${added.table}\`, which the live table does not have`
-        },
-        unverifiable: false
-      };
-    }
-  }
   return { verdict: { tag: entry.tag, verdict: "verified" }, unverifiable: false };
 }
-function judgeBeyond(entry, tables, indexes2, views) {
+function judgeBeyond(entry, expected, live) {
   for (const table8 of entry.createsTables) {
-    if (tables.has(table8.name)) {
+    if (live.tables.has(table8.name) && !expected.tables.has(table8.name)) {
       return {
         tag: entry.tag,
         verdict: "contradicted",
@@ -28377,8 +28433,9 @@ function judgeBeyond(entry, tables, indexes2, views) {
     }
   }
   for (const added of entry.addsColumns) {
-    const columns2 = tables.get(added.table);
-    if (columns2?.includes(added.column)) {
+    const columns2 = live.tables.get(added.table);
+    const explained = expected.tables.get(added.table)?.columns.has(added.column);
+    if (columns2?.includes(added.column) && !explained) {
       return {
         tag: entry.tag,
         verdict: "contradicted",
@@ -28387,7 +28444,7 @@ function judgeBeyond(entry, tables, indexes2, views) {
     }
   }
   for (const index2 of entry.createsIndexes) {
-    if (indexes2.has(index2)) {
+    if (live.indexes.has(index2) && !expected.indexes.has(index2)) {
       return {
         tag: entry.tag,
         verdict: "contradicted",
@@ -28396,7 +28453,7 @@ function judgeBeyond(entry, tables, indexes2, views) {
     }
   }
   for (const view2 of entry.createsViews) {
-    if (views.has(view2)) {
+    if (live.views.has(view2) && !expected.views.has(view2)) {
       return {
         tag: entry.tag,
         verdict: "contradicted",
@@ -28407,19 +28464,20 @@ function judgeBeyond(entry, tables, indexes2, views) {
   return { tag: entry.tag, verdict: "verified" };
 }
 function suggestTag(evidence, tables) {
-  let presentPrefix = 0;
-  while (presentPrefix < evidence.length && evidence[presentPrefix].createsTables.every((table8) => tables.has(table8.name))) {
-    presentPrefix++;
-  }
-  let absentFrom = evidence.length;
-  while (absentFrom > 0 && evidence[absentFrom - 1].createsTables.every((table8) => !tables.has(table8.name))) {
-    absentFrom--;
+  const liveCreated = [
+    ...new Set(evidence.flatMap((entry) => entry.createsTables.map((table8) => table8.name)))
+  ].filter((name2) => tables.has(name2));
+  const state = { tables: new Map, indexes: new Map, views: new Map };
+  let best = null;
+  for (const entry of evidence) {
+    applyEvidenceEntry(state, entry);
+    const allPresent = [...state.tables.keys()].every((name2) => tables.has(name2));
+    const noStray = liveCreated.every((name2) => state.tables.has(name2));
+    if (allPresent && noStray) {
+      best = entry.tag;
+    }
   }
-  const candidate = presentPrefix - 1;
-  return candidate >= 0 && candidate >= absentFrom - 1 ? evidence[candidate].tag : null;
-}
-function hasSignal(entry) {
-  return entry.createsTables.length > 0 || entry.addsColumns.length > 0 || entry.createsIndexes.length > 0 || entry.createsViews.length > 0;
+  return best;
 }
 var init_baseline_validation_util = __esm(() => {
   init_spans();
@@ -33979,7 +34037,14 @@ var init_schemas2 = __esm(() => {
       column: exports_external.string().min(1)
     })),
     createsIndexes: exports_external.array(exports_external.string()),
-    createsViews: exports_external.array(exports_external.string())
+    createsViews: exports_external.array(exports_external.string()),
+    dropsTables: exports_external.array(exports_external.string()),
+    dropsColumns: exports_external.array(exports_external.object({
+      table: exports_external.string().min(1),
+      column: exports_external.string().min(1)
+    })),
+    dropsIndexes: exports_external.array(exports_external.string()),
+    dropsViews: exports_external.array(exports_external.string())
   })).optional();
   DeployBaselineSchema = exports_external.object({
     lastAppliedMigrationTag: exports_external.string().min(1).optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/sandbox",
-    "version": "0.6.1-beta.7",
+    "version": "0.6.1-beta.8",
     "description": "Local development server for Playcademy game development",
     "type": "module",
     "exports": {