it was a one line fix.... garbage collector broke: it ruined everything.

Author: dimitropoulos

Diff for: packages/playground/evaluate/config.ts

@@ -34,7 +34,7 @@ export const config = {
   incrementBy: 100,
   comeUpForAirEvery: 100,
   transcendTheAstralPlane: 100,
-  readStringFromMemory: false,
+  readStringFromMemory: true,
 } satisfies Config;
 
 /** this is the magic type alias that the script is looking for in the evaluationFilePath */

Diff for: packages/playground/evaluate/utils.ts

@@ -231,6 +231,7 @@ export const printType = (typeString: string) => {
 
   // if the first two characters are `{ "` we presume it's an object and format it as such
 
+  // object detection
   if (output.startsWith('{ "')) {
     const lines = output
       .replace(/{ "/g, '{\n  "')
@@ -240,5 +241,15 @@ export const printType = (typeString: string) => {
     const sortedLines = lines.slice(1, lines.length - 1).sort();
     output = [lines[0], ...sortedLines, lines[lines.length - 1]].join("\n");
   }
+
+  // string detection
+  if (output.startsWith(`"`) && output.endsWith(`"`)) {
+    output = output.slice(1, output.length - 1);
+
+    if (output === "") {
+      return "<empty string>";
+    }
+  }
+
   return output;
 };

Diff for: packages/playground/final-doom-pun-intended/data/memory.ts

@@ -46,12 +46,12 @@ type _GenerateLine<
   count extends `1${infer S}`
 
   ? // look up the value in memory
-    memory[address] extends infer value extends keyof DoomPaletteToAscii
+    memory[address] extends infer value
     ? _GenerateLine<
         memory,
         I32PlusOne<address>,
         S,
-        `${line}${DoomPaletteToAscii[value]}`
+        `${line}${DoomPaletteToAscii[value extends keyof DoomPaletteToAscii ? value : "00000000"]}`
       >
 
     : // you fucked up. you. fucked. up... yet again.

Diff for: packages/playground/final-doom-pun-intended/data/process-frame.ts

@@ -1,112 +1,78 @@
 import { Equal, Expect } from "type-testing"
 import { ProgramState } from "./types"
-import { State } from './state'
-import type { Satisfies } from 'ts-type-math'
+import type { evaluate, Satisfies } from 'ts-type-math'
 import { executeInstruction } from "./program"
 
-
-// end-to-end test for garbage collection
-
-type actual1022 = Satisfies<ProgramState, {
-  count: 1022;
+type blank = Satisfies<ProgramState, {
+  count: 0;
   results: [];
-  stack: ["00000000000000000000010000000001", "00000000000000000000000000000000"];
-  instructions: [
-    {
-      kind: "Store";
-      subkind: "I32Store8";
-      offset: "00000000000000000000000000000000";
-    },
-    { kind: 'Const'; value: '10000000000000000000000000000000' },
-    { kind: 'Nop', ziltoid: 'theOmniscient' },
-  ];
+  stack: [];
+  instructions: [];
   activeFuncId: "";
   activeBranches: {};
   activeStackDepth: 0;
   activeLocals: {};
   globals: {};
-  L1Cache: {
-    "00000000000000000000010000000000": "01000001";
-  };
+  L1Cache: {};
   memory: {};
-  garbageCollection: 1022;
+  garbageCollection: 0;
   indirect: {};
   memorySize: "";
   executionContexts: [];
   funcs: {};
 }>
 
-type actual1023 = executeInstruction<actual1022, true, 1023>
-type expected1023 = Satisfies<ProgramState, {
+type s<
+  Update extends Partial<ProgramState>
+> = Satisfies<ProgramState,
+  evaluate<
+    & Omit<
+      blank,
+      keyof Update
+    >
+    & Required<Update>
+  >
+>
+
+// end-to-end test for garbage collection
+
+type actual1023 = Satisfies<ProgramState, s<{
   count: 1023;
-  results: [];
-  stack: [];
   instructions: [
-    { kind: 'Const'; value: '10000000000000000000000000000000' },
+    { kind: 'Nop', ziltoid: 'theOmniscient' },
     { kind: 'Nop', ziltoid: 'theOmniscient' },
   ];
-  activeFuncId: "";
-  activeBranches: {};
-  activeStackDepth: 0;
-  activeLocals: {};
-  globals: {};
   L1Cache: {
-    "00000000000000000000010000000000": "01000001";
-    "00000000000000000000010000000001": "00000000";
+    "00000000000000000000000000000000": "00101110"; // will not change because it matches the source
+    "00000000000000000000000000000001": "00000000"; // will clear the source value
+    "00000000000000000000000000000011": "00000000"; // will never be set in the first place
+    "00000000000000000000000000000100": "01010101"; // will append this new value because it's not false
+    "00000000000000000000000000000101": "00000000"; // will skip because it's false
+    "00000000000000000000000000000111": "00000010"; // will modify the source value
+  }
+  memory: {
+    "00000000000000000000000000000000": "00101110"; // will keep because it hasn't changed
+    "00000000000000000000000000000001": "11111111"; // will be removed because the update for this address is false
+    "00000000000000000000000000000111": "00000001"; // will be modified by the update
+    "11111111111111111111111100000011": "00000001"; // will keep because it's random other data only present in the source
   };
-  memory: {};
   garbageCollection: 1023;
-  indirect: {};
-  memorySize: "";
-  executionContexts: [];
-  funcs: {};
-}>
-type test1023 = Expect<Equal<actual1023, expected1023>>
+}>>
 
-type actual1024 = executeInstruction<actual1023, true, 1024>
-type expected1024 = Satisfies<ProgramState, {
+type actual1025 = executeInstruction<actual1023, true, 1024>
+type expected1025 = Satisfies<ProgramState, s<{
   count: 1024;
-  results: [];
-  stack: ['10000000000000000000000000000000'];
   instructions: [
     { kind: 'Nop', ziltoid: 'theOmniscient' },
   ];
-  activeFuncId: "";
-  activeBranches: {};
-  activeStackDepth: 0;
-  activeLocals: {};
-  globals: {};
   L1Cache: {};
   memory: {
-    "00000000000000000000010000000000": "01000001";
-  };
+    "00000000000000000000000000000000": "00101110"; // source and update match
+  //"00000000000000000000000000000001": "11111111"; // the update cleared this value
+    "00000000000000000000000000000100": "01010101"; // newly added by the update
+    "00000000000000000000000000000111": "00000010"; // modified by the update
+    "11111111111111111111111100000011": "00000001"; // the random other data only present in the source
+  }
   garbageCollection: 0;
-  indirect: {};
-  memorySize: "";
-  executionContexts: [];
-  funcs: {};
-}>
-type test1024 = Expect<Equal<actual1024, expected1024>>
-
-type actual1025 = executeInstruction<actual1024, true, 1025>
-type expected1025 = Satisfies<ProgramState, {
-  count: 1025;
-  results: [];
-  stack: ['10000000000000000000000000000000'];
-  instructions: [];
-  activeFuncId: "";
-  activeBranches: {};
-  activeStackDepth: 0;
-  activeLocals: {};
-  globals: {};
-  L1Cache: {};
-  memory: {
-    "00000000000000000000010000000000": "01000001";
-  };
-  garbageCollection: 0; // 0 again, because we finalized
-  indirect: {};
-  memorySize: "";
-  executionContexts: [];
-  funcs: {};
-}>
-type test1025 = Expect<Equal<actual1025, expected1025>>
+}>>
+type test1025 = Expect<Equal<actual1025, expected1025>>

Diff for: packages/wasm-to-typescript-types/state.test.ts

@@ -495,9 +495,11 @@ export namespace State {
           instructions: state['instructions'];
           activeBranches: state['activeBranches'];
           L1Cache: {}; // clear the L1Cache
-          memory: Patch<
-            state['memory'],
-            TypeMath.GarbageCollect<state['L1Cache']>
+          memory: TypeMath.GarbageCollect<
+            Patch<
+              state['memory'],
+              state['L1Cache']
+            >
           >; // update the memory with the L1Cache
           executionContexts: state['executionContexts'];
           funcs: state['funcs'];

Diff for: packages/wasm-to-typescript-types/state.ts

@@ -33,7 +33,7 @@ export type GarbageCollection = number;
 export type IndirectTable = Record<MemoryAddress, FuncId>;
 
 /** do a memory sweep every 4 kibibytes */
-export type SweepL1Every = 4096;
+export type SweepL1Every = 1024;
 
 export type StorageBits = 8 | 16 | 32 | 64;